Passed
Push — master ( cddcf6...1d3855 )
by Alexander
01:59
created

tcms/xmlrpc/tests/test_serializer.py (1 issue)

Languages
Severity
1
# -*- coding: utf-8 -*-
2
# pylint: disable=invalid-name, protected-access
3
4
import unittest
5
from django import test
6
7
from tcms.management.models import Product
8
from tcms.testcases.models import TestCase
9
from tcms.testplans.models import TestPlan
10
from tcms.xmlrpc.serializer import QuerySetBasedXMLRPCSerializer
11
from tcms.xmlrpc.serializer import XMLRPCSerializer
12
from tcms.xmlrpc.serializer import datetime_to_str
13
from tcms.xmlrpc.serializer import do_nothing
14
from tcms.xmlrpc.serializer import to_str
15
from tcms.xmlrpc.serializer import _get_related_object_pks
16
17
from tcms.tests.factories import ComponentFactory
18
from tcms.tests.factories import ProductFactory
19
from tcms.tests.factories import TestCaseFactory
20
from tcms.tests.factories import TestPlanFactory
21
from tcms.tests.factories import UserFactory
22
23
24
class TestXMLSerializer(test.TestCase):
25
26
    @classmethod
27
    def setUpTestData(cls):
28
        cls.testcase = TestCaseFactory(component=[ComponentFactory(),
29
                                                  ComponentFactory(),
30
                                                  ComponentFactory()])
31
32
    def test_serializer(self):
33
        serializer = XMLRPCSerializer(model=self.testcase)
34
35
        result = serializer.serialize_model()
36
37
        self.assertEqual(self.testcase.category.pk, result['category_id'])
38
        self.assertEqual(str(self.testcase.category), result['category'])
39
40
        component_pks = []
41
42
        for component in self.testcase.component.all():  # pylint: disable=no-member
43
            component_pks.append(component.pk)
44
45
        component_pks.sort()
46
        result['component'].sort()
47
        self.assertEqual(component_pks, result['component'])
48
49
        self.assertEqual(self.testcase.arguments, result['arguments'])
50
51
52
class TestUtilityMethods(unittest.TestCase):
53
54
    def test_datetime_to_str(self):
55
        value = datetime_to_str(None)
56
        self.assertEqual(value, None)
57
58
        from datetime import datetime
59
        now = datetime.now()
60
        value = datetime_to_str(now)
61
        expected_value = datetime.strftime(now, '%Y-%m-%d %H:%M:%S')
62
        self.assertEqual(expected_value, value)
63
64
65
# ################### Mock serializer classes for testing ####################
66
67
68
class MockTestPlanSerializer(QuerySetBasedXMLRPCSerializer):
69
    values_fields_mapping = {
70
        'create_date': ('create_date', datetime_to_str),
71
        'extra_link': ('extra_link', do_nothing),
72
        'is_active': ('is_active', do_nothing),
73
        'name': ('name', do_nothing),
74
        'plan_id': ('plan_id', do_nothing),
75
76
        'author': ('author_id', do_nothing),
77
        'author__username': ('author', to_str),
78
        'product_version': ('product_version_id', do_nothing),
79
        'product_version__value': ('product_version', do_nothing),
80
    }
81
82
    extra_fields = {
83
        'alias': {'product_version': 'default_product_version'},
84
    }
85
86
    m2m_fields = ('case',)
87
88
89
class MockTestCaseSerializer(QuerySetBasedXMLRPCSerializer):
90
    primary_key = 'case_id'
91
92
    values_fields_mapping = {
93
        'arguments': ('arguments', do_nothing),
94
        'case_id': ('case_id', do_nothing),
95
        'create_date': ('create_date', datetime_to_str),
96
97
        'author': ('author_id', do_nothing),
98
        'author__username': ('author', to_str),
99
        'case_status': ('case_status_id', do_nothing),
100
        'case_status__name': ('case_status', do_nothing),
101
    }
102
103
104
class MockProductSerializer(QuerySetBasedXMLRPCSerializer):
105
    """Empty definition to test some method's default behavior"""
106
107
108
# ################### Mock serializer classes for testing ####################
109
110
111
class TestQuerySetBasedSerializer(test.TestCase):
112
    """Test QuerySetBasedXMLRPCSerializer"""
113
114
    @classmethod
115
    def setUpTestData(cls):
116
        cls.case_author = UserFactory()
