Changeset 858 in main


Ignore:
Timestamp:
03/07/12 17:26:39 (10 years ago)
Author:
pcosquer
Message:

navigate: tests if results are groups

Location:
trunk/openPLM/plmapp
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/openPLM/plmapp/navigate.py

    r833 r858  
    3434from collections import defaultdict 
    3535 
    36 from django.contrib.auth.models import User 
     36from django.contrib.auth.models import User, Group 
    3737from django.template.loader import render_to_string 
    3838from django.utils.html import linebreaks 
     
    130130        # a PLMObject and an user may have the same id, so we add a variable 
    131131        # which tells if results contains users 
    132         self.users_result = False 
     132        self.users_result = self.groups_result = False 
    133133        if results: 
    134134            self.users_result = hasattr(results[0], "username") 
     135            self.groups_result = isinstance(results[0], Group) 
     136        self.plmobjects_result = not (self.groups_result or self.users_result) 
    135137        options = ("child", "parents", "doc", "owner", "signer", 
    136138                   "notified", "part", "owned", "to_sign", 
     
    199201        
    200202    def _create_child_edges(self, obj, *args): 
    201         if self.options[OSR] and self.users_result: 
     203        if self.options[OSR] and not self.plmobjects_result: 
    202204            return 
    203205        for child_l in obj.get_children(max_level=-1, related=("child",)): 
     
    214216     
    215217    def _create_parents_edges(self, obj, *args): 
    216         if self.options[OSR] and self.users_result: 
     218        if self.options[OSR] and not self.plmobjects_result: 
    217219            return 
    218220        for parent_l in obj.get_parents(max_level=-1, related=("parent",)): 
     
    229231    
    230232    def _create_part_edges(self, obj, *args): 
    231         if self.options[OSR] and self.users_result: 
     233        if self.options[OSR] and not self.plmobjects_result: 
    232234            return 
    233235        if isinstance(obj, GroupController): 
     
    250252     
    251253    def _create_doc_edges(self, obj, obj_id=None, *args): 
    252         if self.options[OSR] and self.users_result: 
     254        if self.options[OSR] and not self.plmobjects_result: 
    253255            return 
    254256        if isinstance(obj, GroupController): 
     
    289291 
    290292    def _create_object_edges(self, obj, role): 
    291         if self.options[OSR] and self.users_result: 
     293        if self.options[OSR] and not self.plmobjects_result: 
    292294            return 
    293295        node = "User%d" % obj.id 
     
    361363        # now that all parts have been added, we can add the documents 
    362364        if self.options["doc"]: 
    363             if isinstance(self.object, GroupController): 
    364                 self._create_doc_edges(self.object, None) 
    365             links = models.DocumentPartLink.objects.\ 
    366                     filter(part__in=self._part_to_node.keys()) 
    367             for link in links.select_related("document"): 
    368                 if self.options[OSR] and link.document_id not in self.results: 
    369                     continue 
    370                  
    371                 self.edges.add((link.part_id, link.document_id, " ")) 
    372                 self._set_node_attributes(link.document) 
     365            if not (self.options[OSR] and not self.plmobjects_result): 
     366                if isinstance(self.object, GroupController): 
     367                    self._create_doc_edges(self.object, None) 
     368                links = models.DocumentPartLink.objects.\ 
     369                        filter(part__in=self._part_to_node.keys()) 
     370                for link in links.select_related("document"): 
     371                    if self.options[OSR] and link.document_id not in self.results: 
     372                        continue 
     373                     
     374                    self.edges.add((link.part_id, link.document_id, " ")) 
     375                    self._set_node_attributes(link.document) 
    373376 
    374377        elif not isinstance(self.object, UserController): 
    375             ids = self.options["doc_parts"].intersection(self._part_to_node.keys())  
    376             links = models.DocumentPartLink.objects.filter(part__in=ids) 
    377             for link in links.select_related("document"): 
    378                 if self.options[OSR] and link.document_id not in self.results: 
    379                     continue 
    380                  
    381                 self.edges.add((link.part_id, link.document_id, " ")) 
    382                 self._set_node_attributes(link.document) 
     378            if not (self.options[OSR] and not self.plmobjects_result): 
     379                ids = self.options["doc_parts"].intersection(self._part_to_node.keys())  
     380                links = models.DocumentPartLink.objects.filter(part__in=ids) 
     381                for link in links.select_related("document"): 
     382                    if self.options[OSR] and link.document_id not in self.results: 
     383                        continue 
     384                     
     385                    self.edges.add((link.part_id, link.document_id, " ")) 
     386                    self._set_node_attributes(link.document) 
    383387 
    384388        # treats the parts to see if they have an attached document 
  • trunk/openPLM/plmapp/tests/navigate.py

    r835 r858  
    33from django.contrib.auth.models import User 
    44 
    5 from openPLM.plmapp.navigate import NavigationGraph 
     5from openPLM.plmapp.navigate import NavigationGraph, OSR 
    66from openPLM.plmapp.controllers import PartController, DocumentController,\ 
    77        UserController, GroupController 
     
    2525        self.root = self.json = None 
    2626 
    27     def get_graph_data(self, options): 
    28         graph = NavigationGraph(self.controller) 
     27    def get_graph_data(self, options, results=()): 
     28        graph = NavigationGraph(self.controller, results) 
    2929        graph.set_options(options) 
    3030        graph.create_edges() 
     
    6969        Tests a navigate with the "owner" option set. 
    7070        """ 
    71         self.get_graph_data({"owner" : True }) 
    72         self.assertCount(2, 1) 
    73         main, owner = self.nodes 
    74         self.assertEqual("owner", self.edges[0].text_content()) 
    75         text = owner.text_content().strip() 
    76         self.assertTrue(self.user.first_name in text) 
    77         self.assertTrue(self.user.last_name in text) 
     71        for osr, results in ((False, ()), (True, (self.user,))): 
     72            self.get_graph_data({"owner" : True, OSR : osr }, results) 
     73            self.assertCount(2, 1) 
     74            main, owner = self.nodes 
     75            self.assertEqual("owner", self.edges[0].text_content()) 
     76            text = owner.text_content().strip() 
     77            self.assertTrue(self.user.first_name in text) 
     78            self.assertTrue(self.user.last_name in text) 
     79        for result in (self.cie, self.group, self.controller.object): 
     80            self.get_graph_data({"owner" : True, OSR : True }, (result,)) 
     81            self.assertCount(1, 0) 
    7882        
    7983    def test_navigate_signer(self): 
     
    8185        Tests a navigate with the "signer" option set. 
    8286        """ 
    83         self.get_graph_data({"signer" : True }) 
    84         self.assertCount(3, 2) 
    85         main, signer1, signer2 = self.nodes 
    86         for edge in self.edges: 
    87             self.assertTrue("sign" in edge.text_content()) 
    88         for node in (signer1, signer2): 
    89             text = node.text_content().strip() 
    90             self.assertTrue(self.user.first_name in text) 
    91             self.assertTrue(self.user.last_name in text) 
    92         self.assertNotEqual(signer1.attrib["id"], signer2.attrib["id"]) 
     87        for osr, results in ((False, ()), (True, (self.user,))): 
     88            self.get_graph_data({"signer" : True, OSR : osr }, results) 
     89            self.assertCount(3, 2) 
     90            main, signer1, signer2 = self.nodes 
     91            for edge in self.edges: 
     92                self.assertTrue("sign" in edge.text_content()) 
     93            for node in (signer1, signer2): 
     94                text = node.text_content().strip() 
     95                self.assertTrue(self.user.first_name in text) 
     96                self.assertTrue(self.user.last_name in text) 
     97            self.assertNotEqual(signer1.attrib["id"], signer2.attrib["id"]) 
     98        for result in (self.cie, self.group, self.controller.object): 
     99            self.get_graph_data({"signer" : True, OSR : True }, (result,)) 
     100            self.assertCount(1, 0) 
    93101 
    94102    def test_navigate_notified(self): 
     
    97105        """ 
    98106        self.controller.set_role(self.cie, "notified") 
    99         self.get_graph_data({"notified" : True }) 
    100         self.assertCount(2, 1) 
    101         main, owner = self.nodes 
    102         self.assertEqual("notified", self.edges[0].text_content()) 
    103         text = owner.text_content().strip() 
    104         self.assertTrue(self.cie.username in text) 
    105         
     107        for osr, results in ((False, ()), (True, (self.cie,))): 
     108            self.get_graph_data({"notified" : True }) 
     109            self.assertCount(2, 1) 
     110            main, owner = self.nodes 
     111            self.assertEqual("notified", self.edges[0].text_content()) 
     112            text = owner.text_content().strip() 
     113            self.assertTrue(self.cie.username in text) 
     114        for result in (self.user, self.group, self.controller.object): 
     115            self.get_graph_data({"notified" : True, OSR : True }, (result,)) 
     116            self.assertCount(1, 0) 
     117     
    106118 
    107119class PartNavigateTestCase(NavigateTestCase): 
     
    116128                self.user, data, True, True) 
    117129        self.controller.add_child(child1, 15, 789, "kg") 
    118         self.get_graph_data({"child" : True }) 
    119         self.assertCount(2, 1) 
    120         main, child_node = self.nodes 
    121         # check the edge 
    122         self.assertTrue("789" in self.edges[0].text_content()) 
    123         self.assertTrue("15" in self.edges[0].text_content()) 
    124         self.assertTrue("kg" in self.edges[0].text_content()) 
    125         text = child_node.text_content().strip() 
    126         self.assertTrue(data["name"] in text) 
     130        for osr, results in ((False, ()), (True, (child1.object,))): 
     131            self.get_graph_data({"child" : True, OSR : osr }, results) 
     132            self.assertCount(2, 1) 
     133            main, child_node = self.nodes 
     134            # check the edge 
     135            self.assertTrue("789" in self.edges[0].text_content()) 
     136            self.assertTrue("15" in self.edges[0].text_content()) 
     137            self.assertTrue("kg" in self.edges[0].text_content()) 
     138            text = child_node.text_content().strip() 
     139            self.assertTrue(data["name"] in text) 
    127140        # add another child to child1 
    128141        child2 = PartController.create("c2", "Part", "k", 
    129142                self.user, data, True, True) 
    130143        child1.add_child(child2, 15, 789, "kg") 
    131         self.get_graph_data({"child" : True }) 
    132         self.assertCount(3, 2) 
     144        for osr, results in ((False, ()), (True, (child1.object, child2.object))): 
     145            self.get_graph_data({"child" : True, OSR : osr }, results) 
     146            self.assertCount(3, 2) 
     147        # empty graph is child1 is not found 
     148        self.get_graph_data({"child" : True, OSR : True }, (child2.object,)) 
     149        self.assertCount(1, 0) 
    133150        # add child2 to the controller 
    134151        # we should have 3 nodes (controller, child1, child2) 
     
    136153        # child1 -> child2) 
    137154        self.controller.add_child(child2, 15, 789, "kg") 
    138         self.get_graph_data({"child" : True }) 
    139         self.assertCount(3, 3) 
     155        for osr, results in ((False, ()), (True, (child1.object, child2.object))): 
     156            self.get_graph_data({"child" : True, OSR : osr }, results) 
     157            self.assertCount(3, 3) 
     158        for result in (self.cie, self.group, self.user, self.controller.object): 
     159            self.get_graph_data({"child" : True, OSR : True }, (result,)) 
     160            self.assertCount(1, 0) 
    140161 
    141162    def test_navigate_parents(self): 
     
    148169                self.user, data, True, True) 
    149170        parent1.add_child(self.controller, 15, 789, "kg") 
    150         self.get_graph_data({"parents" : True }) 
    151         self.assertCount(2, 1) 
    152         main, parent_node = self.nodes 
    153         self.assertTrue("789" in self.edges[0].text_content()) 
    154         self.assertTrue("15" in self.edges[0].text_content()) 
    155         self.assertTrue("kg" in self.edges[0].text_content()) 
    156         text = parent_node.text_content().strip() 
    157         self.assertTrue(data["name"] in text) 
     171        for osr, results in ((False, ()), (True, (parent1.object, ))): 
     172            self.get_graph_data({"parents" : True, OSR : osr }, results) 
     173            self.assertCount(2, 1) 
     174            main, parent_node = self.nodes 
     175            self.assertTrue("789" in self.edges[0].text_content()) 
     176            self.assertTrue("15" in self.edges[0].text_content()) 
     177            self.assertTrue("kg" in self.edges[0].text_content()) 
     178            text = parent_node.text_content().strip() 
     179            self.assertTrue(data["name"] in text) 
    158180        # add another parent to parent1 
    159181        parent2 = PartController.create("c2", "Part", "k", 
    160182                self.user, data, True, True) 
    161183        parent2.add_child(parent1, 15, 789, "kg") 
    162         self.get_graph_data({"parents" : True }) 
    163         self.assertCount(3, 2) 
     184        for osr, results in ((False, ()), (True, (parent1.object, parent2.object))): 
     185            self.get_graph_data({"parents" : True, OSR : osr }, results) 
     186            self.assertCount(3, 2) 
     187        self.get_graph_data({"parents" : True, OSR : True }, (parent2.object,)) 
     188        self.assertCount(1, 0) 
    164189        # add the controller to parent2 
    165190        parent2.add_child(self.controller, 5, 79, "kg") 
    166         self.get_graph_data({"parents" : True }) 
    167         self.assertCount(3, 3) 
     191        for osr, results in ((False, ()), (True, (parent1.object, parent2.object))): 
     192            self.get_graph_data({"parents" : True, OSR : osr }, results) 
     193            self.assertCount(3, 3) 
     194        for result in (self.cie, self.group, self.user, self.controller.object): 
     195            self.get_graph_data({"parents" : True, OSR : True }, (result,)) 
     196            self.assertCount(1, 0) 
    168197 
    169198    def test_navigate_documents(self): 
     
    176205                self.user, data, True, True) 
    177206        self.controller.attach_to_document(doc) 
    178         self.get_graph_data({"doc" : True }) 
    179         self.assertCount(2, 1) 
    180         main, doc_node = self.nodes 
    181         text = doc_node.text_content().strip() 
    182         self.assertTrue(data["name"] in text) 
     207        for osr, results in ((False, ()), (True, (doc.object,))): 
     208            self.get_graph_data({"doc" : True, OSR : osr }, results) 
     209            self.assertCount(2, 1) 
     210            main, doc_node = self.nodes 
     211            text = doc_node.text_content().strip() 
     212            self.assertTrue(data["name"] in text) 
     213        for result in (self.cie, self.group, self.user, self.controller.object): 
     214            self.get_graph_data({"doc" : True, OSR : True }, (result,)) 
     215            self.assertCount(1, 0) 
    183216 
    184217    def test_navigate_doc_parts(self): 
     
    191224                self.user, data, True, True) 
    192225        self.controller.attach_to_document(doc) 
    193         self.get_graph_data({"doc" : False, 
    194             "doc_parts" : [self.controller.id] }) 
    195         self.assertCount(2, 1) 
    196         main, doc_node = self.nodes 
    197         text = doc_node.text_content().strip() 
    198         self.assertTrue(data["name"] in text) 
     226        for osr, results in ((False, ()), (True, (doc.object,))): 
     227            self.get_graph_data({"doc" : False, OSR : osr, 
     228                "doc_parts" : [self.controller.id] }, results) 
     229            self.assertCount(2, 1) 
     230            main, doc_node = self.nodes 
     231            text = doc_node.text_content().strip() 
     232            self.assertTrue(data["name"] in text) 
    199233 
    200234    def test_navigate_documents2(self): 
     
    212246        self.controller.attach_to_document(doc) 
    213247        child1.attach_to_document(doc) 
    214         self.get_graph_data({"doc" : True, "child" : True}) 
    215         self.assertCount(3, 3) 
     248        for osr, results in ((False, ()), (True, (doc.object, child1.object))): 
     249            self.get_graph_data({"doc" : True, "child" : True}) 
     250            self.assertCount(3, 3) 
    216251 
    217252 
     
    229264                self.user, data, True, True) 
    230265        self.controller.attach_to_part(part) 
    231         self.get_graph_data({"part" : True}) 
    232         self.assertCount(2, 1) 
    233         main, part_node = self.nodes 
    234         text = part_node.text_content().strip() 
    235         self.assertTrue(data["name"] in text) 
     266        for osr, results in ((False, ()), (True, (part.object,))): 
     267            self.get_graph_data({"part" : True, OSR: osr}, results) 
     268            self.assertCount(2, 1) 
     269            main, part_node = self.nodes 
     270            text = part_node.text_content().strip() 
     271            self.assertTrue(data["name"] in text) 
     272        for result in (self.cie, self.group, self.user, self.controller.object): 
     273            self.get_graph_data({"part" : True, OSR : True }, (result,)) 
     274            self.assertCount(1, 0) 
    236275 
    237276class GroupNavigateTestCase(NavigateTestCase): 
     
    239278    def setUp(self): 
    240279        super(GroupNavigateTestCase, self).setUp() 
     280        self.part = self.controller.object 
    241281        self.controller = GroupController(self.group, self.user) 
    242282 
     
    245285        Tests a navigate with the "owner" option set. 
    246286        """ 
    247         self.get_graph_data({"owner" : True }) 
    248         self.assertCount(2, 1) 
    249         main, owner = self.nodes 
    250         self.assertEqual("owner", self.edges[0].text_content()) 
    251         text = owner.text_content().strip() 
    252         self.assertTrue(self.user.first_name in text) 
    253         self.assertTrue(self.user.last_name in text) 
     287        for osr, results in ((False, ()), (True, (self.user,))): 
     288            self.get_graph_data({"owner" : True, OSR : osr }, results) 
     289            self.assertCount(2, 1) 
     290            main, owner = self.nodes 
     291            self.assertEqual("owner", self.edges[0].text_content()) 
     292            text = owner.text_content().strip() 
     293            self.assertTrue(self.user.first_name in text) 
     294            self.assertTrue(self.user.last_name in text) 
     295        for result in (self.cie, self.group, self.part): 
     296            self.get_graph_data({"owner" : True, OSR : True }, (result,)) 
     297            self.assertCount(1, 0) 
    254298 
    255299    def test_navigate_member(self): 
     
    257301        Tests a navigate with the "member" option set. 
    258302        """ 
    259         self.get_graph_data({"user" : True }) 
    260         self.assertCount(2, 1) 
    261         main, owner = self.nodes 
    262         self.assertEqual("member", self.edges[0].text_content()) 
    263         text = owner.text_content().strip() 
    264         self.assertTrue(self.user.first_name in text) 
    265         self.assertTrue(self.user.last_name in text) 
     303        for osr, results in ((False, ()), (True, (self.user,))): 
     304            self.get_graph_data({"user" : True, OSR : osr }, results) 
     305            self.assertCount(2, 1) 
     306            main, owner = self.nodes 
     307            self.assertEqual("member", self.edges[0].text_content()) 
     308            text = owner.text_content().strip() 
     309            self.assertTrue(self.user.first_name in text) 
     310            self.assertTrue(self.user.last_name in text) 
     311        for result in (self.cie, self.group, self.part): 
     312            self.get_graph_data({"member" : True, OSR : True }, (result,)) 
     313            self.assertCount(1, 0) 
    266314 
    267315    def test_navigate_two_members(self): 
     
    276324        brian.groups.add(self.group) 
    277325        brian.save() 
    278         self.get_graph_data({"user" : True }) 
    279         self.assertCount(3, 2) 
    280         for edge in self.edges: 
    281             self.assertEqual("member", edge.text_content()) 
    282         for node in self.nodes[1:]: 
    283             text = node.text_content().strip() 
    284             self.assertTrue(self.user.first_name in text or brian.username in text) 
     326        for osr, results in ((False, ()), (True, (self.user, brian))): 
     327            self.get_graph_data({"user" : True, OSR : osr }, results) 
     328            self.assertCount(3, 2) 
     329            for edge in self.edges: 
     330                self.assertEqual("member", edge.text_content()) 
     331            for node in self.nodes[1:]: 
     332                text = node.text_content().strip() 
     333                self.assertTrue(self.user.first_name in text or brian.username in text) 
     334        # only brian 
     335        self.get_graph_data({"user" : True, OSR : True }, (brian,)) 
     336        self.assertCount(2, 1) 
     337        self.assertEqual("member", self.edges[0].text_content()) 
     338        text = self.nodes[1].text_content().strip() 
     339        self.assertTrue(brian.username in text) 
     340        for result in (self.cie, self.group, self.part): 
     341            self.get_graph_data({"member" : True, OSR : True }, (result,)) 
     342            self.assertCount(1, 0) 
    285343 
    286344    def test_navigate_part(self): 
     
    289347        """ 
    290348        # we already have one part 
    291         self.get_graph_data({"part" : True }) 
    292         self.assertCount(2, 1) 
    293         main, part_node = self.nodes 
    294         self.assertEqual([part_node], self.root.find_class("node_part")) 
    295  
    296     def test_navigate_doc(self): 
    297         """ 
    298         Tests a navigate with the "doc" option set. 
    299         """ 
     349        for osr, results in ((False, ()), (True, (self.part,))): 
     350            self.get_graph_data({"part" : True, OSR : osr }, results) 
     351            self.assertCount(2, 1) 
     352            main, part_node = self.nodes 
     353            self.assertEqual([part_node], self.root.find_class("node_part")) 
    300354        doc = DocumentController.create("d", "Document", "doc", 
    301355                self.user, self.DATA, True, True) 
    302         self.get_graph_data({"doc" : True }) 
    303         self.assertCount(2, 1) 
    304         main, doc_node = self.nodes 
    305         self.assertEqual([doc_node], self.root.find_class("node_document")) 
     356        for result in (self.cie, self.group, self.user, doc.object): 
     357            self.get_graph_data({"part" : True, OSR : True }, (result,)) 
     358            self.assertCount(1, 0) 
     359 
     360    def test_navigate_doc(self): 
     361        """ 
     362        Tests a navigate with the "doc" option set. 
     363        """ 
     364        doc = DocumentController.create("d", "Document", "doc", 
     365                self.user, self.DATA, True, True) 
     366        for osr, results in ((False, ()), (True, (doc.object,))): 
     367            self.get_graph_data({"doc" : True, OSR : osr }, results) 
     368            self.assertCount(2, 1) 
     369            main, doc_node = self.nodes 
     370            self.assertEqual([doc_node], self.root.find_class("node_document")) 
     371        for result in (self.cie, self.group, self.part, self.user): 
     372            self.get_graph_data({"doc" : True, OSR : True }, (result,)) 
     373            self.assertCount(1, 0) 
    306374 
    307375class UserNavigateTestCase(NavigateTestCase): 
     
    317385        """ 
    318386        # we already own self.part 
    319         self.get_graph_data({"owned" : True }) 
    320         self.assertCount(2, 1) 
     387        for osr, results in ((False, ()), (True, (self.part.object,))): 
     388            self.get_graph_data({"owned" : True, OSR : osr }, results) 
     389            self.assertCount(2, 1) 
     390        doc = DocumentController.create("d", "Document", "doc", 
     391                self.user, self.DATA, True, True) 
     392        for osr, results in ((False, ()), (True, (self.part.object, doc.object))): 
     393            self.get_graph_data({"owned" : True, OSR : osr }, results) 
     394            self.assertCount(3, 2) 
     395        for result in (self.cie, self.group, self.user): 
     396            self.get_graph_data({"owned" : True, OSR : True }, (result,)) 
     397            self.assertCount(1, 0) 
    321398 
    322399    def test_navigate_doc_parts(self): 
     
    331408                self.cie, data, True, True) 
    332409        self.part.attach_to_document(doc) 
    333         self.get_graph_data({"owned" : True, 
    334             "doc_parts" : [self.part.id] }) 
    335         self.assertTrue(3, 2) 
     410        for osr, results in ((False, ()), (True, (doc.object,))): 
     411            self.get_graph_data({"owned" : True, OSR : osr, 
     412                "doc_parts" : [self.part.id] }, results) 
     413            self.assertTrue(3, 2) 
     414        for result in (self.cie, self.group, self.user): 
     415            self.get_graph_data({"owned" : True, OSR : True, 
     416                "doc_parts" : [self.part.id]  }, (result,)) 
     417            self.assertCount(1, 0) 
    336418         
    337419    def test_navigate_notified(self): 
     
    342424        self.assertCount(1, 0) 
    343425        self.part.set_role(self.user, "notified") 
    344         self.get_graph_data({"request_notification_from" : True }) 
    345         self.assertCount(2, 1) 
     426        for osr, results in ((False, ()), (True, (self.part.object,))): 
     427            self.get_graph_data({"request_notification_from" : True, OSR : osr }, 
     428                    results) 
     429            self.assertCount(2, 1) 
    346430 
    347431    def test_navigate_signer(self): 
     
    349433        Tests a navigate with the "to_sign" option set. 
    350434        """ 
    351         self.get_graph_data({"to_sign" : True }) 
    352         self.assertCount(3, 2) 
    353         roles = set(e.text_content().strip() for e in self.edges) 
    354         self.assertEqual(set(("sign1stlevel", "sign2ndlevel")), roles) 
    355  
     435        for osr, results in ((False, ()), (True, (self.part.object,))): 
     436            self.get_graph_data({"to_sign" : True, OSR : osr }, results) 
     437            self.assertCount(3, 2) 
     438            roles = set(e.text_content().strip() for e in self.edges) 
     439            self.assertEqual(set(("sign1stlevel", "sign2ndlevel")), roles) 
     440        for result in (self.cie, self.group, self.user): 
     441            self.get_graph_data({"to_sign" : True, OSR : True }, (result,)) 
     442            self.assertCount(1, 0) 
     443 
Note: See TracChangeset for help on using the changeset viewer.