Update DeclarativeCatalog and Override tests

tests/test_catalogs.py

@@ -25,117 +25,6 @@ class CatalogC(CatalogB):
     p32 = di.Provider()
 
 
-class CatalogsInheritanceTests(unittest.TestCase):
-    """Catalogs inheritance tests."""
-
-    def test_cls_providers(self):
-        """Test `di.DeclarativeCatalog.cls_providers` contents."""
-        self.assertDictEqual(CatalogA.cls_providers,
-                             dict(p11=CatalogA.p11,
-                                  p12=CatalogA.p12))
-        self.assertDictEqual(CatalogB.cls_providers,
-                             dict(p21=CatalogB.p21,
-                                  p22=CatalogB.p22))
-        self.assertDictEqual(CatalogC.cls_providers,
-                             dict(p31=CatalogC.p31,
-                                  p32=CatalogC.p32))
-
-    def test_inherited_providers(self):
-        """Test `di.DeclarativeCatalog.inherited_providers` contents."""
-        self.assertDictEqual(CatalogA.inherited_providers, dict())
-        self.assertDictEqual(CatalogB.inherited_providers,
-                             dict(p11=CatalogA.p11,
-                                  p12=CatalogA.p12))
-        self.assertDictEqual(CatalogC.inherited_providers,
-                             dict(p11=CatalogA.p11,
-                                  p12=CatalogA.p12,
-                                  p21=CatalogB.p21,
-                                  p22=CatalogB.p22))
-
-    def test_providers(self):
-        """Test `di.DeclarativeCatalog.inherited_providers` contents."""
-        self.assertDictEqual(CatalogA.providers,
-                             dict(p11=CatalogA.p11,
-                                  p12=CatalogA.p12))
-        self.assertDictEqual(CatalogB.providers,
-                             dict(p11=CatalogA.p11,
-                                  p12=CatalogA.p12,
-                                  p21=CatalogB.p21,
-                                  p22=CatalogB.p22))
-        self.assertDictEqual(CatalogC.providers,
-                             dict(p11=CatalogA.p11,
-                                  p12=CatalogA.p12,
-                                  p21=CatalogB.p21,
-                                  p22=CatalogB.p22,
-                                  p31=CatalogC.p31,
-                                  p32=CatalogC.p32))
-
-
-class CatalogProvidersBindingTests(unittest.TestCase):
-    """Catalog providers binding test cases."""
-
-    def test_provider_is_bound(self):
-        """Test that providers are bound to the catalogs."""
-        self.assertTrue(CatalogA.is_provider_bound(CatalogA.p11))
-        self.assertEquals(CatalogA.get_provider_bind_name(CatalogA.p11), 'p11')
-
-        self.assertTrue(CatalogA.is_provider_bound(CatalogA.p12))
-        self.assertEquals(CatalogA.get_provider_bind_name(CatalogA.p12), 'p12')
-
-    def test_provider_binding_to_different_catalogs(self):
-        """Test that provider could be bound to different catalogs."""
-        p11 = CatalogA.p11
-        p12 = CatalogA.p12
-
-        class CatalogD(di.DeclarativeCatalog):
-            """Test catalog."""
-
-            pd1 = p11
-            pd2 = p12
-
-        class CatalogE(di.DeclarativeCatalog):
-            """Test catalog."""
-
-            pe1 = p11
-            pe2 = p12
-
-        self.assertTrue(CatalogA.is_provider_bound(p11))
-        self.assertTrue(CatalogD.is_provider_bound(p11))
-        self.assertTrue(CatalogE.is_provider_bound(p11))
-        self.assertEquals(CatalogA.get_provider_bind_name(p11), 'p11')
-        self.assertEquals(CatalogD.get_provider_bind_name(p11), 'pd1')
-        self.assertEquals(CatalogE.get_provider_bind_name(p11), 'pe1')
-
-        self.assertTrue(CatalogA.is_provider_bound(p12))
-        self.assertTrue(CatalogD.is_provider_bound(p12))
-        self.assertTrue(CatalogE.is_provider_bound(p12))
-        self.assertEquals(CatalogA.get_provider_bind_name(p12), 'p12')
-        self.assertEquals(CatalogD.get_provider_bind_name(p12), 'pd2')
-        self.assertEquals(CatalogE.get_provider_bind_name(p12), 'pe2')
-
-    def test_provider_rebinding_to_the_same_catalog(self):
-        """Test provider rebinding to the same catalog."""
-        with self.assertRaises(di.Error):
-            class TestCatalog(di.DeclarativeCatalog):
-                """Test catalog."""
-
-                p1 = di.Provider()
-                p2 = p1
-
-    def test_provider_rebinding_to_the_same_catalogs_hierarchy(self):
-        """Test provider rebinding to the same catalogs hierarchy."""
-        class TestCatalog1(di.DeclarativeCatalog):
-            """Test catalog."""
-
-            p1 = di.Provider()
-
-        with self.assertRaises(di.Error):
-            class TestCatalog2(TestCatalog1):
-                """Test catalog."""
-
-                p2 = TestCatalog1.p1
-
-
 class CatalogBundleTests(unittest.TestCase):
     """Catalog bundle test cases."""
 
