Began implementing a shared set of test models to speed up tests.

from django.utils import six

from django.utils.encoding import python_2_unicode_compatible

from shared_models.models import Author, Book

temp_storage_dir = tempfile.mkdtemp(dir=os.environ['DJANGO_TEST_TEMP_DIR'])

temp_storage = FileSystemStorage(temp_storage_dir)

    def __repr__(self):

        return self.__str__()

@python_2_unicode_compatible

class Writer(models.Model):

    name = models.CharField(max_length=50, help_text='Use both first and last names.')

    class Meta:

        ordering = ('name',)

    def __str__(self):

        return self.name

@python_2_unicode_compatible

class Article(models.Model):

    headline = models.CharField(max_length=50)

    slug = models.SlugField()

    pub_date = models.DateField()

    created = models.DateField(editable=False)

    writer = models.ForeignKey(Writer)

    writer = models.ForeignKey(Author)

    article = models.TextField()

    categories = models.ManyToManyField(Category, blank=True)

    status = models.PositiveIntegerField(choices=ARTICLE_STATUS, blank=True, null=True)

class ImprovedArticleWithParentLink(models.Model):

    article = models.OneToOneField(Article, parent_link=True)

class BetterWriter(Writer):

class BetterAuthor(Author):

    score = models.IntegerField()

@python_2_unicode_compatible

class WriterProfile(models.Model):

    writer = models.OneToOneField(Writer, primary_key=True)

class AuthorProfile(models.Model):

    writer = models.OneToOneField(Author, primary_key=True)

    age = models.PositiveIntegerField()

    def __str__(self):

    def __repr__(self):

        return self.__str__()

class Book(models.Model):

    title = models.CharField(max_length=40)

    author = models.ForeignKey(Writer, blank=True, null=True)

    special_id = models.IntegerField(blank=True, null=True, unique=True)

    class Meta:

        unique_together = ('title', 'author')

class BookXtra(models.Model):

    isbn = models.CharField(max_length=16, unique=True)

    suffix1 = models.IntegerField(blank=True, default=0)

from django.test import TestCase

from django.utils import six

from .models import (Article, ArticleStatus, BetterWriter, BigInt, Book,

from shared_models.models import Author, Book

from .models import (Article, ArticleStatus, BetterAuthor, BigInt,

    Category, CommaSeparatedInteger, CustomFieldForExclusionModel, DerivedBook,

    DerivedPost, ExplicitPK, FlexibleDatePost, ImprovedArticle,

    ImprovedArticleWithParentLink, Inventory, Post, Price,

    Product, TextFile, Writer, WriterProfile, Colour, ColourfulItem,

    Product, TextFile, AuthorProfile, Colour, ColourfulItem,

    test_images)

if test_images:

class BookForm(forms.ModelForm):

    class Meta:

        fields = ['title', 'author', 'pubdate']

        model = Book

class DerivedBookForm(forms.ModelForm):

    class Meta:

        fields = ['title', 'author', 'isbn', 'suffix1', 'suffix2']

        model = DerivedBook

        model = DerivedPost

class CustomWriterForm(forms.ModelForm):

class CustomAuthorForm(forms.ModelForm):

   name = forms.CharField(required=False)

   class Meta:

       model = Writer

       model = Author

class FlexDatePostForm(forms.ModelForm):

class RoykoForm(forms.ModelForm):

    class Meta:

        model = Writer

        model = Author

class TestArticleForm(forms.ModelForm):

    class Meta:

    class Meta:

        model = ImprovedArticleWithParentLink

class BetterWriterForm(forms.ModelForm):

class BetterAuthorForm(forms.ModelForm):

    class Meta:

        model = BetterWriter

        model = BetterAuthor

class WriterProfileForm(forms.ModelForm):

class AuthorProfileForm(forms.ModelForm):

    class Meta:

        model = WriterProfile

        model = AuthorProfile

class TextFileForm(forms.ModelForm):

    class Meta:

                                     forms.fields.BooleanField))

    def test_override_field(self):

        class WriterForm(forms.ModelForm):

        class AuthorForm(forms.ModelForm):

            book = forms.CharField(required=False)

            class Meta:

                model = Writer

                model = Author

        wf = WriterForm({'name': 'Richard Lockridge'})

        wf = AuthorForm({'name': 'Richard Lockridge'})

        self.assertTrue(wf.is_valid())

    def test_limit_fields(self):

        assert form.is_valid()

    def test_notrequired_overrides_notblank(self):

        form = CustomWriterForm({})

        form = CustomAuthorForm({})

        assert form.is_valid()

