def test_init(self):
# Arrange
test_data = {"key1": "value1", "key2": "value2", "$key3": "value3"}
# Act
obj1 = ObjectDict()
obj2 = ObjectDict(test_data)
# Assert
self.assertEqual(obj1, {})
self.assertEqual(obj2, test_data)
for key, value in test_data.items():
self.assertTrue(hasattr(obj2, key))
self.assertEqual(getattr(obj2, key), value)
def test_convert_value(self):
# Arrange
test_data = {
"key1": "value1",
"key2": {
"k1": "v1"
},
"key3": {
"k2": {
"k3": "v3"
}
}
}
obj = ObjectDict(test_data)
# Act
key1 = obj.key1
key2 = obj["key2"]
key3 = obj.key3
k1 = key2.k1
k2 = key3["k2"]
k3 = k2.k3
# Assert
self.assertEqual(obj, test_data)
self.assertTrue(isinstance(obj, ObjectDict))
self.assertTrue(isinstance(key1, str))
self.assertTrue(isinstance(key2, ObjectDict))
self.assertTrue(isinstance(key3, ObjectDict))
self.assertTrue(isinstance(k1, str))
self.assertTrue(isinstance(k2, ObjectDict))
self.assertTrue(isinstance(k3, str))
def test_to_mongo(self):
# Arrange
obj = ObjectDict()
obj["$prop1"] = "value1"
obj["prop.2"] = "value2"
obj["prop.$3"] = "value3"
obj["prop4"] = copy.deepcopy(obj)
obj["prop5"] = [{"key.1": "v1", "$key2": "v2"}]
expected = {
"\$prop1": "value1",
"prop$DOT$2": "value2",
"prop$DOT$$3": "value3",
"prop4": {
"\$prop1": "value1",
"prop$DOT$2": "value2",
"prop$DOT$$3": "value3",
},
"prop5": [{
"key$DOT$1": "v1",
"\$key2": "v2"
}]
}
# Act
mongo_dict = dict(obj._to_mongoiter())
# Assert
self.assertTrue(hasattr(obj, "$prop1"))
self.assertTrue(hasattr(obj, "prop.2"))
self.assertTrue(hasattr(obj, "prop.$3"))
self.assertEqual(obj["$prop1"], "value1")
self.assertEqual(obj["prop.2"], "value2")
self.assertEqual(obj["prop.$3"], "value3")
self.assertEqual(mongo_dict, expected)
def _create_manifest_shard(self, resource):
if "\\$collection" in resource:
tmpResource = resource["properties"]
else:
tmpResource = resource
tmpResult = {}
tmpResult["properties"] = self._flatten_shard(tmpResource)
tmpResult["$shard"] = True
tmpResult["$collection"] = self._collection_name
return dict(ObjectDict(tmpResult)._to_mongoiter())
def test_del_property(self):
# Arrange
test_data = {"key1": "value1", "key2": "value2", "$key3": "value3"}
obj = ObjectDict(test_data)
# Act
del obj.key1
del obj["key2"]
# Assert
self.assertNotEqual(obj, test_data)
self.assertFalse(hasattr(obj, "key1"))
self.assertFalse(hasattr(obj, "key2"))
self.assertFalse("key1" in obj)
self.assertFalse("key2" in obj)
self.assertTrue(hasattr(obj, "$key3"))
self.assertEqual(getattr(obj, "$key3"), "value3")
def test_add_property(self):
# Arrange
test_data = {"key1": "value1", "key2": "value2", "$key3": "value3"}
obj = ObjectDict(test_data)
# Act
obj.key4 = "value4"
obj["key5"] = "value5"
# Assert
self.assertTrue(hasattr(obj, "key4"))
self.assertEqual(getattr(obj, "key4"), "value4")
self.assertTrue(hasattr(obj, "key5"))
self.assertEqual(getattr(obj, "key5"), "value5")
self.assertNotEqual(obj, test_data)
for key, value in test_data.items():
self.assertTrue(hasattr(obj, key))
self.assertEqual(getattr(obj, key), value)
def test_convert_value_nested(self):
# Arrange
test_data = {
"key1": "value1",
"key2": {
"k1": "v1"
},
"key3": {
"k2": {
"k3": "v3"
}
},
"key4": [{
"k4": {
"k5": "v5"
}
}]
}
expected_data = {
"key1": "value1",
"key2": {
"k1": "v1"
},
"key3": {
"k2": {
"k3": "v3"
}
},
"key4": [{
"k4": {
"k5": "v5"
}
}, {
"k6": "v6"
}],
"key5": {
"k7": [{
"k8": "v8"
}, {
"k9": "v9"
}]
}
}
obj = ObjectDict(test_data)
# Act
key1 = obj.key1
key2 = obj["key2"]
key3 = obj.key3
key4 = obj.key4
k1 = key2.k1
k2 = key3["k2"]
k3 = k2.k3
key4 = obj.key4
key4.append({"k6": "v6"})
obj.key5 = {"k7": [{"k8": "v8"}]}
k7 = obj.key5.k7
k7.append({"k9": "v9"})
# Assert
self.assertEqual(obj, expected_data)
self.assertTrue(isinstance(obj, ObjectDict))
self.assertTrue(isinstance(key1, str))
self.assertTrue(isinstance(key2, ObjectDict))
self.assertTrue(isinstance(key3, ObjectDict))
self.assertTrue(isinstance(k1, str))
self.assertTrue(isinstance(k2, ObjectDict))
self.assertTrue(isinstance(k3, str))
