Back to upstream version 1.1.5

1 files changed, 46 insertions, 328 deletions

diff --git a/tests/test_using.py b/tests/test_using.py
index 7e141eb..f4d5440 100644
--- a/tests/test_using.py
+++ b/tests/test_using.py
@@ -21,11 +21,6 @@
 """Tests using factory."""
 
 
-import functools
-import os
-import sys
-import warnings
-
 import factory
 
 from .compat import unittest
@@ -39,49 +34,24 @@ class TestObject(object):
         self.four = four
         self.five = five
 
-
-class FakeModel(object):
-    @classmethod
-    def create(cls, **kwargs):
-        instance = cls(**kwargs)
-        instance.id = 1
-        return instance
-
-    class FakeModelManager(object):
+class FakeDjangoModel(object):
+    class FakeDjangoManager(object):
         def create(self, **kwargs):
-            instance = FakeModel.create(**kwargs)
-            instance.id = 2
-            return instance
+            fake_model = FakeDjangoModel(**kwargs)
+            fake_model.id = 1
+            return fake_model
 
-    objects = FakeModelManager()
+    objects = FakeDjangoManager()
 
     def __init__(self, **kwargs):
         for name, value in kwargs.iteritems():
             setattr(self, name, value)
             self.id = None
 
-
-class FakeModelFactory(factory.Factory):
-    ABSTRACT_FACTORY = True
-
-    @classmethod
-    def _create(cls, target_class, *args, **kwargs):
-        return target_class.create(**kwargs)
-
-
-class TestModel(FakeModel):
+class TestModel(FakeDjangoModel):
     pass
 
 
-def disable_warnings(fun):
-    @functools.wraps(fun)
-    def decorated(*args, **kwargs):
-        with warnings.catch_warnings():
-            warnings.simplefilter('ignore')
-            return fun(*args, **kwargs)
-    return decorated
-
-
 class SimpleBuildTestCase(unittest.TestCase):
     """Tests the minimalist 'factory.build/create' functions."""
 
@@ -112,21 +82,19 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.three, 3)
             self.assertEqual(obj.four, None)
 
-    @disable_warnings
     def test_create(self):
-        obj = factory.create(FakeModel, foo='bar')
-        self.assertEqual(obj.id, 2)
+        obj = factory.create(FakeDjangoModel, foo='bar')
+        self.assertEqual(obj.id, 1)
         self.assertEqual(obj.foo, 'bar')
 
-    @disable_warnings
     def test_create_batch(self):
-        objs = factory.create_batch(FakeModel, 4, foo='bar')
+        objs = factory.create_batch(FakeDjangoModel, 4, foo='bar')
 
         self.assertEqual(4, len(objs))
         self.assertEqual(4, len(set(objs)))
 
         for obj in objs:
-            self.assertEqual(obj.id, 2)
+            self.assertEqual(obj.id, 1)
             self.assertEqual(obj.foo, 'bar')
 
     def test_stub(self):
@@ -135,7 +103,7 @@ class SimpleBuildTestCase(unittest.TestCase):
         self.assertFalse(hasattr(obj, 'two'))
 
     def test_stub_batch(self):
-        objs = factory.stub_batch(FakeModel, 4, foo='bar')
+        objs = factory.stub_batch(FakeDjangoModel, 4, foo='bar')
 
         self.assertEqual(4, len(objs))
         self.assertEqual(4, len(set(objs)))
@@ -145,23 +113,22 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.foo, 'bar')
 
     def test_generate_build(self):
-        obj = factory.generate(FakeModel, factory.BUILD_STRATEGY, foo='bar')
+        obj = factory.generate(FakeDjangoModel, factory.BUILD_STRATEGY, foo='bar')
         self.assertEqual(obj.id, None)
         self.assertEqual(obj.foo, 'bar')
 
-    @disable_warnings
     def test_generate_create(self):
-        obj = factory.generate(FakeModel, factory.CREATE_STRATEGY, foo='bar')
-        self.assertEqual(obj.id, 2)
+        obj = factory.generate(FakeDjangoModel, factory.CREATE_STRATEGY, foo='bar')
+        self.assertEqual(obj.id, 1)
         self.assertEqual(obj.foo, 'bar')
 
     def test_generate_stub(self):