# unique/unique_together validation

class UniqueTest(TestCase):

    def setUp(self):

        self.writer = Writer.objects.create(name='Mike Royko')

        self.author = Author.objects.create(name='Mike Royko')

    def test_simple_unique(self):

        form = ProductForm({'slug': 'teddy-bear-blue'})

    def test_unique_null(self):

        title = 'I May Be Wrong But I Doubt It'

        form = BookForm({'title': title, 'author': self.writer.pk})

        form = BookForm({'title': title, 'author': self.author.pk, 'pubdate': '2012-12-12 00:00:00'})

        self.assertTrue(form.is_valid())

        form.save()

        form = BookForm({'title': title, 'author': self.writer.pk})

        form = BookForm({'title': title, 'author': self.author.pk, 'pubdate': '2012-12-12 00:00:00'})

        self.assertFalse(form.is_valid())

        self.assertEqual(len(form.errors), 1)

        self.assertEqual(form.errors['__all__'], ['Book with this Title and Author already exists.'])

        form = BookForm({'title': title})

        form = BookForm({'title': title, 'pubdate': '2012-12-12 00:00:00'})

        self.assertTrue(form.is_valid())

        form.save()

        form = BookForm({'title': title})

        form = BookForm({'title': title, 'pubdate': '2012-12-12 00:00:00'})

        self.assertTrue(form.is_valid())

    def test_inherited_unique(self):

        title = 'Boss'

        Book.objects.create(title=title, author=self.writer, special_id=1)

        form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'special_id': '1', 'isbn': '12345'})

        form = BetterAuthorForm({'name': 'Mike Royko', 'score': 3})

        self.assertFalse(form.is_valid())

        self.assertEqual(len(form.errors), 1)

        self.assertEqual(form.errors['special_id'], ['Book with this Special id already exists.'])

        self.assertEqual(form.errors['name'], ['Author with this Name already exists.'])

    def test_inherited_unique_together(self):

        title = 'Boss'

        form = BookForm({'title': title, 'author': self.writer.pk})

        form = BookForm({'title': title, 'author': self.author.pk, 'pubdate': '2012-12-12 00:00:00'})

        self.assertTrue(form.is_valid())

        form.save()

        form = DerivedBookForm({'title': title, 'author': self.writer.pk, 'isbn': '12345'})

        form = DerivedBookForm({'title': title, 'author': self.author.pk, 'isbn': '12345'})

        self.assertFalse(form.is_valid())

        self.assertEqual(len(form.errors), 1)

        self.assertEqual(form.errors['__all__'], ['Book with this Title and Author already exists.'])

    def test_abstract_inherited_unique(self):

        title = 'Boss'

        isbn = '12345'

        dbook = DerivedBook.objects.create(title=title, author=self.writer, isbn=isbn)

        form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'isbn': isbn})

        dbook = DerivedBook.objects.create(title=title, author=self.author, isbn=isbn,

            pubdate='2012-12-12 00:00')

        form = DerivedBookForm({'title': 'Other', 'author': self.author.pk, 'isbn': isbn})

        self.assertFalse(form.is_valid())

        self.assertEqual(len(form.errors), 1)

        self.assertEqual(form.errors['isbn'], ['Derived book with this Isbn already exists.'])

    def test_abstract_inherited_unique_together(self):

        title = 'Boss'

        isbn = '12345'

        dbook = DerivedBook.objects.create(title=title, author=self.writer, isbn=isbn)

        dbook = DerivedBook.objects.create(title=title, author=self.author, isbn=isbn,

            pubdate='2012-12-12 00:00')

        form = DerivedBookForm({

                    'title': 'Other',

                    'author': self.writer.pk,

                    'author': self.author.pk,

                    'isbn': '9876',

                    'suffix1': '0',

                    'suffix2': '0'

        ]

        for c in categories:

            c.save()

        writer = Writer(name='Test writer')

        writer = Author(name='Test writer')

        writer.save()

        art = Article(

        with self.assertRaises(ValueError):

            f.save()

        # Create a couple of Writers.

        w_royko = Writer(name='Mike Royko')

        # Create a couple of Authors.

        w_royko = Author(name='Mike Royko')

        w_royko.save()

        w_woodward = Writer(name='Bob Woodward')

        w_woodward = Author(name='Bob Woodward')

        w_woodward.save()

        # ManyToManyFields are represented by a MultipleChoiceField, ForeignKeys and any

        # fields with the 'choices' attribute are represented by a ChoiceField.

        # When the ModelForm is passed an instance, that instance's current values are

        # inserted as 'initial' data in each Field.

        w = Writer.objects.get(name='Mike Royko')

        w = Author.objects.get(name='Mike Royko')

        f = RoykoForm(auto_id=False, instance=w)

        self.assertHTMLEqual(six.text_type(f), '''<tr><th>Name:</th><td><input type="text" name="name" value="Mike Royko" maxlength="50" /><br /><span class="helptext">Use both first and last names.</span></td></tr>''')

        self.assertHTMLEqual(six.text_type(f), '''<tr><th>Name:</th><td><input type="text" name="name" value="Mike Royko" maxlength="100" /><br /><span class="helptext">Use both first and last names.</span></td></tr>''')

        art = Article(

                    headline='Test article',

        c4 = Category.objects.create(name='Fourth', url='4th')

        self.assertEqual(c4.name, 'Fourth')

        w_bernstein = Writer.objects.create(name='Carl Bernstein')

        w_bernstein = Author.objects.create(name='Carl Bernstein')

        self.assertEqual(w_bernstein.name, 'Carl Bernstein')

        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type="text" name="headline" maxlength="50" /></li>

<li>Slug: <input type="text" name="slug" maxlength="50" /></li>

        self.assertEqual(list(ImprovedArticleWithParentLinkForm.base_fields), [])

        bw = BetterWriter(name='Joe Better', score=10)

        bw = BetterAuthor(name='Joe Better', score=10)

        bw.save()

        self.assertEqual(sorted(model_to_dict(bw)),

                         ['id', 'name', 'score', 'writer_ptr'])

                         ['author_ptr', 'id', 'name', 'score'])

        form = BetterWriterForm({'name': 'Some Name', 'score': 12})

        form = BetterAuthorForm({'name': 'Some Name', 'score': 12})

        self.assertEqual(form.is_valid(), True)

        bw2 = form.save()

        bw2.delete()

        form = WriterProfileForm()

        form = AuthorProfileForm()

        self.assertHTMLEqual(form.as_p(), '''<p><label for="id_writer">Writer:</label> <select name="writer" id="id_writer">

<option value="" selected="selected">---------</option>

<option value="%s">Bob Woodward</option>

            'writer': six.text_type(w_woodward.pk),

            'age': '65',

        }

        form = WriterProfileForm(data)

        form = AuthorProfileForm(data)

        instance = form.save()

        self.assertEqual(six.text_type(instance), 'Bob Woodward is 65')

        form = WriterProfileForm(instance=instance)

        form = AuthorProfileForm(instance=instance)

        self.assertHTMLEqual(form.as_p(), '''<p><label for="id_writer">Writer:</label> <select name="writer" id="id_writer">

<option value="">---------</option>

<option value="%s" selected="selected">Bob Woodward</option>

from __future__ import unicode_literals

from django.db import models

from django.utils import timezone

from django.utils.encoding import python_2_unicode_compatible

@python_2_unicode_compatible

class Author(models.Model):

    name = models.CharField(max_length=100)

    name = models.CharField(max_length=100, help_text='Use both first and last names.',

        unique=True)

    class Meta:

        ordering = ['name']

    def __str__(self):

        return self.name

@python_2_unicode_compatible

class Book(models.Model):

    name = models.CharField(max_length=200)

    title = models.CharField(max_length=200)

    pages = models.IntegerField(default=0)

    author = models.ForeignKey(Author, null=True)

    author = models.ForeignKey(Author, null=True, blank=True)

    pubdate = models.DateTimeField()

    tags = models.ManyToManyField(Tag)

    class Meta:

        ordering = ['-pubdate', 'name']

        ordering = ['-pubdate', 'title']

        unique_together = ['title', 'author']

    def __str__(self):

        return self.name

        return self.title

            "Is created"

        ])

        b1 = Book(name='Snow Crash', pubdate='2012-02-02 12:00')

        b1 = Book(title='Snow Crash', pubdate='2012-02-02 12:00')

        self.assertEqual(self.get_signal_output(b1.save), [

            "pre_save signal, Snow Crash",

            "post_save signal, Snow Crash",

    def test_m2m_signals(self):

        """ Assigning and removing to/from m2m shouldn't generate an m2m signal """

        b1 = Book(name='Snow Crash', pubdate='2012-02-02 12:00')

        b1 = Book(title='Snow Crash', pubdate='2012-02-02 12:00')

        self.get_signal_output(b1.save)

        a1 = Author(name='Neal Stephenson')

        self.get_signal_output(a1.save)