5552

pending completion

Build # 5552

Build Type

push

travis-ci

Committed by

atodorov

Commit Message

<a href="https://github.com/kiwitcms/Kiwi/commit/<a class=hub.com/kiwitcms/Kiwi/commit/c1251421573efa9a0841a8ede23779c1b99ac6f3">c12514215<a href="https://github.com/kiwitcms/Kiwi/commit/c1251421573efa9a0841a8ede23779c1b99ac6f3">&quot;&gt;Restore a hidden field in template

this was removed in </a><a class="double-link" href="https://github.com/kiwitcms/Kiwi/commit/<a class="double-link" href="https://github.com/kiwitcms/Kiwi/commit/c6b475948615f483737269d0672dba389278b141">c6b475948</a>">c6b475948</a><a href="https://github.com/kiwitcms/Kiwi/commit/c1251421573efa9a0841a8ede23779c1b99ac6f3">
but #1331 depends on this field to get the object ID.

Run Details

697 of 1146 branches covered (60.82%)

Branch coverage included in aggregate %.

3652 of 4591 relevant lines covered (79.55%)

0.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.73

/tcms/testruns/views.py

# -*- coding: utf-8 -*-

from http import HTTPStatus

from django.conf import settings
from django.contrib import messages
from django.contrib.auth import get_user_model
from django.contrib.auth.decorators import permission_required
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import ObjectDoesNotExist
from django.db.models import Count, Q
from django.http import Http404, HttpResponseRedirect, JsonResponse
from django.shortcuts import get_object_or_404, render
from django.urls import reverse
from django.utils.decorators import method_decorator
from django.utils.translation import gettext_lazy as _
from django.views.generic.base import TemplateView, View
from django.views.generic.edit import UpdateView
from django_comments.models import Comment

from tcms.core.contrib.linkreference.models import LinkReference
from tcms.core.utils import clean_request
from tcms.management.models import Build, Priority, Tag
from tcms.testcases.models import BugSystem, TestCasePlan, TestCaseStatus
from tcms.testcases.views import get_selected_testcases
from tcms.testplans.models import TestPlan
from tcms.testruns.data import TestExecutionDataMixin
from tcms.testruns.forms import BaseRunForm, NewRunForm, SearchRunForm
from tcms.testruns.models import TestExecution, TestExecutionStatus, TestRun

User = get_user_model()  # pylint: disable=invalid-name


@method_decorator(permission_required('testruns.add_testrun'), name='dispatch')
class CreateTestRunView(View):
    """Display the create test run page."""

    template_name = 'testruns/mutable.html'
    http_method_names = ['post']

    def post(self, request):
        # If from_plan does not exist will redirect to plans for select a plan
        plan_id = request.POST.get('from_plan')
        if not plan_id:
            messages.add_message(request,
                                 messages.ERROR,
                                 _('Creating a TestRun requires a TestPlan, select one'))
            return HttpResponseRedirect(reverse('plans-search'))

        if not request.POST.get('case'):
            messages.add_message(request,
                                 messages.ERROR,
                                 _('Creating a TestRun requires at least one TestCase'))
            return HttpResponseRedirect(reverse('test_plan_url_short', args=[plan_id]))

        # Ready to write cases to test plan
        test_cases = get_selected_testcases(request)
        test_plan = TestPlan.objects.get(pk=plan_id)

        # note: ordered by pk for test_show_create_new_run_page()
        tcs_values = test_cases.select_related('author',
                                               'case_status',
                                               'category',
                                               'priority').order_by('pk')

        if request.POST.get('POSTING_TO_CREATE'):
            form = NewRunForm(request.POST)
            form.populate(product_id=test_plan.product_id)

            if form.is_valid():
                # Process the data in form.cleaned_data
                default_tester = form.cleaned_data['default_tester']

                test_run = TestRun.objects.create(
                    product_version=test_plan.product_version,
                    stop_date=None,
                    summary=form.cleaned_data.get('summary'),
                    notes=form.cleaned_data.get('notes'),
                    plan=test_plan,
                    build=form.cleaned_data['build'],
                    manager=form.cleaned_data['manager'],
                    default_tester=default_tester,
                )

                loop = 1
                for case in form.cleaned_data['case']:
                    try:
                        tcp = TestCasePlan.objects.get(plan=test_plan, case=case)
                        sortkey = tcp.sortkey
                    except ObjectDoesNotExist:
                        sortkey = loop * 10

                    test_run.add_case_run(case=case, sortkey=sortkey,
                                          assignee=default_tester)
                    loop += 1

                return HttpResponseRedirect(
                    reverse('testruns-get', args=[test_run.pk, ])
                )

        else:
            form = NewRunForm(initial={
                'summary': 'Test run for %s' % test_plan.name,
                'manager': test_plan.author.email,
                'default_tester': request.user.email,
                'notes': '',
            })
            form.populate(product_id=test_plan.product_id)

        context_data = {
            'test_plan': test_plan,
            'test_cases': tcs_values,
            'form': form,
        }
        return render(request, self.template_name, context_data)


class SearchTestRunView(TemplateView):  # pylint: disable=missing-permission-required

    template_name = 'testruns/search.html'

    def get_context_data(self, **kwargs):
        form = SearchRunForm(self.request.GET)
        form.populate(product_id=self.request.GET.get('product'))

        return {
            'form': form,
        }


