← Back to branch summary

~doctormo/coisas/trunk

« back to all changes in this revision

Viewing changes to tests/test_data_classes.py

  • Committer: Martin Owens (DoctorMO)
  • Date: 2009-04-07 01:33:24 UTC
  • Revision ID: doctormo@gmail.com-20090407013324-g6o6a8dbpxn1j7d6
Tighten the circle, introduce sources and forment the structure firther.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_data_classes.py
29
29
 
30
30
import unittest
31
31
from test import test_support
32
 
from base import ItemApiBase, CollectionApiBase
 
32
from base import ItemApiBase, CollectionApiBase, SourceApiBase
33
33
from Coisas.main import load_modules, ModulesClasses, ModuleClasses, TESTING
34
34
from Coisas.base import BusObjectBase
35
35
from Coisas.definitions import DataClass, DataSource, DataCollection, DataItem
55
55
        )
56
56
        return __import__(test_module, fromlist=[test_module], level=0)
57
57
 
58
 
    def plugin_test(self, name, base):
 
58
    def plugin_item_test(self, name, base):
 
59
        """Test that there is API test for plugin items"""
 
60
        self.plugin_test(name, base, 'item', ItemApiBase)
 
61
        
 
62
    def plugin_list_test(self, name, base):
 
63
        """Test that there is API test for plugin items"""
 
64
        self.plugin_test(name, base, 'list', CollectionApiBase)
 
65
 
 
66
    def plugin_source_test(self, name, base):
 
67
        """Test that there is API test for plugin items"""
 
68
        self.plugin_test(name, base, 'source', SourceApiBase)
 
69
 
 
70
    def plugin_test(self, name, base, layer, base_api):
59
71
        """Test each plugin class"""
60
72
        test_module = self.api_test(name, base)
61
73
        
62
 
        api_item_test = False
63
 
        api_list_test = False
 
74
        api_test = False
64
75
        for d_value in ModuleClasses(test_module):
65
 
            if issubclass(d_value, ItemApiBase):
66
 
                api_item_test = d_value
67
 
            if issubclass(d_value, CollectionApiBase):
68
 
                api_list_test = d_value
 
76
            if issubclass(d_value, base_api):
 
77
                api_test = d_value
69
78
        
70
79
        # Test that this has a Test Case
71
 
        self.assert_(api_item_test,
72
 
            "%s '%s' does not have an item test suite." % (
73
 
            self.inter_name, name)
74
 
        )
