from django.test import TestCase
from django.db import IntegrityError, transaction

from ..models import CollectionType, CollectionMethod, Flaw, ADFGPermit, \
    Collection, DatasheetAttachment, CollectionTrap
from ..factories import CollectionTypeFactory, CollectionMethodFactory, \
    FlawFactory, ADFGPermitFactory, CollectionFactory, DatasheetAttachmentFactory, \
    CollectionTrapFactory


class CollectionTypeTestCase(TestCase):
    def test_creation(self):
        c = CollectionTypeFactory()
        self.assertTrue(isinstance(c, CollectionType))
        self.assertEqual(c.__str__(), c.name)

    def test_uniqueness(self):
        c1 = CollectionTypeFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            CollectionTypeFactory(name=c1.name, code=c1.code)
        c3 = CollectionTypeFactory()
        self.assertTrue(isinstance(c3, CollectionType))


class CollectionMethodTestCase(TestCase):
    def test_creation(self):
        c = CollectionMethodFactory()
        self.assertTrue(isinstance(c, CollectionMethod))
        self.assertEqual(c.__str__(), c.name)

    def test_uniqueness(self):
        c1 = CollectionMethodFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            CollectionMethodFactory(name=c1.name, code=c1.code)
        c3 = CollectionMethodFactory()
        self.assertTrue(isinstance(c3, CollectionMethod))


class FlawTestCase(TestCase):
    def test_creation(self):
        f = FlawFactory()
        self.assertTrue(isinstance(f, Flaw))
        self.assertEqual(f.__str__(), f.name)

    def test_uniqueness(self):
        f1 = FlawFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            FlawFactory(name=f1.name)
        f3 = FlawFactory()
        self.assertTrue(isinstance(f3, Flaw))


class ADFGPermitTestCase(TestCase):
    def test_creation(self):
        a = ADFGPermitFactory()
        self.assertTrue(isinstance(a, ADFGPermit))
        self.assertEqual(a.__str__(), a.name)

    def test_uniqueness(self):
        a1 = ADFGPermitFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            ADFGPermitFactory(name=a1.name)
        a3 = ADFGPermitFactory()
        self.assertTrue(isinstance(a3, ADFGPermit))


class CollectionTestCase(TestCase):
    def test_creation(self):
        c = CollectionFactory()
        self.assertTrue(isinstance(c, Collection))
        self.assertEqual(c.__str__(), c.display_name)

    def test_uniqueness(self):
        c1 = CollectionFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            CollectionFactory(project=c1.project, study_location=c1.study_location,
                              collection_type=c1.collection_type,
                              collection_start_date=c1.collection_start_date,
                              collection_end_date=c1.collection_end_date,
                              collection_method=c1.collection_method)
        c3 = CollectionFactory()
        self.assertTrue(isinstance(c3, Collection))


class DatasheetAttachmentTestCase(TestCase):
    def test_creation(self):
        d = DatasheetAttachmentFactory()
        self.assertTrue(isinstance(d, DatasheetAttachment))


class CollectionTrapTestCase(TestCase):
    def test_creation(self):
        c = CollectionTrapFactory()
        self.assertTrue(isinstance(c, CollectionTrap))
        name = "{} # Traps: {} {} {}".format(c.collection, c.number_of_traps,
                                             c.date_opened, c.date_closed)
        self.assertEqual(c.__str__(), name)

    def test_uniqueness(self):
        c1 = CollectionTrapFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            CollectionTrapFactory(collection=c1.collection, date_opened=c1.date_opened,
                                  time_opened=c1.time_opened, date_closed=c1.date_closed,
                                  time_closed=c1.time_closed)
        c3 = CollectionTrapFactory()
        self.assertTrue(isinstance(c3, CollectionTrap))