117
118
        cls.plans = [
119
            TestPlanFactory(),
120
            TestPlanFactory(),
121
            TestPlanFactory(),
122
        ]
123
        TestCaseFactory(author=cls.case_author, default_tester=None, plan=[cls.plans[0]])
124
        TestCaseFactory(author=cls.case_author, default_tester=None, plan=[cls.plans[0]])
125
        TestCaseFactory(author=cls.case_author, default_tester=None, plan=[cls.plans[1]])
126
        TestCaseFactory(author=cls.case_author, default_tester=None, plan=[cls.plans[2]])
127
        TestCaseFactory(author=cls.case_author, default_tester=None, plan=[cls.plans[2]])
128
        TestCaseFactory(author=cls.case_author, default_tester=None, plan=[cls.plans[2]])
129
130
        plan_keys = []
131
132
        for plan in cls.plans:
133
            plan_keys.append(plan.pk)
134
135
        cls.plans = TestPlan.objects.filter(pk__in=plan_keys)
136
        cls.plan_serializer = MockTestPlanSerializer(TestPlan, cls.plans)
137
138
        cls.cases = [
139
            TestCaseFactory(author=cls.case_author, default_tester=None),
140
            TestCaseFactory(author=cls.case_author, default_tester=None),
141
            TestCaseFactory(author=cls.case_author, default_tester=None),
142
        ]
143
144
        case_keys = []
145
146
        for case in cls.cases:
147
            case_keys.append(case.pk)
148
149
        cls.cases = TestCase.objects.filter(pk__in=case_keys)
150
        cls.case_serializer = MockTestCaseSerializer(TestCase, cls.cases)
151
152
        cls.products = [ProductFactory(), ProductFactory(), ProductFactory()]
153
154
        product_keys = []
155
156
        for product in cls.products:
157
            product_keys.append(product.pk)
158
159
        cls.products = Product.objects.filter(pk__in=product_keys)
160
        cls.product_serializer = MockProductSerializer(Product, cls.products)
161
162
    def test_get_values_fields_mapping(self):
163
        mapping = self.product_serializer._get_values_fields_mapping()
164
        self.assertEqual(mapping, {})
165
166
        mapping = self.case_serializer._get_values_fields_mapping()
167
        self.assertEqual(mapping, MockTestCaseSerializer.values_fields_mapping)
168
169
    def testget_values_fields(self):
170
        fields = list(self.case_serializer._get_values_fields())
171
        fields.sort()
172
        expected_fields = list(MockTestCaseSerializer.values_fields_mapping.keys())
173
        expected_fields.sort()
174
        self.assertEqual(expected_fields, fields)
175
176
        fields = self.product_serializer._get_values_fields()
177
        fields.sort()
178
        expected_fields = []
179
180
        for field in Product._meta.fields:
181
            expected_fields.append(field.name)
182
183
        expected_fields.sort()
184
        self.assertEqual(expected_fields, fields)
185
186
    def test_get_m2m_fields(self):
187
        fields = list(self.plan_serializer._get_m2m_fields())
188
        fields.sort()
189
        expected_fields = list(MockTestPlanSerializer.m2m_fields)
190
        expected_fields.sort()
191
        self.assertEqual(expected_fields, fields)
192
193
        fields = list(self.case_serializer._get_m2m_fields())
194
        fields.sort()
195
        expected_fields = []
196
197
        for field in TestCase._meta.many_to_many:
198
            expected_fields.append(field.name)
199
200
        expected_fields.sort()
201
        self.assertEqual(expected_fields, fields)
202
203
        fields = self.product_serializer._get_m2m_fields()
204
        expected_fields = tuple(field.name for field in Product._meta.many_to_many)
205
        self.assertEqual(fields, ())
206
        self.assertEqual(expected_fields, fields)
207
208
    def test_get_primary_key_field(self):
209
        field_name = self.case_serializer._get_primary_key_field()
210
        self.assertEqual(field_name, MockTestCaseSerializer.primary_key)
211
212
        field_name = self.plan_serializer._get_primary_key_field()
213
214
        for field in TestPlan._meta.fields:
215
            if field.primary_key:
216
                expected_field_name = field.name
217
                break
218
219
        self.assertEqual(expected_field_name, field_name)
0 ignored issues
show
The variable expected_field_name does not seem to be defined for all execution paths.
Loading history...
220
221
    def verify_m2m_field_query_result(self, m2m_field_name, result):