def _open_run_get_executions(request, run):  # pylint: disable=missing-permission-required
    """Prepare for executions list in a TestRun page

    This is an internal method. Do not call this directly.
    """

    executions = run.case_run.select_related(
        'run', 'case'
    ).only('run_id',
           'status',
           'assignee',
           'tested_by',
           'case_text_version',
           'sortkey',
           'case__summary',
           'case__is_automated',
           'case__priority',
           'case__category__name'
           )

    # Continue to search the executionss with conditions
    # 4. executions preparing for render executions table
    executions = executions.filter(**clean_request(request))
    order_by = request.GET.get('order_by')
    if order_by:
        return executions.order_by(order_by)

    return executions.order_by('sortkey', 'pk')


def open_run_get_comments_subtotal(execution_ids):
    content_type = ContentType.objects.get_for_model(TestExecution)
    query_set = Comment.objects.filter(
        content_type=content_type,
        site_id=settings.SITE_ID,
        object_pk__in=execution_ids,
        is_removed=False).values('object_pk').annotate(comment_count=Count('pk')).order_by(
            'object_pk')

    result = ((int(row['object_pk']), row['comment_count']) for row in query_set)
    return dict(result)


def open_run_get_users(case_runs):
    tester_ids = set()
    assignee_ids = set()
    for case_run in case_runs:
        if case_run.tested_by_id:
            tester_ids.add(case_run.tested_by_id)
        if case_run.assignee_id:
            assignee_ids.add(case_run.assignee_id)
    testers = User.objects.filter(
        pk__in=tester_ids).values_list('pk', 'username')
    assignees = User.objects.filter(
        pk__in=assignee_ids).values_list('pk', 'username')
    return (dict(testers.iterator()), dict(assignees.iterator()))


class GetTestRunView(TemplateView):  # pylint: disable=missing-permission-required
    """Display testrun's details"""

    template_name = 'run/get.html'

    def get_context_data(self, **kwargs):
        # Get the test run
        try:
            # todo: this is redundant b/c we've got self.object pointing to the
            # same object and we don't have to read it twice from the DB
            # todo: self.object however isn't present b/c this is not a DetailsView
            # and we're not calling super() anywhere
            test_run = TestRun.objects.select_related().get(pk=kwargs['pk'])
        except ObjectDoesNotExist:
            raise Http404

        # Get the test executions that belong to the run
        # 2. get test run's all executions
        test_executions = _open_run_get_executions(self.request, test_run)

        status = TestExecutionStatus.objects.order_by('-weight', 'name')

        # Count the status
        # 3. calculate number of executions of each status
        status_stats_result = test_run.stats_executions_status(status)

        # Get the test execution bugs summary
        # 6. get the number of bugs of this run
        execution_bugs_count = test_run.get_bug_count()

        return {
            'test_run': test_run,
            'executions': _walk_executions(test_executions),
            'executions_count': len(test_executions),
            'status_stats': status_stats_result,
            'execution_bugs_count': execution_bugs_count,
            'test_status': status,
            'priorities': Priority.objects.filter(is_active=True),
            'case_own_tags': _get_tags(test_executions),
            'bug_trackers': BugSystem.objects.all(),
        }


def _get_tags(test_executions):
    """Get tag list of testcases"""

    # Get the list of testcases belong to the run
    test_cases = []
    for test_execution in test_executions:
        test_cases.append(test_execution.case_id)

    tags = Tag.objects.filter(case__in=test_cases).values_list('name', flat=True)
    tags = list(set(tags))
    tags.sort()

    return tags


def _walk_executions(test_executions):
    """Walking executions for helping rendering executions table"""

    priorities = dict(Priority.objects.values_list('pk', 'value'))
    testers, assignees = open_run_get_users(test_executions)
    execution_pks = []
    for execution in test_executions:
        execution_pks.append(execution.pk)
    comments_subtotal = open_run_get_comments_subtotal(execution_pks)

    for execution in test_executions:
        yield (execution,
               testers.get(execution.tested_by_id, None),
               assignees.get(execution.assignee_id, None),
               priorities.get(execution.case.priority_id),
               comments_subtotal.get(execution.pk, 0),
               LinkReference.objects.filter(is_defect=True,
                                            execution=execution.pk).count())


@method_decorator(permission_required('testruns.change_testrun'), name='dispatch')
class EditTestRunView(UpdateView):
    model = TestRun
    template_name = 'testruns/mutable.html'
    form_class = BaseRunForm

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['test_plan'] = self.object.plan
        context['builds'] = Build.objects.filter(product=self.object.plan.product, is_active=True)

        return context

    def get_form(self, form_class=None):
        form = super().get_form()
        form.populate(self.object.plan.product_id)

        return form

    def get_initial(self):
        return {
            'manager': self.object.manager,
            'default_tester': self.object.default_tester,
        }


class TestRunReportView(TemplateView,  # pylint: disable=missing-permission-required
                        TestExecutionDataMixin):
    """Test Run report"""

    template_name = 'run/report.html'

    def get_context_data(self, **kwargs):
        """Generate report for specific TestRun

        There are four data source to generate this report.
        1. TestRun
        2. Test executions included in the TestRun
        3. Comments associated with each test execution
        4. Statistics
        5. bugs
        """
        run = TestRun.objects.select_related('manager', 'plan').get(pk=kwargs['pk'])

        case_runs = TestExecution.objects.filter(
            run=run
        ).select_related(
            'status', 'case', 'tested_by'
        ).only(
            'close_date',
            'status__name',
            'case__category__name',
            'case__summary', 'case__is_automated',
            'tested_by__username'
        )
        mode_stats = self.stats_mode_executions(case_runs)
        summary_stats = self.get_summary_stats(case_runs)

        comments = self.get_execution_comments(run.pk)
        for case_run in case_runs:
            case_run.user_comments = comments.get(case_run.pk, [])

        context = super().get_context_data(**kwargs)
        context.update({
            'test_run': run,
            'executions': case_runs,
            'executions_count': len(case_runs),
            'mode_stats': mode_stats,
            'summary_stats': summary_stats,
        })

        return context


