1 files changed, 153 insertions, 23 deletions
diff --git a/tests/test_django.py b/tests/test_django.py
index e4bbc2b..41a26cf 100644
--- a/tests/test_django.py
+++ b/tests/test_django.py
@@ -42,7 +42,7 @@ except ImportError:  # pragma: no cover
         Image = None
 
 
-from .compat import is_python2, unittest
+from .compat import is_python2, unittest, mock
 from . import testdata
 from . import tools
 
@@ -55,6 +55,7 @@ if django is not None:
     from django.db import models as django_models
     from django.test import simple as django_test_simple
     from django.test import utils as django_test_utils
+    from django.db.models import signals
     from .djapp import models
 else:  # pragma: no cover
     django_test = unittest
@@ -70,6 +71,7 @@ else:  # pragma: no cover
     models.NonIntegerPk = Fake
     models.WithFile = Fake
     models.WithImage = Fake
+    models.WithSignals = Fake
 
 
 test_state = {}
@@ -97,51 +99,82 @@ def tearDownModule():
 
 
 class StandardFactory(factory.django.DjangoModelFactory):
-    FACTORY_FOR = models.StandardModel
+    class Meta:
+        model = models.StandardModel
 
     foo = factory.Sequence(lambda n: "foo%d" % n)
 
 
 class StandardFactoryWithPKField(factory.django.DjangoModelFactory):
-    FACTORY_FOR = models.StandardModel
-    FACTORY_DJANGO_GET_OR_CREATE = ('pk',)
+    class Meta:
+        model = models.StandardModel
+        django_get_or_create = ('pk',)
 
     foo = factory.Sequence(lambda n: "foo%d" % n)
     pk = None
 
 
 class NonIntegerPkFactory(factory.django.DjangoModelFactory):
-    FACTORY_FOR = models.NonIntegerPk
+    class Meta:
+        model = models.NonIntegerPk
 
     foo = factory.Sequence(lambda n: "foo%d" % n)
     bar = ''
 
 
 class AbstractBaseFactory(factory.django.DjangoModelFactory):
-    FACTORY_FOR = models.AbstractBase
-    ABSTRACT_FACTORY = True
+    class Meta:
+        model = models.AbstractBase
+        abstract = True
 
     foo = factory.Sequence(lambda n: "foo%d" % n)
 
 
 class ConcreteSonFactory(AbstractBaseFactory):
-    FACTORY_FOR = models.ConcreteSon
+    class Meta:
+        model = models.ConcreteSon
+
+
+class AbstractSonFactory(AbstractBaseFactory):
+    class Meta:
+        model = models.AbstractSon
+
+
+class ConcreteGrandSonFactory(AbstractBaseFactory):
+    class Meta:
+        model = models.ConcreteGrandSon
 
 
 class WithFileFactory(factory.django.DjangoModelFactory):
-    FACTORY_FOR = models.WithFile
+    class Meta:
+        model = models.WithFile
 
     if django is not None:
         afile = factory.django.FileField()
 
 
 class WithImageFactory(factory.django.DjangoModelFactory):
-    FACTORY_FOR = models.WithImage
+    class Meta:
+        model = models.WithImage
 
     if django is not None:
         animage = factory.django.ImageField()
 
 
+class WithSignalsFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = models.WithSignals
+
+
+@unittest.skipIf(django is None, "Django not installed.")
+class ModelTests(django_test.TestCase):
+    def test_unset_model(self):
+        class UnsetModelFactory(factory.django.DjangoModelFactory):
+            pass
+
+        self.assertRaises(factory.FactoryError, UnsetModelFactory.create)
+
+
 @unittest.skipIf(django is None, "Django not installed.")
 class DjangoPkSequenceTestCase(django_test.TestCase):
     def setUp(self):
@@ -206,17 +239,20 @@ class DjangoPkForceTestCase(django_test.TestCase):
 
 @unittest.skipIf(django is None, "Django not installed.")
 class DjangoModelLoadingTestCase(django_test.TestCase):
-    """Tests FACTORY_FOR = 'app.Model' pattern."""
+    """Tests class Meta:
+     model = 'app.Model' pattern."""
 
     def test_loading(self):
         class ExampleFactory(factory.DjangoModelFactory):
-            FACTORY_FOR = 'djapp.StandardModel'
+            class Meta:
+                model = 'djapp.StandardModel'
 
-        self.assertEqual(models.StandardModel, ExampleFactory._get_target_class())
+        self.assertEqual(models.StandardModel, ExampleFactory._get_model_class())
 
     def test_building(self):
         class ExampleFactory(factory.DjangoModelFactory):
-            FACTORY_FOR = 'djapp.StandardModel'
+            class Meta:
+                model = 'djapp.StandardModel'
 
         e = ExampleFactory.build()
         self.assertEqual(models.StandardModel, e.__class__)
@@ -227,7 +263,8 @@ class DjangoModelLoadingTestCase(django_test.TestCase):
         See https://github.com/rbarrois/factory_boy/issues/109.
         """
         class ExampleFactory(factory.DjangoModelFactory):
-            FACTORY_FOR = 'djapp.StandardModel'
+            class Meta:
+                model = 'djapp.StandardModel'
 
         class Example2Factory(ExampleFactory):
             pass
@@ -241,14 +278,16 @@ class DjangoModelLoadingTestCase(django_test.TestCase):
         See https://github.com/rbarrois/factory_boy/issues/109.
         """
         class ExampleFactory(factory.DjangoModelFactory):
