def test_create_graph_with_data(self):
        # reset the counters for a clean run.
        ruruki._VID = 0
        ruruki._EID = 0

        data = helpers.get_test_dump_graph_file_handler()
        graph = ruruki.create_graph(data=data)

        tmp_file = helpers.create_tmp_file_handler()
        graph.dump(tmp_file)

        data.seek(0)
        tmp_file.seek(0)

        # sorted the edges and vertices before comparing the two dicts
        d1 = json.load(data)
        for key in d1:
            d1[key].sort()

        d2 = json.load(tmp_file)
        for key in d2:
            d2[key].sort()

        self.assertDictEqual(
            d1,
            d2,
        )
示例#2
0
    def setUp(self):
        self.graph = graphs.Graph()
        self.graph.load(helpers.get_test_dump_graph_file_handler())

        # See test_utils/small_people_graph.dump
        # get and set each of the vertices and edges for later use.
        self.marko = self.graph.get_vertices(name="marko").all()[0]
        self.vadas = self.graph.get_vertices(name="vadas").all()[0]
        self.lop = self.graph.get_vertices(name="lop").all()[0]
        self.josh = self.graph.get_vertices(name="josh").all()[0]
        self.ripple = self.graph.get_vertices(name="ripple").all()[0]
        self.peter = self.graph.get_vertices(name="peter").all()[0]

        self.peter_created_lop = self.graph.get_edges(self.peter, "created",
                                                      self.lop).all()[0]

        self.josh_created_lop = self.graph.get_edges(self.josh, "created",
                                                     self.lop).all()[0]

        self.marko_created_lop = self.graph.get_edges(self.marko,
                                                      "created",
                                                      tail=self.lop).all()[0]

        self.marko_knows_josh = self.graph.get_edges(self.marko, "knows",
                                                     self.josh).all()[0]

        self.marko_knows_vadas = self.graph.get_edges(self.marko, "knows",
                                                      self.vadas).all()[0]

        self.josh_created_ripple = self.graph.get_edges(
            self.josh, "created", self.ripple).all()[0]
示例#3
0
    def test_dump(self):
        self.maxDiff = None
        tmp_file = helpers.create_tmp_file_handler()
        self.graph.dump(tmp_file)
        tmp_file.seek(0)

        # sorted the edges and vertices before comparing the two dicts
        loaded_temp = json.load(tmp_file)
        for key in loaded_temp:
            loaded_temp[key].sort()

        loaded_dump = json.load(helpers.get_test_dump_graph_file_handler())
        for key in loaded_dump:
            loaded_dump[key].sort()

        self.assertDictEqual(
            loaded_temp,
            loaded_dump,
        )
示例#4
0
    def test_dump(self):
        self.maxDiff = None
        tmp_file = helpers.create_tmp_file_handler()
        self.graph.dump(tmp_file)
        tmp_file.seek(0)

        # sorted the edges and vertices before comparing the two dicts
        loaded_temp = json.load(tmp_file)
        for key in loaded_temp:
            loaded_temp[key].sort()

        loaded_dump = json.load(helpers.get_test_dump_graph_file_handler())
        for key in loaded_dump:
            loaded_dump[key].sort()

        self.assertDictEqual(
            loaded_temp,
            loaded_dump,
        )
示例#5
0
    def test_dump(self):
        self.maxDiff = None
        tmp_file = helpers.create_tmp_file_handler()
        self.graph.dump(tmp_file)
        tmp_file.seek(0)

        # sorted the edges and vertices before comparing the two dicts
        loaded_temp = json.load(tmp_file)
        loaded_dump = json.load(helpers.get_test_dump_graph_file_handler())

        # THIS IS A TOTAL HACK
        # lets fist make sure that all the keys exist
        self.assertEqual(
            sorted(loaded_temp),
            sorted(loaded_dump),
        )

        # now we check the content
        for key in loaded_dump:
            a = loaded_temp[key].sort(key=lambda x: sorted(x))
            b = loaded_dump[key].sort(key=lambda x: sorted(x))
            self.assertEqual(a, b)