-        obj = factory.generate(FakeModel, factory.STUB_STRATEGY, foo='bar')
+        obj = factory.generate(FakeDjangoModel, 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(FakeModel, factory.BUILD_STRATEGY, 20, foo='bar')
+        objs = factory.generate_batch(FakeDjangoModel, factory.BUILD_STRATEGY, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
@@ -170,19 +137,18 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.id, None)
             self.assertEqual(obj.foo, 'bar')
 
-    @disable_warnings
     def test_generate_batch_create(self):
-        objs = factory.generate_batch(FakeModel, factory.CREATE_STRATEGY, 20, foo='bar')
+        objs = factory.generate_batch(FakeDjangoModel, factory.CREATE_STRATEGY, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
 
         for obj in objs:
-            self.assertEqual(obj.id, 2)
+            self.assertEqual(obj.id, 1)
             self.assertEqual(obj.foo, 'bar')
 
     def test_generate_batch_stub(self):
-        objs = factory.generate_batch(FakeModel, factory.STUB_STRATEGY, 20, foo='bar')
+        objs = factory.generate_batch(FakeDjangoModel, factory.STUB_STRATEGY, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
@@ -192,18 +158,17 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.foo, 'bar')
 
     def test_simple_generate_build(self):
-        obj = factory.simple_generate(FakeModel, False, foo='bar')
+        obj = factory.simple_generate(FakeDjangoModel, False, foo='bar')
         self.assertEqual(obj.id, None)
         self.assertEqual(obj.foo, 'bar')
 
-    @disable_warnings
     def test_simple_generate_create(self):
-        obj = factory.simple_generate(FakeModel, True, foo='bar')
-        self.assertEqual(obj.id, 2)
+        obj = factory.simple_generate(FakeDjangoModel, True, foo='bar')
+        self.assertEqual(obj.id, 1)
         self.assertEqual(obj.foo, 'bar')
 
     def test_simple_generate_batch_build(self):
-        objs = factory.simple_generate_batch(FakeModel, False, 20, foo='bar')
+        objs = factory.simple_generate_batch(FakeDjangoModel, False, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
@@ -212,15 +177,14 @@ class SimpleBuildTestCase(unittest.TestCase):
             self.assertEqual(obj.id, None)
             self.assertEqual(obj.foo, 'bar')
 
-    @disable_warnings
     def test_simple_generate_batch_create(self):
-        objs = factory.simple_generate_batch(FakeModel, True, 20, foo='bar')
+        objs = factory.simple_generate_batch(FakeDjangoModel, True, 20, foo='bar')
 
         self.assertEqual(20, len(objs))
         self.assertEqual(20, len(set(objs)))
 
         for obj in objs:
-            self.assertEqual(obj.id, 2)
+            self.assertEqual(obj.id, 1)
             self.assertEqual(obj.foo, 'bar')
 
     def test_make_factory(self):
@@ -242,8 +206,6 @@ class SimpleBuildTestCase(unittest.TestCase):
 class UsingFactoryTestCase(unittest.TestCase):
     def testAttribute(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = 'one'
 
         test_object = TestObjectFactory.build()
@@ -262,8 +224,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testSequence(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.Sequence(lambda n: 'one' + n)
             two = factory.Sequence(lambda n: 'two' + n)
 
@@ -277,8 +237,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testSequenceCustomBegin(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             @classmethod
             def _setup_next_sequence(cls):
                 return 42
@@ -296,8 +254,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def test_sequence_batch(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.Sequence(lambda n: 'one' + n)
             two = factory.Sequence(lambda n: 'two' + n)
 
@@ -311,8 +267,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testLazyAttribute(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.LazyAttribute(lambda a: 'abc' )
             two = factory.LazyAttribute(lambda a: a.one + ' xyz')
 
@@ -322,8 +276,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testLazyAttributeSequence(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.LazyAttributeSequence(lambda a, n: 'abc' + n)
             two = factory.LazyAttributeSequence(lambda a, n: a.one + ' xyz' + n)
 
@@ -337,8 +289,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testLazyAttributeDecorator(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             @factory.lazy_attribute
             def one(a):
                 return 'one'
@@ -351,8 +301,6 @@ class UsingFactoryTestCase(unittest.TestCase):
             n = 3
 
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = 'xx'
             two = factory.SelfAttribute('one')
             three = TmpObj()
@@ -367,8 +315,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testSequenceDecorator(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             @factory.sequence
             def one(n):
                 return 'one' + n
@@ -378,8 +324,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testLazyAttributeSequenceDecorator(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             @factory.lazy_attribute_sequence
             def one(a, n):
                 return 'one' + n
@@ -393,8 +337,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testBuildWithParameters(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.Sequence(lambda n: 'one' + n)
             two = factory.Sequence(lambda n: 'two' + n)
 
@@ -408,9 +350,7 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertEqual(test_object1.two, 'two1')
 
     def testCreate(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         test_model = TestModelFactory.create()
@@ -418,9 +358,7 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertTrue(test_model.id)
 
     def test_create_batch(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         objs = TestModelFactory.create_batch(20, two=factory.Sequence(int))
@@ -434,9 +372,7 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertTrue(obj.id)
 
     def test_generate_build(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         test_model = TestModelFactory.generate(factory.BUILD_STRATEGY)
@@ -444,9 +380,7 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertFalse(test_model.id)
 
     def test_generate_create(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         test_model = TestModelFactory.generate(factory.CREATE_STRATEGY)
@@ -454,9 +388,7 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertTrue(test_model.id)
 
     def test_generate_stub(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         test_model = TestModelFactory.generate(factory.STUB_STRATEGY)
@@ -464,9 +396,7 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertFalse(hasattr(test_model, 'id'))
 
     def test_generate_batch_build(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         objs = TestModelFactory.generate_batch(factory.BUILD_STRATEGY, 20, two='two')
@@ -480,9 +410,7 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertFalse(obj.id)
 
     def test_generate_batch_create(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         objs = TestModelFactory.generate_batch(factory.CREATE_STRATEGY, 20, two='two')
@@ -496,9 +424,7 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertTrue(obj.id)
 
     def test_generate_batch_stub(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         objs = TestModelFactory.generate_batch(factory.STUB_STRATEGY, 20, two='two')
@@ -512,9 +438,7 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertFalse(hasattr(obj, 'id'))
 
     def test_simple_generate_build(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         test_model = TestModelFactory.simple_generate(False)
@@ -522,9 +446,7 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertFalse(test_model.id)
 
     def test_simple_generate_create(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         test_model = TestModelFactory.simple_generate(True)
@@ -532,9 +454,7 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertTrue(test_model.id)
 
     def test_simple_generate_batch_build(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         objs = TestModelFactory.simple_generate_batch(False, 20, two='two')
@@ -548,9 +468,7 @@ class UsingFactoryTestCase(unittest.TestCase):
             self.assertFalse(obj.id)
 
     def test_simple_generate_batch_create(self):
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
-
+        class TestModelFactory(factory.Factory):
             one = 'one'
 
         objs = TestModelFactory.simple_generate_batch(True, 20, two='two')
@@ -565,8 +483,6 @@ 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))
@@ -584,8 +500,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testInheritance(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = 'one'
             two = factory.LazyAttribute(lambda a: a.one + ' two')
 
@@ -606,8 +520,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testInheritanceWithInheritedClass(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = 'one'
             two = factory.LazyAttribute(lambda a: a.one + ' two')
 
@@ -623,8 +535,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testDualInheritance(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = 'one'
 
         class TestOtherFactory(factory.Factory):
@@ -641,13 +551,12 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertEqual('three', obj.three)
         self.assertEqual('four', obj.four)
 
-    @disable_warnings
     def testSetCreationFunction(self):
         def creation_function(class_to_create, **kwargs):
             return "This doesn't even return an instance of {0}".format(class_to_create.__name__)
 
-        class TestModelFactory(FakeModelFactory):
-            FACTORY_FOR = TestModel
+        class TestModelFactory(factory.Factory):
+            pass
 
         TestModelFactory.set_creation_function(creation_function)
 
@@ -656,8 +565,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testClassMethodAccessible(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             @classmethod
             def alt_create(cls, **kwargs):
                 return kwargs
@@ -666,8 +573,6 @@ class UsingFactoryTestCase(unittest.TestCase):
 
     def testStaticMethodAccessible(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             @staticmethod
             def alt_create(**kwargs):
                 return kwargs
@@ -675,65 +580,16 @@ class UsingFactoryTestCase(unittest.TestCase):
         self.assertEqual(TestObjectFactory.alt_create(foo=1), {"foo": 1})
 
 
-class NonKwargParametersTestCase(unittest.TestCase):
-    def test_build(self):
-        class TestObject(object):
-            def __init__(self, *args, **kwargs):
-                self.args = args
-                self.kwargs = kwargs
-
-        class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-            FACTORY_ARG_PARAMETERS = ('one', 'two',)
-
-            one = 1
-            two = 2
-            three = 3
-
-        obj = TestObjectFactory.build()
-        self.assertEqual((1, 2), obj.args)
-        self.assertEqual({'three': 3}, obj.kwargs)
-
-    def test_create(self):
-        class TestObject(object):
-            def __init__(self, *args, **kwargs):
-                self.args = None
-                self.kwargs = None
-
-            @classmethod
-            def create(cls, *args, **kwargs):
-                inst = cls()
-                inst.args = args
-                inst.kwargs = kwargs
-                return inst
-
-        class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-            FACTORY_ARG_PARAMETERS = ('one', 'two')
-
-            one = 1
-            two = 2
-            three = 3
-
-            @classmethod
-            def _create(cls, target_class, *args, **kwargs):
-                return target_class.create(*args, **kwargs)
-
-        obj = TestObjectFactory.create()
-        self.assertEqual((1, 2), obj.args)
-        self.assertEqual({'three': 3}, obj.kwargs)
-
-
 class SubFactoryTestCase(unittest.TestCase):
     def testSubFactory(self):
-        class TestModel2(FakeModel):
+        class TestModel2(FakeDjangoModel):
             pass
 
-        class TestModelFactory(FakeModelFactory):
+        class TestModelFactory(factory.Factory):
             FACTORY_FOR = TestModel
             one = 3
 
-        class TestModel2Factory(FakeModelFactory):
+        class TestModel2Factory(factory.Factory):
             FACTORY_FOR = TestModel2
             two = factory.SubFactory(TestModelFactory, one=1)
 
@@ -743,13 +599,13 @@ class SubFactoryTestCase(unittest.TestCase):
         self.assertEqual(1, test_model.two.id)
 
     def testSubFactoryWithLazyFields(self):
-        class TestModel2(FakeModel):
+        class TestModel2(FakeDjangoModel):
             pass
 
-        class TestModelFactory(FakeModelFactory):
+        class TestModelFactory(factory.Factory):
             FACTORY_FOR = TestModel
 
-        class TestModel2Factory(FakeModelFactory):
+        class TestModel2Factory(factory.Factory):
             FACTORY_FOR = TestModel2
             two = factory.SubFactory(TestModelFactory,
                                           one=factory.Sequence(lambda n: 'x%sx' % n),
@@ -941,85 +797,11 @@ 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):
 
     def test_iterator(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.Iterator(xrange(10, 30))
 
         objs = TestObjectFactory.build_batch(20)
@@ -1029,8 +811,6 @@ class IteratorTestCase(unittest.TestCase):
 
     def test_infinite_iterator(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.InfiniteIterator(xrange(5))
 
         objs = TestObjectFactory.build_batch(20)
@@ -1040,8 +820,6 @@ class IteratorTestCase(unittest.TestCase):
 
     def test_infinite_iterator_list_comprehension(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.InfiniteIterator([j * 3 for j in xrange(5)])
 
         # Scope bleeding: j will end up in TestObjectFactory's scope.
@@ -1050,8 +828,6 @@ class IteratorTestCase(unittest.TestCase):
 
     def test_infinite_iterator_list_comprehension_protected(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = factory.InfiniteIterator([_j * 3 for _j in xrange(5)])
 
         # Scope bleeding : _j will end up in TestObjectFactory's scope.
@@ -1063,8 +839,6 @@ class IteratorTestCase(unittest.TestCase):
 
     def test_iterator_decorator(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             @factory.iterator
             def one():
                 for i in xrange(10, 50):
@@ -1077,8 +851,6 @@ class IteratorTestCase(unittest.TestCase):
 
     def test_infinite_iterator_decorator(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             @factory.infinite_iterator
             def one():
                 for i in xrange(5):
@@ -1093,8 +865,6 @@ class IteratorTestCase(unittest.TestCase):
 class PostGenerationTestCase(unittest.TestCase):
     def test_post_generation(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = 1
 
             @factory.post_generation()
@@ -1111,8 +881,6 @@ class PostGenerationTestCase(unittest.TestCase):
 
     def test_post_generation_extraction(self):
         class TestObjectFactory(factory.Factory):
-            FACTORY_FOR = TestObject
-
             one = 1
 
             @factory.post_generation()
@@ -1136,40 +904,10 @@ 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):
@@ -1215,25 +953,5 @@ class PostGenerationTestCase(unittest.TestCase):
         self.assertEqual(obj, obj.related.three)
 
 
-class CircularTestCase(unittest.TestCase):
-    def test_example(self):
-        sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-
-        from cyclic import foo
-        f = foo.FooFactory.build(bar__foo=None)
-        self.assertEqual(42, f.x)
-        self.assertEqual(13, f.bar.y)
-        self.assertIsNone(f.bar.foo)
-
-        from cyclic import bar
-        b = bar.BarFactory.build(foo__bar__foo__bar=None)
-        self.assertEqual(13, b.y)
-        self.assertEqual(42, b.foo.x)
-        self.assertEqual(13, b.foo.bar.y)
-        self.assertEqual(42, b.foo.bar.foo.x)
-        self.assertIsNone(b.foo.bar.foo.bar)
-
-
-
 if __name__ == '__main__':
     unittest.main()