133 lines
4.5 KiB
Python
133 lines
4.5 KiB
Python
from types import MappingProxyType
|
|
from typing import List, Set, Iterable, Iterator, Any
|
|
from unittest import TestCase
|
|
from unittest.mock import MagicMock, call
|
|
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=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_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']
|
|
|
|
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_repr_pretty(self) -> None:
|
|
p = MagicMock(spec_set=['text', 'pretty'])
|
|
Namespace(a=1)._repr_pretty_(p, cycle=False)
|
|
self.assertEqual(p.text.call_count, 2)
|
|
self.assertEqual(p.pretty.call_count, 1)
|
|
self.assertListEqual(p.text.call_args_list, [
|
|
call('Namespace('),
|
|
call(')'),
|
|
])
|
|
self.assertEqual(p.pretty.call_args, call({'a': 1}))
|
|
|
|
def test_repr_pretty_cycle(self) -> None:
|
|
p = MagicMock(spec_set=['text', 'pretty'])
|
|
Namespace(a=1)._repr_pretty_(p, cycle=True)
|
|
self.assertEqual(p.text.call_count, 1)
|
|
self.assertFalse(p.pretty.called)
|
|
self.assertEqual(p.text.call_args, call('Namespace(...)'))
|
|
|
|
def test_copy(self) -> None:
|
|
ns: Namespace = Namespace(a=1, b=2)
|
|
self.assertEqual(ns.copy(), ns)
|
|
self.assertIsNot(ns.copy(), ns)
|