Merge tag '2.0.2' into debian/unstable

Release of factory_boy 2.0.2

Conflicts:
	docs/changelog.rst
	docs/index.rst
	docs/subfactory.rst
	tests/cyclic/bar.py
	tests/cyclic/foo.py

1 files changed, 49 insertions, 58 deletions

diff --git a/tests/test_base.py b/tests/test_base.py
index 7575ee2..216711a 100644
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 # Copyright (c) 2010 Mark Sandstrom
-# Copyright (c) 2011 Raphaël Barrois
+# 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
@@ -44,7 +44,7 @@ class FakeDjangoModel(object):
     objects = FakeDjangoManager()
 
     def __init__(self, **kwargs):
-        for name, value in kwargs.iteritems():
+        for name, value in kwargs.items():
             setattr(self, name, value)
             self.id = None
 
@@ -53,25 +53,42 @@ class TestModel(FakeDjangoModel):
 
 
 class SafetyTestCase(unittest.TestCase):
-    def testBaseFactory(self):
-        self.assertRaises(RuntimeError, base.BaseFactory)
+    def test_base_factory(self):
+        self.assertRaises(base.FactoryError, base.BaseFactory)
+
+
+class AbstractFactoryTestCase(unittest.TestCase):
+    def test_factory_for_optional(self):
+        """Ensure that FACTORY_FOR is optional for ABSTRACT_FACTORY."""
+        class TestObjectFactory(base.Factory):
+            ABSTRACT_FACTORY = True
+
+        # Passed
 
 
 class FactoryTestCase(unittest.TestCase):
-    def testDisplay(self):
+    def test_factory_for(self):
+        class TestObjectFactory(base.Factory):
+            FACTORY_FOR = TestObject
+
+        self.assertEqual(TestObject, TestObjectFactory.FACTORY_FOR)
+        obj = TestObjectFactory.build()
+        self.assertFalse(hasattr(obj, 'FACTORY_FOR'))
+
+    def test_display(self):
         class TestObjectFactory(base.Factory):
             FACTORY_FOR = FakeDjangoModel
 
         self.assertIn('TestObjectFactory', str(TestObjectFactory))
         self.assertIn('FakeDjangoModel', str(TestObjectFactory))
 
-    def testLazyAttributeNonExistentParam(self):
+    def test_lazy_attribute_non_existent_param(self):
         class TestObjectFactory(base.Factory):
             one = declarations.LazyAttribute(lambda a: a.does_not_exist )
 
         self.assertRaises(AttributeError, TestObjectFactory)
 
-    def testInheritanceWithSequence(self):
+    def test_inheritance_with_sequence(self):
         """Tests that sequence IDs are shared between parent and son."""
         class TestObjectFactory(base.Factory):
             one = declarations.Sequence(lambda a: a)
@@ -86,15 +103,16 @@ class FactoryTestCase(unittest.TestCase):
         ones = set([x.one for x in (parent, alt_parent, sub, alt_sub)])
         self.assertEqual(4, len(ones))
 
+
 class FactoryDefaultStrategyTestCase(unittest.TestCase):
     def setUp(self):
-        self.default_strategy = base.Factory.default_strategy
+        self.default_strategy = base.Factory.FACTORY_STRATEGY
 
     def tearDown(self):
-        base.Factory.default_strategy = self.default_strategy
+        base.Factory.FACTORY_STRATEGY = self.default_strategy
 
-    def testBuildStrategy(self):
-        base.Factory.default_strategy = base.BUILD_STRATEGY
+    def test_build_strategy(self):
+        base.Factory.FACTORY_STRATEGY = base.BUILD_STRATEGY
 
         class TestModelFactory(base.Factory):
             one = 'one'
@@ -103,8 +121,8 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
         self.assertEqual(test_model.one, 'one')
         self.assertFalse(test_model.id)
 
-    def testCreateStrategy(self):
-        # Default default_strategy
+    def test_create_strategy(self):
+        # Default FACTORY_STRATEGY
 
         class TestModelFactory(base.Factory):
             one = 'one'
@@ -113,8 +131,8 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
         self.assertEqual(test_model.one, 'one')
         self.assertTrue(test_model.id)
 
-    def testStubStrategy(self):
-        base.Factory.default_strategy = base.STUB_STRATEGY
+    def test_stub_strategy(self):
+        base.Factory.FACTORY_STRATEGY = base.STUB_STRATEGY
 
         class TestModelFactory(base.Factory):
             one = 'one'
