summaryrefslogtreecommitdiff
path: root/factory/test_base.py
diff options
context:
space:
mode:
Diffstat (limited to 'factory/test_base.py')
-rw-r--r--factory/test_base.py328
1 files changed, 328 insertions, 0 deletions
diff --git a/factory/test_base.py b/factory/test_base.py
new file mode 100644
index 0000000..ee0bc3c
--- /dev/null
+++ b/factory/test_base.py
@@ -0,0 +1,328 @@
+# Copyright (c) 2010 Mark Sandstrom
+#
+# 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.
+
+import unittest
+
+class TestObject(object):
+ def __init__(self, one=None, two=None, three=None, four=None):
+ self.one = one
+ self.two = two
+ self.three = three
+ 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()
+
+ def __init__(self, **kwargs):
+ for name, value in kwargs.iteritems():
+ setattr(self, name, value)
+ self.id = None
+
+class TestModel(FakeDjangoModel):
+ pass
+
+class FactoryTestCase(unittest.TestCase):
+ def testAttribute(self):
+ class TestObjectFactory(Factory):
+ one = 'one'
+
+ test_object = TestObjectFactory.build()
+ self.assertEqual(test_object.one, 'one')
+
+ def testSequence(self):
+ class TestObjectFactory(Factory):
+ one = Sequence(lambda n: 'one' + n)
+ two = Sequence(lambda n: 'two' + n)
+
+ test_object0 = TestObjectFactory.build()
+ self.assertEqual(test_object0.one, 'one0')
+ self.assertEqual(test_object0.two, 'two0')
+
+ test_object1 = TestObjectFactory.build()
+ self.assertEqual(test_object1.one, 'one1')
+ self.assertEqual(test_object1.two, 'two1')
+
+ def testLazyAttribute(self):
+ class TestObjectFactory(Factory):
+ one = LazyAttribute(lambda a: 'abc' )
+ two = LazyAttribute(lambda a: a.one + ' xyz')
+
+ test_object = TestObjectFactory.build()
+ self.assertEqual(test_object.one, 'abc')
+ self.assertEqual(test_object.two, 'abc xyz')
+
+ def testLazyAttributeNonExistentParam(self):
+ class TestObjectFactory(Factory):
+ one = LazyAttribute(lambda a: a.does_not_exist )
+
+ try:
+ TestObjectFactory()
+ self.fail()
+ except AttributeError as e:
+ self.assertTrue('does not exist' in str(e))
+
+ def testLazyAttributeSequence(self):
+ class TestObjectFactory(Factory):
+ one = LazyAttributeSequence(lambda a, n: 'abc' + n)
+ two = LazyAttributeSequence(lambda a, n: a.one + ' xyz' + n)
+
+ test_object0 = TestObjectFactory.build()
+ self.assertEqual(test_object0.one, 'abc0')
+ self.assertEqual(test_object0.two, 'abc0 xyz0')
+
+ test_object1 = TestObjectFactory.build()
+ self.assertEqual(test_object1.one, 'abc1')
+ self.assertEqual(test_object1.two, 'abc1 xyz1')
+
+ def testLazyAttributeDecorator(self):
+ class TestObjectFactory(Factory):
+ @lazy_attribute
+ def one(a):
+ return 'one'
+
+ test_object = TestObjectFactory.build()
+ self.assertEqual(test_object.one, 'one')
+
+ def testSequenceDecorator(self):
+ class TestObjectFactory(Factory):
+ @sequence
+ def one(n):
+ return 'one' + n
+
+ test_object = TestObjectFactory.build()
+ self.assertEqual(test_object.one, 'one0')
+
+ def testLazyAttributeSequenceDecorator(self):
+ class TestObjectFactory(Factory):
+ @lazy_attribute_sequence
+ def one(a, n):
+ return 'one' + n
+ @lazy_attribute_sequence
+ def two(a, n):
+ return a.one + ' two' + n
+
+ test_object = TestObjectFactory.build()
+ self.assertEqual(test_object.one, 'one0')
+ self.assertEqual(test_object.two, 'one0 two0')
+
+ def testBuildWithParameters(self):
+ class TestObjectFactory(Factory):
+ one = Sequence(lambda n: 'one' + n)
+ two = Sequence(lambda n: 'two' + n)
+
+ test_object0 = TestObjectFactory.build(three='three')
+ self.assertEqual(test_object0.one, 'one0')
+ self.assertEqual(test_object0.two, 'two0')
+ self.assertEqual(test_object0.three, 'three')
+
+ test_object1 = TestObjectFactory.build(one='other')
+ self.assertEqual(test_object1.one, 'other')
+ self.assertEqual(test_object1.two, 'two1')
+
+ def testCreate(self):
+ class TestModelFactory(Factory):
+ one = 'one'
+
+ test_model = TestModelFactory.create()
+ self.assertEqual(test_model.one, 'one')
+ self.assertTrue(test_model.id)
+
+ def testInheritance(self):
+ class TestObjectFactory(Factory):
+ one = 'one'
+ two = LazyAttribute(lambda a: a.one + ' two')
+
+ class TestObjectFactory2(TestObjectFactory):
+ FACTORY_FOR = TestObject
+
+ three = 'three'
+ four = LazyAttribute(lambda a: a.three + ' four')
+
+ test_object = TestObjectFactory2.build()
+ self.assertEqual(test_object.one, 'one')
+ self.assertEqual(test_object.two, 'one two')
+ self.assertEqual(test_object.three, 'three')
+ self.assertEqual(test_object.four, 'three four')
+
+ def testInheritanceWithInheritedClass(self):
+ class TestObjectFactory(Factory):
+ one = 'one'
+ two = LazyAttribute(lambda a: a.one + ' two')
+
+ class TestFactory(TestObjectFactory):
+ three = 'three'
+ four = LazyAttribute(lambda a: a.three + ' four')
+
+ test_object = TestFactory.build()
+ self.assertEqual(test_object.one, 'one')
+ self.assertEqual(test_object.two, 'one two')
+ self.assertEqual(test_object.three, 'three')
+ self.assertEqual(test_object.four, 'three four')
+
+ 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(Factory):
+ pass
+
+ TestModelFactory.set_creation_function(creation_function)
+
+ test_object = TestModelFactory.create()
+ self.assertEqual(test_object, "This doesn't even return an instance of TestModel")
+
+class FactoryDefaultStrategyTestCase(unittest.TestCase):
+ def setUp(self):
+ self.default_strategy = Factory.default_strategy
+
+ def tearDown(self):
+ Factory.default_strategy = self.default_strategy
+
+ def testBuildStrategy(self):
+ Factory.default_strategy = BUILD_STRATEGY
+
+ class TestModelFactory(Factory):
+ one = 'one'
+
+ test_model = TestModelFactory()
+ self.assertEqual(test_model.one, 'one')
+ self.assertFalse(test_model.id)
+
+ def testCreateStrategy(self):
+ # Default default_strategy
+
+ class TestModelFactory(Factory):
+ one = 'one'
+
+ test_model = TestModelFactory()
+ self.assertEqual(test_model.one, 'one')
+ self.assertTrue(test_model.id)
+
+ def testStubStrategy(self):
+ Factory.default_strategy = STUB_STRATEGY
+
+ class TestModelFactory(Factory):
+ one = 'one'
+
+ test_model = TestModelFactory()
+ self.assertEqual(test_model.one, 'one')
+ self.assertFalse(hasattr(test_model, 'id')) # We should have a plain old object
+
+ def testUnknownStrategy(self):
+ Factory.default_strategy = 'unknown'
+
+ class TestModelFactory(Factory):
+ one = 'one'
+
+ self.assertRaises(Factory.UnknownStrategy, TestModelFactory)
+
+ def testStubWithNonStubStrategy(self):
+ class TestModelFactory(StubFactory):
+ one = 'one'
+
+ TestModelFactory.default_strategy = CREATE_STRATEGY
+
+ self.assertRaises(StubFactory.UnsupportedStrategy, TestModelFactory)
+
+class FactoryCreationTestCase(unittest.TestCase):
+ def testFactoryFor(self):
+ class TestFactory(Factory):
+ FACTORY_FOR = TestObject
+
+ self.assertTrue(isinstance(TestFactory.build(), TestObject))
+
+ def testAutomaticAssociatedClassDiscovery(self):
+ class TestObjectFactory(Factory):
+ pass
+
+ self.assertTrue(isinstance(TestObjectFactory.build(), TestObject))
+
+ def testStub(self):
+ class TestFactory(StubFactory):
+ pass
+
+ self.assertEqual(TestFactory.default_strategy, STUB_STRATEGY)
+
+ def testInheritanceWithStub(self):
+ class TestObjectFactory(StubFactory):
+ pass
+
+ class TestFactory(TestObjectFactory):
+ pass
+
+ self.assertEqual(TestFactory.default_strategy, STUB_STRATEGY)
+
+ def testCustomCreation(self):
+ class TestModelFactory(Factory):
+ @classmethod
+ def _prepare(cls, create, **kwargs):
+ kwargs['four'] = 4
+ return super(TestModelFactory, cls)._prepare(create, **kwargs)
+
+ b = TestModelFactory.build(one=1)
+ self.assertEqual(1, b.one)
+ self.assertEqual(4, b.four)
+ self.assertEqual(None, b.id)
+
+ c = TestModelFactory(one=1)
+ self.assertEqual(1, c.one)
+ self.assertEqual(4, c.four)
+ self.assertEqual(1, c.id)
+
+ # Errors
+
+ def testNoAssociatedClassWithAutodiscovery(self):
+ try:
+ class TestFactory(Factory):
+ pass
+ self.fail()
+ except Factory.AssociatedClassError as e:
+ self.assertTrue('autodiscovery' in str(e))
+
+ def testNoAssociatedClassWithoutAutodiscovery(self):
+ try:
+ class Test(Factory):
+ pass
+ self.fail()
+ except Factory.AssociatedClassError as e:
+ self.assertTrue('autodiscovery' not in str(e))
+
+ def testInheritanceFromMoreThanOneFactory(self):
+ class TestObjectFactory(StubFactory):
+ pass
+
+ class TestModelFactory(TestObjectFactory):
+ pass
+
+ try:
+ class TestFactory(TestObjectFactory, TestModelFactory):
+ pass
+ self.fail()
+ except RuntimeError as e:
+ self.assertTrue('one Factory' in str(e))
+
+if __name__ == '__main__':
+ unittest.main()