Example #1
0
    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)
Example #2
0
    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)
Example #3
0
 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)
Example #4
0
 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))
Example #5
0
 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)
Example #6
0
    def test_from_mongo(self):
        # Arrange
        data = {
            "\$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
        obj = ObjectDict._from_mongo(data)
        # Assert
        self.assertTrue(isinstance(obj, ObjectDict))
        self.assertTrue(hasattr(obj, "$prop1"))
        self.assertTrue(hasattr(obj, "prop.2"))
        self.assertTrue(hasattr(obj, "prop.$3"))
        self.assertTrue(hasattr(obj, "prop4"))
        self.assertTrue(hasattr(obj, "prop5"))
        self.assertEqual(obj["$prop1"], "value1")
        self.assertEqual(obj["prop.2"], "value2")
        self.assertEqual(obj["prop.$3"], "value3")
        self.assertEqual(obj["prop4"],  \
            {"$prop1": "value1", "prop.2": "value2", "prop.$3": "value3"})
        self.assertEqual(obj["prop5"], [{"key.1": "v1", "$key2": "v2"}])
Example #7
0
 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)
Example #8
0
 def test_from_mongo(self):
     # Arrange
     data = {
         "\$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
     obj = ObjectDict._from_mongo(data)
     # Assert
     self.assertTrue(isinstance(obj, ObjectDict))
     self.assertTrue(hasattr(obj, "$prop1"))
     self.assertTrue(hasattr(obj, "prop.2"))
     self.assertTrue(hasattr(obj, "prop.$3"))
     self.assertTrue(hasattr(obj, "prop4"))
     self.assertTrue(hasattr(obj, "prop5"))
     self.assertEqual(obj["$prop1"], "value1")
     self.assertEqual(obj["prop.2"], "value2")
     self.assertEqual(obj["prop.$3"], "value3")
     self.assertEqual(obj["prop4"],  \
         {"$prop1": "value1", "prop.2": "value2", "prop.$3": "value3"})
     self.assertEqual(obj["prop5"], [{"key.1": "v1", "$key2": "v2"}])
Example #9
0
 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())
Example #10
0
    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))
Example #11
0
 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")
Example #12
0
 def _insert(self, resources):
     accessPoint = resources[0]["accessPoint"]
     tmpExists = yield self.dblayer.find_one({ "accessPoint": accessPoint })
     self.application._level = max(self.application._level, resources[0]["properties"]["depth"] + 1)
     if tmpExists:
         yield self.dblayer.update({ "accessPoint": accessPoint }, resources[0], replace = True, multi=False)
     else:
         yield self.dblayer.insert(resources)
     
     for manifest in resources[0]["properties"]["summary"]:
         manifest = ObjectDict._from_mongo(manifest)
         manifest["href"] = accessPoint
         manifest["ttl"] = resources[0]["ttl"]
         manifest.pop(self.timestamp, 0)
         yield self._update_manifest(manifest, accessPoint)
Example #13
0
 def _report_to_root(self):
     manifests = []
     cursor = self.db["manifests"].find({ "\\$shard": False}, {"_id": False })
     
     while (yield cursor.fetch_next):
         manifests.append(ObjectDict._from_mongo(cursor.next_object()))
         
     import time
     if self.options["unis_ssl"]["enable"]:
         http_str = "https"
     else:
         http_str = "http"
         
     callback = functools.partial(self.registered, fatal = False)
     service = {
         u"id": u"unis_" + socket.gethostname(),
         u"ts": int(time.time() * 1e6),
         u"\$schema": unicode(SCHEMAS["service"]),
         u"accessPoint": self.options["unis"]["url"],
         u"name": u"unis_" + socket.gethostname(),
         u"status": u"ON",
         u"serviceType": u"ps:tools:unis",
         u"ttl": int(self.options["unis"]["summary_collection_period"]),
         u"runningOn": {
             u"href": u"%s/nodes/%s" % (self.options["unis"]["url"], socket.gethostname()),
             u"rel": u"full"
         },
         u"properties": {
             u"summary": manifests,
             u"depth": self._depth
         }
     }
     
     for lookup in self.options["unis"]["root_urls"]:
         service_url = lookup + '/register'
         http_client = AsyncHTTPClient()
         
         content_type = MIME['PSJSON'] + '; profile=' + SCHEMAS['service']
         http_client.fetch(service_url,
                           method="POST",
                           body=json.dumps(service),
                           headers = {
                               "Content-Type": content_type,
                               "Cache-Control": "no-cache",
                               "Accept": MIME['PSJSON'],
                               "Connection": "close"},
                           callback=callback)
    def _return_resources(self, query):
        try:
            cursor = self._find(query=query)
            response = []
            while (yield cursor.fetch_next):
                resource = ObjectDict._from_mongo(cursor.next_object())
                response.append(resource)

            if len(response) == 1:
                location = self.request.full_url().split('?')[0]
                if not location.endswith(response[0][self.Id]):
                    location = location + "/" + response[0][self.Id]

                self.set_header("Location", location)
                self.write(dumps_mongo(response[0], indent=2))
            else:
                self.write(dumps_mongo(response, indent=2))
        except Exception as exp:
            raise ValueError(exp)
Example #15
0
    def _return_resources(self, query):
        try:
            cursor = self._find(query = query)
            response = []
            while (yield cursor.fetch_next):
                resource = ObjectDict._from_mongo(cursor.next_object())
                response.append(resource)
        
            if len(response) == 1:
                location = self.request.full_url().split('?')[0]
                if not location.endswith(response[0][self.Id]):
                    location = location + "/" + response[0][self.Id]

                self.set_header("Location", location)
                self.write(dumps_mongo(response[0], indent=2))
            else:
                self.write(dumps_mongo(response, indent=2))
        except Exception as exp:
            raise ValueError(exp)
Example #16
0
    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))