@@ -123,23 +141,23 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
         self.assertEqual(test_model.one, 'one')
         self.assertFalse(hasattr(test_model, 'id'))  # We should have a plain old object
 
-    def testUnknownStrategy(self):
-        base.Factory.default_strategy = 'unknown'
+    def test_unknown_strategy(self):
+        base.Factory.FACTORY_STRATEGY = 'unknown'
 
         class TestModelFactory(base.Factory):
             one = 'one'
 
         self.assertRaises(base.Factory.UnknownStrategy, TestModelFactory)
 
-    def testStubWithNonStubStrategy(self):
+    def test_stub_with_non_stub_strategy(self):
         class TestModelFactory(base.StubFactory):
             one = 'one'
 
-        TestModelFactory.default_strategy = base.CREATE_STRATEGY
+        TestModelFactory.FACTORY_STRATEGY = base.CREATE_STRATEGY
 
         self.assertRaises(base.StubFactory.UnsupportedStrategy, TestModelFactory)
 
-        TestModelFactory.default_strategy = base.BUILD_STRATEGY
+        TestModelFactory.FACTORY_STRATEGY = base.BUILD_STRATEGY
         self.assertRaises(base.StubFactory.UnsupportedStrategy, TestModelFactory)
 
     def test_change_strategy(self):
@@ -147,54 +165,35 @@ class FactoryDefaultStrategyTestCase(unittest.TestCase):
         class TestModelFactory(base.StubFactory):
             one = 'one'
 
-        self.assertEqual(base.CREATE_STRATEGY, TestModelFactory.default_strategy)
+        self.assertEqual(base.CREATE_STRATEGY, TestModelFactory.FACTORY_STRATEGY)
 
 
 class FactoryCreationTestCase(unittest.TestCase):
-    def testFactoryFor(self):
+    def test_factory_for(self):
         class TestFactory(base.Factory):
             FACTORY_FOR = TestObject
 
         self.assertTrue(isinstance(TestFactory.build(), TestObject))
 
-    def testAutomaticAssociatedClassDiscovery(self):
-        class TestObjectFactory(base.Factory):
-            pass
-
-        self.assertTrue(isinstance(TestObjectFactory.build(), TestObject))
-
-    def testDeprecationWarning(self):
-        """Make sure the 'auto-discovery' deprecation warning is issued."""
-
-        with warnings.catch_warnings(record=True) as w:
-            # Clear the warning registry.
-            if hasattr(base, '__warningregistry__'):
-                base.__warningregistry__.clear()
-
-            warnings.simplefilter('always')
-            class TestObjectFactory(base.Factory):
-                pass
-
-            self.assertEqual(1, len(w))
-            self.assertIn('deprecated', str(w[0].message))
-
-    def testStub(self):
+    def test_stub(self):
         class TestFactory(base.StubFactory):
             pass
 
-        self.assertEqual(TestFactory.default_strategy, base.STUB_STRATEGY)
+        self.assertEqual(TestFactory.FACTORY_STRATEGY, base.STUB_STRATEGY)
 
-    def testInheritanceWithStub(self):
+    def test_inheritance_with_stub(self):
         class TestObjectFactory(base.StubFactory):
             pass
 
         class TestFactory(TestObjectFactory):
             pass
 
-        self.assertEqual(TestFactory.default_strategy, base.STUB_STRATEGY)
+        self.assertEqual(TestFactory.FACTORY_STRATEGY, base.STUB_STRATEGY)
+
+    def test_custom_creation(self):
+        class TestModelFactory(FakeModelFactory):
+            FACTORY_FOR = TestModel
 
-    def testCustomCreation(self):
-        class TestModelFactory(base.Factory):
             @classmethod
             def _prepare(cls, create, **kwargs):
                 kwargs['four'] = 4
@@ -212,15 +211,7 @@ class FactoryCreationTestCase(unittest.TestCase):
 
     # Errors
 
-    def testNoAssociatedClassWithAutodiscovery(self):
-        try:
-            class TestFactory(base.Factory):
-                pass
-            self.fail()
-        except base.Factory.AssociatedClassError as e:
-            self.assertTrue('autodiscovery' in str(e))
-
-    def testNoAssociatedClassWithoutAutodiscovery(self):
+    def test_no_associated_class(self):
         try:
             class Test(base.Factory):
                 pass