def test_attrAccess(self):
nd = NestedDict(self.data)
self.assertThat(nd.a, IsInstance(NestedDict))
self.assertEqual(self.nestedToDict(nd.a.data), self.data["a"])
self.assertEqual(nd.a.e, nd["a"]["e"])
self.assertEqual(nd.a.b.c, "d")
def test_keys(self):
nd = NestedDict(self.data)
keys = nd.keys()
for key in keys:
self.assertIn(key, self.data)
def test_items(self):
nd = NestedDict(self.data)
for k, v in nd.items():
self.assertIn(k, self.data)
self.assertEqual(self.data[k], self.nestedToDict(v))
def test_lookup(self):
nd = NestedDict(self.data)
self.assertEqual("d", nd.lookup(("a", "b", "c")))
self.assertIsNone(None, nd.lookup(("a", "x", "y")))
self.assertEqual(self.data["a"], self.nestedToDict(nd.lookup(["a"])))
def test_has(self):
nd = NestedDict(self.data)
self.assertTrue(nd.has("a"))
self.assertFalse(nd.has("b"))
self.assertFalse(nd.has("parent"))
def test_storeAction(self):
parser = ArgumentParser()
parser.add_argument("--test", dest="a.b")
ns = parser.parse_args(["--test", "c"], namespace=NestedDict())
self.assertEqual("c", ns.a.b)
def test_hasattr(self):
nd = NestedDict(self.data)
self.assertTrue(hasattr(nd, "a"))
self.assertTrue(hasattr(nd, "a.e"))
self.assertTrue(hasattr(nd, "a.b.c"))
self.assertFalse(hasattr(nd, "b"))
self.assertFalse(hasattr(nd, "a.b.c.d"))
def test_dictAccess(self):
nd = NestedDict(self.data)
self.assertThat(nd["a"], IsInstance(NestedDict))
self.assertEqual(self.nestedToDict(nd["a"].data), self.data["a"])
self.assertEqual(nd["a"]["e"], "f")
self.assertEqual(nd["a"]["b"]["c"], "d")
def test_repr(self):
nd = NestedDict()
self.assertEqual(repr(nd), "<NestedDict ({})>")
nd.update(self.data)
self.assertEqual(repr(nd), "<NestedDict (%s)>" % repr(nd.data))
def test_parent(self):
nd = NestedDict(self.data)
self.assertEqual(nd, nd.a.parent)
self.assertIsNone(nd.parent)
nd.update({"parent": "foo"})
self.assertIsNone(nd.parent)
self.assertEqual("foo", nd.get("parent"))
def test_mapping(self):
nd = NestedDict(self.data)
d = {}
for key, value in self.data.items():
d[key] = nd[key]
self.assertEqual(dict(nd), dict(**nd))
self.assertEqual(dict(nd), d)
def test_get(self):
nd = NestedDict(self.data)
self.assertThat(nd.get("a"), IsInstance(NestedDict))
self.assertEqual(self.nestedToDict(nd.get("a").data), self.data["a"])
self.assertEqual(nd.get("a").get("e"), nd["a"]["e"])
self.assertEqual(nd.a.get("b").c, "d")
self.assertIsNone(nd.get("x"), None)
self.assertEqual(nd.get("x", "y"), "y")
def _get_config(args, fn):
d = {}
file_path = os.path.join(args.conf_dir, fn)
if os.path.exists(file_path):
logger.debug('loading:%s' % file_path)
docs = yaml.load_all(open(file_path, 'r'))
if args.profile:
d = next(doc for doc in docs if doc.get('profile') == args.profile)
else:
d = next(docs)
return NestedDict(d)
def test_storeCons(self):
# taken from argparse docs
parser = ArgumentParser()
parser.add_argument('integers', metavar='N', type=int, nargs='+')
parser.add_argument('--sum',
dest='a.b',
action='store_const',
const=sum,
default=max)
ns = parser.parse_args(["1", "2", "3", "4", "--sum"],
namespace=NestedDict())
self.assertEqual(10, ns.a.b(ns.integers))
def test_update(self):
nd = NestedDict({})
nd.update(self.data)
nd.update({"a": {"b": {"i": "j"}}})
nd.update({"a": {"b": {"c": "x"}}})
nd.update({"a": {"g": "h"}})
self.assertTrue(nd.a.has("g"))
self.assertTrue(nd.a.b.has("c"))
self.assertEqual(nd.a.b.c, "x")
self.assertTrue(nd.a.b.has("i"))
self.assertEqual(nd.a.b.i, "j")
self.assertEqual(nd.a.g, "h")
self.assertEqual(nd.a.e, "f")
def test_delete(self):
nd = NestedDict(self.data)
self.assertIn("b", nd["a"])
delattr(nd["a"], "b")
self.assertNotIn("b", nd["a"])
self.assertIn("e", nd["a"])
del nd["a"]["e"]
self.assertNotIn("e", nd["a"])
self.assertIn("a", nd)
nd.delete("a")
self.assertNotIn("a", nd)
def test_haskey(self):
nd = NestedDict(self.data)
for key in self.data.keys():
self.assertTrue(nd.has_key(key))
def __init__(self, d):
self.args = NestedDict(d)
self.settings = self._get_config(self.args, 'settings.yml')
d = json.loads(self.args.settings)
self.settings.update(d)
def test_call(self):
nd = NestedDict(self.data)
self.assertEqual(self.data, self.nestedToDict(nd()))
self.assertEqual(self.data["a"], self.nestedToDict(nd.a()))
def test_in(self):
nd = NestedDict(self.data)
self.assertIn("a", nd)
self.assertNotIn("g", nd)
def test_setattr(self):
nd = NestedDict()
setattr(nd, "a.b.c", "d")
self.assertEqual("d", nd.data["a"]["b"]["c"])
def test_length(self):
nd = NestedDict(self.data)
self.assertEqual(len(nd), len(self.data))
def test_values(self):
nd = NestedDict(self.data)
self.assertEqual(list(self.data.values()),
[self.nestedToDict(x) for x in nd.values()])
def test_default(self):
parser = ArgumentParser()
parser.add_argument("--test", dest="a.b", default="c", action='store')
ns = parser.parse_args([], namespace=NestedDict())
self.assertEqual("c", ns.a.b)
def test_contains(self):
nd = NestedDict(self.data)
for key in self.data.keys():
self.assertTrue(key in nd)