← Back to branch summary

~ubuntu-branches/ubuntu/vivid/pylint/vivid-proposed

« back to all changes in this revision

Viewing changes to test/unittest_pyreverse_diadefs.py

  • Committer: Bazaar Package Importer
  • Author(s): Sandro Tosi
  • Date: 2011-03-29 19:27:47 UTC
  • mfrom: (1.3.1 upstream) (12.1.3 experimental)
  • Revision ID: james.westby@ubuntu.com-20110329192747-fwcizgk9vg1wi0tv
Tags: 0.23.0-1
http://bugs.debian.org/575679
* New upstream release
  - provides manpages for epylint, pylint-gui, symilar; Closes: #575679
* debian/control
  - mention pyreverse, symilar, epylint, pylint-gui additional commands in
    long description
  - update versioned Depends and b-d-i on logilab-{common, astng}
  - added python-unittest2 to b-d-i, needed to run tests
* debian/pylint.manpages
  - install all the available manpages

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/unittest_pyreverse_diadefs.py
38
38
 
39
39
def _process_classes(classes):
40
40
    """extract class names of a list"""
41
 
    result = []
42
 
    for classe in classes:
43
 
        result.append({'node' : isinstance(classe.node, astng.Class),
44
 
                       'name' : classe.title})
45
 
    result.sort()
46
 
    return result
47
 
 
48
 
def _process_modules(modules):
49
 
    """extract module names from a list"""
50
 
    result = []
51
 
    for module in modules:
52
 
        result.append({'node' : isinstance(module.node, astng.Module),
53
 
                       'name': module.title})
54
 
    result.sort()
55
 
    return result
 
41
    return sorted([(isinstance(c.node, astng.Class), c.title) for c in classes])
56
42
 
57
43
def _process_relations(relations):
58
44
    """extract relation indices from a relation list"""
59
45
    result = []
60
 
    for rel_type, rels  in relations.items():
 
46
    for rel_type, rels  in relations.iteritems():
61
47
        for rel in rels:
62
48
            result.append( (rel_type, rel.from_object.title,
63
49
                            rel.to_object.title) )
73
59
        cl_config = Config()
74
60
        cl_config.classes = ['Specialization']
75
61
        cl_h = DiaDefGenerator(Linker(PROJECT), DiadefsHandler(cl_config) )
76
 
        self.assertEquals( (0, 0), df_h._get_levels())
77
 
        self.assertEquals( False, df_h.module_names)
78
 
        self.assertEquals( (-1, -1), cl_h._get_levels())
79
 
        self.assertEquals( True, cl_h.module_names)
 
62
        self.assertEqual( (0, 0), df_h._get_levels())
 
63
        self.assertEqual( False, df_h.module_names)
 
64
        self.assertEqual( (-1, -1), cl_h._get_levels())
 
65
        self.assertEqual( True, cl_h.module_names)
80
66
        for hndl in [df_h, cl_h]:
81
67
            hndl.config.all_ancestors = True
82
68
            hndl.config.all_associated = True
83
69
            hndl.config.module_names = True
84
70
            hndl._set_default_options()
85
 
            self.assertEquals( (-1, -1), hndl._get_levels())
86
 
            self.assertEquals( True, hndl.module_names)
 
71
            self.assertEqual( (-1, -1), hndl._get_levels())
 
72
            self.assertEqual( True, hndl.module_names)
87
73
        handler = DiadefsHandler( Config())
88
74
        df_h = DiaDefGenerator(Linker(PROJECT), handler)
89
75
        cl_config = Config()
94
80
            hndl.config.show_associated = 1
95
81
            hndl.config.module_names = False
96
82
            hndl._set_default_options()
97
 
            self.assertEquals( (2, 1), hndl._get_levels())
98
 
            self.assertEquals( False, hndl.module_names)
 
83
            self.assertEqual( (2, 1), hndl._get_levels())
 
84
            self.assertEqual( False, hndl.module_names)
99
85
    #def test_default_values(self):
100
86
        """test efault values for package or class diagrams"""
101
87
        # TODO : should test difference between default values for package
104
90
class DefaultDiadefGeneratorTC(unittest.TestCase):
105
91
    def test_known_values1(self):
106
92
        dd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)
107
 
        self.assertEquals(len(dd), 2)
 
93
        self.assertEqual(len(dd), 2)
108
94
        keys = [d.TYPE for d in dd]
109
 
        self.assertEquals(keys, ['package', 'class'])
 
95
        self.assertEqual(keys, ['package', 'class'])
110
96
        pd = dd[0]
111
 
        self.assertEquals(pd.title, 'packages No Name')
112
 
        modules = _process_modules(pd.objects)
113
 
        self.assertEquals(modules, [{'node': True, 'name': 'data'},
114
 
                                    {'node': True, 'name': 'data.clientmodule_test'},
115
 
                                    {'node': True, 'name': 'data.suppliermodule_test'}])
 
97
        self.assertEqual(pd.title, 'packages No Name')
 
98
        modules = sorted([(isinstance(m.node, astng.Module), m.title)
 
99
                         for m in pd.objects])
 
