def test__setitem_by_slice_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1)]
rel = junction_.Junction((dogs,persons),('owners','pets'))
rel[:] = pairs
self.assertIs(rel._list[0], pairs[0]) # (0,0)
self.assertIs(rel._list[1], pairs[1]) # (1,1)
self.assertIs(rel._list[2], pairs[2]) # (2,0)
self.assertIs(rel._list[3], pairs[3]) # (0,1)
self.assertEqual(rel._fkmaps[0], {0 : [0, 3], 1 : [1], 2 : [2]})
self.assertEqual(rel._fkmaps[1], {0 : [0, 2], 1 : [1, 3]})
rel[1:3] = [ pairs[0], pairs[3] ]
self.assertIs(rel._list[0], pairs[0]) # (0,0)
self.assertIs(rel._list[1], pairs[0]) # (0,0)
self.assertIs(rel._list[2], pairs[3]) # (0,1)
self.assertIs(rel._list[3], pairs[3]) # (0,1)
self.assertEqual(rel._fkmaps[0], {0 : [0, 1, 2, 3]})
self.assertEqual(rel._fkmaps[1], {0 : [0, 1], 1 : [2, 3]})
def test__pair_1(self):
dogs, persons = (Dogs(), Persons())
rel = junction_.Junction((dogs, persons), ('owners', 'pets'))
l_pin = endpoint_.Endpoint(rel, relation_.LEFT)
r_pin = endpoint_.Endpoint(rel, relation_.RIGHT)
self.assertEqual(l_pin.pair(1, 2), pair_.Pair(1, 2))
self.assertEqual(r_pin.pair(2, 1), pair_.Pair(1, 2))
def test__opposite_entities_1(self):
(nil, one) = (Str(('nil', )), Str(('one', )))
(zero, jeden, dwa) = (Str(('zero', )), Str(('jeden', )), Str(
('dwa', )))
l_tab = Strs({'0': nil, '1': one})
r_tab = Strs({0: zero, 1: jeden, 2: dwa})
pairs = (pair_.Pair('0', 1), pair_.Pair('0', 2), pair_.Pair('1', 0))
rel = junction_.Junction((l_tab, r_tab), ('opposite', 'opposite'),
pairs)
left = endpoint_.Endpoint(rel, relation_.LEFT)
right = endpoint_.Endpoint(rel, relation_.RIGHT)
self.assertEqual(len(tuple(left.opposite_entities('0'))), 2)
self.assertEqual(len(tuple(left.opposite_entities('1'))), 1)
self.assertIs(tuple(left.opposite_entities('0'))[0], jeden)
self.assertIs(tuple(left.opposite_entities('0'))[1], dwa)
self.assertIs(tuple(left.opposite_entities('1'))[0], zero)
self.assertEqual(len(tuple(right.opposite_entities(0))), 1)
self.assertEqual(len(tuple(right.opposite_entities(1))), 1)
self.assertEqual(len(tuple(right.opposite_entities(2))), 1)
self.assertIs(tuple(right.opposite_entities(0))[0], one)
self.assertIs(tuple(right.opposite_entities(1))[0], nil)
self.assertIs(tuple(right.opposite_entities(2))[0], nil)
def test__setitem_by_slice_3(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1) ]
rel = junction_.Junction((dogs,persons),('owners','pets'), pairs)
with self.assertRaisesRegex(TypeError, r'%s is not an instance of %s' % (repr('foo'), repr(pair_.Pair))):
rel[:] = ['foo', 'bar']
def test__opposite_records_2(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
self.assertEqual(list(rel.opposite_records(relation_.LEFT, 4)), [])
self.assertEqual(list(rel.opposite_records(relation_.RIGHT, 4)), [])
def test__indices_for_2(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
self.assertEqual(rel.indices_for(relation_.LEFT, 4), [])
self.assertEqual(rel.indices_for(relation_.RIGHT, 4), [])
def test__opposite_records_1(self):
(nil, one) = (Str(('nil', )), Str(('one', )))
(zero, jeden, dwa) = (Str(('zero', )), Str(('jeden', )), Str(
('dwa', )))
l_tab = Strs({'0': nil, '1': one})
r_tab = Strs({0: zero, 1: jeden, 2: dwa})
pairs = (pair_.Pair('0', 1), pair_.Pair('0', 2), pair_.Pair('1', 0))
rel = junction_.Junction((l_tab, r_tab), ('opposite', 'opposite'),
pairs)
left = endpoint_.Endpoint(rel, relation_.LEFT)
right = endpoint_.Endpoint(rel, relation_.RIGHT)
lo = {
'0': tuple(left.opposite_records('0')),
'1': tuple(left.opposite_records('1'))
}
ro = {
0: tuple(right.opposite_records(0)),
1: tuple(right.opposite_records(1)),
2: tuple(right.opposite_records(2))
}
self.assertEqual(len(lo['0']), 2)
self.assertEqual(len(lo['1']), 1)
self.assertIsInstance(lo['0'][0], StrRec)
self.assertIsInstance(lo['0'][1], StrRec)
self.assertIsInstance(lo['1'][0], StrRec)
self.assertEqual(lo['0'][0], StrRec(jeden, r_tab, 1))
self.assertEqual(lo['0'][1], StrRec(dwa, r_tab, 2))
self.assertEqual(lo['1'][0], StrRec(zero, r_tab, 0))
self.assertIs(lo['0'][0].table, r_tab)
self.assertIs(lo['0'][1].table, r_tab)
self.assertIs(lo['1'][0].table, r_tab)
self.assertEqual(lo['0'][0].id, 1)
self.assertEqual(lo['0'][1].id, 2)
self.assertEqual(lo['1'][0].id, 0)
self.assertEqual(len(ro[0]), 1)
self.assertEqual(len(ro[1]), 1)
self.assertEqual(len(ro[2]), 1)
self.assertIsInstance(ro[0][0], StrRec)
self.assertIsInstance(ro[1][0], StrRec)
self.assertIsInstance(ro[2][0], StrRec)
self.assertEqual(ro[0][0], StrRec(one, l_tab, 1))
self.assertEqual(ro[1][0], StrRec(nil, l_tab, 0))
self.assertEqual(ro[2][0], StrRec(nil, l_tab, 0))
self.assertIs(ro[0][0].table, l_tab)
self.assertIs(ro[1][0].table, l_tab)
self.assertIs(ro[2][0].table, l_tab)
self.assertIs(ro[0][0].id, '1')
self.assertIs(ro[1][0].id, '0')
self.assertIs(ro[2][0].id, '0')
def test__index_2(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(0,0) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
self.assertEqual(rel.index(pairs[0]), 0)
self.assertEqual(rel.index(pairs[1]), 1)
self.assertEqual(rel.index(pairs[2]), 0)
def test__setitem_by_index_2(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1)]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
with self.assertRaises(IndexError): rel[ 4] = pairs[2]
with self.assertRaises(IndexError): rel[-5] = pairs[2]
def test__repr_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(0,0) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
self.assertEqual(repr(rel), 'Junction((%s,%s),(%s,%s))' % (
functions_.modelrefstr(dogs), functions_.modelrefstr(persons),
repr('owners'), repr('pets')
))
def test__count_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(0,0) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
self.assertEqual(rel.count(pairs[0]), 2)
self.assertEqual(rel.count(pairs[1]), 1)
self.assertEqual(rel.count(pairs[2]), 2)
self.assertEqual(rel.count(pair_.Pair(2,2)), 0)
def test__contains_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs[:3])
self.assertTrue(pairs[0] in rel)
self.assertTrue(pairs[1] in rel)
self.assertTrue(pairs[2] in rel)
self.assertTrue(pairs[3] not in rel)
def test__relations_for_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
self.assertEqual([id(x) for x in rel.relations_for(relation_.LEFT, 0)], [id(pairs[0]),id(pairs[3])])
self.assertEqual([id(x) for x in rel.relations_for(relation_.LEFT, 1)], [id(pairs[1])])
self.assertEqual([id(x) for x in rel.relations_for(relation_.LEFT, 2)], [id(pairs[2])])
self.assertEqual([id(x) for x in rel.relations_for(relation_.RIGHT, 0)], [id(pairs[0]),id(pairs[2])])
self.assertEqual([id(x) for x in rel.relations_for(relation_.RIGHT, 1)], [id(pairs[1]),id(pairs[3])])
def test__opposite_entities_1(self):
left = Chars({'a' : Char(('A',)), 'b' : Char(('B',)), 'c' : Char(('C',))})
right = Chars({'a' : Char(('X',)), 'b' : Char(('Y',))})
pairs = [ pair_.Pair('a','a'), pair_.Pair('b','b'), pair_.Pair('c','a'), pair_.Pair('a','b') ]
rel = junction_.Junction((left,right),('r','l'),pairs)
self.assertEqual(list(rel.opposite_entities(relation_.LEFT, 'a')), [Char(('X',)), Char(('Y',))])
self.assertEqual(list(rel.opposite_entities(relation_.LEFT, 'b')), [Char(('Y',))])
self.assertEqual(list(rel.opposite_entities(relation_.LEFT, 'c')), [Char(('X',))])
self.assertEqual(list(rel.opposite_entities(relation_.RIGHT, 'a')), [Char(('A',)),Char(('C',))])
self.assertEqual(list(rel.opposite_entities(relation_.RIGHT, 'b')), [Char(('B',)),Char(('A',))])
def test__opposite_keys_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair('a','a'), pair_.Pair('b','b'), pair_.Pair('c','a'), pair_.Pair('a','b') ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
self.assertEqual(list(rel.opposite_keys(relation_.LEFT, 'a')), ['a', 'b'])
self.assertEqual(list(rel.opposite_keys(relation_.LEFT, 'b')), ['b'])
self.assertEqual(list(rel.opposite_keys(relation_.LEFT, 'c')), ['a'])
self.assertEqual(list(rel.opposite_keys(relation_.RIGHT, 'a')), ['a','c'])
self.assertEqual(list(rel.opposite_keys(relation_.RIGHT, 'b')), ['b','a'])
def test__reversed_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
rev = list(reversed(rel))
self.assertIs(rev[0], pairs[3])
self.assertIs(rev[1], pairs[2])
self.assertIs(rev[2], pairs[1])
self.assertIs(rev[3], pairs[0])
def test__iter_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1) ]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
it = iter(rel)
self.assertIs(next(it), pairs[0])
self.assertIs(next(it), pairs[1])
self.assertIs(next(it), pairs[2])
self.assertIs(next(it), pairs[3])
def test__delitem_by_slice_3(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1)]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
del rel[1:-1]
self.assertEqual(len(rel), 2)
self.assertIs(rel._list[0], pairs[0]) # (0,0)
self.assertIs(rel._list[1], pairs[3]) # (0,1)
self.assertEqual(rel._fkmaps[0], {0 : [0, 1]})
self.assertEqual(rel._fkmaps[1], {0 : [0], 1 : [1]})
def test__delitem_by_index_4(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1)]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
with self.assertRaises(IndexError): del rel[ 4]
with self.assertRaises(IndexError): del rel[-5]
self.assertEqual(len(rel), 4)
self.assertIs(rel._list[0], pairs[0]) # (0,0)
self.assertIs(rel._list[1], pairs[1]) # (1,1)
self.assertIs(rel._list[2], pairs[2]) # (2,0)
self.assertIs(rel._list[3], pairs[3]) # (0,1)
def test__opposite_keys_1(self):
dogs = Dogs()
persons = Persons()
pairs = (pair_.Pair('0', 1), pair_.Pair('0', 2), pair_.Pair('1', 0))
rel = junction_.Junction((dogs, persons), ('owners', 'pets'), pairs)
left = endpoint_.Endpoint(rel, relation_.LEFT)
right = endpoint_.Endpoint(rel, relation_.RIGHT)
self.assertEqual(tuple(left.opposite_keys('0')), (1, 2))
self.assertEqual(tuple(left.opposite_keys('1')), (0, ))
self.assertEqual(tuple(right.opposite_keys(0)), ('1', ))
self.assertEqual(tuple(right.opposite_keys(1)), ('0', ))
self.assertEqual(tuple(right.opposite_keys(2)), ('0', ))
self.assertEqual(tuple(left.opposite_keys('2')), ())
def test__insert_2(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1)]
rel = junction_.Junction((dogs,persons),('owners','pets'),[pairs[1], pairs[0], pairs[3]])
rel.insert(1,pairs[3])
self.assertEqual(len(rel), 4)
self.assertIs(rel[0], pairs[1]) # (1,1)
self.assertIs(rel[1], pairs[3]) # (0,1)
self.assertIs(rel[2], pairs[0]) # (0,0)
self.assertIs(rel[3], pairs[3]) # (0,1)
self.assertEqual(rel._fkmaps[0], {0 : [1,2,3], 1 : [0]})
self.assertEqual(rel._fkmaps[1], {0 : [2], 1 : [0,1,3]})
def test__init_3(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair('a','a'), pair_.Pair('b','b'), pair_.Pair('c','a'), pair_.Pair('a','b')]
rel = junction_.Junction((dogs, persons), ('owners', 'pets'), pairs, False)
self.assertEqual(len(dogs.relations), 0)
self.assertEqual(len(persons.relations), 0)
self.assertIs(rel._list[0], pairs[0]) # ('a','a')
self.assertIs(rel._list[1], pairs[1]) # ('b','b')
self.assertIs(rel._list[2], pairs[2]) # ('c','a')
self.assertIs(rel._list[3], pairs[3]) # ('a','b')
self.assertEqual(rel._fkmaps[0], {'a' : [0, 3], 'b' : [1], 'c' : [2]})
self.assertEqual(rel._fkmaps[1], {'a' : [0, 2], 'b' : [1, 3]})
def test__insert_1(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1)]
rel = junction_.Junction((dogs,persons),('owners','pets'))
rel.insert(0,pairs[0])
rel.insert(1,pairs[1])
rel.insert(2,pairs[2])
rel.insert(2,pairs[3])
self.assertIs(rel._list[0], pairs[0]) # (0,0)
self.assertIs(rel._list[1], pairs[1]) # (1,1)
self.assertIs(rel._list[2], pairs[3]) # (0,1)
self.assertIs(rel._list[3], pairs[2]) # (2,0)
self.assertEqual(rel._fkmaps[0], {0 : [0, 2], 1 : [1], 2 : [3]})
self.assertEqual(rel._fkmaps[1], {0 : [0, 3], 1 : [1, 2]})
def test__init_2(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1)]
rel = junction_.Junction((dogs, persons), ('owners', 'pets'), pairs)
self.assertEqual(len(dogs.relations), 1)
self.assertEqual(len(persons.relations), 1)
self.assertIs(dogs.relations['owners'].relation, rel)
self.assertIs(persons.relations['pets'].relation, rel)
self.assertIs(rel._list[0], pairs[0]) # (0,0)
self.assertIs(rel._list[1], pairs[1]) # (1,1)
self.assertIs(rel._list[2], pairs[2]) # (2,0)
self.assertIs(rel._list[3], pairs[3]) # (0,1)
self.assertEqual(rel._fkmaps[0], {0 : [0, 3], 1 : [1], 2 : [2]})
self.assertEqual(rel._fkmaps[1], {0 : [0, 2], 1 : [1, 3]})
def test__setitem_by_slice_2(self):
dogs = Dogs()
persons = Persons()
pairs = [ pair_.Pair(0,0), pair_.Pair(1,1), pair_.Pair(2,0), pair_.Pair(0,1)]
rel = junction_.Junction((dogs,persons),('owners','pets'),pairs)
rel[2:6] = [ pairs[0], pairs[1], pairs[3], pairs[2] ]
self.assertEqual(len(rel), 6)
self.assertIs(rel._list[0], pairs[0]) # (0,0)
self.assertIs(rel._list[1], pairs[1]) # (1,1)
self.assertIs(rel._list[2], pairs[0]) # (0,0)
self.assertIs(rel._list[3], pairs[1]) # (1,1)
self.assertIs(rel._list[4], pairs[3]) # (0,1)
self.assertIs(rel._list[5], pairs[2]) # (2,0)
self.assertEqual(rel._fkmaps[0], {0 : [0, 2, 4], 1 : [1, 3], 2 : [5]})
self.assertEqual(rel._fkmaps[1], {0 : [0, 2, 5], 1 : [1, 3, 4]})
def test__opposite_records_1(self):
left = Chars({'a' : Char(('A',)), 'b' : Char(('B',)), 'c' : Char(('C',))})
right = Chars({'a' : Char(('X',)), 'b' : Char(('Y',))})
pairs = [ pair_.Pair('a','a'), pair_.Pair('b','b'), pair_.Pair('c','a'), pair_.Pair('a','b') ]
rel = junction_.Junction((left,right),('r','l'),pairs)
lo = { 'a': list(rel.opposite_records(relation_.LEFT, 'a')),
'b': list(rel.opposite_records(relation_.LEFT, 'b')),
'c': list(rel.opposite_records(relation_.LEFT, 'c')) }
ro = { 'a': list(rel.opposite_records(relation_.RIGHT, 'a')),
'b': list(rel.opposite_records(relation_.RIGHT, 'b')) }
self.assertEqual(lo['a'], [CharRec(('X',), right, 'a'), CharRec(('Y',), right, 'b')])
self.assertEqual(lo['b'], [CharRec(('Y',), right, 'b')])
self.assertEqual(lo['c'], [CharRec(('X',), right, 'a')])
self.assertEqual(ro['a'], [CharRec(('A',), left, 'a'), CharRec(('C',), left, 'c')])
self.assertEqual(ro['b'], [CharRec(('B',), left, 'b'), CharRec(('A',), left, 'a')])
self.assertIsInstance(lo['a'][0], CharRec)
self.assertIsInstance(lo['a'][1], CharRec)
self.assertIsInstance(lo['b'][0], CharRec)
self.assertIsInstance(lo['c'][0], CharRec)
self.assertIsInstance(ro['a'][0], CharRec)
self.assertIsInstance(ro['a'][1], CharRec)
self.assertIsInstance(ro['b'][0], CharRec)
self.assertIsInstance(ro['b'][1], CharRec)
self.assertIs(lo['a'][0].table, right)
self.assertIs(lo['a'][1].table, right)
self.assertIs(lo['b'][0].table, right)
self.assertIs(lo['c'][0].table, right)
self.assertIs(ro['a'][0].table, left)
self.assertIs(ro['a'][1].table, left)
self.assertIs(ro['b'][0].table, left)
self.assertIs(ro['b'][1].table, left)
self.assertIs(lo['a'][0].id, 'a')
self.assertIs(lo['a'][1].id, 'b')
self.assertIs(lo['b'][0].id, 'b')
self.assertIs(lo['c'][0].id, 'a')
self.assertIs(ro['a'][0].id, 'a')
self.assertIs(ro['a'][1].id, 'c')
self.assertIs(ro['b'][0].id, 'b')
self.assertIs(ro['b'][1].id, 'a')
def test__eq_1(self):
self.assertTrue(pair_.Pair(12, 34) == pair_.Pair(12, 34))
self.assertFalse(pair_.Pair(12, 34) == pair_.Pair(32, 12))
def test__wrap_2(self):
p = pair_.Pair(0, 1)
self.assertIs(pair_.PairList().__wrap__(p), p)
def test__init_1(self):
rel = pair_.Pair(21, 12)
self.assertEqual(rel._data, (21, 12))
def test__repr_1(self):
self.assertEqual(repr(pair_.Pair(12, 34)), 'Pair(%r,%r)' % (12, 34))