@method_decorator(permission_required('testruns.add_testrun'), name='dispatch')
class CloneTestRunView(View):
    """Clone cases from filter caserun"""

    template_name = 'testruns/mutable.html'
    http_method_names = ['post']

    def post(self, request, pk):
        test_run = get_object_or_404(TestRun, pk=pk)
        confirmed_case_status = TestCaseStatus.get_confirmed()
        disabled_cases = 0

        if request.POST.get('case_run'):
            test_cases = []
            for test_case_run in test_run.case_run.filter(pk__in=request.POST.getlist('case_run')):
                if test_case_run.case.case_status == confirmed_case_status:
                    test_cases.append(test_case_run.case)
                else:
                    disabled_cases += 1
        else:
            test_cases = None

        if not test_cases:
            messages.add_message(request,
                                 messages.ERROR,
                                 _('At least one TestCase is required'))
            return HttpResponseRedirect(reverse('testruns-get', args=[pk]))

        form = NewRunForm(initial={
            'summary': _('Clone of ') + test_run.summary,
            'notes': test_run.notes,
            'manager': test_run.manager,
            'build': test_run.build_id,
            'default_tester': test_run.default_tester,
        })
        form.populate(product_id=test_run.plan.product_id)

        context_data = {
            'is_cloning': True,
            'disabled_cases': disabled_cases,
            'test_plan': test_run.plan,
            'test_cases': test_cases,
            'form': form,
        }
        return render(request, self.template_name, context_data)


@method_decorator(permission_required('testruns.change_testrun'), name='dispatch')
class ChangeTestRunStatusView(View):
    """Change test run finished or running"""

    http_method_names = ['get']

    def get(self, request, pk):
        test_run = get_object_or_404(TestRun, pk=pk)

        test_run.update_completion_status(request.GET.get('finished') == '1')
        test_run.save()

        return HttpResponseRedirect(reverse('testruns-get', args=[pk, ]))


@method_decorator(permission_required('testruns.add_testexecution'), name='dispatch')
class AddCasesToRunView(View):
    """Add cases to a TestRun"""

    def post(self, request, pk):
        # Selected cases' ids to add to run
        test_cases_ids = request.POST.getlist('case')
        if not test_cases_ids:
            # user clicked Update button without selecting new Test Cases
            # to be dded to TestRun
            messages.add_message(request,
                                 messages.ERROR,
                                 _('At least one TestCase is required'))
            return HttpResponseRedirect(reverse('add-cases-to-run', args=[pk]))

        try:
            test_cases_ids = list(map(int, test_cases_ids))
        except (ValueError, TypeError):
            # this will happen only on malicious requests
            messages.add_message(request,
                                 messages.ERROR,
                                 _('TestCase ID is not a valid integer'))
            return HttpResponseRedirect(reverse('add-cases-to-run', args=[pk]))

        try:
            test_run = TestRun.objects.select_related(
                'plan'
            ).only('plan_id').get(pk=pk)
        except ObjectDoesNotExist:
            raise Http404

        executions_ids = test_run.case_run.values_list('case', flat=True)

        # avoid add cases that are already in current run with pk
        test_cases_ids = set(test_cases_ids) - set(executions_ids)

        test_plan = test_run.plan
        test_cases = test_run.plan.case.filter(case_status__name='CONFIRMED').select_related(
            'default_tester').only('default_tester_id').filter(
                pk__in=test_cases_ids)

        if request.POST.get('_use_plan_sortkey'):
            test_case_pks = (test_case.pk for test_case in test_cases)
            query_set = TestCasePlan.objects.filter(
                plan=test_plan, case__in=test_case_pks).values('case', 'sortkey')
            sort_keys_in_plan = dict((row['case'], row['sortkey']) for row in query_set.iterator())
            for test_case in test_cases:
                sort_key = sort_keys_in_plan.get(test_case.pk, 0)
                test_run.add_case_run(case=test_case, sortkey=sort_key)
        else:
            for test_case in test_cases:
                test_run.add_case_run(case=test_case)

        return HttpResponseRedirect(reverse('testruns-get',
                                            args=[test_run.pk, ]))

    def get(self, request, pk):
        # information about TestRun, used in the page header
        test_run = TestRun.objects.select_related(
            'plan', 'manager', 'build'
        ).only(
            'plan', 'plan__name',
            'manager__email', 'build__name'
        ).get(pk=pk)

        # select all CONFIRMED cases from the TestPlan that is a parent
        # of this particular TestRun
        rows = TestCasePlan.objects.values(
            'case',
            'case__create_date', 'case__summary',
            'case__category__name',
            'case__priority__value',
            'case__author__username'
        ).filter(
            plan_id=test_run.plan,
            case__case_status=TestCaseStatus.objects.filter(name='CONFIRMED').first().pk
        ).order_by('case')  # order b/c of PostgreSQL

        # also grab a list of all TestCase IDs which are already present in the
        # current TestRun so we can mark them as disabled and not allow them to
        # be selected
        executions = TestExecution.objects.filter(run=pk).values_list('case', flat=True)

        data = {
            'test_run': test_run,
            'confirmed_cases': rows,
            'confirmed_cases_count': rows.count(),
            'executions_count': len(executions),
            'exist_execution_ids': executions,
        }

        return render(request, 'run/assign_case.html', data)


