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
