Fixed differences with upstream branch.

7 files changed, 337 insertions, 51 deletions

diff --git a/tests/cyclic/__init__.py b/tests/cyclic/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/cyclic/__init__.py
diff --git a/tests/cyclic/bar.py b/tests/cyclic/bar.py
new file mode 100644
index 0000000..fed0602
--- /dev/null
+++ b/tests/cyclic/bar.py
@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2011-2013 Raphaël Barrois
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Helper to test circular factory dependencies."""
+
+import factory
+
+class Bar(object):
+    def __init__(self, foo, y):
+        self.foo = foo
+        self.y = y
+
+
+class BarFactory(factory.Factory):
+    FACTORY_FOR = Bar
+
+    y = 13
+    foo = factory.SubFactory('cyclic.foo.FooFactory')
+
diff --git a/tests/cyclic/foo.py b/tests/cyclic/foo.py
new file mode 100644
index 0000000..7f00f12
--- /dev/null
+++ b/tests/cyclic/foo.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2011-2013 Raphaël Barrois
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Helper to test circular factory dependencies."""
+
+import factory
+
+from cyclic import bar
+
+class Foo(object):
+    def __init__(self, bar, x):
+        self.bar = bar
+        self.x = x
+
+
+class FooFactory(factory.Factory):
+    FACTORY_FOR = Foo
+
+    x = 42
+    bar = factory.SubFactory(bar.BarFactory)
diff --git a/tests/test_base.py b/tests/test_base.py
index 216711a..73e59fa 100644
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -35,19 +35,25 @@ class TestObject(object):
         self.four = four
 
 class FakeDjangoModel(object):
-    class FakeDjangoManager(object):
-        def create(self, **kwargs):
-            fake_model = FakeDjangoModel(**kwargs)
-            fake_model.id = 1
-            return fake_model
-
-    objects = FakeDjangoManager()
+    @classmethod
+    def create(cls, **kwargs):
+        instance = cls(**kwargs)
+        instance.id = 1
+        return instance
 
     def __init__(self, **kwargs):
         for name, value in kwargs.items():
             setattr(self, name, value)
             self.id = None
 
+class FakeModelFactory(base.Factory):
+    ABSTRACT_FACTORY = True
+
+    @classmethod
+    def _create(cls, target_class, *args, **kwargs):
+        return target_class.create(**kwargs)
+
+
 class TestModel(FakeDjangoModel):
     pass
 
@@ -84,6 +90,8 @@ class FactoryTestCase(unittest.TestCase):
 
     def test_lazy_attribute_non_existent_param(self):
         class TestObjectFactory(base.Factory):
+            FACTORY_FOR = TestObject
+
             one = declarations.LazyAttribute(lambda a: a.does_not_exist )
 
         self.assertRaises(AttributeError, TestObjectFactory)
@@ -91,9 +99,13 @@ class FactoryTestCase(unittest.TestCase):
     def test_inheritance_with_sequence(self):
         """Tests that sequence IDs are shared between parent and son."""
         class TestObjectFactory(base.Factory):
+            FACTORY_FOR = TestObject
+
             one = declarations.Sequence(lambda a: a)
 
         class TestSubFactory(TestObjectFactory):
+            FACTORY_FOR = TestObject
+
             pass
 
         parent = TestObjectFactory.build()