100
        self.assertEqual(modules, [(True, 'data'),
 
101
                                   (True, 'data.clientmodule_test'),
 
102
                                   (True, 'data.suppliermodule_test')])
116
103
        cd = dd[1]
117
 
        self.assertEquals(cd.title, 'classes No Name')
 
104
        self.assertEqual(cd.title, 'classes No Name')
118
105
        classes = _process_classes(cd.objects)
119
 
        self.assertEquals(classes, [{'node': True, 'name': 'Ancestor'},
120
 
                                    {'node': True, 'name': 'DoNothing'},
121
 
                                    {'node': True, 'name': 'Interface'},
122
 
                                    {'node': True, 'name': 'Specialization'}]
 
106
        self.assertEqual(classes, [(True, 'Ancestor'),
 
107
                                   (True, 'DoNothing'),
 
108
                                   (True, 'Interface'),
 
109
                                   (True, 'Specialization')]
123
110
                          )
124
111
 
125
112
    _should_rels = [('association', 'DoNothing', 'Ancestor'),
131
118
        cd = DefaultDiadefGenerator(Linker(PROJECT), HANDLER).visit(PROJECT)[1]
132
119
        cd.extract_relationships()
133
120
        relations = _process_relations(cd.relationships)
134
 
        self.assertEquals(relations, self._should_rels)
 
121
        self.assertEqual(relations, self._should_rels)
135
122
 
136
123
    def test_functional_relation_extraction(self):
137
124
        """functional test of relations extraction;
143
130
        diadefs = handler.get_diadefs(project, Linker(project, tag=True) )
144
131
        cd = diadefs[1]
145
132
        relations = _process_relations(cd.relationships)
146
 
        self.assertEquals(relations, self._should_rels)
 
133
        self.assertEqual(relations, self._should_rels)
147
134
 
148
135
    def test_known_values2(self):
149
136
        project = MANAGER.project_from_files(['data.clientmodule_test'], astng_wrapper)
150
137
        dd = DefaultDiadefGenerator(Linker(project), HANDLER).visit(project)
151
 
        self.assertEquals(len(dd), 1)
 
138
        self.assertEqual(len(dd), 1)
152
139
        keys = [d.TYPE for d in dd]
153
 
        self.assertEquals(keys, ['class'])
 
140
        self.assertEqual(keys, ['class'])
154
141
        cd = dd[0]
155
 
        self.assertEquals(cd.title, 'classes No Name')
 
142
        self.assertEqual(cd.title, 'classes No Name')
156
143
        classes = _process_classes(cd.objects)
157
 
        self.assertEquals(classes, [{'node': True, 'name': 'Ancestor'},
158
 
                                    {'node': True, 'name': 'DoNothing'},
159
 
                                    {'node': True, 'name': 'Specialization'}]
 
144
        self.assertEqual(classes, [(True, 'Ancestor'),
 
145
                                   (True, 'DoNothing'),
 
146
                                   (True, 'Specialization')]
160
147
                          )
161
148
 
162
149
class ClassDiadefGeneratorTC(unittest.TestCase):
165
152
        cdg = ClassDiadefGenerator(Linker(PROJECT), HANDLER)
166
153
        special = 'data.clientmodule_test.Specialization'
167
154
        cd = cdg.class_diagram(PROJECT, special)
168
 
        self.assertEquals(cd.title, special)
 
155
        self.assertEqual(cd.title, special)
169
156
        classes = _process_classes(cd.objects)
170
 
        self.assertEquals(classes, [{'node': True,
171
 
                                    'name': 'data.clientmodule_test.Ancestor'},
172
 
                                    {'node': True, 'name': special},
173
 
                                    {'node': True,
174
 
                                    'name': 'data.suppliermodule_test.DoNothing'},
175
 
                                    ])
 
157
        self.assertEqual(classes, [(True, 'data.clientmodule_test.Ancestor'),
 
158
                                   (True, special),
 
159
                                   (True, 'data.suppliermodule_test.DoNothing'),
 
160
                                  ])
176
161
        
177
162
    def test_known_values2(self):
178
163
        HANDLER.config.module_names = False
179
164
        cd = ClassDiadefGenerator(Linker(PROJECT), HANDLER).class_diagram(PROJECT, 'data.clientmodule_test.Specialization')
180
 
        self.assertEquals(cd.title, 'data.clientmodule_test.Specialization')
 
165
        self.assertEqual(cd.title, 'data.clientmodule_test.Specialization')
181
166
        classes = _process_classes(cd.objects)
182
 
        self.assertEquals(classes, [{'node': True, 'name': 'Ancestor' },
183
 
                                    {'node': True, 'name': 'DoNothing'},
184
 
                                    {'node': True, 'name': 'Specialization'}
185
 
                                    ])
 
167
        self.assertEqual(classes, [(True, 'Ancestor'),
 
168
                                   (True, 'DoNothing'),
 
169
                                   (True, 'Specialization')
 
170
                                  ])
186
171
 
187
172
 
188
173
if __name__ == '__main__':