@@ -223,8 +112,111 @@ class CatalogBundleTests(unittest.TestCase):
         self.assertRaises(di.Error, CatalogC.is_bundle_owner, object())
 
 
-class CatalogTests(unittest.TestCase):
-    """Catalog test cases."""
+class DeclarativeCatalogTests(unittest.TestCase):
+    """Declarative catalog tests."""
+
+    def test_cls_providers(self):
+        """Test `di.DeclarativeCatalog.cls_providers` contents."""
+        self.assertDictEqual(CatalogA.cls_providers,
+                             dict(p11=CatalogA.p11,
+                                  p12=CatalogA.p12))
+        self.assertDictEqual(CatalogB.cls_providers,
+                             dict(p21=CatalogB.p21,
+                                  p22=CatalogB.p22))
+        self.assertDictEqual(CatalogC.cls_providers,
+                             dict(p31=CatalogC.p31,
+                                  p32=CatalogC.p32))
+
+    def test_inherited_providers(self):
+        """Test `di.DeclarativeCatalog.inherited_providers` contents."""
+        self.assertDictEqual(CatalogA.inherited_providers, dict())
+        self.assertDictEqual(CatalogB.inherited_providers,
+                             dict(p11=CatalogA.p11,
+                                  p12=CatalogA.p12))
+        self.assertDictEqual(CatalogC.inherited_providers,
+                             dict(p11=CatalogA.p11,
+                                  p12=CatalogA.p12,
+                                  p21=CatalogB.p21,
+                                  p22=CatalogB.p22))
+
+    def test_providers(self):
+        """Test `di.DeclarativeCatalog.inherited_providers` contents."""
+        self.assertDictEqual(CatalogA.providers,
+                             dict(p11=CatalogA.p11,
+                                  p12=CatalogA.p12))
+        self.assertDictEqual(CatalogB.providers,
+                             dict(p11=CatalogA.p11,
+                                  p12=CatalogA.p12,
+                                  p21=CatalogB.p21,
+                                  p22=CatalogB.p22))
+        self.assertDictEqual(CatalogC.providers,
+                             dict(p11=CatalogA.p11,
+                                  p12=CatalogA.p12,
+                                  p21=CatalogB.p21,
+                                  p22=CatalogB.p22,
+                                  p31=CatalogC.p31,
+                                  p32=CatalogC.p32))
+
+    def test_provider_is_bound(self):
+        """Test that providers are bound to the catalogs."""
+        self.assertTrue(CatalogA.is_provider_bound(CatalogA.p11))
+        self.assertEquals(CatalogA.get_provider_bind_name(CatalogA.p11), 'p11')
+
+        self.assertTrue(CatalogA.is_provider_bound(CatalogA.p12))
+        self.assertEquals(CatalogA.get_provider_bind_name(CatalogA.p12), 'p12')
+
+    def test_provider_binding_to_different_catalogs(self):
+        """Test that provider could be bound to different catalogs."""
+        p11 = CatalogA.p11
+        p12 = CatalogA.p12
+
+        class CatalogD(di.DeclarativeCatalog):
+            """Test catalog."""
+
+            pd1 = p11
+            pd2 = p12
+
+        class CatalogE(di.DeclarativeCatalog):
+            """Test catalog."""
+
+            pe1 = p11
+            pe2 = p12
+
+        self.assertTrue(CatalogA.is_provider_bound(p11))
+        self.assertTrue(CatalogD.is_provider_bound(p11))
+        self.assertTrue(CatalogE.is_provider_bound(p11))
+        self.assertEquals(CatalogA.get_provider_bind_name(p11), 'p11')
+        self.assertEquals(CatalogD.get_provider_bind_name(p11), 'pd1')
+        self.assertEquals(CatalogE.get_provider_bind_name(p11), 'pe1')
+
+        self.assertTrue(CatalogA.is_provider_bound(p12))
+        self.assertTrue(CatalogD.is_provider_bound(p12))
+        self.assertTrue(CatalogE.is_provider_bound(p12))
+        self.assertEquals(CatalogA.get_provider_bind_name(p12), 'p12')
+        self.assertEquals(CatalogD.get_provider_bind_name(p12), 'pd2')
+        self.assertEquals(CatalogE.get_provider_bind_name(p12), 'pe2')
+
+    def test_provider_rebinding_to_the_same_catalog(self):
+        """Test provider rebinding to the same catalog."""
+        with self.assertRaises(di.Error):
+            class TestCatalog(di.DeclarativeCatalog):
+                """Test catalog."""
+
+                p1 = di.Provider()
+                p2 = p1
+
+    def test_provider_rebinding_to_the_same_catalogs_hierarchy(self):
+        """Test provider rebinding to the same catalogs hierarchy."""
+        class TestCatalog1(di.DeclarativeCatalog):
+            """Test catalog."""
+
+            p1 = di.Provider()
+
+        with self.assertRaises(di.Error):
+            class TestCatalog2(TestCatalog1):
+                """Test catalog."""
+
+                p2 = TestCatalog1.p1
 
     def test_get(self):
         """Test getting of providers using get() method."""