@@ -115,6 +127,8 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
         base.Factory.FACTORY_STRATEGY = base.BUILD_STRATEGY
 
         class TestModelFactory(base.Factory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         test_model = TestModelFactory()
@@ -124,7 +138,9 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
     def test_create_strategy(self):
         # Default FACTORY_STRATEGY
 
-        class TestModelFactory(base.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         test_model = TestModelFactory()
@@ -135,6 +151,8 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
         base.Factory.FACTORY_STRATEGY = base.STUB_STRATEGY
 
         class TestModelFactory(base.Factory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         test_model = TestModelFactory()
@@ -145,12 +163,16 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
         base.Factory.FACTORY_STRATEGY = 'unknown'
 
         class TestModelFactory(base.Factory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         self.assertRaises(base.Factory.UnknownStrategy, TestModelFactory)
 
     def test_stub_with_non_stub_strategy(self):
         class TestModelFactory(base.StubFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         TestModelFactory.FACTORY_STRATEGY = base.CREATE_STRATEGY
@@ -163,6 +185,8 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
     def test_change_strategy(self):
         @base.use_strategy(base.CREATE_STRATEGY)
         class TestModelFactory(base.StubFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         self.assertEqual(base.CREATE_STRATEGY, TestModelFactory.FACTORY_STRATEGY)
@@ -183,6 +207,8 @@ class FactoryCreationTestCase(unittest.TestCase):
 
     def test_inheritance_with_stub(self):
         class TestObjectFactory(base.StubFactory):
+            FACTORY_FOR = TestObject
+
             pass
 
         class TestFactory(TestObjectFactory):
@@ -224,12 +250,16 @@ class PostGenerationParsingTestCase(unittest.TestCase):
 
     def test_extraction(self):
         class TestObjectFactory(base.Factory):
+            FACTORY_FOR = TestObject
+
             foo = declarations.PostGenerationDeclaration()
 
         self.assertIn('foo', TestObjectFactory._postgen_declarations)
 
     def test_classlevel_extraction(self):
         class TestObjectFactory(base.Factory):
+            FACTORY_FOR = TestObject
+
             foo = declarations.PostGenerationDeclaration()
             foo__bar = 42
 
diff --git a/tests/test_containers.py b/tests/test_containers.py
index 7c8d829..70ed885 100644
--- a/tests/test_containers.py
+++ b/tests/test_containers.py
@@ -178,6 +178,17 @@ class DeclarationDictTestCase(unittest.TestCase):
         self.assertEqual(set(['one', 'three']), set(d))
         self.assertEqual(set([1, 3]), set(d.values()))
 
+    def test_update_with_public_ignores_factory_attributes(self):
+        """Ensure that a DeclarationDict ignores FACTORY_ keys."""
+        d = containers.DeclarationDict()
+        d.update_with_public({
+            'one': 1,
+            'FACTORY_FOR': 2,
+            'FACTORY_ARG_PARAMETERS': 3,
+        })
+        self.assertEqual(['one'], list(d))
+        self.assertEqual([1], list(d.values()))
+
 
 class AttributeBuilderTestCase(unittest.TestCase):
     def test_empty(self):
diff --git a/tests/test_using.py b/tests/test_using.py
index 497e206..821fad3 100644
--- a/tests/test_using.py
+++ b/tests/test_using.py
@@ -21,6 +21,11 @@
 """Tests using factory."""
 
 
+import functools
+import os
+import sys
+import warnings
+
 import factory
 
 from .compat import is_python2, unittest
@@ -71,7 +76,16 @@ class FakeModel(object):
             setattr(self, name, value)
             self.id = None
 
-class TestModel(FakeDjangoModel):
+
+class FakeModelFactory(factory.Factory):
+    ABSTRACT_FACTORY = True
+
+    @classmethod
+    def _create(cls, target_class, *args, **kwargs):
+        return target_class.create(**kwargs)
+
+
+class TestModel(FakeModel):
     pass
 
 
@@ -116,7 +130,7 @@ class SimpleBuildTestCase(unittest.TestCase):
         self.assertEqual(obj.foo, 'bar')
 
     def test_create_batch(self):
-        objs = factory.create_batch(FakeDjangoModel, 4, foo='bar')
+        objs = factory.create_batch(FakeModel, 4, foo='bar')
 
         self.assertEqual(4, len(objs))
         self.assertEqual(4, len(set(objs)))
@@ -142,7 +156,7 @@ class SimpleBuildTestCase(unittest.TestCase):
         self.assertFalse(hasattr(obj, 'two'))
 
     def test_stub_batch(self):
-        objs = factory.stub_batch(FakeDjangoModel, 4, foo='bar')
+        objs = factory.stub_batch(FakeModel, 4, foo='bar')
 
         self.assertEqual(4, len(objs))
         self.assertEqual(4, len(set(objs)))
@@ -152,7 +166,7 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.foo, 'bar')
 
     def test_generate_build(self):
-        obj = factory.generate(FakeDjangoModel, factory.BUILD_STRATEGY, foo='bar')
+        obj = factory.generate(FakeModel, factory.BUILD_STRATEGY, foo='bar')
         self.assertEqual(obj.id, None)
         self.assertEqual(obj.foo, 'bar')
 
@@ -168,12 +182,12 @@ class SimpleBuildTestCase(unittest.TestCase):
         self.assertEqual(obj.foo, 'bar')
 
     def test_generate_stub(self):
-        obj = factory.generate(FakeDjangoModel, factory.STUB_STRATEGY, foo='bar')
+        obj = factory.generate(FakeModel, factory.STUB_STRATEGY, foo='bar')
         self.assertFalse(hasattr(obj, 'id'))
         self.assertEqual(obj.foo, 'bar')
 
     def test_generate_batch_build(self):
-        objs = factory.generate_batch(FakeDjangoModel, factory.BUILD_STRATEGY, 20, foo='bar')
+        objs = factory.generate_batch(FakeModel, factory.BUILD_STRATEGY, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
@@ -183,7 +197,7 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.foo, 'bar')
 
     def test_generate_batch_create(self):
-        objs = factory.generate_batch(FakeDjangoModel, factory.CREATE_STRATEGY, 20, foo='bar')
+        objs = factory.generate_batch(FakeModel, factory.CREATE_STRATEGY, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
@@ -204,7 +218,7 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.foo, 'bar')
 
     def test_generate_batch_stub(self):
-        objs = factory.generate_batch(FakeDjangoModel, factory.STUB_STRATEGY, 20, foo='bar')
+        objs = factory.generate_batch(FakeModel, factory.STUB_STRATEGY, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
@@ -214,7 +228,7 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.foo, 'bar')
 
     def test_simple_generate_build(self):
-        obj = factory.simple_generate(FakeDjangoModel, False, foo='bar')
+        obj = factory.simple_generate(FakeModel, False, foo='bar')
         self.assertEqual(obj.id, None)
         self.assertEqual(obj.foo, 'bar')
 
@@ -229,7 +243,7 @@ class SimpleBuildTestCase(unittest.TestCase):
         self.assertEqual(obj.foo, 'bar')
 
     def test_simple_generate_batch_build(self):
-        objs = factory.simple_generate_batch(FakeDjangoModel, False, 20, foo='bar')
+        objs = factory.simple_generate_batch(FakeModel, False, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
@@ -239,7 +253,7 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.foo, 'bar')
 
     def test_simple_generate_batch_create(self):
-        objs = factory.simple_generate_batch(FakeDjangoModel, True, 20, foo='bar')
+        objs = factory.simple_generate_batch(FakeModel, True, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
@@ -278,6 +292,8 @@ class SimpleBuildTestCase(unittest.TestCase):
 class UsingFactoryTestCase(unittest.TestCase):
     def test_attribute(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = 'one'
 
         test_object = TestObjectFactory.build()
@@ -321,6 +337,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_sequence_custom_begin(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             @classmethod
             def _setup_next_sequence(cls):
                 return 42
@@ -402,6 +420,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_lazy_attribute(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = factory.LazyAttribute(lambda a: 'abc' )
             two = factory.LazyAttribute(lambda a: a.one + ' xyz')
 
@@ -426,6 +446,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_lazy_attribute_decorator(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             @factory.lazy_attribute
             def one(a):
                 return 'one'
@@ -438,6 +460,8 @@ class UsingFactoryTestCase(unittest.TestCase):
             n = 3
 
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = 'xx'
             two = factory.SelfAttribute('one')
             three = TmpObj()
@@ -469,6 +493,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_sequence_decorator(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             @factory.sequence
             def one(n):
                 return 'one%d' % n
@@ -478,6 +504,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_lazy_attribute_sequence_decorator(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             @factory.lazy_attribute_sequence
             def one(a, n):
                 return 'one%d' % n
@@ -516,7 +544,9 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertTrue(test_model.id)
 
     def test_create_batch(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         objs = TestModelFactory.create_batch(20, two=factory.Sequence(int))
@@ -530,7 +560,9 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertTrue(obj.id)
 
     def test_generate_build(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         test_model = TestModelFactory.generate(factory.BUILD_STRATEGY)
@@ -538,7 +570,9 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertFalse(test_model.id)
 
     def test_generate_create(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         test_model = TestModelFactory.generate(factory.CREATE_STRATEGY)
@@ -546,7 +580,9 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertTrue(test_model.id)
 
     def test_generate_stub(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         test_model = TestModelFactory.generate(factory.STUB_STRATEGY)
@@ -554,7 +590,9 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertFalse(hasattr(test_model, 'id'))
 
     def test_generate_batch_build(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         objs = TestModelFactory.generate_batch(factory.BUILD_STRATEGY, 20, two='two')
@@ -568,7 +606,9 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertFalse(obj.id)
 
     def test_generate_batch_create(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         objs = TestModelFactory.generate_batch(factory.CREATE_STRATEGY, 20, two='two')
@@ -582,7 +622,9 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertTrue(obj.id)
 
     def test_generate_batch_stub(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         objs = TestModelFactory.generate_batch(factory.STUB_STRATEGY, 20, two='two')
@@ -596,7 +638,9 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertFalse(hasattr(obj, 'id'))
 
     def test_simple_generate_build(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         test_model = TestModelFactory.simple_generate(False)
@@ -604,7 +648,9 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertFalse(test_model.id)
 
     def test_simple_generate_create(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         test_model = TestModelFactory.simple_generate(True)
@@ -612,7 +658,9 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertTrue(test_model.id)
 
     def test_simple_generate_batch_build(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         objs = TestModelFactory.simple_generate_batch(False, 20, two='two')
@@ -626,7 +674,9 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertFalse(obj.id)
 
     def test_simple_generate_batch_create(self):
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+
             one = 'one'
 
         objs = TestModelFactory.simple_generate_batch(True, 20, two='two')
@@ -641,6 +691,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_stub_batch(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = 'one'
             two = factory.LazyAttribute(lambda a: a.one + ' two')
             three = factory.Sequence(lambda n: int(n))
@@ -658,6 +710,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_inheritance(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = 'one'
             two = factory.LazyAttribute(lambda a: a.one + ' two')
 
@@ -678,6 +732,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_inheritance_with_inherited_class(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = 'one'
             two = factory.LazyAttribute(lambda a: a.one + ' two')
 
@@ -693,6 +749,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_dual_inheritance(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = 'one'
 
         class TestOtherFactory(factory.Factory):
@@ -711,6 +769,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_class_method_accessible(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             @classmethod
             def alt_create(cls, **kwargs):
                 return kwargs
@@ -719,6 +779,8 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_static_method_accessible(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             @staticmethod
             def alt_create(**kwargs):
                 return kwargs
@@ -861,11 +923,11 @@ class SubFactoryTestCase(unittest.TestCase):
         class TestModel2(FakeModel):
             pass
 
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
             FACTORY_FOR = TestModel
             one = 3
 
-        class TestModel2Factory(factory.Factory):
+        class TestModel2Factory(FakeModelFactory):
             FACTORY_FOR = TestModel2
             two = factory.SubFactory(TestModelFactory, one=1)
 
@@ -878,10 +940,10 @@ class SubFactoryTestCase(unittest.TestCase):
         class TestModel2(FakeModel):
             pass
 
-        class TestModelFactory(factory.Factory):
+        class TestModelFactory(FakeModelFactory):
             FACTORY_FOR = TestModel
 
-        class TestModel2Factory(factory.Factory):
+        class TestModel2Factory(FakeModelFactory):
             FACTORY_FOR = TestModel2
             two = factory.SubFactory(TestModelFactory,
                                           one=factory.Sequence(lambda n: 'x%dx' % n),
@@ -1073,6 +1135,78 @@ class SubFactoryTestCase(unittest.TestCase):
         self.assertEqual(outer.side_a.inner_from_a.a, outer.foo * 2)
         self.assertEqual(outer.side_a.inner_from_a.b, 4)
 
+    def test_nonstrict_container_attribute(self):
+        class TestModel2(FakeModel):
+            pass
+
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+            one = 3
+            two = factory.ContainerAttribute(lambda obj, containers: len(containers or []), strict=False)
+
+        class TestModel2Factory(FakeModelFactory):
+            FACTORY_FOR = TestModel2
+            one = 1
+            two = factory.SubFactory(TestModelFactory, one=1)
+
+        obj = TestModel2Factory.build()
+        self.assertEqual(1, obj.one)
+        self.assertEqual(1, obj.two.one)
+        self.assertEqual(1, obj.two.two)
+
+        obj = TestModelFactory()
+        self.assertEqual(3, obj.one)
+        self.assertEqual(0, obj.two)
+
+    def test_strict_container_attribute(self):
+        class TestModel2(FakeModel):
+            pass
+
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+            one = 3
+            two = factory.ContainerAttribute(lambda obj, containers: len(containers or []), strict=True)
+
+        class TestModel2Factory(FakeModelFactory):
+            FACTORY_FOR = TestModel2
+            one = 1
+            two = factory.SubFactory(TestModelFactory, one=1)
+
+        obj = TestModel2Factory.build()
+        self.assertEqual(1, obj.one)
+        self.assertEqual(1, obj.two.one)
+        self.assertEqual(1, obj.two.two)
+
+        self.assertRaises(TypeError, TestModelFactory.build)
+
+    def test_function_container_attribute(self):
+        class TestModel2(FakeModel):
+            pass
+
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
+            one = 3
+
+            @factory.container_attribute
+            def two(self, containers):
+                if containers:
+                    return len(containers)
+                return 42
+
+        class TestModel2Factory(FakeModelFactory):
+            FACTORY_FOR = TestModel2
+            one = 1
+            two = factory.SubFactory(TestModelFactory, one=1)
+
+        obj = TestModel2Factory.build()
+        self.assertEqual(1, obj.one)
+        self.assertEqual(1, obj.two.one)
+        self.assertEqual(1, obj.two.two)
+
+        obj = TestModelFactory()
+        self.assertEqual(3, obj.one)
+        self.assertEqual(42, obj.two)
+
 
 class IteratorTestCase(unittest.TestCase):
 
@@ -1115,6 +1249,8 @@ class IteratorTestCase(unittest.TestCase):
 
     def test_iterator_decorator(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             @factory.iterator
             def one():
                 for i in range(10, 50):
@@ -1257,6 +1393,8 @@ class DjangoModelFactoryTestCase(unittest.TestCase):
 class PostGenerationTestCase(unittest.TestCase):
     def test_post_generation(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = 1
 
             @factory.post_generation
@@ -1294,6 +1432,8 @@ class PostGenerationTestCase(unittest.TestCase):
 
     def test_post_generation_extraction(self):
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             one = 1
 
             @factory.post_generation
@@ -1317,10 +1457,40 @@ class PostGenerationTestCase(unittest.TestCase):
             self.assertEqual(kwargs, {'foo': 13})
 
         class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+
             bar = factory.PostGeneration(my_lambda)
 
         obj = TestObjectFactory.build(bar=42, bar__foo=13)
 
+    def test_post_generation_method_call(self):
+        calls = []
+
+        class TestObject(object):
+            def __init__(self, one=None, two=None):
+                self.one = one
+                self.two = two
+                self.extra = None
+
+            def call(self, *args, **kwargs):
+                self.extra = (args, kwargs)
+
+        class TestObjectFactory(factory.Factory):
+            FACTORY_FOR = TestObject
+            one = 3
+            two = 2
+            post_call = factory.PostGenerationMethodCall('call', one=1)
+
+        obj = TestObjectFactory.build()
+        self.assertEqual(3, obj.one)
+        self.assertEqual(2, obj.two)
+        self.assertEqual(((), {'one': 1}), obj.extra)
+
+        obj = TestObjectFactory.build(post_call__one=2, post_call__two=3)
+        self.assertEqual(3, obj.one)
+        self.assertEqual(2, obj.two)
+        self.assertEqual(((), {'one': 2, 'two': 3}), obj.extra)
+
     def test_related_factory(self):
         class TestRelatedObject(object):
             def __init__(self, obj=None, one=None, two=None):
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 787164a..b353c9d 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -25,23 +25,6 @@ from factory import utils
 
 from .compat import unittest
 
-class DecLengthCompareTestCase(unittest.TestCase):
-    def test_reciprocity(self):
-        self.assertEqual(1, utils.declength_compare('a', 'bb'))
-        self.assertEqual(-1, utils.declength_compare('aa', 'b'))
-
-    def test_not_lexical(self):
-        self.assertEqual(1, utils.declength_compare('abc', 'aaaa'))
-        self.assertEqual(-1, utils.declength_compare('aaaa', 'abc'))
-
-    def test_same_length(self):
-        self.assertEqual(-1, utils.declength_compare('abc', 'abd'))
-        self.assertEqual(1, utils.declength_compare('abe', 'abd'))
-
-    def test_equality(self):
-        self.assertEqual(0, utils.declength_compare('abc', 'abc'))
-        self.assertEqual(0, utils.declength_compare([1, 2, 3], [1, 2, 3]))
-
 
 class ExtractDictTestCase(unittest.TestCase):
     def test_empty_dict(self):
@@ -102,6 +85,7 @@ class ExtractDictTestCase(unittest.TestCase):
         self.assertIn('foo__bar', d)
         self.assertNotIn('foo__foo__bar', d)
 
+
 class MultiExtractDictTestCase(unittest.TestCase):
     def test_empty_dict(self):
         self.assertEqual({'foo': {}}, utils.multi_extract_dict(['foo'], {}))
@@ -230,3 +214,19 @@ class MultiExtractDictTestCase(unittest.TestCase):
         self.assertNotIn('foo__foo__bar', d)
         self.assertNotIn('bar__foo', d)
         self.assertNotIn('bar__bar__baz', d)
+
+
+class ImportObjectTestCase(unittest.TestCase):
+    def test_datetime(self):
+        imported = utils.import_object('datetime', 'date')
+        import datetime
+        d = datetime.date
+        self.assertEqual(d, imported)
+
+    def test_unknown_attribute(self):
+        self.assertRaises(AttributeError, utils.import_object,
+            'datetime', 'foo')
+
+    def test_invalid_module(self):
+        self.assertRaises(ImportError, utils.import_object,
+            'this-is-an-invalid-module', '__name__')