Unit tests

.coveragerc

@@ -0,0 +1,4 @@
+[run]
+include=
+    objtools/*
+    tests/*

objtools/collections.py

@@ -5,25 +5,23 @@ from typing import (
 
 
 def namespacify(value: Any) -> Any:
-    if isinstance(value, (Namespace, MutableNamespace)):
+    if isinstance(value, Namespace):
         return value
-    elif isinstance(value, MutableMapping):
-        return MutableNamespace(value)
-    elif isinstance(value, Mapping):
+    if isinstance(value, Mapping):
         return Namespace(value)
-    elif isinstance(value, (str, ByteString)):
+    if isinstance(value, (str, ByteString)):
         # Do not treat strings and bytestrings as normal sequences
         return value
-    elif isinstance(value, Sequence):
+    if isinstance(value, Sequence):
         return list(map(namespacify, value))
-    elif isinstance(value, Set):
+    if isinstance(value, Set):
         return set(map(namespacify, value))
-    elif isinstance(value, Iterable):
+    if isinstance(value, Iterable):
         return map(namespacify, value)
     return value
 
 
-class Namespace(Mapping):
+class Namespace(MutableMapping):
 
     def __init__(self, *args: Iterable, **kwargs: Any):
         for iterable in (*args, kwargs):
@@ -54,9 +52,6 @@ class Namespace(Mapping):
     def copy(self) -> 'Namespace':
         return self.__class__(self.__dict__)
 
-
-class MutableNamespace(Namespace, MutableMapping):
-
     def __setitem__(self, name: Any, value: Any) -> None:
         setattr(self, name, value)
 

tests/test_collections.py

@@ -0,0 +1,113 @@
+from types import MappingProxyType
+from typing import List, Set, Iterable, Iterator, Any
+from unittest import TestCase
+from objtools.collections import namespacify, Namespace
+
+
+class TestNamespacify(TestCase):
+
+    def test_namespace(self) -> None:
+        ns: Namespace = Namespace(a='b')
+        self.assertIs(ns, namespacify(ns))
+
+    def test_mapping(self) -> None:
+        ns: Namespace = namespacify(MappingProxyType({'a': 'b', 'c': 'd'}))
+        self.assertIsInstance(ns, Namespace)
+        self.assertEqual(dict(ns), {'a': 'b', 'c': 'd'})
+
+    def test_str(self) -> None:
+        ns: str = namespacify('something')
+        self.assertEqual(ns, 'something')
+
+    def test_bytes(self) -> None:
+        ns: bytes = namespacify(b'something')
+        self.assertEqual(ns, b'something')
+
+    def test_sequence(self) -> None:
+        ns: List[Namespace] = namespacify([{'a': 'b'}, {'c': 'd'}])
+        self.assertIsInstance(ns, list)
+        self.assertTrue(all(isinstance(n, Namespace) for n in ns))
+        self.assertListEqual(list(map(dict, ns)), [{'a': 'b'}, {'c': 'd'}])
+
+    def test_set(self) -> None:
+        ns: Set[int] = namespacify({1, 2, 3, 4, 5})
+        self.assertSetEqual(ns, {1, 2, 3, 4, 5})
+
+    def test_iterable(self) -> None:
+        ns: Iterable[Namespace] = namespacify(
+            map(MappingProxyType, [{'a': 'b'}, {'c': 'd'}])
+        )
+        self.assertNotIsInstance(ns, list)
+        ns = list(ns)
+        self.assertTrue(all(isinstance(n, Namespace) for n in ns))
+        self.assertListEqual(list(map(dict, ns)), [{'a': 'b'}, {'c': 'd'}])
+
+    def test_any(self) -> None:
+        self.assertEqual(namespacify(42), 42)
+        self.assertEqual(namespacify(42.0), 42.0)
+        self.assertEqual(namespacify(True), True)
+        self.assertEqual(namespacify(namespacify), namespacify)
+
+
+class TestNamespace(TestCase):
+
+    def test_init(self) -> None:
+        ns: Namespace = Namespace()
+        self.assertDictEqual(dict(ns), {})
+        ns = Namespace({'b': 3}, {'a': 4}, a=1, b=2)
+        self.assertDictEqual(dict(ns), {'a': 1, 'b': 2})
+
+    def test_getitem(self) -> None:
+        ns: Namespace = Namespace(a=1)
+        self.assertEqual(ns['a'], 1)
+        with self.assertRaises(KeyError):
+            ns['b']
+
+    def test_getattr(self) -> None:
+        ns: Any = Namespace(a=1)
+        self.assertEqual(getattr(ns, 'a'), 1)
+        with self.assertRaises(AttributeError):
+            ns.b
+
+    def test_iter(self) -> None:
+        ns: Namespace = Namespace(a=1, b=2)
+        iterator: Iterator = iter(ns)
+        self.assertEqual(next(iterator), 'a')
+        self.assertEqual(next(iterator), 'b')
+
+    def test_len(self) -> None:
+        self.assertEqual(len(Namespace(a=1, b=2)), 2)
+        self.assertEqual(len(Namespace()), 0)
+
+    def test_repr(self) -> None:
+        self.assertEqual(repr(Namespace()), 'Namespace({})')
+        self.assertEqual(repr(Namespace(a=1)), "Namespace({'a': 1})")
+
+    def test_str(self) -> None:
+        self.assertEqual(str(Namespace()), '{}')
+        self.assertEqual(str(Namespace(a=1)), "{'a': 1}")
+
+    def test_copy(self) -> None:
+        ns: Namespace = Namespace(a=1, b=2)
+        self.assertEqual(ns.copy(), ns)
+        self.assertIsNot(ns.copy(), ns)
+
+    def test_set(self) -> None:
+        ns: Any = Namespace(a=4)
+        ns.a = 1
+        ns['b'] = 2
+        self.assertEqual(ns, Namespace(a=1, b=2))
+
+    def test_del(self) -> None:
+        ns: Any = Namespace(a=1, b=2)
+        del ns.a
+        self.assertEqual(ns, Namespace(b=2))
+        del ns['b']
+        self.assertEqual(ns, Namespace())
+
+    def test_del_not_found(self) -> None:
+        ns: Any = Namespace(a=1, b=2)
+        with self.assertRaises(AttributeError):
+            del ns.c
+        with self.assertRaises(KeyError):
+            del ns['c']

tests/test_registry.py

@@ -0,0 +1,63 @@
+from unittest import TestCase
+from unittest.mock import patch
+from objtools.registry import ClassRegistry
+
+
+class TestRegistry(TestCase):
+
+    def test_register(self) -> None:
+        registry = ClassRegistry()
+        registry.register('lol', str)
+        self.assertDictEqual(registry, {'lol': str})
+
+    def test_unregister(self) -> None:
+        registry = ClassRegistry({'lol': str})
+        registry.unregister('lol')
+        self.assertDictEqual(registry, {})
+
+    def test_check_key(self) -> None:
+        registry = ClassRegistry()
+        with patch.object(registry, 'check_key') as mock:
+            mock.side_effect = KeyError('something')
+            with self.assertRaises(KeyError, msg='something'):
+                registry.register('lol', str)
+
+            mock.side_effect = AssertionError('something')
+            with self.assertRaises(KeyError, msg='something'):
+                registry.register('lol', str)
+
+    def test_check_value(self) -> None:
+        registry = ClassRegistry()
+        with patch.object(registry, 'check_value') as mock:
+            mock.side_effect = ValueError('something')
+            with self.assertRaises(ValueError, msg='something'):
+                registry.register('lol', str)
+
+            mock.side_effect = AssertionError('something')
+            with self.assertRaises(ValueError, msg='something'):
+                registry.register('lol', str)
+
+    def test_metaclass(self) -> None:
+        registry = ClassRegistry()
+
+        class Thing(metaclass=registry.metaclass):  # type: ignore
+            pass
+
+        self.assertDictEqual(registry, {'Thing': Thing})
+
+    def test_metaclass_no_register(self) -> None:
+        registry = ClassRegistry()
+
+        class Thing(metaclass=registry.metaclass,  # type: ignore
+                    register=False):
+            pass
+
+        self.assertDictEqual(registry, {})
+
+    def test_metaclass_key(self) -> None:
+        registry = ClassRegistry()
+
+        class Thing(metaclass=registry.metaclass, key='foo'):  # type: ignore
+            pass
+
+        self.assertDictEqual(registry, {'foo': Thing})