@@ -254,130 +246,112 @@ class CatalogTests(unittest.TestCase):
         self.assertTrue(len(CatalogC.filter(di.Provider)) == 6)
         self.assertTrue(len(CatalogC.filter(di.Value)) == 0)
 
+    def test_repr(self):
+        """Test declarative catalog representation."""
+
+    def test_abstract_catalog_backward_compatibility(self):
+        """Test that di.AbstractCatalog is available."""
+        self.assertIs(di.DeclarativeCatalog, di.AbstractCatalog)
+
 
 class OverrideTests(unittest.TestCase):
     """Catalog overriding and override decorator test cases."""
 
-    class Catalog(di.DeclarativeCatalog):
-        """Test catalog."""
-
-        obj = di.Object(object())
-        another_obj = di.Object(object())
-
     def tearDown(self):
         """Tear test environment down."""
-        self.Catalog.reset_override()
+        CatalogA.reset_override()
 
     def test_overriding(self):
         """Test catalog overriding with another catalog."""
-        @di.override(self.Catalog)
+        @di.override(CatalogA)
         class OverridingCatalog(di.DeclarativeCatalog):
             """Overriding catalog."""
 
-            obj = di.Value(1)
-            another_obj = di.Value(2)
+            p11 = di.Value(1)
+            p12 = di.Value(2)
 
-        self.assertEqual(self.Catalog.obj(), 1)
-        self.assertEqual(self.Catalog.another_obj(), 2)
-        self.assertEqual(len(self.Catalog.overridden_by), 1)
+        self.assertEqual(CatalogA.p11(), 1)
+        self.assertEqual(CatalogA.p12(), 2)
+        self.assertEqual(len(CatalogA.overridden_by), 1)
 
     def test_overriding_with_dynamic_catalog(self):
         """Test catalog overriding with another dynamic catalog."""
-        self.Catalog.override(di.DynamicCatalog(obj=di.Value(1),
-                                                another_obj=di.Value(2)))
-        self.assertEqual(self.Catalog.obj(), 1)
-        self.assertEqual(self.Catalog.another_obj(), 2)
-        self.assertEqual(len(self.Catalog.overridden_by), 1)
+        CatalogA.override(di.DynamicCatalog(p11=di.Value(1),
+                                            p12=di.Value(2)))
+        self.assertEqual(CatalogA.p11(), 1)
+        self.assertEqual(CatalogA.p12(), 2)
+        self.assertEqual(len(CatalogA.overridden_by), 1)
 
     def test_is_overridden(self):
         """Test catalog is_overridden property."""