# todo: this view should be removed in favor of API
@method_decorator(permission_required('testruns.change_testrun'), name='dispatch')
class ManageTestRunCC(View):
    """Add or remove cc from a test run"""

    template_name = 'run/get_cc.html'
    http_method_names = ['get']

    def get(self, request, pk):
        test_run = get_object_or_404(TestRun, pk=pk)
        action = request.GET.get('do')
        username_or_email = request.GET.get('user')
        context_data = {'test_run': test_run, 'is_ajax': True}

        try:
            user = User.objects.get(
                Q(username=username_or_email) |
                Q(email=username_or_email)
            )
            context_data['message'] = ''
        except ObjectDoesNotExist:
            context_data['message'] = _('The user you typed does not exist in database')
            return render(request, self.template_name, context_data)

        if action == 'add':
            test_run.add_cc(user=user)
        elif action == 'remove':
            test_run.remove_cc(user=user)

        return render(request, self.template_name, context_data)


@method_decorator(permission_required('testruns.change_testexecution'), name='dispatch')
class UpdateCaseRunTextView(View):
    """Update the IDLE cases to newest text"""

    http_method_names = ['post']

    def post(self, request, pk):
        test_run = get_object_or_404(TestRun, pk=pk)

        if request.POST.get('case_run'):
            executions = test_run.case_run.filter(pk__in=request.POST.getlist('case_run'))
        else:
            executions = test_run.case_run.all()

        executions = executions.filter(status__name='IDLE')

        for execution in executions:
            latest_version = execution.case.history.latest().history_id
            if execution.case_text_version != latest_version:
                info = "%s: %s -> %s" % (
                    execution.case.summary,
                    execution.case_text_version,
                    latest_version
                )
                messages.add_message(request, messages.SUCCESS, info)

                execution.case_text_version = latest_version
                execution.save()

        return HttpResponseRedirect(reverse('testruns-get', args=[pk]))


def get_caseruns_of_runs(runs, kwargs=None):
    """
    Filtering argument -
        priority
        tester
        plan tag
    """

    if kwargs is None:
        kwargs = {}
    plan_tag = kwargs.get('plan_tag', None)
    if plan_tag:
        runs = runs.filter(plan__tag__name=plan_tag)
    caseruns = TestExecution.objects.filter(run__in=runs)
    priority = kwargs.get('priority', None)
    if priority:
        caseruns = caseruns.filter(case__priority__pk=priority)
    tester = kwargs.get('tester', None)
    if not tester:
        caseruns = caseruns.filter(tested_by=None)
    if tester:
        caseruns = caseruns.filter(tested_by__pk=tester)
    status = kwargs.get('status', None)
    if status:
        caseruns = caseruns.filter(status__name__iexact=status)
    return caseruns


@method_decorator(permission_required('testruns.change_testexecution'), name='dispatch')
class UpdateAssigneeView(View):
    """Updates TestExecution.assignee. Called from the front-end."""

    http_method_names = ['post']

    def post(self, request):
        assignee = request.POST.get('assignee')
        try:
            user = User.objects.get(username=assignee)
        except User.DoesNotExist:
            try:
                user = User.objects.get(email=assignee)
            except User.DoesNotExist:
                return JsonResponse({'rc': 1,
                                     'response': _('User %s not found!') % assignee},
                                    status=HTTPStatus.NOT_FOUND)

        object_ids = request.POST.getlist('ids[]')

        for caserun_pk in object_ids:
            execution = get_object_or_404(TestExecution, pk=int(caserun_pk))
            execution.assignee = user
            execution.save()

        return JsonResponse({'rc': 0, 'response': 'ok'})