75
 
        self.assert_(api_list_test,
76
 
            "%s '%s' does not have a collection test suite." % (
77
 
            self.inter_name, name)
 
80
        self.assert_(api_test,
 
81
            "%s '%s' does not have an %s test suite." % (
 
82
            self.inter_name, name, layer)
78
83
        )
79
84
        
80
85
        # Test that it inherits from the data class for this plugin
81
 
        api_item_check = False
82
 
        api_list_check = False
 
86
        api_check = False
83
87
        base_data_class = get_base_data_class( base )
84
88
        test_base = self.api_test(base_data_class.__module__, base_data_class)
85
89
        for d_value in ModuleClasses(test_base):
86
 
            if issubclass(d_value, ItemApiBase):
87
 
                if issubclass(api_item_test, d_value):
88
 
                    api_item_check = True
89
 
            if issubclass(d_value, CollectionApiBase):
90
 
                if issubclass(api_list_test, d_value):
91
 
                    api_list_check = True
92
 
   
93
 
        self.assert_(api_list_check,
94
 
            "%s '%s' doesn't inherit from collection api base class." % (
95
 
            self.inter_name, name)
96
 
        )
97
 
   
98
 
        self.assert_(api_item_check,
99
 
            "%s '%s' does not inherit from item api base class." % (
100
 
            self.inter_name, name)
 
90
            if issubclass(d_value, base_api) and issubclass(api_test, d_value):
 
91
                api_check = True
 
92
   
 
93
        self.assert_(api_check,
 
94
            "%s '%s' doesn't inherit from %s api base class." % (
 
95
            self.inter_name, name, layer)
101
96
        )
102
97
 
103
98
    def class_test(self, name, base):
138
133
    for d_base in f_base.__bases__:
139
134
        if 'classes' in d_base.__module__:
140
135
            return d_base
141
 
        deeper = data_base_class(d_base)
 
136
        deeper = get_base_data_class(d_base)
142
137
        if deeper:
143
138
            return deeper  
144
139
    return None
145
140
 
146
 
def make_api_test_exists(g_name, d_base, api='plugin'):
 
141
def make_api_test_exists(g_name, d_base, layer='none'):
147
142
    """Create an API Check Test"""
148
 
    def plugin_test_exists(self):
149
 
        """No Information"""
150
 
        self.plugin_test(g_name, d_base)
 
143
    def plugin_item_exists(self):
 
144
        """No Information"""
 
145
        self.plugin_item_test(g_name, d_base)
 
146
    def plugin_list_exists(self):
 
147
        """No Information"""
 
148
        self.plugin_list_test(g_name, d_base)
 
149
    def plugin_source_exists(self):
 
150
        """No Information"""
 
151
        self.plugin_source_test(g_name, d_base)
 
152
 
 
153
    if layer == 'item':
 
154
        result = plugin_item_exists
 
155
    elif layer == 'list':
 
156
        result = plugin_list_exists
 
157
    elif layer == 'source':
 
158
        result = plugin_source_exists
 
159
    
 
160
    h_name = ' '.join(g_name.split('.')[1:]).title()
 
161
    result.func_doc = "Tests Exist for %s %s" % (h_name, layer.title())
 
162
    return result
 
163
 
 
164
 
 
165
def make_class_test_exists(g_name, d_base):
 
166
    """Make a test suite for a data class"""
151
167
    def class_test_exists(self):
152
168
        """No Information"""
153
169
        self.class_test(g_name, d_base)
154
 
 
155
 
    result = plugin_test_exists
156
 
    if api == 'class':
157
 
        result = class_test_exists
158
 
    
 
170
    result = class_test_exists
159
171
    h_name = ' '.join(g_name.split('.')[1:]).title()
160
172
    result.func_doc = "Tests Exist for %s" % (h_name)
161
173
    return result
162
174
 
 
175
 
163
176
def add_extra_tests(test_case, results):
164
177
    """Add each of the results to the test class"""
165
178
    for name, func in results.iteritems():
166
179
        setattr(test_case, name, func)
167
180
 
168
 
def add_api_tests(test_case, source, api_type='plugin'):
 
181
 
 
182
def add_api_tests(test_case, source):
169
183
    """Add a whole bunch of API tests as required"""
170
184
    result = {}
171
185
    for module_name, target_class in ModulesClasses(source):
172
186
        class_name = module_name.replace('Coisas.', '')
 
187
        layer = None
173
188
        if issubclass(target_class, DataItem):
174
 
            # Add an API test for a plugin's DataItem
175
 
            func = make_api_test_exists(class_name, target_class, api=api_type)
176
 
            test_name = "test_%s_api" % (class_name.replace('.','_'))
 
189
            layer = 'item'
 
190
        elif issubclass(target_class, DataCollection):
 
191
            layer = 'list'
 
192
        elif issubclass(target_class, DataSource):
 
193
            layer = 'source'
 
194
 
 
195
        if layer:
 
196
            # Add an API test for a plugin
 
197
            func = make_api_test_exists(class_name, target_class, layer=layer)
 
198
            test_name = "test_%s_%s_api" % (class_name.replace('.','_'), layer)
177
199
            result[test_name] = func
 
200
        
178
201
    # We could add source and collection API tests too.
179
202
    add_extra_tests(test_case, result)
180
203
 
 
204
 
 
205
def add_class_tests(test_case, source):
 
206
    """Add a whole bunch of data class tests"""
 
207
    for module_name, target_class in ModulesClasses(source):
 
208
        class_name = module_name.replace('Coisas.', '')
 
209
        if issubclass(target_class, DataItem):
 
210
            test_name = "test_%s_class" % (class_name.replace('.','_'))
 
211
            add_extra_tests(test_case, { test_name :
 
212
                make_class_test_exists(class_name, target_class),
 
213
            })
 
214
 
 
215
 
181
216
class DataClassTestCase(RootTestCase):
182
217
    """Test Data Classes have API Test Cases"""
183
218
    inter_type = 'classes'
184
219
    inter_name = 'Data Class'
185
220
 
186
221
CLASSES = load_modules( Coisas.classes )
187
 
add_api_tests(DataClassTestCase, CLASSES, 'class')
 
222
add_class_tests(DataClassTestCase, CLASSES)
188
223
 
189
224
class PluginsTestCase(RootTestCase):
190
225
    """Test Plugins have Tests for their APIs"""