test/unittest_rqlrewrite.py
changeset 7791 31bb51ea5485
parent 7790 7e16e056eecb
child 7795 b8027b317d1c
--- a/test/unittest_rqlrewrite.py	Wed Sep 14 09:10:58 2011 +0200
+++ b/test/unittest_rqlrewrite.py	Wed Sep 14 09:11:50 2011 +0200
@@ -110,7 +110,7 @@
                            'P name "read", P require_group G')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'X'): (constraint,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any C WHERE C is Card, B eid %(D)s, "
                              "EXISTS(C in_state A, B in_group E, F require_state A, "
                              "F name 'read', F require_group E, A is State, E is CWGroup, F is CWPermission)")
@@ -129,13 +129,13 @@
                              "F name 'read', F require_group E, A is State, E is CWGroup, F is CWPermission), "
                              "(EXISTS(S ref LIKE 'PUBLIC%')) OR (EXISTS(B in_group G, G name 'public', G is CWGroup)), "
                              "S is Affaire")
-        self.failUnless('D' in kwargs)
+        self.assertTrue('D' in kwargs)
 
     def test_or(self):
         constraint = '(X identity U) OR (X in_state ST, CL identity U, CL in_state ST, ST name "subscribed")'
         rqlst = parse('Any S WHERE S owned_by C, C eid %(u)s, S is in (CWUser, CWGroup)')
         rewrite(rqlst, {('C', 'X'): (constraint,)}, {'u':1})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any S WHERE S owned_by C, C eid %(u)s, S is IN(CWUser, CWGroup), A eid %(B)s, "
                              "EXISTS((C identity A) OR (C in_state D, E identity A, "
                              "E in_state D, D name 'subscribed'), D is State, E is CWUser)")
