From aca21e665d1f46325fa323f2d6e2bf2b1f01119a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9rome=20Perrin?= <jerome@nexedi.com> Date: Thu, 22 Mar 2007 10:34:09 +0000 Subject: [PATCH] Big cleanup. Separate some test in different test methods to isolate failures more easilly git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@13548 20353a03-c40f-0410-a6d1-a30d3c3de9de --- product/ERP5/tests/testPredicate.py | 188 +++++++++++++++++----------- 1 file changed, 117 insertions(+), 71 deletions(-) diff --git a/product/ERP5/tests/testPredicate.py b/product/ERP5/tests/testPredicate.py index 408668aef2..8df4cd07f8 100644 --- a/product/ERP5/tests/testPredicate.py +++ b/product/ERP5/tests/testPredicate.py @@ -31,13 +31,7 @@ """ -import os, sys -if __name__ == '__main__': - execfile(os.path.join(sys.path[0], 'framework.py')) - -# Needed in order to have a log file inside the current folder -os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log') -os.environ['EVENT_LOG_SEVERITY'] = '-300' +import unittest from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase from Products.ERP5Type.tests.utils import createZODBPythonScript @@ -122,6 +116,16 @@ class TestPredicates(ERP5TypeTestCase): self.failUnless('Predicate' in [x.id for x in predicate_folder.allowedContentTypes()]) return predicate_folder + + def createPredicate(self, **kw): + """Generic method to create a predicate""" + return self.getPredicateFolder().newContent( + portal_type = 'Predicate', **kw) + + def createDocument(self, **kw): + """Creates a document.""" + return self.getOrganisationModule().newContent( + portal_type='Organisation', **kw) def stepCreatePredicateTrueScript(self, sequence=None, **kw) : """Creates a script that always return true""" @@ -135,11 +139,6 @@ class TestPredicates(ERP5TypeTestCase): 'Predicate_false', '', """return 0""") sequence.edit(test_method_id = 'Predicate_false') - def createPredicate(self, **kw): - """Generic method to create a predicate""" - return self.getPredicateFolder().newContent( - portal_type = 'Predicate', **kw) - def stepCreateTestMethodIdPredicate(self, sequence=None, **kw) : """Creates a predicate with a test method_id""" sequence.edit(predicate = self.createPredicate( @@ -264,71 +263,121 @@ class TestPredicates(ERP5TypeTestCase): doc = sequence.get('doc') predicate = sequence.get('predicate') self.assertFalse(predicate.test(doc)) - + ############################################################################ ## Test Methods ############################################################ ############################################################################ - def test_Interface(self, quiet=QUIET, run=RUN_ALL_TESTS): + def test_Interface(self): """Test Predicate implements Predicate interface.""" - if not run : return from Products.ERP5Type.Interface import Predicate as IPredicate from Products.ERP5Type.Document.Predicate import Predicate predicate = self.createPredicate() self.failUnless(IPredicate.isImplementedBy(predicate)) from Interface.Verify import verifyClass verifyClass(IPredicate, Predicate) + + + def test_BasicCategoryMembership(self): + # Predicates can test that a document is member of a category + doc = self.createDocument(region='europe/western_europe/france',) + pred = self.createPredicate( + membership_criterion_base_category_list=['region'], + membership_criterion_category_list= + ['region/europe/western_europe/france']) + # our document is member of france region, so the predicate is true + self.assertTrue(pred.test(doc)) + + + def test_BasicCategoryMembershipNotStrict(self): + # Predicates are not only true for strict membership, but can also be used + # with a parent category + doc = self.createDocument(region='europe/western_europe/france',) + pred = self.createPredicate( + membership_criterion_base_category_list=['region'], + membership_criterion_category_list=['region/europe']) + self.assertTrue(pred.test(doc)) + + + def test_BasicCategoryNonMembership(self): + # if the document is not member of the category, the predicate returns + # false + doc = self.createDocument(region='europe/western_europe/france',) + pred = self.createPredicate( + membership_criterion_base_category_list=['region'], + membership_criterion_category_list= + ['region/europe/western_europe/germany']) + self.assertFalse(pred.test(doc)) + + + def test_NonExistantCategoryMembership(self): + # the predicate also return false for non existant category and no error is + # raised. + doc = self.createDocument() + pred = self.createPredicate( + membership_criterion_base_category_list=['not_exist'], + membership_criterion_category_list=['not_exist/nothing']) + self.assertFalse(pred.test(doc)) + + + def test_EmptyPredicates(self): + # empty predicate are true + doc = self.createDocument() + pred = self.createPredicate() + self.assertTrue(pred.test(doc)) + + + def test_TestMethodId(self): + doc = self.createDocument(region='europe/western_europe/france',) + calls = [] + def true_method(): + calls.append(True) + return True + doc.true_method = true_method + def false_method(): + calls.append(False) + return False + doc.false_method = false_method + + # predicates can also be created with a test method id, which will be the + # id of a method to call on the document (of course it can be a python + # script). This method must return a boolean value. + pred = self.createPredicate(test_method_id='true_method') + self.assertTrue(pred.test(doc)) + self.assertEquals([True], calls) + + pred = self.createPredicate(test_method_id='false_method') + self.assertFalse(pred.test(doc)) + self.assertEquals([True, False], calls) - def test_CategoryMembership(self, quiet=QUIET, run=RUN_ALL_TESTS): - """Test basic category membership""" - if not run : return - self.playSequence(""" - stepCreateDocument - stepSetDocumentFranceRegionMembership - stepSetDocumentStoreverGroupMembership - stepCreateRegionFrancePredicate - stepAssertPredicateTrue - stepCreateGroupStoreverPredicate - stepAssertPredicateTrue - stepCreateGroupStoreverRegionFrancePredicate - stepAssertPredicateTrue - stepSetDocumentGermanyRegionMembership - stepAssertPredicateFalse - stepCreateRegionFrancePredicate - stepAssertPredicateFalse - """) - - def test_EmptyPredicates(self, quiet=QUIET, run=RUN_ALL_TESTS): - """Test empty and always false predicates.""" - if not run : return - self.playSequence(""" - stepCreateDocument - stepCreateEmptyPredicate - stepAssertPredicateTrue - stepCreateAlwaysFalsePredicate - stepAssertPredicateFalse - """) + # the use of method id can be mixed with category membership, both will + # have to be true for the predicate to be true. + pred = self.createPredicate( + test_method_id='true_method', + membership_criterion_base_category_list=['region'], + membership_criterion_category_list= + ['region/europe/western_europe/france']) + self.assertTrue(pred.test(doc)) + self.assertEquals([True, False, True], calls) + + pred = self.createPredicate( + test_method_id='false_method', + membership_criterion_base_category_list=['region'], + membership_criterion_category_list= + ['region/europe/western_europe/france']) + self.assertFalse(pred.test(doc)) + self.assertEquals([True, False, True, False], calls) - def test_TestMethodId(self, quiet=QUIET, run=RUN_ALL_TESTS): - """Test test_method_id attribute.""" - if not run : return - self.playSequence(""" - stepCreateDocument - stepSetDocumentFranceRegionMembership - stepCreateRegionFrancePredicate - stepAssertPredicateTrue - stepCreatePredicateTrueScript - stepCreateTestMethodIdPredicate - stepAssertPredicateTrue - stepCreateRegionFrancePredicateTruePredicate - stepAssertPredicateTrue - stepCreatePredicateFalseScript - stepCreateTestMethodIdPredicate - stepAssertPredicateFalse - stepCreateRegionFrancePredicateFalsePredicate - stepAssertPredicateFalse - """) + pred = self.createPredicate( + test_method_id='true_method', + membership_criterion_base_category_list=['region'], + membership_criterion_category_list=['region/other']) + self.assertFalse(pred.test(doc)) + # Note that if the document is not member of the category, the test_method + # is not called. + self.assertEquals([True, False, True, False], calls) + def test_PredicateFusion(self, quiet=QUIET, run=RUN_ALL_TESTS): """Test simple predicates fusion. New predicate act as a logical AND between predicates @@ -419,16 +468,13 @@ class TestPredicates(ERP5TypeTestCase): # TODO : # multi membership category +# asPredicate scripts # predicate range # predicate + category fusion using setPredicateCategoryList # predicate matrix ? -if __name__ == '__main__': - framework() -else: - import unittest - def test_suite(): - suite = unittest.TestSuite() - suite.addTest(unittest.makeSuite(TestPredicates)) - return suite +def test_suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestPredicates)) + return suite -- 2.30.9