import datetime

from django.test import TestCase

from django import forms

from models import Category, Writer, Book, DerivedBook, Post

from mforms import (ProductForm, PriceForm, BookForm, DerivedBookForm, 

                   ExplicitPKForm, PostForm, DerivedPostForm, CustomWriterForm)

class IncompleteCategoryFormWithFields(forms.ModelForm):

    """

    A form that replaces the model's url field with a custom one. This should

    prevent the model field's validation from being called.

    """

    url = forms.CharField(required=False)

    class Meta:

        fields = ('name', 'slug')

        model = Category

class IncompleteCategoryFormWithExclude(forms.ModelForm):

    """

    A form that replaces the model's url field with a custom one. This should

    prevent the model field's validation from being called.

    """

    url = forms.CharField(required=False)

    class Meta:

        exclude = ['url']

        model = Category

class ValidationTest(TestCase):

    def test_validates_with_replaced_field_not_specified(self):

        form = IncompleteCategoryFormWithFields(data={'name': 'some name', 'slug': 'some-slug'})

        assert form.is_valid()

    def test_validates_with_replaced_field_excluded(self):

        form = IncompleteCategoryFormWithExclude(data={'name': 'some name', 'slug': 'some-slug'})

        assert form.is_valid()

    def test_notrequired_overrides_notblank(self):

        form = CustomWriterForm({})

        assert form.is_valid()

# unique/unique_together validation

class UniqueTest(TestCase):

    def setUp(self):

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

    def test_simple_unique(self):

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

        self.assertTrue(form.is_valid())

        obj = form.save()

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

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

        self.assertEqual(form.errors['slug'], [u'Product with this Slug already exists.'])

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

        self.assertTrue(form.is_valid())

    def test_unique_together(self):

        """ModelForm test of unique_together constraint"""

        form = PriceForm({'price': '6.00', 'quantity': '1'})

        self.assertTrue(form.is_valid())

        form.save()

        form = PriceForm({'price': '6.00', 'quantity': '1'})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['__all__'], [u'Price with this Price and Quantity already exists.'])

    def test_unique_null(self):

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

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

        self.assertTrue(form.is_valid())

        form.save()

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

        self.assertFalse(form.is_valid())

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

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

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

        self.assertTrue(form.is_valid())

        form.save()

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

        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': u'1', 'isbn': '12345'})

        self.assertFalse(form.is_valid())

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

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

    def test_inherited_unique_together(self):

        title = 'Boss'

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

        self.assertTrue(form.is_valid())

        form.save()

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

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['__all__'], [u'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})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['isbn'], [u'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)

        form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'isbn': '9876', 'suffix1': u'0', 'suffix2': u'0'})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['__all__'], [u'Derived book with this Suffix1 and Suffix2 already exists.'])

    def test_explicitpk_unspecified(self):

        """Test for primary_key being in the form and failing validation."""

        form = ExplicitPKForm({'key': u'', 'desc': u'' })

        self.assertFalse(form.is_valid())

    def test_explicitpk_unique(self):

        """Ensure keys and blank character strings are tested for uniqueness."""

        form = ExplicitPKForm({'key': u'key1', 'desc': u''})

        self.assertTrue(form.is_valid())

        form.save()

        form = ExplicitPKForm({'key': u'key1', 'desc': u''})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['__all__'], [u'Explicit pk with this Key and Desc already exists.'])

        self.assertEqual(form.errors['desc'], [u'Explicit pk with this Desc already exists.'])

        self.assertEqual(form.errors['key'], [u'Explicit pk with this Key already exists.'])

    def test_unique_for_date(self):

        p = Post.objects.create(title="Django 1.0 is released",

            slug="Django 1.0", subtitle="Finally", posted=datetime.date(2008, 9, 3))

        form = PostForm({'title': "Django 1.0 is released", 'posted': '2008-09-03'})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['title'], [u'Title must be unique for Posted date.'])

        form = PostForm({'title': "Work on Django 1.1 begins", 'posted': '2008-09-03'})

        self.assertTrue(form.is_valid())

        form = PostForm({'title': "Django 1.0 is released", 'posted': '2008-09-04'})

        self.assertTrue(form.is_valid())

        form = PostForm({'slug': "Django 1.0", 'posted': '2008-01-01'})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['slug'], [u'Slug must be unique for Posted year.'])

        form = PostForm({'subtitle': "Finally", 'posted': '2008-09-30'})

        self.assertFalse(form.is_valid())

        self.assertEqual(form.errors['subtitle'], [u'Subtitle must be unique for Posted month.'])

        form = PostForm({'subtitle': "Finally", "title": "Django 1.0 is released",

            "slug": "Django 1.0", 'posted': '2008-09-03'}, instance=p)

        self.assertTrue(form.is_valid())

        form = PostForm({'title': "Django 1.0 is released"})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['posted'], [u'This field is required.'])

    def test_inherited_unique_for_date(self):

        p = Post.objects.create(title="Django 1.0 is released",

            slug="Django 1.0", subtitle="Finally", posted=datetime.date(2008, 9, 3))

        form = DerivedPostForm({'title': "Django 1.0 is released", 'posted': '2008-09-03'})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['title'], [u'Title must be unique for Posted date.'])

        form = DerivedPostForm({'title': "Work on Django 1.1 begins", 'posted': '2008-09-03'})

        self.assertTrue(form.is_valid())

        form = DerivedPostForm({'title': "Django 1.0 is released", 'posted': '2008-09-04'})

        self.assertTrue(form.is_valid())

        form = DerivedPostForm({'slug': "Django 1.0", 'posted': '2008-01-01'})

        self.assertFalse(form.is_valid())

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

        self.assertEqual(form.errors['slug'], [u'Slug must be unique for Posted year.'])

        form = DerivedPostForm({'subtitle': "Finally", 'posted': '2008-09-30'})

        self.assertFalse(form.is_valid())

        self.assertEqual(form.errors['subtitle'], [u'Subtitle must be unique for Posted month.'])

        form = DerivedPostForm({'subtitle': "Finally", "title": "Django 1.0 is released",

            "slug": "Django 1.0", 'posted': '2008-09-03'}, instance=p)

        self.assertTrue(form.is_valid())