示例#6
0
    def test_dump(self):
        self.maxDiff = None
        tmp_file = helpers.create_tmp_file_handler()
        self.graph.dump(tmp_file)
        tmp_file.seek(0)

        # sorted the edges and vertices before comparing the two dicts
        loaded_temp = json.load(tmp_file)
        loaded_dump = json.load(helpers.get_test_dump_graph_file_handler())

        # THIS IS A TOTAL HACK
        # lets fist make sure that all the keys exist
        self.assertEqual(
            sorted(loaded_temp),
            sorted(loaded_dump),
        )

        # now we check the content
        for key in loaded_dump:
            a = loaded_temp[key].sort(key=lambda x: sorted(x))
            b = loaded_dump[key].sort(key=lambda x: sorted(x))
            self.assertEqual(a, b)
示例#7
0
文件: base.py 项目: jenmud/ruruki
    def setUp(self):
        self.graph = graphs.Graph()
        self.graph.load(helpers.get_test_dump_graph_file_handler())

        # See test_utils/small_people_graph.dump
        # get and set each of the vertices and edges for later use.
        self.marko = self.graph.get_vertices(name="marko").all()[0]
        self.vadas = self.graph.get_vertices(name="vadas").all()[0]
        self.lop = self.graph.get_vertices(name="lop").all()[0]
        self.josh = self.graph.get_vertices(name="josh").all()[0]
        self.ripple = self.graph.get_vertices(name="ripple").all()[0]
        self.peter = self.graph.get_vertices(name="peter").all()[0]

        self.peter_created_lop = self.graph.get_edges(
            self.peter, "created", self.lop
        ).all()[0]

        self.josh_created_lop = self.graph.get_edges(
            self.josh, "created", self.lop
        ).all()[0]

        self.marko_created_lop = self.graph.get_edges(
            self.marko, "created", tail=self.lop
        ).all()[0]

        self.marko_knows_josh = self.graph.get_edges(
            self.marko, "knows", self.josh
        ).all()[0]

        self.marko_knows_vadas = self.graph.get_edges(
            self.marko, "knows", self.vadas
        ).all()[0]

        self.josh_created_ripple = self.graph.get_edges(
            self.josh, "created", self.ripple
        ).all()[0]
