Пример #1
0
    def testTwoRelationships(self):
        schema = Schema()
        schema.addEntity('A')
        schema.addEntity('B')
        schema.addEntity('C')
        schema.addRelationship('AB', ('A', Schema.MANY), ('B', Schema.ONE))
        schema.addRelationship('BC', ('B', Schema.ONE), ('C', Schema.MANY))

        relPaths = RelationalSpace.getRelationalPaths(schema, 0)
        hop0 = [['A'], ['B'], ['C'], ['AB'], ['BC']]
        TestUtil.assertUnorderedListEqual(self, hop0, relPaths)

        relPaths = RelationalSpace.getRelationalPaths(schema, 1)
        hop1 = [['A', 'AB'], ['B', 'AB'], ['B', 'BC'], ['C', 'BC'],
                ['AB', 'A'], ['AB', 'B'], ['BC', 'C'], ['BC', 'B']]
        TestUtil.assertUnorderedListEqual(self, hop0 + hop1, relPaths)

        relPaths = RelationalSpace.getRelationalPaths(schema, 2)
        hop2 = [['A', 'AB', 'B'], ['B', 'AB', 'A'], ['B', 'BC', 'C'],
                ['C', 'BC', 'B'], ['AB', 'A', 'AB'], ['AB', 'B', 'BC'],
                ['BC', 'C', 'BC'], ['BC', 'B', 'AB']]
        TestUtil.assertUnorderedListEqual(self, hop0 + hop1 + hop2, relPaths)

        relPaths = RelationalSpace.getRelationalPaths(schema, 3)
        hop3 = [['A', 'AB', 'B', 'BC'], ['B', 'AB', 'A', 'AB'],
                ['B', 'BC', 'C', 'BC'], ['C', 'BC', 'B', 'AB'],
                ['AB', 'A', 'AB', 'B'], ['AB', 'B', 'BC', 'C'],
                ['BC', 'C', 'BC', 'B'], ['BC', 'B', 'AB', 'A']]
        TestUtil.assertUnorderedListEqual(self, hop0 + hop1 + hop2 + hop3,
                                          relPaths)
Пример #2
0
    def testOneEntity(self):
        schema = Schema()
        schema.addEntity('A')
        relPaths = RelationalSpace.getRelationalPaths(schema, 0)
        TestUtil.assertUnorderedListEqual(self, [['A']], relPaths)

        schema = Schema()
        schema.addEntity('B')
        relPaths = RelationalSpace.getRelationalPaths(schema, 0)
        TestUtil.assertUnorderedListEqual(self, [['B']], relPaths)

        schema.addEntity('A')
        relPaths = RelationalSpace.getRelationalPaths(schema, 0)
        TestUtil.assertUnorderedListEqual(self, [['A'], ['B']], relPaths)
Пример #3
0
    def testOneRelationshipOneToMany(self):
        schema = Schema()
        schema.addEntity('A')
        schema.addEntity('B')
        schema.addRelationship('AB', ('A', Schema.MANY), ('B', Schema.ONE))

        relPaths = RelationalSpace.getRelationalPaths(schema, 0)
        hop0 = [['A'], ['B'], ['AB']]
        TestUtil.assertUnorderedListEqual(self, hop0, relPaths)

        relPaths = RelationalSpace.getRelationalPaths(schema, 1)
        hop1 = [['A', 'AB'], ['AB', 'A'], ['AB', 'B'], ['B', 'AB']]
        TestUtil.assertUnorderedListEqual(self, hop0 + hop1, relPaths)

        relPaths = RelationalSpace.getRelationalPaths(schema, 2)
        hop2 = [['A', 'AB', 'B'], ['AB', 'A', 'AB'], ['B', 'AB', 'A']]
        TestUtil.assertUnorderedListEqual(self, hop0 + hop1 + hop2, relPaths)

        relPaths = RelationalSpace.getRelationalPaths(schema, 3)
        hop3 = [['AB', 'A', 'AB', 'B'], ['B', 'AB', 'A', 'AB']]
        TestUtil.assertUnorderedListEqual(self, hop0 + hop1 + hop2 + hop3,
                                          relPaths)

        relPaths = RelationalSpace.getRelationalPaths(schema, 4)
        hop4 = [['B', 'AB', 'A', 'AB', 'B']]
        TestUtil.assertUnorderedListEqual(self,
                                          hop0 + hop1 + hop2 + hop3 + hop4,
                                          relPaths)

        relPaths = RelationalSpace.getRelationalPaths(schema, 5)
        hop5 = []
        TestUtil.assertUnorderedListEqual(
            self, hop0 + hop1 + hop2 + hop3 + hop4 + hop5, relPaths)
Пример #4
0
    def testOneRelationshipManyToOne(self):
        schema = Schema()
        schema.addEntity('A')
        schema.addEntity('B')
        schema.addRelationship('AB', ('A', Schema.ONE), ('B', Schema.MANY))

        relPaths = RelationalSpace.getRelationalPaths(schema, 3)
        hopUpTo3 = [['A'], ['B'], ['AB'], ['A', 'AB'], ['AB',
                                                        'A'], ['AB', 'B'],
                    ['B', 'AB'], ['A', 'AB', 'B'], ['AB', 'B', 'AB'],
                    ['B', 'AB', 'A'], ['A', 'AB', 'B', 'AB'],
                    ['AB', 'B', 'AB', 'A']]
        TestUtil.assertUnorderedListEqual(self, hopUpTo3, relPaths)