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

from ..models import Flaw, Experiment, ProtocolAttachment, TreatmentType, \
    Treatment, TreatmentReplicate, AliveDeadCount
from ..factories import FlawFactory, ExperimentFactory, ProtocolAttachmentFactory, \
    TreatmentTypeFactory, TreatmentFactory, TreatmentReplicateFactory, \
    AliveDeadCountFactory


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 ExperimentTestCase(TestCase):
    def test_creation(self):
        e = ExperimentFactory()
        self.assertTrue(isinstance(e, Experiment))
        self.assertEqual(e.__str__(), e.name)

    def test_uniqueness(self):
        e1 = ExperimentFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            ExperimentFactory(name=e1.name, code=e1.code)
        e3 = ExperimentFactory()
        self.assertTrue(isinstance(e3, Experiment))


class ProtocolAttachmentTestCase(TestCase):
    def test_creation(self):
        p = ProtocolAttachmentFactory()
        self.assertTrue(isinstance(p, ProtocolAttachment))
        self.assertEqual(p.__str__(), p.protocol)


class TreatmentTypeTestCase(TestCase):
    def test_creation(self):
        t = TreatmentTypeFactory()
        self.assertTrue(isinstance(t, TreatmentType))
        label = "{} {} {} {}".format(t.experiment, t.name, t.treatment_type,
                                     t.placement)
        self.assertEqual(t.__str__(), label)

    def test_uniqueness(self):
        t1 = TreatmentTypeFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            TreatmentTypeFactory(name=t1.name, experiment=t1.experiment)
        t3 = TreatmentTypeFactory()
        self.assertTrue(isinstance(t3, TreatmentType))


class TreatmentTestCase(TestCase):
    def test_creation(self):
        t = TreatmentFactory()
        self.assertTrue(isinstance(t, Treatment))
        label = "{}_{}_{}_{}".format(t.treatment_type, t.study_location,
                                     t.species, t.sex)
        self.assertEqual(t.__str__(), label)

    def test_uniqueness(self):
        t1 = TreatmentFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            TreatmentFactory(treatment_type=t1.treatment_type, container=t1.container,
                             study_location=t1.study_location, species=t1.species,
                             sex=t1.sex)
        t3 = TreatmentFactory()
        self.assertTrue(isinstance(t3, Treatment))


class TreatmentReplicateTestCase(TestCase):
    def test_creation(self):
        t = TreatmentReplicateFactory()
        self.assertTrue(isinstance(t, TreatmentReplicate))
        label = "{}_{}_{}_{}".format(t.treatment, t.setup_date,
                                     t.name, t.setup_sample_size)
        self.assertEqual(t.__str__(), label)

    def test_uniqueness(self):
        t1 = TreatmentReplicateFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            TreatmentReplicateFactory(treatment=t1.treatment, name=t1.name,
                                      setup_date=t1.setup_date,
                                      setup_time=t1.setup_time)
        t3 = TreatmentReplicateFactory()
        self.assertTrue(isinstance(t3, TreatmentReplicate))


class AliveDeadCountTestCase(TestCase):
    def test_creation(self):
        a = AliveDeadCountFactory()
        self.assertTrue(isinstance(a, AliveDeadCount))
        label = "{}".format(a.status_date)
        self.assertEqual(a.__str__(), label)

    def test_uniqueness(self):
        a1 = AliveDeadCountFactory()
        with transaction.atomic(), self.assertRaises(IntegrityError):
            AliveDeadCountFactory(treatment_replicate=a1.treatment_replicate,
                                  status_date=a1.status_date,
                                  status_time=a1.status_time,
                                  count_alive=a1.count_alive,
                                  count_dead=a1.count_dead)
        a3 = AliveDeadCountFactory()
        self.assertTrue(isinstance(a3, AliveDeadCount))