示例#8
0
    def test_load(self):
        graph = Graph()
        fh = helpers.get_test_dump_graph_file_handler()
        graph.load(fh)

        marko = self.graph.get_vertex(0)
        vadas = self.graph.get_vertex(1)
        lop = self.graph.get_vertex(2)
        josh = self.graph.get_vertex(3)
        ripple = self.graph.get_vertex(4)
        peter = self.graph.get_vertex(5)

        peter_created_lop = self.graph.get_edge(0)
        josh_created_lop = self.graph.get_edge(1)
        marko_created_lop = self.graph.get_edge(2)
        marko_knows_josh = self.graph.get_edge(3)
        marko_knows_vadas = self.graph.get_edge(4)
        josh_created_ripple = self.graph.get_edge(5)

        # The containers that the graph uses checks the attributes on
        # vertices and edges and not the `id` from the python built-in
        # function.
        self.assertIn(marko, self.graph)
        self.assertEqual(marko.label, "person")
        self.assertEqual(marko.ident, 0)
        self.assertDictEqual(
            marko.properties,
            {
                "age": 29,
                "name": "marko",
            },
        )

        self.assertIn(vadas, self.graph)
        self.assertEqual(vadas.label, "person")
        self.assertEqual(vadas.ident, 1)
        self.assertDictEqual(
            vadas.properties,
            {
                "age": 27,
                "name": "vadas",
            },
        )

        self.assertIn(lop, self.graph)
        self.assertEqual(lop.label, "app")
        self.assertEqual(lop.ident, 2)
        self.assertDictEqual(
            lop.properties,
            {
                "lang": "java",
                "name": "lop",
            },
        )

        self.assertIn(josh, self.graph)
        self.assertEqual(josh.label, "person")
        self.assertEqual(josh.ident, 3)
        self.assertDictEqual(
            josh.properties,
            {
                "age": 32,
                "name": "josh",
            },
        )

        self.assertIn(ripple, self.graph)
        self.assertEqual(ripple.label, "app")
        self.assertEqual(ripple.ident, 4)
        self.assertDictEqual(
            ripple.properties,
            {
                "lang": "java",
                "name": "ripple",
            },
        )

        self.assertIn(peter, self.graph)
        self.assertEqual(peter.label, "person")
        self.assertEqual(peter.ident, 5)
        self.assertDictEqual(
            peter.properties,
            {
                "age": 35,
                "name": "peter",
            },
        )

        self.assertIn(peter_created_lop, self.graph)
        self.assertEqual(
            peter_created_lop.label, "created"
        )
        self.assertEqual(
            peter_created_lop.head, peter
        )
        self.assertEqual(
            peter_created_lop.tail, lop
        )
        self.assertDictEqual(
            peter_created_lop.properties,
            {
                "weight": 0.2
            }
        )

        self.assertIn(josh_created_lop, self.graph)
        self.assertEqual(
            josh_created_lop.label, "created"
        )
        self.assertEqual(
            josh_created_lop.head, josh
        )
        self.assertEqual(
            josh_created_lop.tail, lop
        )
        self.assertDictEqual(
            josh_created_lop.properties,
            {
                "weight": 0.4
            }
        )

        self.assertIn(marko_created_lop, self.graph)
        self.assertEqual(
            marko_created_lop.label, "created"
        )
        self.assertEqual(
            marko_created_lop.head, marko
        )
        self.assertEqual(
            marko_created_lop.tail, lop
        )
        self.assertDictEqual(
            marko_created_lop.properties,
            {
                "weight": 0.4
            }
        )

        self.assertIn(marko_knows_josh, self.graph)
        self.assertEqual(
            marko_knows_josh.label, "knows"
        )
        self.assertEqual(
            marko_knows_josh.head, marko
        )
        self.assertEqual(
            marko_knows_josh.tail, josh
        )
        self.assertDictEqual(
            marko_knows_josh.properties,
            {
                "weight": 1
            }
        )

        self.assertIn(marko_knows_vadas, self.graph)
        self.assertEqual(
            marko_knows_vadas.label, "knows"
        )
        self.assertEqual(
            marko_knows_vadas.head, marko
        )
        self.assertEqual(
            marko_knows_vadas.tail, vadas
        )
        self.assertDictEqual(
            marko_knows_vadas.properties,
            {
                "weight": 0.5
            }
        )

        self.assertIn(josh_created_ripple, self.graph)
        self.assertEqual(
            josh_created_ripple.label, "created"
        )
        self.assertEqual(
            josh_created_ripple.head, josh
        )
        self.assertEqual(
            josh_created_ripple.tail, ripple
        )
        self.assertDictEqual(
            josh_created_ripple.properties,
            {
                "weight": 1
            }
        )
