def to_xmlrpc(cls, query=None): """ Convert the query set for XMLRPC """ if query is None: query = {} serializer = XMLRPCSerializer(queryset=cls.objects.filter(**query)) return serializer.serialize_queryset()
def get_logs(case_run_id): """ Description: Get log links to TestCaseRun Params: $case_run_id - Integer: """ links = LinkReference.objects.filter(test_case_run=case_run_id) s = XMLRPCSerializer(links) return s.serialize_queryset()
def get_logs(request, case_run_id): """ Description: Get log links to TestCaseRun Params: $case_run_id - Integer: """ test_case_run = TestCaseRun.objects.get(pk=case_run_id) links = LinkReference.get_from(test_case_run) s = XMLRPCSerializer(links) return s.serialize_queryset()
def test_serialize_model_foreignkey(self): '''Testing whether the foreign key is serialized properly If foreign key has related object, the field should be serialized with the correct value. If there is no related object with the foreign key, both the field and the related object retrived via the relationship are set to None. ''' from tcms.xmlrpc.serializer import XMLRPCSerializer s = XMLRPCSerializer(model=self.testcase_with_default_tester_null) result = s.serialize_model() self.assertEqual(result['default_tester'], None) self.assertEqual(result['default_tester_id'], None) s = XMLRPCSerializer(model=self.testcase_with_default_tester_0) result = s.serialize_model() self.assertEqual(result['default_tester'], None) self.assertEqual(result['default_tester_id'], None) s = XMLRPCSerializer(model=self.testcase_with_valid_default_tester) result = s.serialize_model() self.assertNotEqual(result['default_tester'], None) self.assertNotEqual(result['default_tester_id'], None)
def get_logs(request, case_run_id): """Get log links to TestCaseRun :param int case_run_id: case run ID. :return: list of mappings of found logs :class:`LinkReference`. :rtype: list[dict] """ test_case_run = TestCaseRun.objects.get(pk=case_run_id) links = LinkReference.get_from(test_case_run) s = XMLRPCSerializer(links) return s.serialize_queryset()
def get_logs(case_run_id): """ .. function:: XML-RPC TestCaseRun.get_logs(case_run_id) Get log links for the specified TestCaseRun :param case_run_id: PK of TestCaseRun object :type case_run_id: int :return: Serialized list of :class:`tcms.core.contrib.linkreference.models.LinkReference` objects """ links = LinkReference.objects.filter(test_case_run=case_run_id) serialier = XMLRPCSerializer(links) return serialier.serialize_queryset()
def get_logs(request, case_run_id): """ Description: Get log links to TestCaseRun Params: $case_run_id - Integer: """ try: test_case_run = TestCaseRun.objects.get(pk=case_run_id) except ObjectDoesNotExist: raise links = LinkReference.get_from(test_case_run) s = XMLRPCSerializer(links) return s.serialize_queryset()
def test_serializer(self): serializer = XMLRPCSerializer(model=self.testcase) result = serializer.serialize_model() self.assertEqual(self.testcase.category.pk, result['category_id']) self.assertEqual(str(self.testcase.category), result['category']) component_pks = [c.pk for c in self.testcase.component.all()] component_pks.sort() result['component'].sort() self.assertEqual(component_pks, result['component']) self.assertEqual(self.testcase.alias, result['alias']) self.assertEqual(self.testcase.arguments, result['arguments'])
def get_links(query): """ .. function:: XML-RPC TestExecution.get_links(query) Get URL links for the specified TestExecution :param query: Field lookups for :class:`tcms.core.contrib.linkreference.models.LinkReference` :type query: dict :return: Serialized list of :class:`tcms.core.contrib.linkreference.models.LinkReference` objects """ links = LinkReference.objects.filter(**query) serialier = XMLRPCSerializer(links) return serialier.serialize_queryset()
def update(case_id, plan_id, sortkey): """ Description: Updates the sortkey of the selected test-case-plan. Params: $case_id - Integer: An integer representing the ID of the test case in the database. $plan_id - Integer: An integer representing the ID of the test plan in the database. $sortkey - Integer: An integer representing the ID of the sortkey in the database. Returns: A blessed TestCasePlan object hash Example: # Update sortkey of selected test-case-plan to 450 >>> TestCasePlan.update(81307, 3551, 450) """ if not isinstance(case_id, int): raise ValueError('Parameter case_id must be an integer') if not isinstance(plan_id, int): raise ValueError('Parameter plan_id must be an integer') tcp = TestCasePlan.objects.get(plan_id=plan_id, case_id=case_id) if isinstance(sortkey, int): tcp.sortkey = sortkey tcp.save(update_fields=['sortkey']) return XMLRPCSerializer(model=tcp).serialize_model()
def get_test_cases(plan_id): """ Description: Get the list of cases that this plan is linked to. Params: $plan_id - Integer: An integer representing the ID of the plan in the database Returns: Array: An array of test case object hashes. Example: >>> TestPlan.get_test_cases(137) """ from tcms.testcases.models import TestCase from tcms.testplans.models import TestPlan from tcms.xmlrpc.serializer import XMLRPCSerializer tp = TestPlan.objects.get(pk=plan_id) tcs = TestCase.objects.filter(plan=tp).order_by('testcaseplan__sortkey') serialized_tcs = XMLRPCSerializer(tcs.iterator()).serialize_queryset() if serialized_tcs: for serialized_tc in serialized_tcs: case_id = serialized_tc.get('case_id', None) tc = tcs.get(pk=case_id) tcp = tc.testcaseplan_set.get(plan=tp) serialized_tc['sortkey'] = tcp.sortkey return serialized_tcs
def test_serializer(self): serializer = XMLRPCSerializer(model=self.testcase) result = serializer.serialize_model() self.assertEqual(self.testcase.category.pk, result['category_id']) self.assertEqual(str(self.testcase.category), result['category']) component_pks = [] for component in self.testcase.component.all(): # pylint: disable=no-member component_pks.append(component.pk) component_pks.sort() result['component'].sort() self.assertEqual(component_pks, result['component']) self.assertEqual(self.testcase.arguments, result['arguments'])
def _test_backward_compatible(self, model_class, object_pk): '''Ensure new serialization method to generate same data''' base_object = model_class.objects.get(pk=object_pk) sample_result = model_class.to_xmlrpc(query={'pk': object_pk})[0] remove_alias_extra_fields(model_class, sample_result) base_result = XMLRPCSerializer(model=base_object).serialize_model() sample_fields = [name for name in sample_result.keys()] base_fields = [name for name in base_result.keys()] # Ensure fields are same. test_result = list(set(sample_fields) - set(base_fields)) self.assertEqual(test_result, []) test_result = list(set(base_fields) - set(sample_fields)) self.assertEqual(test_result, []) # Ensure values are same. for sample_field, sample_value in sample_result.iteritems(): self.assertEqual(sample_value, base_result[sample_field])
def get(request, case_id, plan_id): """ Description: Used to load an existing test-case-plan from the database. Params: $case_id - Integer: An integer representing the ID of the test case in the database. $plan_id - Integer: An integer representing the ID of the test plan in the database. Returns: A blessed TestCasePlan object hash Example: >>> TestCasePlan.get(81307, 3551) """ tc = TestCase.objects.get(pk=case_id) tp = TestPlan.objects.get(pk=plan_id) tcp = TestCasePlan.objects.get(plan=tp, case=tc) return XMLRPCSerializer(model=tcp).serialize_model()
def get(request, case_id, plan_id): """Used to load an existing test-case-plan from the database. :param int case_id: case ID. :param int plan_id: plan ID. :return: a mapping of :class:`TestCasePlan`. :rtype: dict Example:: >>> TestCasePlan.get(1, 2) """ tc = TestCase.objects.get(pk=case_id) tp = TestPlan.objects.get(pk=plan_id) tcp = TestCasePlan.objects.get(plan=tp, case=tc) return XMLRPCSerializer(model=tcp).serialize_model()
def get(case_id, plan_id): """ Description: Used to load an existing test-case-plan from the database. Params: $case_id - Integer: An integer representing the ID of the test case in the database. $plan_id - Integer: An integer representing the ID of the test plan in the database. Returns: A blessed TestCasePlan object hash Example: >>> TestCasePlan.get(81307, 3551) """ if not isinstance(case_id, int): raise ValueError('Parameter case_id must be an integer') if not isinstance(plan_id, int): raise ValueError('Parameter plan_id must be an integer') tcp = TestCasePlan.objects.get(plan_id=plan_id, case_id=case_id) return XMLRPCSerializer(model=tcp).serialize_model()
def update(request, case_id, plan_id, sortkey): """ Description: Updates the sortkey of the selected test-case-plan. Params: $case_id - Integer: An integer representing the ID of the test case in the database. $plan_id - Integer: An integer representing the ID of the test plan in the database. $sortkey - Integer: An integer representing the ID of the sortkey in the database. Returns: A blessed TestCasePlan object hash Example: # Update sortkey of selected test-case-plan to 450 >>> TestCasePlan.update(81307, 3551, 450) """ tc = TestCase.objects.get(pk=case_id) tp = TestPlan.objects.get(pk=plan_id) tcp = TestCasePlan.objects.get(plan=tp, case=tc) if isinstance(sortkey, int): tcp.sortkey = sortkey tcp.save(update_fields=['sortkey']) return XMLRPCSerializer(model=tcp).serialize_model()
def update(request, case_id, plan_id, sortkey): """Updates the sortkey of the selected test-case-plan. :param int case_id: case ID. :param int plan_id: plan ID. :param int sortkey: the sort key. :return: a mapping of :class:`TestCasePlan`. :rtype: dict Example:: # Update sortkey of selected test-case-plan to 10 >>> TestCasePlan.update(1, 2, 10) """ tc = TestCase.objects.get(pk=case_id) tp = TestPlan.objects.get(pk=plan_id) tcp = TestCasePlan.objects.get(plan=tp, case=tc) if isinstance(sortkey, int): tcp.sortkey = sortkey tcp.save(update_fields=['sortkey']) return XMLRPCSerializer(model=tcp).serialize_model()
def get_test_cases(request, plan_id): """Get the list of cases that this plan is linked to. :param int plan_id: plan ID. :return: list of mappings of found :class:`TestCase`. :rtype: list[dict] Example:: TestPlan.get_test_cases(1) """ from tcms.testcases.models import TestCase from tcms.testplans.models import TestPlan from tcms.xmlrpc.serializer import XMLRPCSerializer tp = TestPlan.objects.get(pk=plan_id) tcs = TestCase.objects.filter(plan=tp).order_by('testcaseplan__sortkey') serialized_tcs = XMLRPCSerializer(tcs.iterator()).serialize_queryset() if serialized_tcs: for serialized_tc in serialized_tcs: case_id = serialized_tc.get('case_id', None) tc = tcs.get(pk=case_id) tcp = tc.testcaseplan_set.get(plan=tp) serialized_tc['sortkey'] = tcp.sortkey return serialized_tcs
def serialize(self): """ Convert the model for XMLPRC """ s = XMLRPCSerializer(model=self) return s.serialize_model()
def to_xmlrpc(cls, query={}): """ Convert the query set for XMLRPC """ s = XMLRPCSerializer(queryset=cls.objects.filter(**query).order_by('pk')) return s.serialize_queryset()
def _get_user_dict(user): user_dict = XMLRPCSerializer(model=user).serialize_model() if 'password' in user_dict: del user_dict['password'] return user_dict
def serialize(self): """ Convert the model for XMLPRC """ serializer = XMLRPCSerializer(model=self) return serializer.serialize_model()
def get_user_dict(user): u = XMLRPCSerializer(model=user) u = u.serialize_model() if 'password' in u: del u['password'] return u
def to_xmlrpc(cls, query={}): """ Convert the query set for XMLRPC """ s = XMLRPCSerializer(queryset=cls.objects.filter(**query)) return s.serialize_queryset()