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 generator_proxy(plan_pks): def key_func(data): return (data['plan_id'], data['case_id']) params_sql = ','.join(itertools.repeat('%s', len(plan_pks))) metas = SQLExecution(sqls.TP_EXPORT_ALL_CASES_META % params_sql, plan_pks).rows compoment_dict = create_dict( sqls.TP_EXPORT_ALL_CASES_COMPONENTS % params_sql, plan_pks, key_func) tag_dict = create_dict(sqls.TP_EXPORT_ALL_CASE_TAGS % params_sql, plan_pks, key_func) sql = sqls.TP_EXPORT_ALL_CASE_TEXTS % (params_sql, params_sql) plan_text_dict = create_dict(sql, plan_pks * 2, key_func) for meta in metas: plan_id = meta['plan_id'] case_id = meta['case_id'] c_meta = compoment_dict.get((plan_id, case_id), None) if c_meta: meta['c_meta'] = c_meta tag = tag_dict.get((plan_id, case_id), None) if tag: meta['tag'] = tag plan_text = plan_text_dict.get((plan_id, case_id), None) if plan_text: meta['latest_text'] = plan_text yield meta
def runs_subtotal(self, form): sql, params = self._prepare_sql(form, sqls.by_plan_build_runs_subtotal) rows = SQLExecution(sql, params, with_field_name=False).rows result = GroupByResult() for plan_id, plan_name, runs_count in rows: plan = TestPlan(pk=plan_id, name=plan_name) result[plan] = runs_count return result
def status_matrix(self, form): sql, params = self._prepare_sql(form, sqls.by_plan_build_status_matrix) rows = SQLExecution(sql, params, with_field_name=False).rows status_matrix = GroupByResult() for plan_id, plan_name, status_name, total_count in rows: plan = TestPlan(pk=plan_id, name=plan_name) status_subtotal = status_matrix.setdefault(plan, GroupByResult()) status_subtotal[status_name] = total_count return status_matrix
def plan_generator(): repeat = len(plan_pks) params_sql = ','.join(itertools.repeat('%s', repeat)) sql = sqls.TP_PRINTABLE_CASE_TEXTS % (params_sql, params_sql) result_set = SQLExecution(sql, plan_pks * 2) group_data = itertools.groupby(result_set.rows, itemgetter('plan_id')) cases_dict = {key: list(values) for key, values in group_data} for tp in tps: tp.result_set = cases_dict.get(tp.plan_id, None) yield tp
def _get_builds(self): '''Get builds from valid form @param form: the form containing valid data @type form: L{CustomSearchForm} @return: queried test builds @rtype: L{QuerySet} ''' sql, params = self._prepare_sql(sqls.custom_builds) rows = SQLExecution(sql, params).rows return [TestBuild(pk=row['build_id'], name=row['name']) for row in rows]
def passed_failed_case_runs_subtotal(self, form): sql, params = self._prepare_sql( form, sqls.by_plan_tags_passed_failed_case_runs_subtotal) sql_executor = SQLExecution(sql, params, with_field_name=False) rows = sql_executor.rows tags = GroupByResult() for tag_id, name, total_count in rows: status_subtotal = tags.setdefault(tag_id, GroupByResult()) status_subtotal[name] = total_count return tags
def runs_subtotal(self, form): sql, params = self._prepare_sql(form, sqls.by_plan_build_runs_subtotal) rows = list(SQLExecution(sql, params, with_field_name=False).rows) plans = { p.pk: p for p in TestPlan.objects.filter( pk__in=[plan_id for plan_id, _ in rows]).only('pk', 'name') } result = GroupByResult() for plan_id, runs_count in rows: result[plans[plan_id]] = runs_count return result
def status_matrix(self): """Case run status matrix used to render progress bar""" sql, params = self._prepare_sql( sqls.custom_builds_case_runs_subtotal_by_status) rows = SQLExecution(sql, params, with_field_name=False).rows builds = GroupByResult() for build_id, case_run_status_id, total_count in rows: status_subtotal = builds.setdefault(build_id, GroupByResult()) status_subtotal[case_run_status_id] = total_count return builds
def _get_builds(self): """Get builds from valid form :param form: the form containing valid data :type form: :class:`CustomSearchForm` :return: queried test builds :rtype: QuerySet """ sql, params = self._prepare_sql(sqls.custom_builds) rows = SQLExecution(sql, params).rows return [ TestBuild(pk=row['build_id'], name=row['name']) for row in rows ]
def status_matrix(self, form): sql, params = self._prepare_sql(form, sqls.by_case_run_tester_status_matrix) sql_executor = SQLExecution(sql, params, with_field_name=False) status_matrix = GroupByResult({}) rows = sql_executor.rows for tested_by_id, name, total_count in rows: status_subtotal = status_matrix.setdefault(tested_by_id, GroupByResult({})) status_subtotal[name] = total_count return status_matrix
def runs_subtotal_groupby_builds(self, form): sql, params = self._prepare_sql( form, sqls.by_case_run_tester_runs_subtotal_groupby_build) sql_executor = SQLExecution(sql, params, with_field_name=False) rows = sql_executor.rows builds = GroupByResult({}) for build_id, tested_by_id, total_count in rows: tested_by_ids = builds.setdefault(build_id, GroupByResult({})) tested_by_ids[tested_by_id] = total_count return builds
def create_group_by_dict(sql, params, key_func): """ @param sql: the SQL query to execute @type sql: basestring @param params: parameters to bind with SQL @type params: list or tuple @param key_func: key function @type key_func: callable object @return: dict with SQL query results @:rtype: dict """ result_set = SQLExecution(sql, params) group_data = itertools.groupby(result_set.rows, key_func) return dict((key, [v for v in values]) for key, values in group_data)
def status_matrix(self, form): sql, params = self._prepare_sql(form, sqls.by_plan_build_status_matrix) rows = list(SQLExecution(sql, params, with_field_name=False).rows) plans = { p.pk: p for p in TestPlan.objects.filter( pk__in=[plan_id for plan_id, _, _ in rows]).only('pk', 'name') } status_matrix = GroupByResult() for plan_id, status_name, total_count in rows: status_subtotal = status_matrix.setdefault(plans[plan_id], GroupByResult()) status_subtotal[status_name] = total_count return status_matrix
def status_matrix(self, form): sql, params = self._prepare_sql(form, sqls.by_case_priority_subtotal) sql_executor = SQLExecution(sql, params, with_field_name=False) rows = sql_executor.rows builds = GroupByResult() for build_id, priority_id, priority_value, name, total_count in rows: priorities = builds.setdefault(build_id, GroupByResult()) priority = Priority(pk=priority_id, value=priority_value) status_subtotal = priorities.setdefault(priority, GroupByResult()) status_subtotal[name] = total_count return builds
def status_matrix_groupby_builds(self, form): sql, params = self._prepare_sql( form, sqls.by_case_run_tester_status_matrix_groupby_build) sql_executor = SQLExecution(sql, params, with_field_name=False) builds = GroupByResult({}) for build_id, tested_by_id, name, total_count in sql_executor.rows: tested_by_ids = builds.setdefault(build_id, GroupByResult({})) status_subtotal = tested_by_ids.setdefault(tested_by_id, GroupByResult({})) status_subtotal[name] = total_count return builds
def stats_caseruns_status(run_id, case_run_statuss): '''Get statistics based on case runs' status @param run_id: id of test run from where to get statistics @type run_id: int @param case_run_statuss: iterable object containing TestCaseRunStatus objects @type case_run_statuss: iterable object @return: the statistics including the number of each status mapping, total number of case runs, complete percent, and failure percent. @rtype: namedtuple ''' rows = SQLExecution(STATS_CASERUNS_STATUS, (run_id,)).rows caserun_statuss_subtotal = dict((status.pk, [0, status]) for status in case_run_statuss) for row in rows: status_pk = row['case_run_status_id'] caserun_statuss_subtotal[status_pk][0] = row['status_count'] complete_count = 0 failure_count = 0 caseruns_total_count = 0 status_complete_names = TestCaseRunStatus.complete_status_names status_failure_names = TestCaseRunStatus.failure_status_names for status_pk, total_info in caserun_statuss_subtotal.iteritems(): status_caseruns_count, caserun_status = total_info status_name = caserun_status.name caseruns_total_count += status_caseruns_count if status_name in status_complete_names: complete_count += status_caseruns_count if status_name in status_failure_names: failure_count += status_caseruns_count # Final calculation complete_percent = .0 if caseruns_total_count: complete_percent = complete_count * 100.0 / caseruns_total_count failure_percent = .0 if complete_count: failure_percent = failure_count * 100.0 / complete_count return TestCaseRunStatusSubtotal(caserun_statuss_subtotal, caseruns_total_count, complete_percent, failure_percent)
def get_case_runs_comments(self, build_ids, status_ids): '''Get case runs' bugs according to builds and status @param build_ids: IDs of builds @type build_ids: list or tuple @param status_ids: IDs of case run status @type status_ids: list or tuple @return: mapping between case run ID and its comments @rtype: dict ''' ct = ContentType.objects.get_for_model(TestCaseRun) rows = SQLExecution(sqls.custom_details_case_runs_comments, (ct.pk, build_ids, status_ids)).rows return dict((case_run_id, list(comments)) for case_run_id, comments in groupby(rows, key=lambda row: row['case_run_id']))
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): sql, params = self._prepare_sql( form, sqls.by_plan_build_detail_status_matrix) rows = SQLExecution(sql, params, with_field_name=False).rows status_matrix = GroupByResult() plan_ids = build_ids = run_ids = [] for plan_id, build_id, run_id, status_name, _ in rows: plan_ids.append(plan_id) build_ids.append(build_id) run_ids.append(run_id) plans = { plan.pk: plan for plan in TestPlan.objects.filter( pk__in=plan_ids).only('pk', 'name') } test_builds = { build.pk: build for build in TestBuild.objects.filter( pk__in=build_ids).only('pk', 'name') } runs = { run.pk: run for run in TestRun.objects.filter( pk__in=run_ids).only('pk', 'summary') } for row in rows: plan_id, build_id, run_id, status_name, total_count = row builds = status_matrix.setdefault(plans[plan_id], GroupByResult()) runs = builds.setdefault(test_builds[build_id], GroupByResult()) status_subtotal = runs.setdefault(runs[run_id], GroupByResult()) status_subtotal[status_name] = total_count return status_matrix
def case_runs_total(self, form): sql, params = self._prepare_sql(form, sqls.testing_report_case_runs_total) return SQLExecution(sql, params).scalar
def get_run_bug_ids(run_id): rows = SQLExecution(GET_RUN_BUG_IDS, (run_id,)).rows return set((row['bug_id'], row['url_reg_exp'] % row['bug_id']) for row in rows)
def get_bug_count(self): sql_executor = SQLExecution(GET_BUG_COUNT, [ self.pk, ]) return sql_executor.scalar
def runs_count(self, form): sql, params = self._prepare_sql(form, sqls.testing_report_runs_total) sql_executor = SQLExecution(sql, params) return sql_executor.scalar