@@ -145,7 +145,7 @@
                            'P name "read", P require_group G')
         rqlst = parse('Any 2') # this is the simplified rql st for Any X WHERE X eid 12
         rewrite(rqlst, {('2', 'X'): (constraint,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any 2 WHERE B eid %(C)s, "
                              "EXISTS(2 in_state A, B in_group D, E require_state A, "
                              "E name 'read', E require_group D, A is State, D is CWGroup, E is CWPermission)")
@@ -155,7 +155,7 @@
                            'P name "read", P require_group G')
         rqlst = parse('Any A,C WHERE A documented_by C?')
         rewrite(rqlst, {('C', 'X'): (constraint,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any A,C WHERE A documented_by C?, A is Affaire "
                              "WITH C BEING "
                              "(Any C WHERE EXISTS(C in_state B, D in_group F, G require_state B, G name 'read', "
@@ -166,7 +166,7 @@
                            'P name "read", P require_group G')
         rqlst = parse('Any A,C,T WHERE A documented_by C?, C title T')
         rewrite(rqlst, {('C', 'X'): (constraint,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any A,C,T WHERE A documented_by C?, A is Affaire "
                              "WITH C,T BEING "
                              "(Any C,T WHERE C title T, EXISTS(C in_state B, D in_group F, "
@@ -179,7 +179,7 @@
         constraint2 = 'X in_state S, S name "public"'
         rqlst = parse('Any A,C,T WHERE A documented_by C?, C title T')
         rewrite(rqlst, {('C', 'X'): (constraint1, constraint2)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any A,C,T WHERE A documented_by C?, A is Affaire "
                              "WITH C,T BEING (Any C,T WHERE C title T, "
                              "EXISTS(C in_state B, D in_group F, G require_state B, G name 'read', G require_group F), "
@@ -194,7 +194,7 @@
         rewrite(rqlst, {('LA', 'X'): (constraint1, constraint2),
                         ('X', 'X'): (constraint3,),
                         ('Y', 'X'): (constraint3,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u'Any X,LA,Y WHERE LA? documented_by X, LA concerne Y, B eid %(C)s, '
                              'EXISTS(X created_by B), EXISTS(Y created_by B), '
                              'X is Card, Y is IN(Division, Note, Societe) '
@@ -223,7 +223,7 @@
     #     rewrite(rqlst, {('C', 'X'): (c1,),
     #                     ('A', 'X'): (c2,),
     #                     }, {})
-    #     self.failUnlessEqual(rqlst.as_string(),
+    #     self.assertEqual(rqlst.as_string(),
     #                          "")
 
     def test_optional_var_inlined_imbricated_error(self):
@@ -243,14 +243,14 @@
         snippet = ('X in_state S, S name "hop"')
         rqlst = parse('Card C WHERE C in_state STATE')
         rewrite(rqlst, {('C', 'X'): (snippet,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any C WHERE C in_state STATE, C is Card, "
                              "EXISTS(STATE name 'hop'), STATE is State")
     def test_relation_optimization_1_rhs(self):
         snippet = ('TW subworkflow_exit X, TW name "hop"')
         rqlst = parse('WorkflowTransition C WHERE C subworkflow_exit EXIT')
         rewrite(rqlst, {('EXIT', 'X'): (snippet,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any C WHERE C subworkflow_exit EXIT, C is WorkflowTransition, "
                              "EXISTS(C name 'hop'), EXIT is SubWorkflowExitPoint")
 
@@ -259,14 +259,14 @@
         snippet = ('X in_state S?, S name "hop"')
         rqlst = parse('Card C WHERE C in_state STATE?')
         rewrite(rqlst, {('C', 'X'): (snippet,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any C WHERE C in_state STATE?, C is Card, "
                              "EXISTS(STATE name 'hop'), STATE is State")
     def test_relation_optimization_2_rhs(self):
         snippet = ('TW? subworkflow_exit X, TW name "hop"')
         rqlst = parse('SubWorkflowExitPoint EXIT WHERE C? subworkflow_exit EXIT')
         rewrite(rqlst, {('EXIT', 'X'): (snippet,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any EXIT WHERE C? subworkflow_exit EXIT, EXIT is SubWorkflowExitPoint, "
                              "EXISTS(C name 'hop'), C is WorkflowTransition")
 
@@ -275,14 +275,14 @@
         snippet = ('X in_state S?, S name "hop"')
         rqlst = parse('Card C WHERE C in_state STATE')
         rewrite(rqlst, {('C', 'X'): (snippet,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any C WHERE C in_state STATE, C is Card, "
                              "EXISTS(STATE name 'hop'), STATE is State")
     def test_relation_optimization_3_rhs(self):
         snippet = ('TW? subworkflow_exit X, TW name "hop"')
         rqlst = parse('WorkflowTransition C WHERE C subworkflow_exit EXIT')
         rewrite(rqlst, {('EXIT', 'X'): (snippet,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any C WHERE C subworkflow_exit EXIT, C is WorkflowTransition, "
                              "EXISTS(C name 'hop'), EXIT is SubWorkflowExitPoint")
 
@@ -291,14 +291,14 @@
         snippet = ('X in_state S, S name "hop"')
         rqlst = parse('Card C WHERE C in_state STATE?')
         rewrite(rqlst, {('C', 'X'): (snippet,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any C WHERE C in_state STATE?, C is Card, "
                              "EXISTS(C in_state A, A name 'hop', A is State), STATE is State")
     def test_relation_non_optimization_1_rhs(self):
         snippet = ('TW subworkflow_exit X, TW name "hop"')
         rqlst = parse('SubWorkflowExitPoint EXIT WHERE C? subworkflow_exit EXIT')
         rewrite(rqlst, {('EXIT', 'X'): (snippet,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              "Any EXIT WHERE C? subworkflow_exit EXIT, EXIT is SubWorkflowExitPoint, "
                              "EXISTS(A subworkflow_exit EXIT, A name 'hop', A is WorkflowTransition), "
                              "C is WorkflowTransition")
@@ -313,7 +313,7 @@
         trinfo_constraint = ('X wf_info_for Y, Y require_permission P, P name "read"')
         rqlst = parse('Any U,T WHERE U is CWUser, T wf_info_for U')
         rewrite(rqlst, {('T', 'X'): (trinfo_constraint, 'X wf_info_for Y, Y in_group G, G name "managers"')}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any U,T WHERE U is CWUser, T wf_info_for U, "
                              "EXISTS(U in_group B, B name 'managers', B is CWGroup), T is TrInfo")
 
@@ -322,14 +322,14 @@
         trinfo_constraint = ('X wf_info_for Y, Y require_permission P, P name "read"')
         rqlst = parse('Any T WHERE T wf_info_for X')
         rewrite(rqlst, {('T', 'X'): (trinfo_constraint, 'X in_group G, G name "managers"')}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u'XXX dunno what should be generated')
 
     def test_add_ambiguity_exists(self):
         constraint = ('X concerne Y')
         rqlst = parse('Affaire X')
         rewrite(rqlst, {('X', 'X'): (constraint,)}, {})
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any X WHERE X is Affaire, ((EXISTS(X concerne A, A is Division)) OR (EXISTS(X concerne C, C is Societe))) OR (EXISTS(X concerne B, B is Note))")
 
     def test_add_ambiguity_outerjoin(self):
@@ -337,7 +337,7 @@
         rqlst = parse('Any X,C WHERE X? documented_by C')
         rewrite(rqlst, {('X', 'X'): (constraint,)}, {})
         # ambiguity are kept in the sub-query, no need to be resolved using OR
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any X,C WHERE X? documented_by C, C is Card WITH X BEING (Any X WHERE EXISTS(X concerne A), X is Affaire)")
 
 
@@ -345,76 +345,76 @@
         constraint = RRQLExpression('S owned_by U')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'SU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any C WHERE C is Card, A eid %(B)s, EXISTS(C owned_by A)")
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'OU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any C WHERE C is Card")
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'SOU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any C WHERE C is Card, A eid %(B)s, EXISTS(C owned_by A)")
 
     def test_rrqlexpr_nonexistant_subject_2(self):
         constraint = RRQLExpression('S owned_by U, O owned_by U, O is Card')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'SU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              'Any C WHERE C is Card, A eid %(B)s, EXISTS(C owned_by A)')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'OU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              'Any C WHERE C is Card, B eid %(D)s, EXISTS(A owned_by B, A is Card)')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'SOU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              'Any C WHERE C is Card, A eid %(B)s, EXISTS(C owned_by A, D owned_by A, D is Card)')
 
     def test_rrqlexpr_nonexistant_subject_3(self):
         constraint = RRQLExpression('U in_group G, G name "users"')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'SU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u'Any C WHERE C is Card, A eid %(B)s, EXISTS(A in_group D, D name "users", D is CWGroup)')
 
     def test_rrqlexpr_nonexistant_subject_4(self):
         constraint = RRQLExpression('U in_group G, G name "users", S owned_by U')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'SU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u'Any C WHERE C is Card, A eid %(B)s, EXISTS(A in_group D, D name "users", C owned_by A, D is CWGroup)')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'OU')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u'Any C WHERE C is Card, A eid %(B)s, EXISTS(A in_group D, D name "users", D is CWGroup)')
 
     def test_rrqlexpr_nonexistant_subject_5(self):
         constraint = RRQLExpression('S owned_by Z, O owned_by Z, O is Card')
         rqlst = parse('Card C')
         rewrite(rqlst, {('C', 'S'): (constraint,)}, {}, 'S')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u"Any C WHERE C is Card, EXISTS(C owned_by A, A is CWUser)")
 
     def test_rqlexpr_not_relation_1_1(self):
         constraint = RRQLExpression('X owned_by Z, Z login "hop"', 'X')
         rqlst = parse('Affaire A WHERE NOT EXISTS(A documented_by C)')
         rewrite(rqlst, {('C', 'X'): (constraint,)}, {}, 'X')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u'Any A WHERE NOT EXISTS(A documented_by C, EXISTS(C owned_by B, B login "hop", B is CWUser), C is Card), A is Affaire')
 
     def test_rqlexpr_not_relation_1_2(self):
         constraint = RRQLExpression('X owned_by Z, Z login "hop"', 'X')
         rqlst = parse('Affaire A WHERE NOT EXISTS(A documented_by C)')
         rewrite(rqlst, {('A', 'X'): (constraint,)}, {}, 'X')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u'Any A WHERE NOT EXISTS(A documented_by C, C is Card), A is Affaire, EXISTS(A owned_by B, B login "hop", B is CWUser)')
 
     def test_rqlexpr_not_relation_2(self):
         constraint = RRQLExpression('X owned_by Z, Z login "hop"', 'X')
         rqlst = rqlhelper.parse('Affaire A WHERE NOT A documented_by C', annotate=False)
         rewrite(rqlst, {('C', 'X'): (constraint,)}, {}, 'X')
-        self.failUnlessEqual(rqlst.as_string(),
+        self.assertEqual(rqlst.as_string(),
                              u'Any A WHERE NOT EXISTS(A documented_by C, EXISTS(C owned_by B, B login "hop", B is CWUser), C is Card), A is Affaire')