222
        for object_pk, objects in result.items():
223
            self.assertTrue(isinstance(objects, tuple))
224
            for object_value in objects:
225
                self.assertEqual(object_pk, object_value['pk'])
226
                self.assertTrue(m2m_field_name in object_value)
227
228
    def test_query_m2m_field(self):
229
        m2m_field_name = 'case'
230
231
        result = self.plan_serializer._query_m2m_field(m2m_field_name)
232
233
        self.assertEqual(len(result), len(self.plans),
234
                         'There are cases in database, but not serialized.')
235
        self.verify_m2m_field_query_result(m2m_field_name, result)
236
237
    def test_query_m2m_fields(self):
238
        result = self.plan_serializer._query_m2m_fields()
239
        self.assertTrue(isinstance(result, dict))
240
        self.assertEqual(len(result), len(MockTestPlanSerializer.m2m_fields))
241
242
        for m2m_field_name, this_query_result in result.items():
243
            self.assertTrue(m2m_field_name in MockTestPlanSerializer.m2m_fields)
244
            self.assertTrue(isinstance(this_query_result, dict))
245
246
            # Method to verify object_values is same with test case
247
            # test_query_m2m_field
248
            self.verify_m2m_field_query_result(m2m_field_name,
249
                                               this_query_result)
250
251
    def test_get_related_object_pks(self):
252
        m2m_field_name = 'case'
253
254
        m2m_query_result = self.plan_serializer._query_m2m_fields()
255
256
        result = _get_related_object_pks(m2m_query_result,
257
                                         self.plans[0].pk,
258
                                         m2m_field_name)
259
        result.sort()
260
261
        expected_values = []
262
263
        for case in self.plans[0].case.all():
264
            expected_values.append(case.pk)
265
266
        expected_values.sort()
267
        self.assertEqual(expected_values, result)
268
269
    # ####### Test cases for extra_fields #######
270
271
    def test_get_extra_fields(self):
272
        extra_fields = self.plan_serializer.get_extra_fields()
273
        self.assertNotEqual(extra_fields, {})
274
        self.assertTrue('alias' in extra_fields)
275
276
        extra_fields = self.case_serializer.get_extra_fields()
277
        self.assertEqual(extra_fields, {})
278
279
    def test_handle_extra_fields_alias(self):
280
        serialize_result = {'plan_id': 1000, 'product_version': 1}
281
        test_data = serialize_result.copy()
282
283
        self.plan_serializer._handle_extra_fields(test_data)
284
        self.assertTrue('default_product_version' in test_data)
285
        self.assertEqual(test_data['default_product_version'],
286
                         serialize_result['product_version'])
287
        self.assertEqual(test_data['plan_id'], serialize_result['plan_id'])
288
        self.assertEqual(test_data['product_version'],
289
                         serialize_result['product_version'])
290
291
        test_data = serialize_result.copy()
292
293
        self.case_serializer._handle_extra_fields(test_data)
294
        self.assertEqual(test_data, serialize_result)
295
296
    # ####### Test cases for core serialization method #######
297
298
    def test_serialize_queryset(self):
299
        serialize_result = self.plan_serializer.serialize_queryset()
300
        self.assertEqual(len(self.plans), len(serialize_result))
301
302
        for plan in serialize_result:
303
            plan_id = plan['plan_id']
304
            expected_plan = TestPlan.objects.get(pk=plan_id)
305
            self.assertEqual(expected_plan.name, plan['name'])
306
            self.assertEqual(expected_plan.is_active, plan['is_active'])
307
            self.assertEqual(expected_plan.extra_link, plan['extra_link'])
308
            self.assertEqual(datetime_to_str(expected_plan.create_date),
309
                             plan['create_date'])
310
            self.assertEqual(expected_plan.author_id, plan['author_id'])
311
            self.assertEqual(expected_plan.author.username, plan['author'])
312
            self.assertEqual(expected_plan.product_version_id,
313
                             plan['product_version_id'])
314
            self.assertEqual(expected_plan.product_version.value,
315
                             plan['product_version'])
316
317
    def test_serialize_queryset_with_empty_querset(self):
318
        cases = self.cases.filter(pk__lt=0)  # pylint: disable=no-member
319
        serializer = MockTestCaseSerializer(TestCase, cases)
320
        result = serializer.serialize_queryset()
321
        self.assertTrue(len(result) == 0)
322