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(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 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 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 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(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 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()
