def test_excluded(self):
"Prevent D from B (go through C)"
kwargs = {
'excluded_routes': [
{
'target': 'tests.D',
'source': 'tests.B'
},
],
}
tree = ModelTree(A, **kwargs)
self.assertEqual(tree._excluded_joins, {(B, D): None})
self.assertTrue(tree._join_allowed(C, D))
self.assertFalse(tree._join_allowed(B, D))
expected_paths = [
[],
[B],
[C],
[C, D],
[C, D, E],
[C, D, F],
[B, G],
[B, G, H],
[B, G, H, I],
[C, D, E, J],
[C, D, E, J, K],
]
compare_paths(self, tree, expected_paths)
def test_required_long(self):
"G from H rather than D or B."
kwargs = {
'required_routes': [{
'target': 'tests.G',
'source': 'tests.H'
}],
}
tree = ModelTree(A, **kwargs)
self.assertEqual(tree._required_joins, {(H, G): None})
self.assertTrue(tree._join_allowed(H, G))
self.assertFalse(tree._join_allowed(B, G))
self.assertFalse(tree._join_allowed(D, G))
expected_paths = [
[],
[B],
[C],
[B, D],
[B, D, E],
[B, D, F],
[B, D, F, H, G],
[B, D, F, H],
[B, D, F, H, I],
[B, D, E, J],
[B, D, E, J, K],
]
compare_paths(self, tree, expected_paths)
def test_required(self):
"D from C rather than B (default)"
kwargs = {
'required_routes': [{
'target': 'tests.D',
'source': 'tests.C'
}],
}
tree = ModelTree(A, **kwargs)
self.assertEqual(tree._required_joins, {(C, D): None})
self.assertTrue(tree._join_allowed(C, D))
self.assertFalse(tree._join_allowed(B, D))
expected_paths = [
[],
[B],
[C],
[C, D],
[C, D, E],
[C, D, F],
[B, G],
[B, G, H],
[B, G, H, I],
[C, D, E, J],
[C, D, E, J, K],
]
compare_paths(self, tree, expected_paths)
def test_excluded(self):
"Prevent D from B (go through C)"
kwargs = {
'excluded_routes': [
{
'target': 'tests.D',
'source': 'tests.B'
},
],
}
tree = ModelTree(A, **kwargs)
self.assertEqual(tree._excluded_joins, {(B, D): None})
self.assertTrue(tree._join_allowed(C, D))
self.assertFalse(tree._join_allowed(B, D))
expected_paths = [
[],
[B],
[C],
[C, D],
[C, D, E],
[C, D, F],
[B, G],
[B, G, H],
[B, G, H, I],
[C, D, E, J],
[C, D, E, J, K],
]
compare_paths(self, tree, expected_paths)
def test_required(self):
"D from C rather than B (default)"
kwargs = {
'required_routes': [{
'target': 'tests.D',
'source': 'tests.C'
}],
}
tree = ModelTree(A, **kwargs)
self.assertEqual(tree._required_joins, {(C, D): None})
self.assertTrue(tree._join_allowed(C, D))
self.assertFalse(tree._join_allowed(B, D))
expected_paths = [
[],
[B],
[C],
[C, D],
[C, D, E],
[C, D, F],
[B, G],
[B, G, H],
[B, G, H, I],
[C, D, E, J],
[C, D, E, J, K],
]
compare_paths(self, tree, expected_paths)
def test_required_long(self):
"G from H rather than D or B."
kwargs = {
'required_routes': [{
'target': 'tests.G',
'source': 'tests.H'
}],
}
tree = ModelTree(A, **kwargs)
self.assertEqual(tree._required_joins, {(H, G): None})
self.assertTrue(tree._join_allowed(H, G))
self.assertFalse(tree._join_allowed(B, G))
self.assertFalse(tree._join_allowed(D, G))
expected_paths = [
[],
[B],
[C],
[B, D],
[B, D, E],
[B, D, F],
[B, D, F, H, G],
[B, D, F, H],
[B, D, F, H, I],
[B, D, E, J],
[B, D, E, J, K],
]
compare_paths(self, tree, expected_paths)
def test_required_excluded_combo_long(self):
"G from H (rather than D or B), not F from D, not D from B"
kwargs = {
'required_routes': [{
'target': 'tests.G',
'source': 'tests.H'
}],
'excluded_routes': [{
'target': 'tests.D',
'source': 'tests.B',
}, {
'target': 'tests.F',
'source': 'tests.D',
}],
}
tree = ModelTree(A, **kwargs)
self.assertEqual(tree._required_joins, {G: H})
self.assertEqual(tree._required_join_fields, {})
self.assertEqual(tree._excluded_joins, {D: B, F: D})
self.assertEqual(tree._excluded_join_fields, {})
self.assertTrue(tree._join_allowed(C, D))
self.assertFalse(tree._join_allowed(B, D))
self.assertTrue(tree._join_allowed(H, G))
self.assertTrue(tree._join_allowed(H, F))
self.assertFalse(tree._join_allowed(B, G))
self.assertFalse(tree._join_allowed(D, G))
self.assertFalse(tree._join_allowed(D, F))
expected_paths = [
[],
[B],
[C],
[C, D],
[C, D, E],
[C, D, E, J, F],
[C, D, E, J, F, H, G],
[C, D, E, J, F, H],
[C, D, E, J, F, H, I],
[C, D, E, J],
[C, D, E, J, K],
]
compare_paths(self, tree, models, expected_paths)
def test_required_excluded_combo_long(self):
"G from H (rather than D or B), not F from D, not D from B"
kwargs = {
'required_routes': [{
'target': 'tests.G',
'source': 'tests.H'
}],
'excluded_routes': [{
'target': 'tests.D',
'source': 'tests.B',
}, {
'target': 'tests.F',
'source': 'tests.D',
}],
}
tree = ModelTree(A, **kwargs)
self.assertEqual(tree._required_joins, {(H, G): None})
self.assertEqual(tree._excluded_joins, {(B, D): None, (D, F): None})
self.assertTrue(tree._join_allowed(C, D))
self.assertFalse(tree._join_allowed(B, D))
self.assertTrue(tree._join_allowed(H, G))
self.assertTrue(tree._join_allowed(H, F))
self.assertFalse(tree._join_allowed(B, G))
self.assertFalse(tree._join_allowed(D, G))
self.assertFalse(tree._join_allowed(D, F))
expected_paths = [
[],
[B],
[C],
[C, D],
[C, D, E],
[C, D, E, J, F],
[C, D, E, J, F, H, G],
[C, D, E, J, F, H],
[C, D, E, J, F, H, I],
[C, D, E, J],
[C, D, E, J, K],
]
compare_paths(self, tree, expected_paths)
