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_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)
class ProxyModelTestCase(TestCase):
def setUp(self):
self.tree = ModelTree(model='proxy.Root')
def test_without_model(self):
f = TargetProxy._meta.pk
qs = self.tree.query_string_for_field(f)
self.assertEqual(qs, 'standard_path__id')
def test_with_model(self):
f = TargetProxy._meta.pk
qs = self.tree.query_string_for_field(f, model=TargetProxy)
self.assertEqual(qs, 'proxy_path__id')
class ProxyModelTestCase(TestCase):
def setUp(self):
self.tree = ModelTree(model='generic.GenericModel')
def test_content_type_fk(self):
f = ContentType._meta.pk
qs = self.tree.query_string_for_field(f)
self.assertEqual(qs, 'content_type__id')
def test_required_collision(self):
"""Prevent two rules requiring the same target, e.g.
C->D and B->D"""
kwargs = {
'required_routes': [{
'target': 'tests.D',
'source': 'tests.C'
}, {
'target': 'tests.D',
'source': 'tests.B'
}],
}
with self.assertRaises(ValueError):
ModelTree(A, **kwargs)
def test_default(self):
tree = ModelTree(A)
expected_paths = [
[],
[B],
[C],
[B, D],
[B, D, E],
[B, D, F],
[B, G],
[B, G, H],
[B, G, 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, {(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)
def test_default(self):
tree = ModelTree(A)
expected_paths = [
[],
[(B, 'b_set')],
[(C, 'c_set')],
[(B, 'b_set'), (D, 'd_set')],
[(B, 'b_set'), (D, 'd_set'), (E, 'e_set')],
[(B, 'b_set'), (D, 'd_set'), (F, 'f')],
[(B, 'b_set'), (G, 'g_set')],
[(B, 'b_set'), (G, 'g_set'), (H, 'h_set')],
[(B, 'b_set'), (G, 'g_set'), (H, 'h_set'), (I, 'i_set')],
[(B, 'b_set'), (D, 'd_set'), (E, 'e_set'), (J, 'j_set')],
[(B, 'b_set'), (D, 'd_set'), (E, 'e_set'), (J, 'j_set'),
(K, 'k_set')],
]
compare_paths_with_accessor(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 setUp(self):
self.tree = ModelTree(model='generic.GenericModel')
def setUp(self):
self.tree = ModelTree(model='proxy.Root')
def test_tree_from_proxy(self):
tree = ModelTree(model='proxy.TargetNonProxy')
f = TargetProxy._meta.pk
qs = tree.query_string_for_field(f, model=TargetProxy)
self.assertEqual(qs, 'path__proxy_path__id')
