def test_to_xmlrpc(self): testrun1 = TestRun.objects.get(pk=self.testrun_pks[0]) result = TestRun.to_xmlrpc(query={'pk__in': self.testrun_pks}) self.assertEqual(len(result), 2) # Verify fields sample_testrun = result[0] sample_fields = set([name for name in sample_testrun.keys()]) test_fields = set(self.test_fields) test_result = list(sample_fields ^ test_fields) self.assertEqual(test_result, []) result = dict([(item['run_id'], item) for item in result]) sample_testrun1 = result[self.testrun_pks[0]] self.assertEqual(testrun1.errata_id, sample_testrun1['errata_id']) self.assertEqual(testrun1.product_version.pk, sample_testrun1['product_version_id']) self.assertEqual(testrun1.product_version.value, sample_testrun1['product_version']) self.assertEqual(testrun1.default_tester.pk, sample_testrun1['default_tester_id']) self.assertEqual(testrun1.default_tester.username, sample_testrun1['default_tester']) tags = [tag.pk for tag in testrun1.tag.all()] tags.sort() sample_tags = sample_testrun1['tag'] sample_tags.sort() self.assertEqual(tags, sample_tags)
def dashboard(request): """List the recent plan/run""" runs_query = { 'people': request.user, 'is_active': True, 'status': 'running', } tps = TestPlan.objects.filter( Q(author=request.user) | Q(owner=request.user)) tps = tps.order_by('-plan_id') tps = tps.select_related('product', 'type') tps = tps.extra(select={ 'num_runs': RawSQL.num_runs, }) tps_active = tps.filter(is_active=True) trs = TestRun.list(runs_query) latest_fifteen_testruns = trs.order_by('-run_id')[:15] test_plans_disable_count = tps.count() - tps_active.count() context_data = { 'user_profile': { 'user': request.user }, 'test_plans_count': tps.count(), 'test_plans_disable_count': test_plans_disable_count, 'test_runs_count': trs.count(), 'last_15_test_plans': tps_active[:15], 'last_15_test_runs': latest_fifteen_testruns, } return render(request, 'profile/dashboard.html', context_data)
def generate_status_matrix(self, build_ids): matrix_dataset = {} # TODO: replace defaultdict with GroupByResult status_total_line = defaultdict(int) rows = SQLExecution(sqls.custom_details_status_matrix, params=(build_ids,), with_field_name=False).rows for row in rows: plan_id, plan_name, run_id, run_summary, \ status_name, status_count = row plan = TestPlan(pk=plan_id, name=plan_name) plan_node = matrix_dataset.setdefault(plan, {}) run = TestRun(pk=run_id, summary=run_summary) run_node = plan_node.setdefault(run, defaultdict(int)) run_node[status_name] = status_count run_node['TOTAL'] += status_count # calculate the last total line status_total_line[status_name] += status_count status_total_line['TOTAL'] += status_count # Add total line to final data set matrix_dataset[None] = status_total_line return matrix_dataset
def filter(request, values={}): """Performs a search and returns the resulting list of test runs. :param dict values: a mapping containing these criteria. * build: ForeignKey: TestBuild * cc: ForeignKey: Auth.User * env_value: ForeignKey: Environment Value * default_tester: ForeignKey: Auth.User * run_id: (int) * manager: ForeignKey: Auth.User * notes: (str) * plan: ForeignKey: TestPlan * summary: (str) * tag: ForeignKey: Tag * product_version: ForeignKey: Version :return: list of mappings of found :class:`TestRun`. :rtype: list Example:: # Get all of runs contain 'TCMS' in summary >>> TestRun.filter({'summary__icontain': 'TCMS'}) # Get all of runs managed by xkuang >>> TestRun.filter({'manager__username': '******'}) # Get all of runs the manager name starts with x >>> TestRun.filter({'manager__username__startswith': 'x'}) # Get runs contain the case ID 1, 2, 3 >>> TestRun.filter({'case_run__case__case_id__in': [1, 2, 3]}) """ return TestRun.to_xmlrpc(values)
def recent(request, username, template_name='profile/recent.html'): """List the recent plan/run""" if username != request.user.username: return http.HttpResponseRedirect(reverse('nitrate-login')) else: up = {'user': request.user} runs_query = { 'people': request.user, 'is_active': True, 'status': 'running', } tps = TestPlan.objects.filter(Q(author=request.user) | Q(owner=request.user)) tps = tps.order_by('-plan_id') tps = tps.select_related('product', 'type') tps = tps.extra(select={ 'num_runs': RawSQL.num_runs, }) tps_active = tps.filter(is_active=True) trs = TestRun.list(runs_query) latest_fifteen_testruns = trs.order_by('-run_id')[:15] test_plans_disable_count = tps.count() - tps_active.count() context_data = { 'module': MODULE_NAME, 'user_profile': up, 'test_plans_count': tps.count(), 'test_plans_disable_count': test_plans_disable_count, 'test_runs_count': trs.count(), 'last_15_test_plans': tps_active[:15], 'last_15_test_runs': latest_fifteen_testruns, } return render(request, template_name, context=context_data)
def ajax_search(request, template_name='run/common/json_runs.txt'): """Response request to search test runs from Search Runs""" search_form = SearchRunForm(request.GET) if request.GET.get('product'): search_form.populate(product_id=request.GET['product']) else: search_form.populate() if search_form.is_valid(): trs = TestRun.list(search_form.cleaned_data) trs = trs.select_related( 'manager', 'default_tester', 'plan', 'build').only('run_id', 'summary', 'manager__username', 'default_tester__id', 'default_tester__username', 'plan__name', 'env_value', 'build__product__name', 'stop_date', 'product_version__value') # Further optimize by adding caserun attributes: column_names = [ '', 'run_id', 'summary', 'manager__username', 'default_tester__username', 'plan', 'build__product__name', 'product_version', 'total_num_caseruns', 'stop_date', 'completed', ] data_table_result = DataTableResult(request.GET, trs, column_names) response_data = data_table_result.get_response_data() searched_runs = response_data['querySet'] # Get associated statistics data run_ids = [run.pk for run in searched_runs] qs = TestCaseRun.objects.filter( run__in=run_ids).values('run').annotate(cases_count=Count('case')) cases_subtotal = magic_convert(qs, key_name='run', value_name='cases_count') for run in searched_runs: run_id = run.pk cases_count = cases_subtotal.get(run_id, 0) run.nitrate_stats = { 'cases': cases_count, } else: response_data = { 'sEcho': int(request.GET.get('sEcho', 0)), 'iTotalRecords': 0, 'iTotalDisplayRecords': 0, 'runs': TestRun.objects.none(), } json_data = render_to_string(template_name, response_data, request=request) return HttpResponse(json_data, content_type='application/json')
def filter(request, values={}): """Performs a search and returns the resulting list of test runs. :param dict values: a mapping containing these criteria. * build: ForeignKey: TestBuild * cc: ForeignKey: Auth.User * env_value: ForeignKey: Environment Value * default_tester: ForeignKey: Auth.User * run_id: (int) * manager: ForeignKey: Auth.User * notes: (str) * plan: ForeignKey: TestPlan * summary: (str) * tag: ForeignKey: Tag * product_version: ForeignKey: Version :return: list of mappings of found :class:`TestRun`. :rtype: list Example:: # Get all of runs contain 'TCMS' in summary TestRun.filter({'summary__icontain': 'TCMS'}) # Get all of runs managed by xkuang TestRun.filter({'manager__username': '******'}) # Get all of runs the manager name starts with x TestRun.filter({'manager__username__startswith': 'x'}) # Get runs contain the case ID 1, 2, 3 TestRun.filter({'case_run__case__case_id__in': [1, 2, 3]}) """ return TestRun.to_xmlrpc(values)
def generate_status_matrix(build_ids): matrix_dataset = {} # TODO: replace defaultdict with GroupByResult status_total_line = defaultdict(int) rows = TestCaseRun.objects.filter(build__in=build_ids).values( 'run__plan', 'run__plan__name', 'run', 'run__summary', 'case_run_status__name').annotate( total_count=Count('pk')).order_by('run__plan', 'run') for row in rows: plan_id = row['run__plan'] plan_name = row['run__plan__name'] run_id = row['run'] run_summary = row['run__summary'] status_name = row['case_run_status__name'] status_count = row['total_count'] plan = TestPlan(pk=plan_id, name=plan_name) plan_node = matrix_dataset.setdefault(plan, {}) run = TestRun(pk=run_id, summary=run_summary) run_node = plan_node.setdefault(run, defaultdict(int)) run_node[status_name] = status_count run_node['TOTAL'] += status_count # calculate the last total line status_total_line[status_name] += status_count status_total_line['TOTAL'] += status_count # Add total line to final data set matrix_dataset[None] = status_total_line return matrix_dataset
def recent(request, username, template_name='profile/recent.html'): """List the recent plan/run""" if username != request.user.username: return http.HttpResponseRedirect(reverse('tcms-login')) else: up = {'user': request.user} runs_query = { 'people': request.user, 'is_active': True, 'status': 'running', } tps = TestPlan.objects.filter(Q(author=request.user) | Q(owner=request.user)) tps = tps.order_by('-plan_id') tps = tps.select_related('product', 'type') tps = tps.extra(select={ 'num_runs': RawSQL.num_runs, }) tps_active = tps.filter(is_active=True) trs = TestRun.list(runs_query) latest_fifteen_testruns = trs.order_by('-run_id')[:15] test_plans_disable_count = tps.count() - tps_active.count() context_data = { 'user_profile': up, 'test_plans_count': tps.count(), 'test_plans_disable_count': test_plans_disable_count, 'test_runs_count': trs.count(), 'last_15_test_plans': tps_active[:15], 'last_15_test_runs': latest_fifteen_testruns, } return render(request, template_name, context_data)
def status_matrix(self, form): status_matrix = GroupByResult() query = self._filter_query( form, TestCaseRun.objects.values( 'build', 'build__name', 'run__plan__tag', 'run__plan', 'run__plan__name', 'run', 'run__summary', 'case_run_status__name').annotate(total_count=Count('pk'))) for row in query: tag_id = row['run__plan__tag'] build_id = row['build'] build_name = row['build__name'] plan_id = row['run__plan'] plan_name = row['run__plan__name'] run_id = row['run'] run_summary = row['run__summary'] status_name = row['case_run_status__name'] total_count = row['total_count'] builds = status_matrix.setdefault(tag_id, GroupByResult()) plans = builds.setdefault(Build(pk=build_id, name=build_name), GroupByResult()) runs = plans.setdefault(TestPlan(pk=plan_id, name=plan_name), GroupByResult()) status_subtotal = runs.setdefault( TestRun(pk=run_id, summary=run_summary), GroupByResult()) status_subtotal[status_name] = total_count return status_matrix
def filter(query={}): # pylint: disable=invalid-name """ .. function:: XML-RPC TestRun.filter(query) Perform a search and return the resulting list of test runs. :param query: Field lookups for :class:`tcms.testruns.models.TestRun` :type query: dict :return: List of serialized :class:`tcms.testruns.models.TestRun` objects :rtype: list(dict) """ return TestRun.to_xmlrpc(query)
def search_runs(request): """Search test runs""" search_form = SearchRunForm(request.GET) product_id = request.GET.get('product') search_form.populate(product_id=int(product_id) if product_id else None) runs = TestRun.objects.none() if search_form.is_valid(): runs = (TestRun.list(search_form.cleaned_data).select_related( 'manager', 'default_tester', 'build', 'plan', 'build__product').only( 'run_id', 'summary', 'manager__username', 'default_tester__id', 'default_tester__username', 'plan__name', 'build__product__name', 'stop_date', 'product_version__value').extra( select={'cases_count': RawSQL.total_num_caseruns})) column_names = [ '', 'run_id', 'summary', 'manager__username', 'default_tester__username', 'build__product__name', 'product_version__value', 'env_groups', 'cases_count', 'stop_date', 'completed', ] dt = DataTableResult(request.GET, runs, column_names, default_order_key='-pk') response_data = dt.get_response_data() calculate_associated_data(response_data['querySet']) if 'sEcho' in request.GET: resp_data = (get_template('run/common/json_runs.txt').render( response_data, request)) return JsonResponse(json.loads(resp_data)) else: return render(request, 'run/all.html', context={ 'module': MODULE_NAME, 'sub_module': 'runs', 'object_list': response_data['querySet'], 'search_form': search_form, 'total_count': runs.count() })
def get_test_runs(plan_id): """ Description: Get the list of runs in this plan. Params: $plan_id - Integer: An integer representing the ID of this plan in the database Returns: Array: An array of test run object hashes. Example: >>> TestPlan.get_test_runs(plan_id) """ from tcms.testruns.models import TestRun query = {'plan': plan_id} return TestRun.to_xmlrpc(query)
def get_test_runs(request, plan_id): """Get the list of runs in this plan. :param int plan_id: plan ID. :return: list of mappings of found :class:`TestRun`. :rtype: list[dict] Example:: >>> TestPlan.get_test_runs(1) """ from tcms.testruns.models import TestRun query = {'plan': plan_id} return TestRun.to_xmlrpc(query)
def get_test_runs(request, plan_id): """Get the list of runs in this plan. :param int plan_id: plan ID. :return: list of mappings of found :class:`TestRun`. :rtype: list[dict] Example:: TestPlan.get_test_runs(1) """ from tcms.testruns.models import TestRun query = {'plan': plan_id} return TestRun.to_xmlrpc(query)
def get_test_runs(request, plan_id): """ Description: Get the list of runs in this plan. Params: $plan_id - Integer: An integer representing the ID of this plan in the database Returns: Array: An array of test run object hashes. Example: >>> TestPlan.get_test_runs(plan_id) """ from tcms.testruns.models import TestRun query = {'plan': plan_id} return TestRun.to_xmlrpc(query)
def recent(request, username): """List the recent plan/run""" if username != request.user.username: return http.HttpResponseRedirect(reverse('nitrate-login')) plans_subtotal = { item['is_active']: item['count'] for item in TestPlan.objects.values('is_active').annotate( count=Count('pk')) } plans_count = sum(plans_subtotal.values()) disabled_plans_count = plans_subtotal.get(False, 0) plans = (TestPlan.objects.filter( Q(author=request.user) | Q(owner=request.user), is_active=True).select_related('product', 'type').order_by('-plan_id').only( 'name', 'is_active', 'type__name', 'product__name')) plans = TestPlan.apply_subtotal(plans, runs_count=True) runs = (TestRun.list({ 'people': request.user, 'is_active': True, 'status': 'running' }).only('summary', 'start_date').order_by('-run_id')) first_15_runs = runs[:15] subtotal = stats_case_runs_status([item.pk for item in first_15_runs]) for run in first_15_runs: run.case_runs_subtotal = subtotal[run.pk] return render(request, 'profile/recent.html', context={ 'module': MODULE_NAME, 'user_profile': { 'user': request.user }, 'test_plans_count': plans_count, 'test_plans_disable_count': disabled_plans_count, 'test_runs_count': runs.count(), 'last_15_test_plans': plans[:15], 'last_15_test_runs': first_15_runs, })
def filter(query=None): # pylint: disable=redefined-builtin """ .. function:: RPC TestRun.filter(query) Perform a search and return the resulting list of test runs. :param query: Field lookups for :class:`tcms.testruns.models.TestRun` :type query: dict :return: List of serialized :class:`tcms.testruns.models.TestRun` objects :rtype: list(dict) """ if query is None: query = {} return TestRun.to_xmlrpc(query)
def get_runs(request, build_id): """ Description: Returns the list of runs that this Build is used in. Params: $id - Integer: Build ID. Returns: Array: List of run object hashes. Example: >>> Build.get_runs(1234) """ from tcms.testruns.models import TestRun tb = TestBuild.objects.get(build_id=build_id) query = {"build": tb} return TestRun.to_xmlrpc(query)
def get_runs(request, build_id): """Returns the list of runs that this Build is used in. :param int build_id: build ID. :return: list of test runs. :rtype: list Example:: >>> Build.get_runs(1234) """ from tcms.testruns.models import TestRun tb = TestBuild.objects.get(build_id=build_id) query = {'build': tb} return TestRun.to_xmlrpc(query)
def get_runs(request, build_id): """ Description: Returns the list of runs that this Build is used in. Params: $id - Integer: Build ID. Returns: Array: List of run object hashes. Example: >>> Build.get_runs(1234) """ from tcms.testruns.models import TestRun tb = TestBuild.objects.get(build_id=build_id) query = {'build': tb} return TestRun.to_xmlrpc(query)
def get_runs(build_id): """ .. function:: XML-RPC Build.get_runs(build_id) Returns the list of TestRuns that this Build is used in. :param build_id: the object ID :type build_id: int :return: List of serialized :class:`tcms.testruns.models.TestRun` objects :rtype: list(dict) :raises: TestBuild.DoesNotExist if build not found """ from tcms.testruns.models import TestRun tb = TestBuild.objects.get(build_id=build_id) query = {'build': tb} return TestRun.to_xmlrpc(query)
def get_runs(request, product): """Get the list of runs associated with this product. :params product: product ID or name. :type product: int or str :return: a list of mappings of test runs. :rtype: list Example:: # Get with product id >>> Product.get_runs(1) # Get with product name >>> Product.get_runs('product name') """ from tcms.testruns.models import TestRun p = pre_check_product(values=product) query = {'build__product': p} return TestRun.to_xmlrpc(query)
def get_runs(request, product): """ Description: Get the list of runs 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 Test Run objects. Example: # Get with product id >>> Product.get_runs(61) # Get with product name >>> Product.get_runs('Red Hat Enterprise Linux 5') """ from tcms.testruns.models import TestRun p = pre_check_product(values=product) query = {'build__product': p} return TestRun.to_xmlrpc(query)
def status_matrix(self, form): query = self._filter_query( form, TestCaseRun.objects.values( 'run__plan', 'run__plan__name', 'build', 'build__name', 'run', 'run__summary', 'case_run_status__name').annotate(total_count=Count('pk'))) status_matrix = GroupByResult() for row in query: plan = TestPlan(pk=row['run__plan'], name=row['run__plan__name']) builds = status_matrix.setdefault(plan, GroupByResult()) build = Build(pk=row['build'], name=row['build__name']) runs = builds.setdefault(build, GroupByResult()) run = TestRun(pk=row['run'], summary=row['run__summary']) status_subtotal = runs.setdefault(run, GroupByResult()) status_subtotal[row['case_run_status__name']] = row['total_count'] return status_matrix
def status_matrix(self, form): sql, params = self._prepare_sql(form, sqls.by_plan_tags_detail_status_matrix) rows = SQLExecution(sql, params, with_field_name=False).rows status_matrix = GroupByResult() for row in rows: (tag_id, build_id, build_name, plan_id, plan_name, run_id, run_summary, status_name, total_count) = row builds = status_matrix.setdefault(tag_id, GroupByResult()) plans = builds.setdefault(TestBuild(pk=build_id, name=build_name), GroupByResult()) runs = plans.setdefault(TestPlan(pk=plan_id, name=plan_name), GroupByResult()) status_subtotal = runs.setdefault( TestRun(pk=run_id, summary=run_summary), GroupByResult()) status_subtotal[status_name] = total_count return status_matrix
def status_matrix(self, form): status_matrix = GroupByResult() query = self._filter_query( form, TestCaseRun.objects.values( 'build', 'build__name', 'run__plan__tag', 'run__plan', 'run__plan__name', 'run', 'run__summary', 'status__name').annotate(total_count=Count('pk'))) for row in query: builds = status_matrix.setdefault(row['run__plan__tag'], GroupByResult()) plans = builds.setdefault( Build(pk=row['build'], name=row['build__name']), GroupByResult()) runs = plans.setdefault( TestPlan(pk=row['run__plan'], name=row['run__plan__name']), GroupByResult()) status_subtotal = runs.setdefault( TestRun(pk=row['run'], summary=row['run__summary']), GroupByResult()) status_subtotal[row['status__name']] = row['total_count'] return status_matrix
def filter(request, values={}): """ Description: Performs a search and returns the resulting list of test runs. Params: $values - Hash: keys must match valid search fields. +--------------------------------------------------------+ | Run Search Parameters | +--------------------------------------------------------+ | Key | Valid Values | | build | ForeignKey: Build | | cc | ForeignKey: Auth.User | | env_value | ForeignKey: Environment Value | | default_tester | ForeignKey: Auth.User | | run_id | Integer | | manager | ForeignKey: Auth.User | | notes | String | | plan | ForeignKey: Test Plan | | summary | String | | tag | ForeignKey: Tag | | product_version | ForeignKey: Version | +--------------------------------------------------------+ Returns: Array: Matching test runs are retuned in a list of run object hashes. Example: # Get all of runs contain 'TCMS' in summary >>> TestRun.filter({'summary__icontain': 'TCMS'}) # Get all of runs managed by xkuang >>> TestRun.filter({'manager__username': '******'}) # Get all of runs the manager name starts with x >>> TestRun.filter({'manager__username__startswith': 'x'}) # Get runs contain the case ID 12345, 23456, 34567 >>> TestRun.filter({'case_run__case__case_id__in': [12345, 23456, 34567]}) """ return TestRun.to_xmlrpc(values)
def pbuild(request, username, product_id, template_name='profile/product_builds.html'): """List the recent plan/run""" if username != request.user.username: return http.HttpResponseRedirect(reverse('tcms-login')) else: up = {'user': request.user} runs_query = { 'people': request.user, 'is_active': True, } product_id = int(product_id) tps = TestPlan.objects.filter( Q(author=request.user) | Q(owner=request.user)) tps = tps.order_by('-plan_id') tps = tps.select_related('product', 'type') tps = tps.extra(select={ 'num_runs': RawSQL.num_runs, }) tps_active = tps.filter(is_active=True) trs = TestRun.list(runs_query) latest_fifteen_testruns = trs.order_by('-run_id')[:15] all_test_runs = trs.order_by('-run_id') test_plans_disable_count = tps.count() - tps_active.count() # My codes prod_builds = { run.build for run in all_test_runs if (run.build.product_id == product_id) } prod_build_count = len(prod_builds) prod = dict() prod[1] = 'MESSAGING' prod[2] = 'VOICE' prod[3] = 'INTERNAL SYSTEM' prod[4] = 'PHLO' prod[5] = 'DATA' prod[6] = 'CONSOLE' prod[7] = 'ZENTRUNK' product = prod[product_id] all_builds = {run.build for run in all_test_runs} build_count = len(all_builds) context_data = { 'user_profile': up, 'test_plans_count': tps.count(), 'test_plans_disable_count': test_plans_disable_count, 'test_runs_count': trs.count(), 'last_15_test_plans': tps_active[:15], 'last_15_test_runs': latest_fifteen_testruns, 'all_builds': all_builds, 'build_count': build_count, 'prod_build_count': prod_build_count, 'prod_builds': prod_builds, 'product_id': product_id, 'username': username, 'product': product, } return render(request, template_name, context_data)
def update(request, run_ids, values): """Updates the fields of the selected test run. :param run_ids: give one or more run IDs. It could be an integer, a string containing comma separated IDs, or a list of int each of them is a run ID. :type run_ids: int, str or list :param dict values: a mapping containing these data to update specified runs. * plan: (int) TestPlan.plan_id * product: (int) Product.id * build: (int) Build.id * errata_id: (int) Errata.id * manager: (int) Auth.User.id * default_tester: Intege Auth.User.id * summary: (str) * estimated_time: (TimeDelta) in format ``2h30m30s`` which is recommended or ``HH:MM:SS``. * product_version: (int) * plan_text_version: (int) * notes: (str) * status: (int) 0:RUNNING 1:FINISHED :return: list of mappings of the updated test runs. :rtype: list[dict] Example:: # Update status to finished for run 1 and 2 >>> TestRun.update([1, 2], {'status': 1}) """ from datetime import datetime from tcms.core import forms from tcms.testruns.forms import XMLRPCUpdateRunForm if (values.get('product_version') and not values.get('product')): raise ValueError('Field "product" is required by product_version') if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time( values.get('estimated_time')) form = XMLRPCUpdateRunForm(values) if values.get('product_version'): form.populate(product_id=values['product']) if form.is_valid(): trs = TestRun.objects.filter(pk__in=pre_process_ids(value=run_ids)) _values = dict() if form.cleaned_data['plan']: _values['plan'] = form.cleaned_data['plan'] if form.cleaned_data['build']: _values['build'] = form.cleaned_data['build'] if form.cleaned_data['errata_id']: _values['errata_id'] = form.cleaned_data['errata_id'] if form.cleaned_data['manager']: _values['manager'] = form.cleaned_data['manager'] if 'default_tester' in values: if values.get('default_tester') and \ form.cleaned_data['default_tester']: _values['default_tester'] = form.cleaned_data['default_tester'] else: _values['default_tester'] = None if form.cleaned_data['summary']: _values['summary'] = form.cleaned_data['summary'] if values.get('estimated_time') is not None: _values['estimated_time'] = form.cleaned_data['estimated_time'] if form.cleaned_data['product_version']: _values['product_version'] = form.cleaned_data['product_version'] if 'notes' in values: if values['notes'] in (None, ''): _values['notes'] = values['notes'] if form.cleaned_data['notes']: _values['notes'] = form.cleaned_data['notes'] if form.cleaned_data['plan_text_version']: _values['plan_text_version'] = form.cleaned_data[ 'plan_text_version'] if isinstance(form.cleaned_data['status'], int): if form.cleaned_data['status']: _values['stop_date'] = datetime.now() else: _values['stop_date'] = None trs.update(**_values) else: raise ValueError(forms.errors_to_list(form)) query = {'pk__in': trs.values_list('pk', flat=True)} return TestRun.to_xmlrpc(query)
def update(request, run_ids, values): """Updates the fields of the selected test run. :param run_ids: give one or more run IDs. It could be an integer, a string containing comma separated IDs, or a list of int each of them is a run ID. :type run_ids: int, str or list :param dict values: a mapping containing these data to update specified runs. * plan: (int) TestPlan.plan_id * product: (int) Product.id * build: (int) Build.id * manager: (int) Auth.User.id * default_tester: Intege Auth.User.id * summary: (str) * estimated_time: (TimeDelta) in format ``2h30m30s`` which is recommended or ``HH:MM:SS``. * product_version: (int) * plan_text_version: (int) * notes: (str) * status: (int) 0:RUNNING 1:FINISHED :return: list of mappings of the updated test runs. :rtype: list[dict] .. versionchanged:: 4.5 Argument ``errata_id`` is removed. Example:: # Update status to finished for run 1 and 2 TestRun.update([1, 2], {'status': 1}) """ from datetime import datetime from tcms.core import forms from tcms.testruns.forms import XMLRPCUpdateRunForm if (values.get('product_version') and not values.get('product')): raise ValueError('Field "product" is required by product_version') if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time( values.get('estimated_time')) form = XMLRPCUpdateRunForm(values) if values.get('product_version'): form.populate(product_id=values['product']) if form.is_valid(): trs = TestRun.objects.filter(pk__in=pre_process_ids(value=run_ids)) _values = dict() if form.cleaned_data['plan']: _values['plan'] = form.cleaned_data['plan'] if form.cleaned_data['build']: _values['build'] = form.cleaned_data['build'] if form.cleaned_data['manager']: _values['manager'] = form.cleaned_data['manager'] if 'default_tester' in values: default_tester = form.cleaned_data['default_tester'] if values.get('default_tester') and default_tester: _values['default_tester'] = default_tester else: _values['default_tester'] = None if form.cleaned_data['summary']: _values['summary'] = form.cleaned_data['summary'] if values.get('estimated_time') is not None: _values['estimated_time'] = form.cleaned_data['estimated_time'] if form.cleaned_data['product_version']: _values['product_version'] = form.cleaned_data['product_version'] if 'notes' in values: if values['notes'] in (None, ''): _values['notes'] = values['notes'] if form.cleaned_data['notes']: _values['notes'] = form.cleaned_data['notes'] if form.cleaned_data['plan_text_version']: _values['plan_text_version'] = form.cleaned_data[ 'plan_text_version'] if isinstance(form.cleaned_data['status'], int): if form.cleaned_data['status']: _values['stop_date'] = datetime.now() else: _values['stop_date'] = None trs.update(**_values) else: raise ValueError(forms.errors_to_list(form)) query = {'pk__in': trs.values_list('pk', flat=True)} return TestRun.to_xmlrpc(query)
def update(request, run_ids, values): """ Description: Updates the fields of the selected test run. Params: $run_ids - Integer/Array/String: An integer or alias representing the ID in the database, an array of run_ids, or a string of comma separated run_ids. $values - Hash of keys matching TestRun fields and the new values to set each field to. See params of TestRun.create for description +-------------------+----------------+--------------------------------+ | Field | Type | Description | +-------------------+----------------+--------------------------------+ | plan | Integer | TestPlan.plan_id | | product | Integer | Product.id | | build | Integer | Build.id | | errata_id | Integer | Errata.id | | manager | Integer | Auth.User.id | | default_tester | Intege | Auth.User.id | | summary | String | | | estimated_time | TimeDelta | 2h30m30s(recommend) or HH:MM:SS| | product_version | Integer | | | plan_text_version | Integer | | | notes | String | | | status | Integer | 0:RUNNING 1:FINISHED | +-------------------+----------------+ -------------------------------+ Returns: Hash: The updated test run object. Example: # Update status to finished for run 1193 and 1194 >>> TestRun.update([1193, 1194], {'status': 1}) """ from datetime import datetime from tcms.core import forms from tcms.testruns.forms import XMLRPCUpdateRunForm if (values.get('product_version') and not values.get('product')): raise ValueError('Field "product" is required by product_version') if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time( values.get('estimated_time')) form = XMLRPCUpdateRunForm(values) if values.get('product_version'): form.populate(product_id=values['product']) if form.is_valid(): trs = TestRun.objects.filter(pk__in=pre_process_ids(value=run_ids)) _values = dict() if form.cleaned_data['plan']: _values['plan'] = form.cleaned_data['plan'] if form.cleaned_data['build']: _values['build'] = form.cleaned_data['build'] if form.cleaned_data['errata_id']: _values['errata_id'] = form.cleaned_data['errata_id'] if form.cleaned_data['manager']: _values['manager'] = form.cleaned_data['manager'] if 'default_tester' in values: if values.get('default_tester') and \ form.cleaned_data['default_tester']: _values['default_tester'] = form.cleaned_data['default_tester'] else: _values['default_tester'] = None if form.cleaned_data['summary']: _values['summary'] = form.cleaned_data['summary'] if values.get('estimated_time') is not None: _values['estimated_time'] = form.cleaned_data['estimated_time'] if form.cleaned_data['product_version']: _values['product_version'] = form.cleaned_data['product_version'] if 'notes' in values: if values['notes'] in (None, ''): _values['notes'] = values['notes'] if form.cleaned_data['notes']: _values['notes'] = form.cleaned_data['notes'] if form.cleaned_data['plan_text_version']: _values['plan_text_version'] = form.cleaned_data[ 'plan_text_version'] if isinstance(form.cleaned_data['status'], int): if form.cleaned_data['status']: _values['stop_date'] = datetime.now() else: _values['stop_date'] = None trs.update(**_values) else: raise ValueError(forms.errors_to_list(form)) query = {'pk__in': trs.values_list('pk', flat=True)} return TestRun.to_xmlrpc(query)
def update(request, run_ids, values): """ Description: Updates the fields of the selected test run. Params: $run_ids - Integer/Array/String: An integer or alias representing the ID in the database, an array of run_ids, or a string of comma separated run_ids. $values - Hash of keys matching TestRun fields and the new values to set each field to. See params of TestRun.create for description +-------------------+----------------+--------------------------------+ | Field | Type | Description | +-------------------+----------------+--------------------------------+ | plan | Integer | TestPlan.plan_id | | product | Integer | Product.id | | build | Integer | Build.id | | manager | Integer | Auth.User.id | | default_tester | Intege | Auth.User.id | | summary | String | | | estimated_time | TimeDelta | 2h30m30s(recommend) or HH:MM:SS| | product_version | Integer | | | plan_text_version | Integer | | | notes | String | | | status | Integer | 0:RUNNING 1:FINISHED | +-------------------+----------------+ -------------------------------+ Returns: Hash: The updated test run object. Example: # Update status to finished for run 1193 and 1194 >>> TestRun.update([1193, 1194], {'status': 1}) """ from datetime import datetime from tcms.core import forms from tcms.testruns.forms import XMLRPCUpdateRunForm if (values.get('product_version') and not values.get('product')): raise ValueError('Field "product" is required by product_version') if values.get('estimated_time'): values['estimated_time'] = pre_process_estimated_time( values.get('estimated_time')) form = XMLRPCUpdateRunForm(values) if values.get('product_version'): form.populate(product_id=values['product']) if form.is_valid(): trs = TestRun.objects.filter(pk__in=pre_process_ids(value=run_ids)) _values = dict() if form.cleaned_data['plan']: _values['plan'] = form.cleaned_data['plan'] if form.cleaned_data['build']: _values['build'] = form.cleaned_data['build'] if form.cleaned_data['manager']: _values['manager'] = form.cleaned_data['manager'] if 'default_tester' in values: if values.get('default_tester') and \ form.cleaned_data['default_tester']: _values['default_tester'] = form.cleaned_data['default_tester'] else: _values['default_tester'] = None if form.cleaned_data['summary']: _values['summary'] = form.cleaned_data['summary'] if values.get('estimated_time') is not None: _values['estimated_time'] = form.cleaned_data['estimated_time'] if form.cleaned_data['product_version']: _values['product_version'] = form.cleaned_data['product_version'] if 'notes' in values: if values['notes'] in (None, ''): _values['notes'] = values['notes'] if form.cleaned_data['notes']: _values['notes'] = form.cleaned_data['notes'] if form.cleaned_data['plan_text_version']: _values['plan_text_version'] = form.cleaned_data[ 'plan_text_version'] if isinstance(form.cleaned_data['status'], int): if form.cleaned_data['status']: _values['stop_date'] = datetime.now() else: _values['stop_date'] = None trs.update(**_values) else: raise ValueError(forms.errors_to_list(form)) query = {'pk__in': trs.values_list('pk', flat=True)} return TestRun.to_xmlrpc(query)