-            FACTORY_FOR = 'djapp.StandardModel'
+            class Meta:
+                model = 'djapp.StandardModel'
 
             foo = factory.Sequence(lambda n: n)
 
         class Example2Factory(ExampleFactory):
-            FACTORY_FOR = 'djapp.StandardSon'
+            class Meta:
+                model = 'djapp.StandardSon'
 
-        self.assertEqual(models.StandardSon, Example2Factory._get_target_class())
+        self.assertEqual(models.StandardSon, Example2Factory._get_model_class())
 
         e1 = ExampleFactory.build()
         e2 = Example2Factory.build()
@@ -301,8 +340,13 @@ class DjangoNonIntegerPkTestCase(django_test.TestCase):
 @unittest.skipIf(django is None, "Django not installed.")
 class DjangoAbstractBaseSequenceTestCase(django_test.TestCase):
     def test_auto_sequence(self):
-        with factory.debug():
-            obj = ConcreteSonFactory()
+        """The sequence of the concrete son of an abstract model should be autonomous."""
+        obj = ConcreteSonFactory()
+        self.assertEqual(1, obj.pk)
+
+    def test_auto_sequence(self):
+        """The sequence of the concrete grandson of an abstract model should be autonomous."""
+        obj = ConcreteGrandSonFactory()
         self.assertEqual(1, obj.pk)
 
 
@@ -439,9 +483,9 @@ class DjangoImageFieldTestCase(unittest.TestCase):
         self.assertEqual('django/example.jpg', o.animage.name)
 
         i = Image.open(os.path.join(settings.MEDIA_ROOT, o.animage.name))
-        colors = i.getcolors()
-        # 169 pixels with color 190 from the GIF palette
-        self.assertEqual([(169, 190)], colors)
+        colors = i.convert('RGB').getcolors()
+        # 169 pixels with rgb(0, 0, 255)
+        self.assertEqual([(169, (0, 0, 255))], colors)
         self.assertEqual('GIF', i.format)
 
     def test_with_file(self):
@@ -511,5 +555,91 @@ class DjangoImageFieldTestCase(unittest.TestCase):
         self.assertFalse(o.animage)
 
 
+@unittest.skipIf(django is None, "Django not installed.")
+class PreventSignalsTestCase(unittest.TestCase):
+    def setUp(self):
+        self.handlers = mock.MagicMock()
+
+        signals.pre_init.connect(self.handlers.pre_init)
+        signals.pre_save.connect(self.handlers.pre_save)
+        signals.post_save.connect(self.handlers.post_save)
+
+    def tearDown(self):
+        signals.pre_init.disconnect(self.handlers.pre_init)
+        signals.pre_save.disconnect(self.handlers.pre_save)
+        signals.post_save.disconnect(self.handlers.post_save)
+
+    def assertSignalsReactivated(self):
+        WithSignalsFactory()
+
+        self.assertEqual(self.handlers.pre_save.call_count, 1)
+        self.assertEqual(self.handlers.post_save.call_count, 1)
+
+    def test_context_manager(self):
+        with factory.django.mute_signals(signals.pre_save, signals.post_save):
+            WithSignalsFactory()
+
+        self.assertEqual(self.handlers.pre_init.call_count, 1)
+        self.assertFalse(self.handlers.pre_save.called)
+        self.assertFalse(self.handlers.post_save.called)
+
+        self.assertSignalsReactivated()
+
+    def test_class_decorator(self):
+        @factory.django.mute_signals(signals.pre_save, signals.post_save)
+        class WithSignalsDecoratedFactory(factory.django.DjangoModelFactory):
+            class Meta:
+                model = models.WithSignals
+
+        WithSignalsDecoratedFactory()
+
+        self.assertEqual(self.handlers.pre_init.call_count, 1)
+        self.assertFalse(self.handlers.pre_save.called)
+        self.assertFalse(self.handlers.post_save.called)
+
+        self.assertSignalsReactivated()
+
+    def test_class_decorator_build(self):
+        @factory.django.mute_signals(signals.pre_save, signals.post_save)
+        class WithSignalsDecoratedFactory(factory.django.DjangoModelFactory):
+            class Meta:
+                model = models.WithSignals
+
+        WithSignalsDecoratedFactory.build()
+
+        self.assertEqual(self.handlers.pre_init.call_count, 1)
+        self.assertFalse(self.handlers.pre_save.called)
+        self.assertFalse(self.handlers.post_save.called)
+
+        self.assertSignalsReactivated()
+
+    def test_function_decorator(self):
+        @factory.django.mute_signals(signals.pre_save, signals.post_save)
+        def foo():
+            WithSignalsFactory()
+
+        foo()
+
+        self.assertEqual(self.handlers.pre_init.call_count, 1)
+        self.assertFalse(self.handlers.pre_save.called)
+        self.assertFalse(self.handlers.post_save.called)
+
+        self.assertSignalsReactivated()
+
+    def test_classmethod_decorator(self):
+        class Foo(object):
+            @classmethod
+            @factory.django.mute_signals(signals.pre_save, signals.post_save)
+            def generate(cls):
+                WithSignalsFactory()
+
+        Foo.generate()
+
+        self.assertEqual(self.handlers.pre_init.call_count, 1)
+        self.assertFalse(self.handlers.pre_save.called)
+        self.assertFalse(self.handlers.post_save.called)
+
+        self.assertSignalsReactivated()
+
 if __name__ == '__main__':  # pragma: no cover
     unittest.main()