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