def update(request, case_ids, values): """Updates the fields of the selected case or cases. $values - Hash of keys matching TestCase fields and the new values to set each field to. :param case_ids: give one or more case IDs. It could be an integer, a string containing comma separated IDs, or a list of int each of them is a case ID. :type case_ids: int, str or list :param dict values: a mapping containing these case data to update. * case_status: (ini) optional * product: (ini) optional (Required if changes category) * category: (ini) optional * priority: (ini) optional * default_tester: (str or int) optional (str - user_name, int - user_id) * estimated_time: (str) optional (2h30m30s(recommend) or HH:MM:SS * is_automated: (ini) optional (0 - Manual, 1 - Auto, 2 - Both) * is_automated_proposed: (bool) optional * script: (str) optional * arguments: (str) optional * summary: (str) optional * requirement: (str) optional * alias: (str) optional * notes: (str) optional * extra_link: (str) optional (reference link) :return: a list of mappings of updated :class:`TestCase`. :rtype: list(dict) Example:: # Update alias to 'tcms' for case 1 and 2 >>> TestCase.update([1, 2], {'alias': 'tcms'}) """ from tcms.core import forms from tcms.xmlrpc.forms import UpdateCaseForm if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time(values.get('estimated_time')) form = UpdateCaseForm(values) if values.get('category') and not values.get('product'): raise ValueError('Product ID is required for category') if values.get('product'): form.populate(product_id=values['product']) if form.is_valid(): tcs = TestCase.update( case_ids=pre_process_ids(value=case_ids), values=form.cleaned_data, ) else: raise ValueError(forms.errors_to_list(form)) query = {'pk__in': tcs.values_list('pk', flat=True)} return TestCase.to_xmlrpc(query)
def update(request, case_ids, values): """Updates the fields of the selected case or cases. $values - Hash of keys matching TestCase fields and the new values to set each field to. :param case_ids: give one or more case IDs. It could be an integer, a string containing comma separated IDs, or a list of int each of them is a case ID. :type case_ids: int, str or list :param dict values: a mapping containing these case data to update. * case_status: (ini) optional * product: (ini) optional (Required if changes category) * category: (ini) optional * priority: (ini) optional * default_tester: (str or int) optional (str - user_name, int - user_id) * estimated_time: (str) optional (2h30m30s(recommend) or HH:MM:SS * is_automated: (ini) optional (0 - Manual, 1 - Auto, 2 - Both) * is_automated_proposed: (bool) optional * script: (str) optional * arguments: (str) optional * summary: (str) optional * requirement: (str) optional * alias: (str) optional * notes: (str) optional * extra_link: (str) optional (reference link) :return: a list of mappings of updated :class:`TestCase`. :rtype: list(dict) Example:: # Update alias to 'tcms' for case 1 and 2 TestCase.update([1, 2], {'alias': 'tcms'}) """ from tcms.core import forms from tcms.xmlrpc.forms import UpdateCaseForm if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time(values.get('estimated_time')) form = UpdateCaseForm(values) if values.get('category') and not values.get('product'): raise ValueError('Product ID is required for category') if values.get('product'): form.populate(product_id=values['product']) if form.is_valid(): tcs = TestCase.update( case_ids=pre_process_ids(value=case_ids), values=form.cleaned_data, ) else: raise ValueError(forms.errors_to_list(form)) query = {'pk__in': tcs.values_list('pk', flat=True)} return TestCase.to_xmlrpc(query)
def filter(request, query): """ Description: Performs a search and returns the resulting list of test cases. Params: $query - Hash: keys must match valid search fields. +------------------------------------------------------------------+ | Case Search Parameters | +------------------------------------------------------------------+ | Key | Valid Values | | author | A bugzilla login (email address) | | attachment | ForeignKey: Attchment | | alias | String | | case_id | Integer | | case_status | ForeignKey: Case Stat | | category | ForeignKey: Category | | component | ForeignKey: Component | | default_tester | ForeignKey: Auth.User | | estimated_time | String: 2h30m30s(recommend) or HH:MM:SS | | plan | ForeignKey: Test Plan | | priority | ForeignKey: Priority | | category__product | ForeignKey: Product | | summary | String | | tags | ForeignKey: Tags | | create_date | Datetime | | is_automated | 1: Only show current 0: show not current | | script | Text | +------------------------------------------------------------------+ Returns: Array: Matching test cases are retuned in a list of hashes. Example: # Get all of cases contain 'TCMS' in summary >>> TestCase.filter({'summary__icontain': 'TCMS'}) # Get all of cases create by xkuang >>> TestCase.filter({'author__username': '******'}) # Get all of cases the author name starts with x >>> TestCase.filter({'author__username__startswith': 'x'}) # Get all of cases belong to the plan 137 >>> TestCase.filter({'plan__plan_id': 137}) # Get all of cases belong to the plan create by xkuang >>> TestCase.filter({'plan__author__username': '******'}) # Get cases with ID 12345, 23456, 34567 - Here is only support array so far. >>> TestCase.filter({'case_id__in': [12345, 23456, 34567]}) """ if query.get('estimated_time'): query['estimated_time'] = timedelta2int( pre_process_estimated_time(query.get('estimated_time')) ) return TestCase.to_xmlrpc(query)
def filter(query=None): # pylint: disable=redefined-builtin """ .. function:: XML-RPC TestCase.filter(query) Perform a search and return the resulting list of test cases augmented with their latest ``text``. :param query: Field lookups for :class:`tcms.testcases.models.TestCase` :type query: dict :return: Serialized list of :class:`tcms.testcases.models.TestCase` objects. :rtype: list(dict) """ if query is None: query = {} return TestCase.to_xmlrpc(query)
def filter(request, query): """Performs a search and returns the resulting list of test cases. :param dict query: a mapping containing these criteria. * author: A Bugzilla login (email address) * attachment: ForeignKey: Attachment * alias: (str) * case_id: (int) * case_status: ForeignKey: Case Stat * category: ForeignKey: :class:`Category` * component: ForeignKey: :class:`Component` * default_tester: ForeignKey: ``Auth.User`` * estimated_time: String: 2h30m30s(recommend) or HH:MM:SS * plan: ForeignKey: :class:`TestPlan` * priority: ForeignKey: :class:`Priority` * category__product: ForeignKey: :class:`Product` * summary: (str) * tags: ForeignKey: :class:`Tags` * create_date: Datetime * is_automated: 1: Only show current 0: show not current * script: (str) :return: list of mappings of found :class:`TestCase`. :rtype: list Example:: # Get all of cases contain 'TCMS' in summary >>> TestCase.filter({'summary__icontain': 'TCMS'}) # Get all of cases create by xkuang >>> TestCase.filter({'author__username': '******'}) # Get all of cases the author name starts with x >>> TestCase.filter({'author__username__startswith': 'x'}) # Get all of cases belong to the plan 1 >>> TestCase.filter({'plan__plan_id': 1}) # Get all of cases belong to the plan create by xkuang >>> TestCase.filter({'plan__author__username': '******'}) # Get cases with ID 12345, 23456, 34567 - Here is only support array so far. >>> TestCase.filter({'case_id__in': [12345, 23456, 34567]}) """ if query.get('estimated_time'): query['estimated_time'] = timedelta2int( pre_process_estimated_time(query.get('estimated_time')) ) return TestCase.to_xmlrpc(query)
def filter(request, query): """Performs a search and returns the resulting list of test cases. :param dict query: a mapping containing these criteria. * author: A Bugzilla login (email address) * attachments: ForeignKey: Attachment * alias: (str) * case_id: (int) * case_status: ForeignKey: Case Stat * category: ForeignKey: :class:`Category` * component: ForeignKey: :class:`Component` * default_tester: ForeignKey: ``Auth.User`` * estimated_time: String: 2h30m30s(recommend) or HH:MM:SS * plan: ForeignKey: :class:`TestPlan` * priority: ForeignKey: :class:`Priority` * category__product: ForeignKey: :class:`Product` * summary: (str) * tags: ForeignKey: :class:`Tags` * create_date: Datetime * is_automated: 1: Only show current 0: show not current * script: (str) :return: list of mappings of found :class:`TestCase`. :rtype: list Example:: # Get all of cases contain 'TCMS' in summary TestCase.filter({'summary__icontain': 'TCMS'}) # Get all of cases create by xkuang TestCase.filter({'author__username': '******'}) # Get all of cases the author name starts with x TestCase.filter({'author__username__startswith': 'x'}) # Get all of cases belong to the plan 1 TestCase.filter({'plan__plan_id': 1}) # Get all of cases belong to the plan create by xkuang TestCase.filter({'plan__author__username': '******'}) # Get cases with ID 12345, 23456, 34567 - Here is only support array so far. TestCase.filter({'case_id__in': [12345, 23456, 34567]}) """ if query.get('estimated_time'): query['estimated_time'] = timedelta2int( pre_process_estimated_time(query.get('estimated_time')) ) deprecate_critetion_attachment(query) return TestCase.to_xmlrpc(query)
def get_cases(request, product): """Get the list of cases associated with this product. :param product: product ID or name. :type product: int or str :return: a list of mappings of :class:`TestCase`. Example:: # Get with product id >>> Product.get_cases(61) # Get with product name >>> Product.get_cases('product name') """ from tcms.testcases.models import TestCase p = pre_check_product(values=product) query = {'category__product': p} return TestCase.to_xmlrpc(query)
def get_cases(request, product): """ Description: Get the list of cases associated with this product. Params: $product - Integer/String Integer: product_id of the product in the Database String: Product name Returns: Array: Returns an array of TestCase objects. Example: # Get with product id >>> Product.get_cases(61) # Get with product name >>> Product.get_cases('Red Hat Enterprise Linux 5') """ from tcms.testcases.models import TestCase p = pre_check_product(values=product) query = {'category__product': p} return TestCase.to_xmlrpc(query)
def get_test_cases(request, run_id): """Get the list of cases that this run is linked to. :param int run_id: run ID. :return: a list of mappings of found :class:`TestCase`. :rtype: list[dict] Example:: >>> TestRun.get_test_cases(1) """ tcs_serializer = TestCase.to_xmlrpc(query={'case_run__run_id': run_id}) qs = TestCaseRun.objects.filter(run_id=run_id).values( 'case', 'pk', 'case_run_status__name') extra_info = dict(((row['case'], row) for row in qs.iterator())) for case in tcs_serializer: info = extra_info[case['case_id']] case['case_run_id'] = info['pk'] case['case_run_status'] = info['case_run_status__name'] return tcs_serializer
def get_test_cases(request, run_id): """Get the list of cases that this run is linked to. :param int run_id: run ID. :return: a list of mappings of found :class:`TestCase`. :rtype: list[dict] Example:: TestRun.get_test_cases(1) """ tcs_serializer = TestCase.to_xmlrpc(query={'case_run__run_id': run_id}) qs = TestCaseRun.objects.filter(run_id=run_id).values( 'case', 'pk', 'case_run_status__name') extra_info = {row['case']: row for row in qs.iterator()} for case in tcs_serializer: info = extra_info[case['case_id']] case['case_run_id'] = info['pk'] case['case_run_status'] = info['case_run_status__name'] return tcs_serializer
def get_cases(run_id): """ .. function:: RPC TestRun.get_cases(run_id) Get the list of test cases that are attached to a test run. :param run_id: PK of TestRun to inspect :type run_id: int :return: Serialized list of :class:`tcms.testcases.models.TestCase` objects augmented with ``execution_id`` and ``status`` information. :rtype: list(dict) """ tcs_serializer = TestCase.to_xmlrpc(query={'case_run__run_id': run_id}) qs = TestExecution.objects.filter(run_id=run_id).values( 'case', 'pk', 'status__name') extra_info = dict(((row['case'], row) for row in qs.iterator())) for case in tcs_serializer: info = extra_info[case['id']] case['execution_id'] = info['pk'] case['status'] = info['status__name'] return tcs_serializer
def test_to_xmlrpc(self): result = TestCase.to_xmlrpc(query={'pk__in': self.case_pks}) self.assertEqual(len(result), 2) # Verify fields sample_testcase = result[0] sample_fields = set([name for name in sample_testcase.keys()]) test_fields = set(self.test_fields) test_result = list(sample_fields ^ test_fields) self.assertEqual(test_result, []) result = dict([(item['case_id'], item) for item in result]) case = result[self.case_pks[0]] sample_case = TestCase.objects.get(pk=self.case_pks[0]) self.assertEqual(case['is_automated'], sample_case.is_automated) self.assertEqual(case['summary'], sample_case.summary) self.assertEqual(case['alias'], sample_case.alias) self.assertEqual(case['author'], sample_case.author.username) self.assertEqual(case['author_id'], sample_case.author.pk) self.assertEqual(case['priority'], sample_case.priority.value) self.assertEqual(case['priority_id'], sample_case.priority.pk) components = case['component'] components.sort() sample_components = [item.pk for item in sample_case.component.all()] sample_components.sort() self.assertEqual(components, sample_components) tags = case['tag'] tags.sort() sample_tags = [item.pk for item in sample_case.tag.all()] sample_tags.sort() self.assertEqual(tags, sample_tags)
def get_test_cases(request, run_id): """ Description: Get the list of cases that this run is linked to. Params: $run_id - Integer: An integer representing the ID in the database for this run. Returns: Array: An array of test case object hashes. Example: >>> TestRun.get_test_cases(1193) """ tcs_serializer = TestCase.to_xmlrpc(query={'case_run__run_id': run_id}) qs = TestCaseRun.objects.filter(run_id=run_id).values( 'case', 'pk', 'case_run_status__name') extra_info = dict(((row['case'], row) for row in qs.iterator())) for case in tcs_serializer: info = extra_info[case['case_id']] case['case_run_id'] = info['pk'] case['case_run_status'] = info['case_run_status__name'] return tcs_serializer
def update(request, case_ids, values): """ Description: Updates the fields of the selected case or cases. Params: $case_ids - Integer/String/Array Integer: A single TestCase ID. String: A comma separates string of TestCase IDs for batch processing. Array: An array of case IDs for batch mode processing $values - Hash of keys matching TestCase fields and the new values to set each field to. Returns: Array: an array of case hashes. If the update on any particular case failed, the has will contain a ERROR key and the message as to why it failed. +-----------------------+----------------+-----------------------------------------+ | Field | Type | Null | +-----------------------+----------------+-----------------------------------------+ | case_status | Integer | Optional | | product | Integer | Optional(Required if changes category) | | category | Integer | Optional | | priority | Integer | Optional | | default_tester | String/Integer | Optional(str - user_name, int - user_id)| | estimated_time | String | Optional(2h30m30s(recommend) or HH:MM:SS| | is_automated | Integer | Optional(0 - Manual, 1 - Auto, 2 - Both)| | is_automated_proposed | Boolean | Optional | | script | String | Optional | | arguments | String | Optional | | summary | String | Optional | | requirement | String | Optional | | alias | String | Optional | | notes | String | Optional | | extra_link | String | Optional(reference link) +-----------------------+----------------+-----------------------------------------+ Example: # Update alias to 'tcms' for case 12345 and 23456 >>> TestCase.update([12345, 23456], {'alias': 'tcms'}) """ from tcms.core import forms from tcms.xmlrpc.forms import UpdateCaseForm if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time(values.get('estimated_time')) form = UpdateCaseForm(values) if values.get('category') and not values.get('product'): raise ValueError('Product ID is required for category') if values.get('product'): form.populate(product_id=values['product']) if form.is_valid(): tcs = TestCase.update( case_ids=pre_process_ids(value=case_ids), values=form.cleaned_data, ) else: raise ValueError(forms.errors_to_list(form)) query = {'pk__in': tcs.values_list('pk', flat=True)} return TestCase.to_xmlrpc(query)