示例#9
0
    def test_load(self):
        graph = Graph()
        fh = helpers.get_test_dump_graph_file_handler()
        graph.load(fh)

        marko = self.graph.get_vertex(0)
        vadas = self.graph.get_vertex(1)
        lop = self.graph.get_vertex(2)
        josh = self.graph.get_vertex(3)
        ripple = self.graph.get_vertex(4)
        peter = self.graph.get_vertex(5)

        peter_created_lop = self.graph.get_edge(0)
        josh_created_lop = self.graph.get_edge(1)
        marko_created_lop = self.graph.get_edge(2)
        marko_knows_josh = self.graph.get_edge(3)
        marko_knows_vadas = self.graph.get_edge(4)
        josh_created_ripple = self.graph.get_edge(5)

        # The containers that the graph uses checks the attributes on
        # vertices and edges and not the `id` from the python built-in
        # function.
        self.assertIn(marko, self.graph)
        self.assertEqual(marko.label, "person")
        self.assertEqual(marko.ident, 0)
        self.assertDictEqual(
            marko.properties,
            {
                "age": 29,
                "name": "marko",
            },
        )

        self.assertIn(vadas, self.graph)
        self.assertEqual(vadas.label, "person")
        self.assertEqual(vadas.ident, 1)
        self.assertDictEqual(
            vadas.properties,
            {
                "age": 27,
                "name": "vadas",
            },
        )

        self.assertIn(lop, self.graph)
        self.assertEqual(lop.label, "app")
        self.assertEqual(lop.ident, 2)
        self.assertDictEqual(
            lop.properties,
            {
                "lang": "java",
                "name": "lop",
            },
        )

        self.assertIn(josh, self.graph)
        self.assertEqual(josh.label, "person")
        self.assertEqual(josh.ident, 3)
        self.assertDictEqual(
            josh.properties,
            {
                "age": 32,
                "name": "josh",
            },
        )

        self.assertIn(ripple, self.graph)
        self.assertEqual(ripple.label, "app")
        self.assertEqual(ripple.ident, 4)
        self.assertDictEqual(
            ripple.properties,
            {
                "lang": "java",
                "name": "ripple",
            },
        )

        self.assertIn(peter, self.graph)
        self.assertEqual(peter.label, "person")
        self.assertEqual(peter.ident, 5)
        self.assertDictEqual(
            peter.properties,
            {
                "age": 35,
                "name": "peter",
            },
        )

        self.assertIn(peter_created_lop, self.graph)
        self.assertEqual(
            peter_created_lop.label, "created"
        )
        self.assertEqual(
            peter_created_lop.head, peter
        )
        self.assertEqual(
            peter_created_lop.tail, lop
        )
        self.assertDictEqual(
            peter_created_lop.properties,
            {
                "weight": 0.2
            }
        )

        self.assertIn(josh_created_lop, self.graph)
        self.assertEqual(
            josh_created_lop.label, "created"
        )
        self.assertEqual(
            josh_created_lop.head, josh
        )
        self.assertEqual(
            josh_created_lop.tail, lop
        )
        self.assertDictEqual(
            josh_created_lop.properties,
            {
                "weight": 0.4
            }
        )

        self.assertIn(marko_created_lop, self.graph)
        self.assertEqual(
            marko_created_lop.label, "created"
        )
        self.assertEqual(
            marko_created_lop.head, marko
        )
        self.assertEqual(
            marko_created_lop.tail, lop
        )
        self.assertDictEqual(
            marko_created_lop.properties,
            {
                "weight": 0.4
            }
        )

        self.assertIn(marko_knows_josh, self.graph)
        self.assertEqual(
            marko_knows_josh.label, "knows"
        )
        self.assertEqual(
            marko_knows_josh.head, marko
        )
        self.assertEqual(
            marko_knows_josh.tail, josh
        )
        self.assertDictEqual(
            marko_knows_josh.properties,
            {
                "weight": 1
            }
        )

        self.assertIn(marko_knows_vadas, self.graph)
        self.assertEqual(
            marko_knows_vadas.label, "knows"
        )
        self.assertEqual(
            marko_knows_vadas.head, marko
        )
        self.assertEqual(
            marko_knows_vadas.tail, vadas
        )
        self.assertDictEqual(
            marko_knows_vadas.properties,
            {
                "weight": 0.5
            }
        )

        self.assertIn(josh_created_ripple, self.graph)
        self.assertEqual(
            josh_created_ripple.label, "created"
        )
        self.assertEqual(
            josh_created_ripple.head, josh
        )
        self.assertEqual(
            josh_created_ripple.tail, ripple
        )
        self.assertDictEqual(
            josh_created_ripple.properties,
            {
                "weight": 1
            }
        )