Exemple #1
0
    def test_project_rdefs(self):
        project = Container.by_etype('Project')

        self.assertEqual(
            set([('requirement', 'Ticket', 'Card'),
                 ('documents', 'Folder', 'Project'),
                 ('version_of', 'Version', 'Project'),
                 ('concerns', 'Ticket', 'Project'),
                 ('implements', 'Patch', 'Ticket'),
                 ('subproject_of', 'Project', 'Project')]),
            set([rdefrepr(rdef) for rdef in project.rdefs]))

        self.assertEqual(
            set([('implements', 'Patch', 'Ticket'),
                 ('done_in_version', 'Ticket', 'Version'),
                 ('concerns', 'Ticket', 'Project'),
                 ('version_of', 'Version', 'Project'),
                 ('subproject_of', 'Project', 'Project'),
                 ('documents', 'Folder', 'Project'),
                 ('requirement', 'Ticket', 'Card')]),
            set([rdefrepr(rdef) for rdef in project.inner_rdefs]))
        self.assertEqual(
            set([('canread', 'CWUser', 'Project'),
                 ('canwrite', 'CWUser', 'Project')]),
            set([rdefrepr(rdef) for rdef in project.border_rdefs]))

        self.assertEqual(
            frozenset(
                ['Card', 'Patch', 'Ticket', 'Version', 'Folder', 'Project']),
            project.etypes)
    def test_border_rdefs_and_permissions(self):
        project = Container.by_etype('Project')
        self.assertEqual(set([('canwrite', 'Project', 'CWUser'),
                              ('canread', 'Project', 'CWUser')]),
                         set(rdefrepr(rdef) for rdef in project.border_rdefs))

        expected = {('canwrite', 'Project', 'CWUser'):
                    {'add': ('managers', 'EXPR(S project P, U canwrite P)'),
                     'delete': ('managers', 'EXPR(S project P, U canwrite P)'),
                     'read': ('managers', 'users'),
                     'update': ()},
                    ('canread', 'Project', 'CWUser'):
                    {'add': ('managers', 'EXPR(S project P, U canwrite P)'),
                     'delete': ('managers', 'EXPR(S project P, U canwrite P)'),
                     'read': ('managers', 'users'),
                     'update': ()}}

        self.assertEqual(expected,
                         {rdefrepr(rdef): permsrepr(rdef.permissions)
                          for rdef in project.border_rdefs})

        version = Container.by_etype('Version')
        self.assertEqual(set([('version_of', 'Version', 'Project'),
                              ('canread', 'Version', 'CWUser'),
                              # NOTE: since XFile is an etype of the Version container
                              # this rdef appears as a border.
                              # It may cause problems when weaving permissions rules
                              # if not properly considered.
                              ('documented_by', 'Project', 'XFile'),
                              ('canwrite', 'Version', 'CWUser')]),
                         set(rdefrepr(rdef) for rdef in version.border_rdefs))

        expected = {('canread', 'Version', 'CWUser'):
                    {'add': ('managers',),
                     'delete': ('managers',),
                     'read': ('managers', 'users', 'guests'),
                     'update': ()},
                    ('canwrite', 'Version', 'CWUser'):
                    {'add': ('managers',),
                     'delete': ('managers',),
                     'read': ('managers', 'users', 'guests'),
                     'update': ()},
                    ('documented_by', 'Project', 'XFile'):
                    {'add': ('managers', 'project_managers'),
                     'delete': ('managers', 'project_managers'),
                     'read': ('managers', 'users'),
                     'update': ()},
                    ('version_of', 'Version', 'Project'):
                    {'add': ('managers', 'EXPR(O project P, U canwrite P)'),
                     'delete': ('managers', 'EXPR(O project P, U canwrite P)'),
                     'read': ('managers', 'users'),
                     'update': ()}}

        self.assertEqual(expected,
                         {rdefrepr(rdef): permsrepr(rdef.permissions)
                          for rdef in version.border_rdefs})
    def test_rdefs(self):
        project = Container.by_etype('Project')
        self.assertEqual(set([('version_of', 'Version', 'Project'),
                              ('documented_by', 'Project', 'XFile')]),
                         set(rdefrepr(rdef) for rdef in project.rdefs))

        version = Container.by_etype('Version')
        self.assertEqual(set([('done_in_version', 'Ticket', 'Version'),
                              ('documented_by', 'Version', 'XFile'),
                              ('documented_by', 'Ticket', 'XFile')]),
                         set(rdefrepr(rdef) for rdef in version.rdefs))
    def test_static_structure(self):
        diamond = config.Container.by_etype('Diamond')
        mess = config.Container.by_etype('Mess')

        self.assertEqual(
            set([('to_right', 'IAmAnAttributeCarryingRelation', 'Right'),
                 ('top_from_right', 'Right', 'Diamond'),
                 ('top_by_right', 'Bottom', 'Right'),
                 ('to_left', 'IAmAnAttributeCarryingRelation', 'Left'),
                 ('has_near_top', 'Diamond', 'NearTop'),
                 ('top_from_left', 'Left', 'Diamond'),
                 ('top_by_left', 'Bottom', 'Left')]),
            set([rdefrepr(rdef) for rdef in diamond.rdefs]))

        self.assertEqual(set([('to_mess', 'Bottom', 'Mess')]),
                         set([rdefrepr(rdef) for rdef in mess.rdefs]))
Exemple #5
0
    def test_folder_rdefs(self):
        folder = Container.by_etype('Folder')

        self.assertEqual(
            set([('element', 'Folder', 'XFile'),
                 ('parent', 'Folder', 'Folder'),
                 ('element', 'Folder', 'Card')]),
            set([rdefrepr(rdef) for rdef in folder.rdefs]))
        self.assertEqual(
            set([('element', 'Folder', 'XFile'),
                 ('parent', 'Folder', 'Folder'),
                 ('element', 'Folder', 'Card')]),
            set([rdefrepr(rdef) for rdef in folder.inner_rdefs]))
        self.assertEqual(
            set([('documents', 'Folder', 'Project'),
                 ('content', 'Patch', 'XFile'),
                 ('requirement', 'Ticket', 'Card')]),
            set([rdefrepr(rdef) for rdef in folder.border_rdefs]))
 def test_utils(self):
     schema = self.vreg.schema
     for etype, expected in (('Diamond', [
         ('has_near_top', 'Diamond', 'NearTop'),
         ('top_from_left', 'Left', 'Diamond'),
         ('top_from_right', 'Right', 'Diamond')
     ]), ('NearTop', []), ('IAmAnAttributeCarryingRelation', []), ('Left', [
         ('to_left', 'IAmAnAttributeCarryingRelation', 'Left'),
         ('top_by_left', 'Bottom', 'Left'),
         ('composite_but_not_in_diamond', 'EtypeNotInContainers', 'Left')
     ]), ('Right', [('to_right', 'IAmAnAttributeCarryingRelation', 'Right'),
                    ('top_by_right', 'Bottom', 'Right')]), ('Bottom', [])):
         self.assertCountEqual(expected, [
             rdefrepr(rdef) for rdef in utils.children_rdefs(schema[etype])
         ])