-        self.assertFalse(self.Catalog.is_overridden)
+        self.assertFalse(CatalogA.is_overridden)
 
-        @di.override(self.Catalog)
+        @di.override(CatalogA)
         class OverridingCatalog(di.DeclarativeCatalog):
             """Overriding catalog."""
 
-        self.assertTrue(self.Catalog.is_overridden)
+        self.assertTrue(CatalogA.is_overridden)
 
     def test_last_overriding(self):
         """Test catalog last_overriding property."""
-        @di.override(self.Catalog)
+        @di.override(CatalogA)
         class OverridingCatalog1(di.DeclarativeCatalog):
             """Overriding catalog."""
 
-        @di.override(self.Catalog)
+        @di.override(CatalogA)
         class OverridingCatalog2(di.DeclarativeCatalog):
             """Overriding catalog."""
 
-        self.assertIs(self.Catalog.last_overriding, OverridingCatalog2)
+        self.assertIs(CatalogA.last_overriding, OverridingCatalog2)
 
     def test_last_overriding_on_not_overridden(self):
         """Test catalog last_overriding property on not overridden catalog."""
         with self.assertRaises(di.Error):
-            self.Catalog.last_overriding
+            CatalogA.last_overriding
 
     def test_reset_last_overriding(self):
         """Test resetting last overriding catalog."""
-        @di.override(self.Catalog)
+        @di.override(CatalogA)
         class OverridingCatalog1(di.DeclarativeCatalog):
             """Overriding catalog."""
 
-            obj = di.Value(1)
-            another_obj = di.Value(2)
+            p11 = di.Value(1)
+            p12 = di.Value(2)
 
-        @di.override(self.Catalog)
+        @di.override(CatalogA)
         class OverridingCatalog2(di.DeclarativeCatalog):
             """Overriding catalog."""
 
-            obj = di.Value(3)
-            another_obj = di.Value(4)
+            p11 = di.Value(3)
+            p12 = di.Value(4)
 
-        self.Catalog.reset_last_overriding()
+        CatalogA.reset_last_overriding()
 
-        self.assertEqual(self.Catalog.obj(), 1)
-        self.assertEqual(self.Catalog.another_obj(), 2)
+        self.assertEqual(CatalogA.p11(), 1)
+        self.assertEqual(CatalogA.p12(), 2)
 
     def test_reset_last_overriding_when_not_overridden(self):
         """Test resetting last overriding catalog when it is not overridden."""
         with self.assertRaises(di.Error):
-            self.Catalog.reset_last_overriding()
+            CatalogA.reset_last_overriding()
 
     def test_reset_override(self):
         """Test resetting all catalog overrides."""
-        @di.override(self.Catalog)
+        @di.override(CatalogA)
         class OverridingCatalog1(di.DeclarativeCatalog):
             """Overriding catalog."""
 
-            obj = di.Value(1)
-            another_obj = di.Value(2)
+            p11 = di.Value(1)
+            p12 = di.Value(2)
 
-        @di.override(self.Catalog)
+        @di.override(CatalogA)
         class OverridingCatalog2(di.DeclarativeCatalog):
             """Overriding catalog."""
 
-            obj = di.Value(3)
-            another_obj = di.Value(4)
+            p11 = di.Value(3)
+            p12 = di.Value(4)
 
-        self.Catalog.reset_override()
+        CatalogA.reset_override()
 
-        self.assertIsInstance(self.Catalog.obj(), object)
-        self.assertIsInstance(self.Catalog.another_obj(), object)
-
-
-class DeclarativeCatalogReprTest(unittest.TestCase):
-    """Tests for declarative catalog representation."""
-
-    def test_repr(self):
-        """Test declarative catalog representation."""
-        class TestCatalog(di.DeclarativeCatalog):
-            """Test catalog."""
-
-        self.assertIn('TestCatalog', repr(TestCatalog))
-
-
-class AbstractCatalogCompatibilityTest(unittest.TestCase):
-    """Test backward compatibility with di.AbstractCatalog."""
-
-    def test_compatibility(self):
-        """Test that di.AbstractCatalog is available."""
-        self.assertIs(di.DeclarativeCatalog, di.AbstractCatalog)
+        self.assertFalse(CatalogA.p11.is_overridden)
+        self.assertFalse(CatalogA.p12.is_overridden)