def test_create(self): values = { 'summary': f'Test new case: {self.__class__.__name__}', 'is_automated': True, 'is_automated_proposed': True, 'script': '', 'arguments': '', 'extra_link': 'https://localhost/case-2', 'requirement': '', 'alias': 'alias', 'estimated_time': 0, 'case_status': TestCaseStatus.objects.get(name='CONFIRMED'), 'category': TestCaseCategory.objects.all()[0], 'priority': Priority.objects.all()[0], 'default_tester': self.tester, 'notes': '', 'tag': [self.tag_fedora, self.tag_python], 'component': [self.component_db, self.component_web], } TestCase.create(self.tester, values=values, plans=[self.plan]) new_case = TestCase.objects.get(summary=values['summary']) expected = values.copy() expected['estimated_time'] = timedelta(0) from tests.testcases import assert_new_case assert_new_case(new_case, expected) self.assertTrue( TestCasePlan.objects.filter(plan=self.plan, case=new_case).exists())
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 query_testcases_from_request(request, plan=None): """Query TestCases according to criterias coming within REQUEST :param request: the REQUEST object. :param plan: instance of TestPlan to restrict only those TestCases belongs to the TestPlan. Can be None. As you know, query from all TestCases. """ search_form = build_cases_search_form(request) action = request.POST.get('a') if action == 'initial': # todo: build_cases_search_form will also check TESTCASE_OPERATION_ACTIONS # and return slightly different values in case of initialization # move the check there and just execute the query here if the data # is valid d_status = get_case_status(request.POST.get('template_type')) tcs = TestCase.objects.filter(case_status__in=d_status) elif action in TESTCASE_OPERATION_ACTIONS and search_form.is_valid(): tcs = TestCase.list(search_form.cleaned_data, plan) else: tcs = TestCase.objects.none() # Search the relationship if plan: tcs = tcs.filter(plan=plan) tcs = tcs.select_related('author', 'default_tester', 'case_status', 'priority', 'category', 'reviewer') return tcs, search_form
def post(self, request, plan_id): plan = get_object_or_404(TestPlan, pk=int(plan_id)) search_mode = request.POST.get('search_mode') if search_mode == 'quick': form = quick_form = QuickSearchCaseForm(request.POST) normal_form = SearchCaseForm() else: form = normal_form = SearchCaseForm(request.POST) form.populate(product_id=request.POST.get('product')) quick_form = QuickSearchCaseForm() if form.is_valid(): cases = TestCase.list(form.cleaned_data) cases = cases.select_related( 'author', 'default_tester', 'case_status', 'priority' ).only( 'pk', 'summary', 'create_date', 'author__email', 'default_tester__email', 'case_status__name', 'priority__value' ).exclude( case_id__in=plan.case.values_list('case_id', flat=True)) context = { 'module': MODULE_NAME, 'sub_module': self.SUB_MODULE_NAME, 'test_plan': plan, 'test_cases': cases, 'search_form': normal_form, 'quick_form': quick_form, 'search_mode': search_mode } return render(request, self.template_name, context=context)
def test_list_by_multiple_criteria(self): cases = TestCase.list({ 'category': TestCaseCategory.objects.get(name='functional'), 'issue_key': ['2000'], }) self.assertEqual([self.case_1], list(cases))
def query_testcases_from_request(request, plan=None): # pylint: disable=missing-permission-required """Query TestCases according to criterias coming within REQUEST :param request: the REQUEST object. :type request: :class:`django.http.HttpRequest` :param plan: instance of TestPlan to restrict only those TestCases belongs to the TestPlan. Can be None. As you know, query from all TestCases. :type plan: :class:`tcms.testplans.models.TestPlan` :return: Queryset with testcases and search form :rtype: :class:`django.db.models.query.QuerySet`, dict """ search_form = build_cases_search_form(request, True, plan) action = request.POST.get('a') if action == 'initial': # todo: build_cases_search_form will also check TESTCASE_OPERATION_ACTIONS # and return slightly different values in case of initialization # move the check there and just execute the query here if the data # is valid d_status = get_case_status(request.POST.get('template_type')) tcs = TestCase.objects.filter(case_status__in=d_status) elif action in TESTCASE_OPERATION_ACTIONS and search_form.is_valid(): tcs = TestCase.list(search_form.cleaned_data, plan) else: tcs = TestCase.objects.none() # Search the relationship if plan: tcs = tcs.filter(plan=plan) tcs = tcs.select_related('author', 'default_tester', 'case_status', 'priority', 'category', 'reviewer') return tcs, search_form
def post(self, request, plan_id): plan = get_object_or_404(TestPlan, pk=int(plan_id)) search_mode = request.POST.get('search_mode') if search_mode == 'quick': form = quick_form = QuickSearchCaseForm(request.POST) normal_form = SearchCaseForm() else: form = normal_form = SearchCaseForm(request.POST) form.populate(product_id=request.POST.get('product')) quick_form = QuickSearchCaseForm() cases = [] if form.is_valid(): cases = TestCase.list(form.cleaned_data) cases = cases.select_related( 'author', 'default_tester', 'case_status', 'priority' ).only( 'pk', 'summary', 'create_date', 'author__email', 'default_tester__email', 'case_status__name', 'priority__value' ).exclude( case_id__in=plan.case.values_list('case_id', flat=True)) context = { 'test_plan': plan, 'test_cases': cases, 'search_form': normal_form, 'quick_form': quick_form, 'search_mode': search_mode } return render(request, self.template_name, context=context)
def create(values, **kwargs): """ .. function:: XML-RPC TestCase.create(values) Create a new TestCase object and store it in the database. :param values: Field values for :class:`tcms.testcases.models.TestCase` :type values: dict :return: Serialized :class:`tcms.testcases.models.TestCase` object :rtype: dict :raises: PermissionDenied if missing *testcases.add_testcase* permission Minimal test case parameters:: >>> values = { 'category': 135, 'product': 61, 'summary': 'Testing XML-RPC', 'priority': 1, } >>> TestCase.create(values) """ request = kwargs.get(REQUEST_KEY) if not (values.get('category') or values.get('summary')): raise ValueError() if values.get('estimated_time'): values['estimated_time'] = parse_duration(values.get('estimated_time')) form = NewCaseForm(values) form.populate(values.get('product')) if form.is_valid(): # Create the case test_case = TestCase.create(author=request.user, values=form.cleaned_data) # Add case text to the case test_case.add_text( action=form.cleaned_data['action'] or '', effect=form.cleaned_data['effect'] or '', setup=form.cleaned_data['setup'] or '', breakdown=form.cleaned_data['breakdown'] or '', ) # Add tag to the case for tag in string_to_list(values.get('tag', [])): tag, _ = Tag.objects.get_or_create(name=tag) test_case.add_tag(tag=tag) else: # Print the errors if the form is not passed validation. raise ValueError(form_errors_to_list(form)) result = test_case.serialize() result['text'] = test_case.latest_text().serialize() return result
def link_cases(self, template_name='plan/search_case.html'): """Handle to form to add case to plans""" SUB_MODULE_NAME = 'plans' tcs = None if request.POST.get('action') == 'add_to_plan': if request.user.has_perm('testcases.add_testcaseplan'): tcs = TestCase.objects.filter( case_id__in=request.POST.getlist('case')) for tc in tcs: tp.add_case(tc) else: return HttpResponse("Permission Denied") return HttpResponseRedirect( reverse('test_plan_url_short', args=[plan_id])) search_mode = request.POST.get('search_mode') if request.POST.get('action') == 'search': if search_mode == 'quick': form = quick_form = QuickSearchCaseForm(request.POST) normal_form = SearchCaseForm() else: form = normal_form = SearchCaseForm(request.POST) form.populate(product_id=request.POST.get('product')) quick_form = QuickSearchCaseForm() if form.is_valid(): tcs = TestCase.list(form.cleaned_data) tcs = tcs.select_related( 'author', 'default_tester', 'case_status', 'priority').only('pk', 'summary', 'create_date', 'author__email', 'default_tester__email', 'case_status__name', 'priority__value') tcs = tcs.exclude( case_id__in=tp.case.values_list('case_id', flat=True)) else: normal_form = SearchCaseForm( initial={ 'product': tp.product_id, 'product_version': tp.product_version_id, 'case_status_id': TestCaseStatus.get_CONFIRMED() }) quick_form = QuickSearchCaseForm() context_data = { 'module': MODULE_NAME, 'sub_module': SUB_MODULE_NAME, 'test_plan': tp, 'test_cases': tcs, 'search_form': normal_form, 'quick_form': quick_form, 'search_mode': search_mode } return render(request, template_name, context_data)
def _sendmail(self): mail_context = TestCase.mail_scene(objects=self._update_objects, field=self.target_field, value=self.new_value) if mail_context: from tcms.core.utils.mailto import mailto mail_context['context']['user'] = self.request.user mailto(**mail_context)
def _sendmail(self): mail_context = TestCase.mail_scene(objects=self._update_objects, field=self.target_field, value=self.new_value) if mail_context: from tcms.core.mailto import mailto mail_context['context']['user'] = self.request.user mailto(**mail_context)
def _sendmail(self): mail_context = TestCase.mail_scene(objects=self._update_objects, field=self.target_field) if mail_context: from tcms.core.utils.mailto import mailto mail_context['context']['user'] = self.request.user try: mailto(**mail_context) except Exception: # nosec:B110:try_except_pass pass
def create_test_case(self, form, notify_form, test_plan): """Create new test case""" test_case = TestCase.create(author=self.request.user, values=form.cleaned_data) # Assign the case to the plan if test_plan: test_plan.add_case(test_case) update_case_email_settings(test_case, notify_form) return test_case
def link_cases(self, template_name='plan/search_case.html'): """Handle to form to add case to plans""" SUB_MODULE_NAME = 'plans' tcs = None if request.POST.get('action') == 'add_to_plan': if request.user.has_perm('testcases.add_testcaseplan'): tcs = TestCase.objects.filter(case_id__in=request.POST.getlist('case')) for tc in tcs: tp.add_case(tc) else: return HttpResponse("Permission Denied") return HttpResponseRedirect( reverse('tcms.testplans.views.get', args=[plan_id])) search_mode = request.POST.get('search_mode') if request.POST.get('action') == 'search': if search_mode == 'quick': form = quick_form = QuickSearchCaseForm(request.POST) normal_form = SearchCaseForm() else: form = normal_form = SearchCaseForm(request.POST) form.populate(product_id=request.POST.get('product')) quick_form = QuickSearchCaseForm() if form.is_valid(): tcs = TestCase.list(form.cleaned_data) tcs = tcs.select_related( 'author', 'default_tester', 'case_status', 'priority').only( 'pk', 'summary', 'create_date', 'author__email', 'default_tester__email', 'case_status__name', 'priority__value') tcs = tcs.exclude(case_id__in=tp.case.values_list('case_id', flat=True)) else: normal_form = SearchCaseForm(initial={ 'product': tp.product_id, 'product_version': tp.product_version_id, 'case_status_id': TestCaseStatus.get_CONFIRMED() }) quick_form = QuickSearchCaseForm() context_data = { 'module': MODULE_NAME, 'sub_module': SUB_MODULE_NAME, 'test_plan': tp, 'test_cases': tcs, 'search_form': normal_form, 'quick_form': quick_form, 'search_mode': search_mode } return render_to_response(template_name, context_data, context_instance=RequestContext(request))
def create_testcase(request, form, test_plan): """Create testcase""" test_case = TestCase.create(author=request.user, values=form.cleaned_data) # Assign the case to the plan if test_plan: test_plan.add_case(test_case) # Add components into the case for component in form.cleaned_data['component']: test_case.add_component(component=component) return test_case
def test_list_by_search_keyword(self): criteria = [ { 'search': 'Test list' }, { 'search': self.case_author.email.split('@')[0] }, ] for item in criteria: cases = TestCase.list(item) self.assertEqual([self.case_1], list(cases))
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 test_update(self): TestCase.update( self.case_1.pk, { 'category': f.TestCaseCategoryFactory(name='functional', product=self.product), 'is_automated': 1, 'notes': '', 'script': '', }) case = TestCase.objects.get(pk=self.case_1.pk) category = TestCaseCategory.objects.get(name='functional', product=self.product) self.assertEqual(category, case.category) self.assertEqual(1, case.is_automated) self.assertEqual('', case.notes) self.assertEqual('', case.script)
def test_simple_list_by_property(self): criteria = [ { 'summary': 'list case' }, { 'author': self.case_1.author.username }, { 'author': self.case_1.author.email }, { 'default_tester': self.case_1.default_tester.username }, { 'default_tester': self.case_1.default_tester.email }, { 'tag__name__in': ['python'] }, { 'category': TestCaseCategory.objects.get(name='functional') }, { 'priority': [Priority.objects.get(value='P3')] }, { 'case_status': [TestCaseStatus.objects.first()] }, { 'component': Component.objects.get(name='db') }, { 'is_automated': 1 }, { 'is_automated_proposed': True }, { 'product': self.product.pk }, { 'issue_key': ['2000', '1000'] }, ] for item in criteria: cases = TestCase.list(item) self.assertEqual([self.case_1], list(cases))
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 create_testcase(request, form, test_plan): """Create testcase""" test_case = TestCase.create(author=request.user, values=form.cleaned_data) test_case.add_text(case_text_version=1, author=request.user, action=form.cleaned_data['action'], effect=form.cleaned_data['effect'], setup=form.cleaned_data['setup'], breakdown=form.cleaned_data['breakdown']) # Assign the case to the plan if test_plan: test_case.add_to_plan(plan=test_plan) # Add components into the case for component in form.cleaned_data['component']: test_case.add_component(component=component) return test_case
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 create(values, **kwargs): """ .. function:: XML-RPC TestCase.create(values) Create a new TestCase object and store it in the database. :param values: Field values for :class:`tcms.testcases.models.TestCase` :type values: dict :return: Serialized :class:`tcms.testcases.models.TestCase` object :rtype: dict :raises: PermissionDenied if missing *testcases.add_testcase* permission Minimal test case parameters:: >>> values = { 'category': 135, 'product': 61, 'summary': 'Testing XML-RPC', 'priority': 1, } >>> TestCase.create(values) """ request = kwargs.get(REQUEST_KEY) if not (values.get('category') or values.get('summary')): raise ValueError() form = NewCaseForm(values) form.populate(values.get('product')) if form.is_valid(): # Create the case test_case = TestCase.create(author=request.user, values=form.cleaned_data) else: # Print the errors if the form is not passed validation. raise ValueError(form_errors_to_list(form)) result = test_case.serialize() return result
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 = {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 = 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): """ 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 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 assert_new_case(new_case: TestCase, expected: Dict) -> None: assert expected['summary'] == new_case.summary assert expected['is_automated'] == new_case.is_automated assert expected['is_automated_proposed'] == new_case.is_automated_proposed assert expected['script'] == new_case.script assert expected['arguments'] == new_case.arguments assert expected['extra_link'] == new_case.extra_link assert expected['notes'] == new_case.notes assert expected['default_tester'] == new_case.default_tester assert expected['estimated_time'] == new_case.estimated_time assert expected['category'] == new_case.category assert expected['priority'] == new_case.priority assert expected['case_status'] == new_case.case_status assert set(expected['tag']) == set(new_case.tag.all()) assert (sorted(item.pk for item in expected['component']) == sorted(item.pk for item in new_case.component.all())) if all(item in expected for item in ['action', 'effect', 'setup', 'breakdown']): text = new_case.latest_text() assert expected['action'] == text.action assert expected['effect'] == text.effect assert expected['setup'] == text.setup assert expected['breakdown'] == text.breakdown
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 create(request, values): """Creates a new Test Case object and stores it in the database. :param values: a mapping or list of mappings containing these case information for creation. * product: (int) **Required** ID of Product * category: (int) **Required** ID of Category * priority: (int) **Required** ID of Priority * summary: (str) **Required** * case_status: (int) optional ID of case status * plan Array/Str/Int optional ID or List of plan_ids * component: (int)/str optional ID of Priority * default_tester: (str) optional Login of tester * estimated_time: (str) optional 2h30m30s(recommend) or HH:MM:SS Format| * is_automated: (int) optional 0: Manual, 1: Auto, 2: Both * is_automated_proposed: (bool) optional Default 0 * script: (str) optional * arguments: (str) optional * requirement: (str) optional * alias: (str) optional Must be unique * action: (str) optional * effect: (str) optional Expected Result * setup: (str) optional * breakdown: (str) optional * tag Array/str optional String Comma separated * bug Array/str optional String Comma separated * extra_link: (str) optional reference link :return: a mapping of newly created test case if a single case was created, or a list of mappings of created cases if more than one are created. :rtype: dict of list[dict] Example:: # Minimal test case parameters >>> values = { 'category': 1, 'product': 1, 'summary': 'Testing XML-RPC', 'priority': 1, } >>> TestCase.create(values) """ from tcms.core import forms from tcms.xmlrpc.forms import NewCaseForm if not (values.get('category') or values.get('summary')): raise ValueError() values['component'] = pre_process_ids(values.get('component', [])) values['plan'] = pre_process_ids(values.get('plan', [])) values['bug'] = pre_process_ids(values.get('bug', [])) if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time(values.get('estimated_time')) form = NewCaseForm(values) form.populate(values.get('product')) if form.is_valid(): # Create the case tc = TestCase.create(author=request.user, values=form.cleaned_data) # Add case text to the case tc.add_text( action=form.cleaned_data['action'] or '', effect=form.cleaned_data['effect'] or '', setup=form.cleaned_data['setup'] or '', breakdown=form.cleaned_data['breakdown'] or '', ) # Add the case to specific plans for p in form.cleaned_data['plan']: tc.add_to_plan(plan=p) del p # Add components to the case for c in form.cleaned_data['component']: tc.add_component(component=c) del c # Add tag to the case for tag in TestTag.string_to_list(values.get('tag', [])): t, c = TestTag.objects.get_or_create(name=tag) tc.add_tag(tag=t) else: # Print the errors if the form is not passed validation. raise ValueError(forms.errors_to_list(form)) return get(request, tc.case_id)
def create(request, values): """ Description: Creates a new Test Case object and stores it in the database. Params: $values - Array/Hash: A reference to a hash or array of hashes with keys and values matching the fields of the test case to be created. +----------------------------+----------------+-----------+---------------------------------------+ | Field | Type | Null | Description | +----------------------------+----------------+-----------+---------------------------------------+ | product | Integer | Required | ID of Product | | category | Integer | Required | ID of Category | | priority | Integer | Required | ID of Priority | | summary | String | Required | | | case_status | Integer | Optional | ID of case status | | plan | Array/Str/Int | Optional | ID or List of plan_ids | | component | Integer/String | Optional | ID of Priority | | default_tester | String | Optional | Login of tester | | estimated_time | String | Optional | 2h30m30s(recommend) or HH:MM:SS Format| | is_automated | Integer | Optional | 0: Manual, 1: Auto, 2: Both | | is_automated_proposed | Boolean | Optional | Default 0 | | script | String | Optional | | | arguments | String | Optional | | | requirement | String | Optional | | | alias | String | Optional | Must be unique | | action | String | Optional | | | effect | String | Optional | Expected Result | | setup | String | Optional | | | breakdown | String | Optional | | | tag | Array/String | Optional | String Comma separated | | bug | Array/String | Optional | String Comma separated | | extra_link | String | Optional | reference link | +----------------------------+----------------+-----------+---------------------------------------+ Returns: Array/Hash: The newly created object hash if a single case was created, or an array of objects if more than one was created. If any single case threw an error during creation, a hash with an ERROR key will be set in its place. Example: # Minimal test case parameters >>> values = { 'category': 135, 'product': 61, 'summary': 'Testing XML-RPC', 'priority': 1, } >>> TestCase.create(values) """ from tcms.core import forms from tcms.xmlrpc.forms import NewCaseForm if not (values.get('category') or values.get('summary')): raise ValueError() values['component'] = pre_process_ids(values.get('component', [])) values['plan'] = pre_process_ids(values.get('plan', [])) values['bug'] = pre_process_ids(values.get('bug', [])) if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time(values.get('estimated_time')) form = NewCaseForm(values) form.populate(values.get('product')) if form.is_valid(): # Create the case tc = TestCase.create(author=request.user, values=form.cleaned_data) # Add case text to the case tc.add_text( action=form.cleaned_data['action'] or '', effect=form.cleaned_data['effect'] or '', setup=form.cleaned_data['setup'] or '', breakdown=form.cleaned_data['breakdown'] or '', ) # Add the case to specific plans for p in form.cleaned_data['plan']: tc.add_to_plan(plan=p) del p # Add components to the case for c in form.cleaned_data['component']: tc.add_component(component=c) del c # Add tag to the case for tag in TestTag.string_to_list(values.get('tag', [])): t, c = TestTag.objects.get_or_create(name=tag) tc.add_tag(tag=t) else: # Print the errors if the form is not passed validation. raise ValueError(forms.errors_to_list(form)) return get(request, tc.case_id)
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)
def test_get_empty_result(self): result = Product.objects.aggregate(max_pk=Max('pk')) unknown_pk = result['max_pk'] + 1 self.assertListEqual([], list(TestCase.list({'product': unknown_pk})))