1	# -- coding: utf-8 --
2
3	from http import HTTPStatus	1✔
4
5	from django.conf import settings	1✔
6	from django.contrib import messages	1✔
7	from django.contrib.auth import get_user_model	1✔
8	from django.contrib.auth.decorators import permission_required	1✔
9	from django.contrib.contenttypes.models import ContentType	1✔
10	from django.core.exceptions import ObjectDoesNotExist	1✔
11	from django.db.models import Count, Q	1✔
12	from django.http import Http404, HttpResponseRedirect, JsonResponse	1✔
13	from django.shortcuts import get_object_or_404, render	1✔
14	from django.urls import reverse	1✔
15	from django.utils.decorators import method_decorator	1✔
16	from django.utils.translation import gettext_lazy as _	1✔
17	from django.views.generic.base import TemplateView, View	1✔
18	from django.views.generic.edit import UpdateView	1✔
19	from django_comments.models import Comment	1✔
20
21	from tcms.core.contrib.linkreference.models import LinkReference	1✔
22	from tcms.core.utils import clean_request	1✔
23	from tcms.management.models import Build, Priority, Tag	1✔
24	from tcms.testcases.models import BugSystem, TestCasePlan, TestCaseStatus	1✔
25	from tcms.testcases.views import get_selected_testcases	1✔
26	from tcms.testplans.models import TestPlan	1✔
27	from tcms.testruns.data import TestExecutionDataMixin	1✔
28	from tcms.testruns.forms import BaseRunForm, NewRunForm, SearchRunForm	1✔
29	from tcms.testruns.models import TestExecution, TestExecutionStatus, TestRun	1✔
30
31	User = get_user_model() # pylint: disable=invalid-name	1✔
32
33
34	@method_decorator(permission_required('testruns.add_testrun'), name='dispatch')	1✔
35	class CreateTestRunView(View):	1✔
36	"""Display the create test run page."""
37
38	template_name = 'testruns/mutable.html'	1✔
39	http_method_names = ['post']	1✔
40
41	def post(self, request):	1✔
42	# If from_plan does not exist will redirect to plans for select a plan
43	plan_id = request.POST.get('from_plan')	1✔
44	if not plan_id:	1✔
45	messages.add_message(request,	1✔
46	messages.ERROR,
47	_('Creating a TestRun requires a TestPlan, select one'))
48	return HttpResponseRedirect(reverse('plans-search'))	1✔
49
50	if not request.POST.get('case'):	1✔
51	messages.add_message(request,	1✔
52	messages.ERROR,
53	_('Creating a TestRun requires at least one TestCase'))
54	return HttpResponseRedirect(reverse('test_plan_url_short', args=[plan_id]))	1✔
55
56	# Ready to write cases to test plan
57	test_cases = get_selected_testcases(request)	1✔
58	test_plan = TestPlan.objects.get(pk=plan_id)	1✔
59
60	# note: ordered by pk for test_show_create_new_run_page()
61	tcs_values = test_cases.select_related('author',	1✔
62	'case_status',
63	'category',
64	'priority').order_by('pk')
65
66	if request.POST.get('POSTING_TO_CREATE'):	1✔
67	form = NewRunForm(request.POST)	1✔
68	form.populate(product_id=test_plan.product_id)	1✔
69
70	if form.is_valid():	1!
71	# Process the data in form.cleaned_data
72	default_tester = form.cleaned_data['default_tester']	1✔
73
74	test_run = TestRun.objects.create(	1✔
75	product_version=test_plan.product_version,
76	stop_date=None,
77	summary=form.cleaned_data.get('summary'),
78	notes=form.cleaned_data.get('notes'),
79	plan=test_plan,
80	build=form.cleaned_data['build'],
81	manager=form.cleaned_data['manager'],
82	default_tester=default_tester,
83	)
84
85	loop = 1	1✔
86	for case in form.cleaned_data['case']:	1✔
87	try:	1✔
88	tcp = TestCasePlan.objects.get(plan=test_plan, case=case)	1✔
89	sortkey = tcp.sortkey	1✔
90	except ObjectDoesNotExist:	×
91	sortkey = loop * 10	×
92
93	test_run.add_case_run(case=case, sortkey=sortkey,	1✔
94	assignee=default_tester)
95	loop += 1	1✔
96
97	return HttpResponseRedirect(	1✔
98	reverse('testruns-get', args=[test_run.pk, ])
99	)
100
101	else:
102	form = NewRunForm(initial={	1✔
103	'summary': 'Test run for %s' % test_plan.name,
104	'manager': test_plan.author.email,
105	'default_tester': request.user.email,
106	'notes': '',
107	})
108	form.populate(product_id=test_plan.product_id)	1✔
109
110	context_data = {	1✔
111	'test_plan': test_plan,
112	'test_cases': tcs_values,
113	'form': form,
114	}
115	return render(request, self.template_name, context_data)	1✔
116
117
118	class SearchTestRunView(TemplateView): # pylint: disable=missing-permission-required	1✔
119
120	template_name = 'testruns/search.html'	1✔
121
122	def get_context_data(self, **kwargs):	1✔
123	form = SearchRunForm(self.request.GET)	1✔
124	form.populate(product_id=self.request.GET.get('product'))	1✔
125
126	return {	1✔
127	'form': form,
128	}
129
130
131	def _open_run_get_executions(request, run): # pylint: disable=missing-permission-required	1✔
132	"""Prepare for executions list in a TestRun page
133
134	This is an internal method. Do not call this directly.
135	"""
136
137	executions = run.case_run.select_related(	1✔
138	'run', 'case'
139	).only('run_id',
140	'status',
141	'assignee',
142	'tested_by',
143	'case_text_version',
144	'sortkey',
145	'case__summary',
146	'case__is_automated',
147	'case__priority',
148	'case__category__name'
149	)
150
151	# Continue to search the executionss with conditions
152	# 4. executions preparing for render executions table
153	executions = executions.filter(**clean_request(request))	1✔
154	order_by = request.GET.get('order_by')	1✔
155	if order_by:	1!
156	return executions.order_by(order_by)	×
157
158	return executions.order_by('sortkey', 'pk')	1✔
159
160
161	def open_run_get_comments_subtotal(execution_ids):	1✔
162	content_type = ContentType.objects.get_for_model(TestExecution)	1✔
163	query_set = Comment.objects.filter(	1✔
164	content_type=content_type,
165	site_id=settings.SITE_ID,
166	object_pk__in=execution_ids,
167	is_removed=False).values('object_pk').annotate(comment_count=Count('pk')).order_by(
168	'object_pk')
169
170	result = ((int(row['object_pk']), row['comment_count']) for row in query_set)	1✔
171	return dict(result)	1✔
172
173
174	def open_run_get_users(case_runs):	1✔
175	tester_ids = set()	1✔
176	assignee_ids = set()	1✔
177	for case_run in case_runs:	1✔
178	if case_run.tested_by_id:	1✔
179	tester_ids.add(case_run.tested_by_id)	1✔
180	if case_run.assignee_id:	1!
181	assignee_ids.add(case_run.assignee_id)	1✔
182	testers = User.objects.filter(	1✔
183	pk__in=tester_ids).values_list('pk', 'username')
184	assignees = User.objects.filter(	1✔
185	pk__in=assignee_ids).values_list('pk', 'username')
186	return (dict(testers.iterator()), dict(assignees.iterator()))	1✔
187
188
189	class GetTestRunView(TemplateView): # pylint: disable=missing-permission-required	1✔
190	"""Display testrun's details"""
191
192	template_name = 'run/get.html'	1✔
193
194	def get_context_data(self, **kwargs):	1✔
195	# Get the test run
196	try:	1✔
197	# todo: this is redundant b/c we've got self.object pointing to the
198	# same object and we don't have to read it twice from the DB
199	# todo: self.object however isn't present b/c this is not a DetailsView
200	# and we're not calling super() anywhere
201	test_run = TestRun.objects.select_related().get(pk=kwargs['pk'])	1✔
202	except ObjectDoesNotExist:	1✔
203	raise Http404	1✔
204
205	# Get the test executions that belong to the run
206	# 2. get test run's all executions
207	test_executions = _open_run_get_executions(self.request, test_run)	1✔
208
209	status = TestExecutionStatus.objects.order_by('-weight', 'name')	1✔
210
211	# Count the status
212	# 3. calculate number of executions of each status
213	status_stats_result = test_run.stats_executions_status(status)	1✔
214
215	# Get the test execution bugs summary
216	# 6. get the number of bugs of this run
217	execution_bugs_count = test_run.get_bug_count()	1✔
218
219	return {	1✔
220	'test_run': test_run,
221	'executions': _walk_executions(test_executions),
222	'executions_count': len(test_executions),
223	'status_stats': status_stats_result,
224	'execution_bugs_count': execution_bugs_count,
225	'test_status': status,
226	'priorities': Priority.objects.filter(is_active=True),
227	'case_own_tags': _get_tags(test_executions),
228	'bug_trackers': BugSystem.objects.all(),
229	}
230
231
232	def _get_tags(test_executions):	1✔
233	"""Get tag list of testcases"""
234
235	# Get the list of testcases belong to the run
236	test_cases = []	1✔
237	for test_execution in test_executions:	1✔
238	test_cases.append(test_execution.case_id)	1✔
239
240	tags = Tag.objects.filter(case__in=test_cases).values_list('name', flat=True)	1✔
241	tags = list(set(tags))	1✔
242	tags.sort()	1✔
243
244	return tags	1✔
245
246
247	def _walk_executions(test_executions):	1✔
248	"""Walking executions for helping rendering executions table"""
249
250	priorities = dict(Priority.objects.values_list('pk', 'value'))	1✔
251	testers, assignees = open_run_get_users(test_executions)	1✔
252	execution_pks = []	1✔
253	for execution in test_executions:	1✔
254	execution_pks.append(execution.pk)	1✔
255	comments_subtotal = open_run_get_comments_subtotal(execution_pks)	1✔
256
257	for execution in test_executions:	1✔
258	yield (execution,	1✔
259	testers.get(execution.tested_by_id, None),
260	assignees.get(execution.assignee_id, None),
261	priorities.get(execution.case.priority_id),
262	comments_subtotal.get(execution.pk, 0),
263	LinkReference.objects.filter(is_defect=True,
264	execution=execution.pk).count())
265
266
267	@method_decorator(permission_required('testruns.change_testrun'), name='dispatch')	1✔
268	class EditTestRunView(UpdateView):	1✔
269	model = TestRun	1✔
270	template_name = 'testruns/mutable.html'	1✔
271	form_class = BaseRunForm	1✔
272
273	def get_context_data(self, **kwargs):	1✔
274	context = super().get_context_data(**kwargs)	1✔
275	context['test_plan'] = self.object.plan	1✔
276	context['builds'] = Build.objects.filter(product=self.object.plan.product, is_active=True)	1✔
277
278	return context	1✔
279
280	def get_form(self, form_class=None):	1✔
281	form = super().get_form()	1✔
282	form.populate(self.object.plan.product_id)	1✔
283
284	return form	1✔
285
286	def get_initial(self):	1✔
287	return {	1✔
288	'manager': self.object.manager,
289	'default_tester': self.object.default_tester,
290	}
291
292
293	class TestRunReportView(TemplateView, # pylint: disable=missing-permission-required	1✔
294	TestExecutionDataMixin):
295	"""Test Run report"""
296
297	template_name = 'run/report.html'	1✔
298
299	def get_context_data(self, **kwargs):	1✔
300	"""Generate report for specific TestRun
301
302	There are four data source to generate this report.
303	1. TestRun
304	2. Test executions included in the TestRun
305	3. Comments associated with each test execution
306	4. Statistics
307	5. bugs
308	"""
309	run = TestRun.objects.select_related('manager', 'plan').get(pk=kwargs['pk'])	1✔
310
311	case_runs = TestExecution.objects.filter(	1✔
312	run=run
313	).select_related(
314	'status', 'case', 'tested_by'
315	).only(
316	'close_date',
317	'status__name',
318	'case__category__name',
319	'case__summary', 'case__is_automated',
320	'tested_by__username'
321	)
322	mode_stats = self.stats_mode_executions(case_runs)	1✔
323	summary_stats = self.get_summary_stats(case_runs)	1✔
324
325	comments = self.get_execution_comments(run.pk)	1✔
326	for case_run in case_runs:	1✔
327	case_run.user_comments = comments.get(case_run.pk, [])	1✔
328
329	context = super().get_context_data(**kwargs)	1✔
330	context.update({	1✔
331	'test_run': run,
332	'executions': case_runs,
333	'executions_count': len(case_runs),
334	'mode_stats': mode_stats,
335	'summary_stats': summary_stats,
336	})
337
338	return context	1✔
339
340
341	@method_decorator(permission_required('testruns.add_testrun'), name='dispatch')	1✔
342	class CloneTestRunView(View):	1✔
343	"""Clone cases from filter caserun"""
344
345	template_name = 'testruns/mutable.html'	1✔
346	http_method_names = ['post']	1✔
347
348	def post(self, request, pk):	1✔
349	test_run = get_object_or_404(TestRun, pk=pk)	1✔
350	confirmed_case_status = TestCaseStatus.get_confirmed()	1✔
351	disabled_cases = 0	1✔
352
353	if request.POST.get('case_run'):	1✔
354	test_cases = []	1✔
355	for test_case_run in test_run.case_run.filter(pk__in=request.POST.getlist('case_run')):	1✔
356	if test_case_run.case.case_status == confirmed_case_status:	1!
357	test_cases.append(test_case_run.case)	1✔
358	else:
359	disabled_cases += 1	×
360	else:
361	test_cases = None	1✔
362
363	if not test_cases:	1✔
364	messages.add_message(request,	1✔
365	messages.ERROR,
366	_('At least one TestCase is required'))
367	return HttpResponseRedirect(reverse('testruns-get', args=[pk]))	1✔
368
369	form = NewRunForm(initial={	1✔
370	'summary': _('Clone of ') + test_run.summary,
371	'notes': test_run.notes,
372	'manager': test_run.manager,
373	'build': test_run.build_id,
374	'default_tester': test_run.default_tester,
375	})
376	form.populate(product_id=test_run.plan.product_id)	1✔
377
378	context_data = {	1✔
379	'is_cloning': True,
380	'disabled_cases': disabled_cases,
381	'test_plan': test_run.plan,
382	'test_cases': test_cases,
383	'form': form,
384	}
385	return render(request, self.template_name, context_data)	1✔
386
387
388	@method_decorator(permission_required('testruns.change_testrun'), name='dispatch')	1✔
389	class ChangeTestRunStatusView(View):	1✔
390	"""Change test run finished or running"""
391
392	http_method_names = ['get']	1✔
393
394	def get(self, request, pk):	1✔
395	test_run = get_object_or_404(TestRun, pk=pk)	1✔
396
397	test_run.update_completion_status(request.GET.get('finished') == '1')	1✔
398	test_run.save()	1✔
399
400	return HttpResponseRedirect(reverse('testruns-get', args=[pk, ]))	1✔
401
402
403	@method_decorator(permission_required('testruns.add_testexecution'), name='dispatch')	1✔
404	class AddCasesToRunView(View):	1✔
405	"""Add cases to a TestRun"""
406
407	def post(self, request, pk):	1✔
408	# Selected cases' ids to add to run
409	test_cases_ids = request.POST.getlist('case')	×
410	if not test_cases_ids:	×
411	# user clicked Update button without selecting new Test Cases
412	# to be dded to TestRun
413	messages.add_message(request,	×
414	messages.ERROR,
415	_('At least one TestCase is required'))
416	return HttpResponseRedirect(reverse('add-cases-to-run', args=[pk]))	×
417
418	try:	×
419	test_cases_ids = list(map(int, test_cases_ids))	×
420	except (ValueError, TypeError):	×
421	# this will happen only on malicious requests
422	messages.add_message(request,	×
423	messages.ERROR,
424	_('TestCase ID is not a valid integer'))
425	return HttpResponseRedirect(reverse('add-cases-to-run', args=[pk]))	×
426
427	try:	×
428	test_run = TestRun.objects.select_related(	×
429	'plan'
430	).only('plan_id').get(pk=pk)
431	except ObjectDoesNotExist:	×
432	raise Http404	×
433
434	executions_ids = test_run.case_run.values_list('case', flat=True)	×
435
436	# avoid add cases that are already in current run with pk
437	test_cases_ids = set(test_cases_ids) - set(executions_ids)	×
438
439	test_plan = test_run.plan	×
440	test_cases = test_run.plan.case.filter(case_status__name='CONFIRMED').select_related(	×
441	'default_tester').only('default_tester_id').filter(
442	pk__in=test_cases_ids)
443
444	if request.POST.get('_use_plan_sortkey'):	×
445	test_case_pks = (test_case.pk for test_case in test_cases)	×
446	query_set = TestCasePlan.objects.filter(	×
447	plan=test_plan, case__in=test_case_pks).values('case', 'sortkey')
448	sort_keys_in_plan = dict((row['case'], row['sortkey']) for row in query_set.iterator())	×
449	for test_case in test_cases:	×
450	sort_key = sort_keys_in_plan.get(test_case.pk, 0)	×
451	test_run.add_case_run(case=test_case, sortkey=sort_key)	×
452	else:
453	for test_case in test_cases:	×
454	test_run.add_case_run(case=test_case)	×
455
456	return HttpResponseRedirect(reverse('testruns-get',	×
457	args=[test_run.pk, ]))
458
459	def get(self, request, pk):	1✔
460	# information about TestRun, used in the page header
461	test_run = TestRun.objects.select_related(	1✔
462	'plan', 'manager', 'build'
463	).only(
464	'plan', 'plan__name',
465	'manager__email', 'build__name'
466	).get(pk=pk)
467
468	# select all CONFIRMED cases from the TestPlan that is a parent
469	# of this particular TestRun
470	rows = TestCasePlan.objects.values(	1✔
471	'case',
472	'case__create_date', 'case__summary',
473	'case__category__name',
474	'case__priority__value',
475	'case__author__username'
476	).filter(
477	plan_id=test_run.plan,
478	case__case_status=TestCaseStatus.objects.filter(name='CONFIRMED').first().pk
479	).order_by('case') # order b/c of PostgreSQL
480
481	# also grab a list of all TestCase IDs which are already present in the
482	# current TestRun so we can mark them as disabled and not allow them to
483	# be selected
484	executions = TestExecution.objects.filter(run=pk).values_list('case', flat=True)	1✔
485
486	data = {	1✔
487	'test_run': test_run,
488	'confirmed_cases': rows,
489	'confirmed_cases_count': rows.count(),
490	'executions_count': len(executions),
491	'exist_execution_ids': executions,
492	}
493
494	return render(request, 'run/assign_case.html', data)	1✔
495
496
497	# todo: this view should be removed in favor of API
498	@method_decorator(permission_required('testruns.change_testrun'), name='dispatch')	1✔
499	class ManageTestRunCC(View):	1✔
500	"""Add or remove cc from a test run"""
501
502	template_name = 'run/get_cc.html'	1✔
503	http_method_names = ['get']	1✔
504
505	def get(self, request, pk):	1✔
506	test_run = get_object_or_404(TestRun, pk=pk)	1✔
507	action = request.GET.get('do')	1✔
508	username_or_email = request.GET.get('user')	1✔
509	context_data = {'test_run': test_run, 'is_ajax': True}	1✔
510
511	try:	1✔
512	user = User.objects.get(	1✔
513	Q(username=username_or_email) \|
514	Q(email=username_or_email)
515	)
516	context_data['message'] = ''	1✔
517	except ObjectDoesNotExist:	1✔
518	context_data['message'] = _('The user you typed does not exist in database')	1✔
519	return render(request, self.template_name, context_data)	1✔
520
521	if action == 'add':	1✔
522	test_run.add_cc(user=user)	1✔
523	elif action == 'remove':	1✔
524	test_run.remove_cc(user=user)	1✔
525
526	return render(request, self.template_name, context_data)	1✔
527
528
529	@method_decorator(permission_required('testruns.change_testexecution'), name='dispatch')	1✔
530	class UpdateCaseRunTextView(View):	1✔
531	"""Update the IDLE cases to newest text"""
532
533	http_method_names = ['post']	1✔
534
535	def post(self, request, pk):	1✔
536	test_run = get_object_or_404(TestRun, pk=pk)	1✔
537
538	if request.POST.get('case_run'):	1!
539	executions = test_run.case_run.filter(pk__in=request.POST.getlist('case_run'))	×
540	else:
541	executions = test_run.case_run.all()	1✔
542
543	executions = executions.filter(status__name='IDLE')	1✔
544
545	for execution in executions:	1✔
546	latest_version = execution.case.history.latest().history_id	1✔
547	if execution.case_text_version != latest_version:	1✔
548	info = "%s: %s -> %s" % (	1✔
549	execution.case.summary,
550	execution.case_text_version,
551	latest_version
552	)
553	messages.add_message(request, messages.SUCCESS, info)	1✔
554
555	execution.case_text_version = latest_version	1✔
556	execution.save()	1✔
557
558	return HttpResponseRedirect(reverse('testruns-get', args=[pk]))	1✔
559
560
561	def get_caseruns_of_runs(runs, kwargs=None):	1✔
562	"""
563	Filtering argument -
564	priority
565	tester
566	plan tag
567	"""
568
569	if kwargs is None:	×
570	kwargs = {}	×
571	plan_tag = kwargs.get('plan_tag', None)	×
572	if plan_tag:	×
573	runs = runs.filter(plan__tag__name=plan_tag)	×
574	caseruns = TestExecution.objects.filter(run__in=runs)	×
575	priority = kwargs.get('priority', None)	×
576	if priority:	×
577	caseruns = caseruns.filter(case__priority__pk=priority)	×
578	tester = kwargs.get('tester', None)	×
579	if not tester:	×
580	caseruns = caseruns.filter(tested_by=None)	×
581	if tester:	×
582	caseruns = caseruns.filter(tested_by__pk=tester)	×
583	status = kwargs.get('status', None)	×
584	if status:	×
585	caseruns = caseruns.filter(status__name__iexact=status)	×
586	return caseruns	×
587
588
589	@method_decorator(permission_required('testruns.change_testexecution'), name='dispatch')	1✔
590	class UpdateAssigneeView(View):	1✔
591	"""Updates TestExecution.assignee. Called from the front-end."""
592
593	http_method_names = ['post']	1✔
594
595	def post(self, request):	1✔
596	assignee = request.POST.get('assignee')	×
597	try:	×
598	user = User.objects.get(username=assignee)	×
599	except User.DoesNotExist:	×
600	try:	×
601	user = User.objects.get(email=assignee)	×
602	except User.DoesNotExist:	×
603	return JsonResponse({'rc': 1,	×
604	'response': _('User %s not found!') % assignee},
605	status=HTTPStatus.NOT_FOUND)
606
607	object_ids = request.POST.getlist('ids[]')	×
608
609	for caserun_pk in object_ids:	×
610	execution = get_object_or_404(TestExecution, pk=int(caserun_pk))	×
611	execution.assignee = user	×
612	execution.save()	×
613
614	return JsonResponse({'rc': 0, 'response': 'ok'})	×

kiwitcms / Kiwi / 5552

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous