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
introduced
by
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 |