From f57a0c213ffe12325e20e69e5cc03ff27633d06c Mon Sep 17 00:00:00 2001 From: Raphaël Barrois Date: Fri, 13 May 2011 15:24:53 +0200 Subject: Trailing whitespace MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Raphaël Barrois --- tests.py | 120 +++++++++++++++++++++++++++++++-------------------------------- 1 file changed, 60 insertions(+), 60 deletions(-) diff --git a/tests.py b/tests.py index 875d053..89a9363 100644 --- a/tests.py +++ b/tests.py @@ -11,14 +11,14 @@ class TestObject(object): self.four = four class FakeDjangoModel(object): - class FakeDjangoManager(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) @@ -31,73 +31,73 @@ class FactoryTestCase(unittest.TestCase): def testAttribute(self): class TestObjectFactory(Factory): one = 'one' - + test_object = TestObjectFactory.build() - self.assertEqual(test_object.one, 'one') - + 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 @@ -106,126 +106,126 @@ class FactoryTestCase(unittest.TestCase): @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): + + def testStubWithNonStubStrategy(self): class TestModelFactory(StubFactory): one = 'one' - + TestModelFactory.default_strategy = CREATE_STRATEGY self.assertRaises(StubFactory.UnsupportedStrategy, TestModelFactory) @@ -234,21 +234,21 @@ 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 @@ -257,9 +257,9 @@ class FactoryCreationTestCase(unittest.TestCase): pass self.assertEqual(TestFactory.default_strategy, STUB_STRATEGY) - + # Errors - + def testNoAssociatedClassWithAutodiscovery(self): try: class TestFactory(Factory): @@ -267,7 +267,7 @@ class FactoryCreationTestCase(unittest.TestCase): self.fail() except Factory.AssociatedClassError as e: self.assertTrue('autodiscovery' in str(e)) - + def testNoAssociatedClassWithoutAutodiscovery(self): try: class Test(Factory): @@ -275,7 +275,7 @@ class FactoryCreationTestCase(unittest.TestCase): self.fail() except Factory.AssociatedClassError as e: self.assertTrue('autodiscovery' not in str(e)) - + def testInheritanceFromMoreThanOneFactory(self): class TestObjectFactory(StubFactory): pass -- cgit v1.2.3