squad 1.73__py3-none-any.whl → 1.75__py3-none-any.whl

squad/api/rest.py

@@ -3,7 +3,6 @@ import yaml
 
 from django.db.models import Q, F, Value as V, CharField, Prefetch
 from django.db.models.functions import Concat
-from django.db.models.query import prefetch_related_objects
 from django.db.utils import IntegrityError
 from django.core import exceptions as core_exceptions
 from django.core.exceptions import ValidationError
@@ -904,7 +903,10 @@ class BuildViewSet(NestedViewSetMixin, ModelViewSet):
 
      * `api/builds/<id>/failures_with_confidence` GET
 
-       List of failing tests with confidence scores. List is paginated
+       List of failing tests with confidence scores. For each failure SQUAD will look back
+       N builds, where N is defined in project settings. List is paginated.
+
+         * releases_only - when active, look back only on builds with is_release=True
 
      * `api/builds/<id>/metrics` GET
 
@@ -1024,17 +1026,13 @@ class BuildViewSet(NestedViewSetMixin, ModelViewSet):
             result=False,
         ).exclude(
             has_known_issues=True,
-        ).only(
-            'metadata__suite', 'metadata__name', 'metadata__id',
         ).order_by(
-            'metadata__suite', 'metadata__name',
-        ).values_list(
-            'metadata__suite', 'metadata__name', 'metadata__id', named=True,
-        )
+            'id', 'metadata__suite', 'metadata__name', 'environment__slug',
+        ).distinct()
 
         page = self.paginate_queryset(failures)
-        fwc = failures_with_confidence(build.project, build, page)
-        prefetch_related_objects(fwc, "known_issues")
+        releases_only = request.GET.get("releases_only")
+        fwc = failures_with_confidence(build.project, build, page, releases_only=releases_only)
         serializer = FailuresWithConfidenceSerializer(fwc, many=True, context={'request': request})
         return self.get_paginated_response(serializer.data)
 
@@ -1393,6 +1391,16 @@ class ConfidenceSerializer(serializers.BaseSerializer):
 
 class FailuresWithConfidenceSerializer(TestSerializer):
     confidence = ConfidenceSerializer()
+    status = None
+
+    class Meta:
+        model = Test
+        exclude = (
+            'known_issues',
+            'has_known_issues',
+            'result',
+            'url',
+        )
 
 
 class TestViewSet(NestedViewSetMixin, ModelViewSet):

squad/ci/backend/tuxsuite.py

@@ -19,6 +19,7 @@ from cryptography.hazmat.primitives import (
 from squad.ci.backend.null import Backend as BaseBackend
 from squad.ci.exceptions import FetchIssue, TemporaryFetchIssue
 from squad.ci.models import TestJob
+from squad.core.models import TestRun
 
 
 logger = logging.getLogger('squad.ci.backend.tuxsuite')
@@ -99,9 +100,14 @@ class Backend(BaseBackend):
 
         ('BUILD', 'linaro@anders', '1yPYGaOEPNwr2pCqBgONY43zORq')
 
+        The leading string determines the type of the tuxsuite object:
+        - BUILD
+        - OEBUILD
+        - TEST
+
         """
 
-        regex = r'^(BUILD|TEST):([0-9a-z_\-]+@[0-9a-z_\-]+)#([a-zA-Z0-9]+)$'
+        regex = r'^(OEBUILD|BUILD|TEST):([0-9a-z_\-]+@[0-9a-z_\-]+)#([a-zA-Z0-9]+)$'
         matches = re.findall(regex, job_id)
         if len(matches) == 0:
             raise FetchIssue(f'Job id "{job_id}" does not match "{regex}"')
@@ -112,18 +118,19 @@ class Backend(BaseBackend):
     def generate_job_id(self, result_type, result):
         """
             The job id for TuxSuite results is generated using 3 pieces of info:
-            1. If it's either "BUILD" or "TEST" result;
+            1. If it's either "BUILD", "OEBUILD" or "TEST" result;
             2. The TuxSuite project. Ex: "linaro/anders"
             3. The ksuid of the object. Ex: "1yPYGaOEPNwr2pfqBgONY43zORp"
 
             A couple examples for job_id are:
             - BUILD:linaro@anders#1yPYGaOEPNwr2pCqBgONY43zORq
+            - OEBUILD:linaro@lkft#2Wetiz7Qs0TbtfPgPT7hUObWqDK
             - TEST:arm@bob#1yPYGaOEPNwr2pCqBgONY43zORp
 
             Then it's up to SQUAD's TuxSuite backend to parse the job_id
             and fetch results properly.
         """
-        _type = "TEST" if result_type == "test" else "BUILD"
+        _type = result_type.upper()
         project = result["project"].replace("/", "@")
         uid = result["uid"]
         return f"{_type}:{project}#{uid}"
@@ -146,6 +153,72 @@ class Backend(BaseBackend):
 
         return None
 
+    def set_build_name(self, test_job, job_url, results, metadata, settings):
+        """
+        Tuxsuite allows plans with builds and tests within.
+        Some of these plans also support "special tests", which are
+        kind a sanity test to run before spinning a heavy load of tests.
+
+        Here's the default plan hierarchy:
+          - build -> tests
+
+        Now with sanity tests in between:
+          - build -> sanity tests -> tests
+
+        SQUAD needs to get to the build level in
+        order to retrieve the build object and finally retrieve
+        its build name attribute
+        """
+
+        build_id = results['waiting_for']
+        if build_id is None:
+            return
+
+        items = build_id.split('#')
+        if len(items) == 2:
+            _type = items[0]
+            _id = items[1]
+        else:
+            _type = "BUILD"
+            _id = items[0]
+
+        test_id = results['uid']
+
+        try:
+            # Check if the target build or sanity test is fetched
+            job_id = self.generate_job_id(_type.lower(), results)
+            job_id = job_id.replace(test_id, _id)
+
+            candidate = TestRun.objects.get(
+                build=test_job.target_build,
+                job_id=job_id
+            )
+
+            build_name = candidate.metadata.get('build_name')
+            if build_name:
+                metadata['build_name'] = build_name
+                return
+
+        except TestRun.DoesNotExist:
+            pass
+
+        # It is a sanity test, an extra request is needed to get build id
+        if _type == 'TEST':
+            follow_test_url = job_url.replace(test_id, _id)
+            test_json = self.fetch_url(follow_test_url).json()
+            build_id = test_json.get('waiting_for')
+
+        build_id = build_id.replace('BUILD#', '')
+        build_url = job_url.replace(test_id, build_id).replace('/tests/', '/builds/')
+
+        build_metadata = self.fetch_url(build_url).json()
+
+        build_metadata_keys = settings.get('TEST_BUILD_METADATA_KEYS', [])
+        metadata.update({k: build_metadata.get(k) for k in build_metadata_keys})
+
+        if 'toolchain' in build_metadata_keys and 'kconfig' in build_metadata_keys and metadata['build_name'] in [None, '']:
+            metadata['build_name'] = self.generate_test_name(build_metadata)
+
     def parse_build_results(self, test_job, job_url, results, settings):
         required_keys = ['build_status', 'warnings_count', 'download_url', 'retry']
         self.__check_required_keys__(required_keys, results)
@@ -163,6 +236,7 @@ class Backend(BaseBackend):
         metadata_keys = settings.get('BUILD_METADATA_KEYS', [])
         metadata = {k: results.get(k) for k in metadata_keys}
         metadata['job_url'] = job_url
+        metadata['job_id'] = test_job.job_id
         metadata['config'] = urljoin(results.get('download_url') + '/', 'config')
         metadata['build_name'] = test_name
 
@@ -189,6 +263,30 @@ class Backend(BaseBackend):
 
         return status, completed, metadata, tests, metrics, logs
 
+    def parse_oebuild_results(self, test_job, job_url, results, settings):
+        required_keys = ['download_url', 'result']
+        self.__check_required_keys__(required_keys, results)
+
+        # Make metadata
+        metadata_keys = settings.get('OEBUILD_METADATA_KEYS', [])
+        metadata = {k: results.get(k) for k in metadata_keys}
+        metadata['job_url'] = job_url
+        metadata['job_id'] = test_job.job_id
+
+        sources = results.get('sources')
+        if sources:
+            metadata['sources'] = sources
+
+        # Create tests and metrics
+        tests = {}
+        metrics = {}
+        completed = True
+        status = 'Complete'
+        tests['build/build'] = 'pass' if results['result'] == 'pass' else 'fail'
+        logs = self.fetch_url(results['download_url'], 'build.log').text
+
+        return status, completed, metadata, tests, metrics, logs
+
     def parse_test_results(self, test_job, job_url, results, settings):
         status = 'Complete'
         completed = True
@@ -200,6 +298,7 @@ class Backend(BaseBackend):
         metadata_keys = settings.get('TEST_METADATA_KEYS', [])
         metadata = {k: results.get(k) for k in metadata_keys}
         metadata['job_url'] = job_url
+        metadata['job_id'] = test_job.job_id
 
         # Set job name
         try:
@@ -227,25 +326,8 @@ class Backend(BaseBackend):
         # Retrieve TuxRun log
         logs = self.fetch_url(job_url + '/', 'logs?format=txt').text
 
-        # Fetch more metadata if available
-        if results['waiting_for'] is not None:
-            build_id = results['waiting_for']
-
-            # Tuxsuite recently has added support for tests depending on other tests
-            if build_id.startswith('BUILD#') or '#' not in build_id:
-                _, _, test_id = self.parse_job_id(test_job.job_id)
-                build_id = build_id.replace('BUILD#', '')
-                build_url = job_url.replace(test_id, build_id).replace('/tests/', '/builds/')
-
-                # TODO: check if we can save a few seconds by querying a testjob that
-                # already contains build results
-                build_metadata = self.fetch_url(build_url).json()
-
-                build_metadata_keys = settings.get('TEST_BUILD_METADATA_KEYS', [])
-                metadata.update({k: build_metadata.get(k) for k in build_metadata_keys})
-
-                if 'toolchain' in build_metadata_keys and 'kconfig' in build_metadata_keys and metadata['build_name'] in [None, '']:
-                    metadata['build_name'] = self.generate_test_name(build_metadata)
+        # Follow up the chain and retrieve build name
+        self.set_build_name(test_job, job_url, results, metadata, settings)
 
         # Create a boot test
         boot_test_name = 'boot/' + (metadata.get('build_name') or 'boot')

squad/ci/models.py

@@ -4,6 +4,7 @@ import traceback
 import yaml
 from io import StringIO
 from django.db import models, transaction, DatabaseError
+from django.db.models import Q
 from django.utils import timezone
 from dateutil.relativedelta import relativedelta
 
@@ -66,6 +67,19 @@ class Backend(models.Model):
                 yield test_job
 
     def fetch(self, job_id):
+        # Job statuses can be one of:
+        #     * None
+        #     * Submitted
+        #     * Scheduling
+        #     * Scheduled
+        #     * Running
+        #     * Complete
+        #     * Incomplete
+        #     * Canceled
+        #     * Fetching
+        # Only jobs in 'Complete', 'Canceled' and 'Incomplete' are eligible for fetching
+
+        job_status = None
         with transaction.atomic():
             try:
                 test_job = TestJob.objects.select_for_update(nowait=True).get(pk=job_id)
@@ -91,6 +105,8 @@ class Backend(models.Model):
                 test_job.save()
                 return
 
+            job_status = test_job.job_status
+            test_job.job_status = 'Fetching'
             test_job.fetched = True
             test_job.fetched_at = timezone.now()
             test_job.save()
@@ -130,10 +146,16 @@ class Backend(models.Model):
         except DuplicatedTestJob as exception:
             logger.error('Failed to fetch test_job(%d): "%s"' % (test_job.id, str(exception)))
 
+        if test_job.testrun:
+            self.__postprocess_testjob__(test_job)
+
+        # Removed the 'Fetching' job_status only after eventual plugins
+        # are finished, this garantees extra tests and metadata to
+        # be in SQUAD before the build is considered finished
+        test_job.job_status = job_status
         test_job.save()
 
         if test_job.testrun:
-            self.__postprocess_testjob__(test_job)
             UpdateProjectStatus()(test_job.testrun)
 
     def __postprocess_testjob__(self, test_job):
@@ -177,9 +199,16 @@ class Backend(models.Model):
         return '%s (%s)' % (self.name, self.implementation_type)
 
 
+class TestJobManager(models.Manager):
+
+    def pending(self):
+        return self.filter(Q(fetched=False) | Q(job_status='Fetching'))
+
+
 class TestJob(models.Model):
 
     __test__ = False
+    objects = TestJobManager()
 
     # input - internal
     backend = models.ForeignKey(Backend, related_name='test_jobs', on_delete=models.CASCADE)

squad/core/comparison.py

@@ -393,7 +393,7 @@ class TestComparison(BaseComparison):
 
         tests = models.Test.objects.filter(test_run_id__in=test_runs_ids.keys()).annotate(
             suite_slug=F('suite__slug'),
-        ).prefetch_related('metadata').defer('log')
+        ).prefetch_related('metadata').defer('log').order_by()
 
         for test in tests:
             build, env = test_runs_ids.get(test.test_run_id)
@@ -539,6 +539,9 @@ class TestComparison(BaseComparison):
             # No baseline is present, then no comparison is needed
             return
 
+        baseline = self.builds[0]
+        target = self.builds[1]
+
         query = self.base_sql.copy()
         query['select'].append('target.result')
         query['select'].append('target.has_known_issues')
@@ -549,42 +552,54 @@ class TestComparison(BaseComparison):
         tests = [t for t in models.Test.objects.raw(sql)]
         prefetch_related_objects(tests, 'metadata', 'suite')
 
-        env_ids = []
+        env_ids = [t.environment_id for t in tests]
+        envs = {e.id: e for e in models.Environment.objects.filter(id__in=env_ids).all()}
+        envs_slugs = sorted({e.slug for e in envs.values()})
+
+        for build in self.builds:
+            self.environments[build] = envs_slugs
+
         fixed_tests = defaultdict(set)
         regressions = defaultdict(set)
         fixes = defaultdict(set)
 
         for test in tests:
             env_id = test.environment_id
+
             full_name = test.full_name
+            if full_name not in self.results:
+                self.results[full_name] = OrderedDict()
 
-            env_ids.append(env_id)
+            baseline_key = (baseline, envs[env_id].slug)
+            target_key = (target, envs[env_id].slug)
 
             if test.status == 'fail':
                 regressions[env_id].add(full_name)
+                self.results[full_name][target_key] = 'fail'
+                self.results[full_name][baseline_key] = 'pass'
             elif test.status == 'pass':
                 fixes[env_id].add(full_name)
                 fixed_tests[env_id].add(test.metadata_id)
+                self.results[full_name][target_key] = 'pass'
+                self.results[full_name][baseline_key] = 'fail'
 
-        environments = {e.id: e for e in models.Environment.objects.filter(id__in=env_ids).all()}
+        self.results = OrderedDict(sorted(self.results.items()))
 
         for env_id in regressions.keys():
-            self.__regressions__[environments[env_id].slug] = list(regressions[env_id])
+            self.__regressions__[envs[env_id].slug] = list(regressions[env_id])
 
         # It's not a fix if baseline test is intermittent for a given environment:
         # - test.has_known_issues == True and
         # - test.known_issues[env].intermittent == True
-        fixed_tests_environment_slugs = [environments[env_id] for env_id in fixed_tests.keys()]
+        fixed_tests_environment_slugs = [envs[env_id] for env_id in fixed_tests.keys()]
         intermittent_fixed_tests = self.__intermittent_fixed_tests__(fixed_tests, fixed_tests_environment_slugs)
         for env_id in fixes.keys():
-            env_slug = environments[env_id].slug
+            env_slug = envs[env_id].slug
             test_list = [test for test in fixes[env_id] if (test, env_slug) not in intermittent_fixed_tests]
             if len(test_list):
                 self.__fixes__[env_slug] = test_list
 
-        baseline = self.builds[0]
-        target = self.builds[1]
-        for env in environments.values():
+        for env in envs.values():
             if env.slug in self.__regressions__:
                 for test in self.__regressions__[env.slug]:
                     self.__diff__[test][target][env.slug] = False

squad/core/failures.py

@@ -1,32 +1,28 @@
+from django.db.models import prefetch_related_objects
+
 from squad.core.models import Test
 
 
-def failures_with_confidence(project, build, failures):
+def failures_with_confidence(project, build, failures, releases_only=False):
     limit = project.build_confidence_count
     threshold = project.build_confidence_threshold
 
-    # First, get a list of failures x environments
-    with_envs = build.tests.filter(
-        metadata_id__in=[f.metadata__id for f in failures],
-        result=False,
-    ).exclude(
-        has_known_issues=True
-    ).prefetch_related(
-        "metadata",
-        "environment",
-    ).order_by(
-        "metadata__suite",
-        "metadata__name",
-    )
+    prefetch_related_objects(failures, "metadata")
+
+    queryset = project.builds.filter(id__lt=build.id)
+    if releases_only:
+        queryset = queryset.filter(is_release=True)
+    builds = queryset.order_by('-id').all()[:limit]
+    builds_ids = [b.id for b in builds]
 
     # Find previous `limit` tests that contain this test x environment
-    for failure in with_envs:
+    for failure in failures:
         history = Test.objects.filter(
-            build_id__lt=build.id,
+            build_id__in=builds_ids,
             metadata_id=failure.metadata_id,
             environment_id=failure.environment_id,
-        ).order_by('-build_id').defer("log")[:limit]
+        ).only("result").order_by()
 
         failure.set_confidence(threshold, history)
 
-    return with_envs
+    return failures

squad/core/history.py

@@ -1,9 +1,9 @@
-from collections import OrderedDict
+from collections import defaultdict
 from django.core.paginator import Paginator
 
 from squad.core.queries import test_confidence
 from squad.core.utils import parse_name
-from squad.core.models import Test, SuiteMetadata, KnownIssue
+from squad.core.models import SuiteMetadata, KnownIssue, Environment
 
 
 class TestResult(object):
@@ -11,20 +11,20 @@ class TestResult(object):
     __test__ = False
 
     class TestRunStatus(object):
-        def __init__(self, test_run, suite):
-            self.test_run = test_run
+        def __init__(self, test_run_id, suite):
+            self.test_run_id = test_run_id
             self.suite = suite
 
-    def __init__(self, test, suite, metadata, known_issues, is_duplicate=False):
+    def __init__(self, test, suite, metadata, known_issues, is_duplicate=False, list_of_duplicates=None):
         self.test = test
         self.suite = suite
         self.known_issues = known_issues
         if is_duplicate:
-            self.status, self.confidence_score = test_confidence(test)
+            self.status, self.confidence_score = test_confidence(None, list_of_duplicates=list_of_duplicates)
         else:
             self.status, self.confidence_score = (test.status, None)
-        self.test_run = test.test_run
-        self.test_run_status = self.TestRunStatus(self.test_run, self.suite)
+        self.test_run_id = test.test_run_id
+        self.test_run_status = self.TestRunStatus(self.test_run_id, self.suite)
         self.info = {
             "test_description": metadata.description if metadata else '',
             "test_instructions": metadata.instructions_to_reproduce if metadata else '',
@@ -51,11 +51,6 @@ class TestHistory(object):
 
         self.top = builds[0]
 
-        environments = OrderedDict()
-        results = OrderedDict()
-        for build in builds:
-            results[build] = {}
-
         issues_by_env = {}
         for issue in KnownIssue.active_by_project_and_test(project, full_test_name).all():
             for env in issue.environments.all():
@@ -65,16 +60,27 @@ class TestHistory(object):
 
         suite = project.suites.prefetch_related('metadata').get(slug=suite_slug)
         metadata = SuiteMetadata.objects.get(kind='test', suite=suite_slug, name=test_name)
-        tests = Test.objects.filter(build__in=builds, metadata_id=metadata.id).prefetch_related('build', 'environment', 'test_run', 'metadata').order_by()
-        for test in tests:
-            build = test.build
-            environment = test.environment
-            environments[environment] = True
-            known_issues = issues_by_env.get(environment.id)
-            is_duplicate = False
-            if environment in results[build]:
-                is_duplicate = True
-            results[build][environment] = TestResult(test, suite, metadata, known_issues, is_duplicate)
-
-        self.environments = sorted(environments.keys(), key=lambda env: env.slug)
-        self.results = results
+
+        results = defaultdict()
+        environments_ids = set()
+        for build in builds:
+            results[build] = defaultdict(list)
+            for test in build.tests.filter(metadata=metadata).order_by():
+                test.metadata = metadata
+                test.suite = suite
+                results[build][test.environment_id].append(test)
+                environments_ids.add(test.environment_id)
+
+        results_without_duplicates = defaultdict()
+        for build in results:
+            results_without_duplicates[build] = defaultdict()
+            for env in results[build]:
+                tests = results[build][env]
+
+                is_duplicate = len(tests) > 1
+                known_issues = issues_by_env.get(tests[0].environment_id)
+                result = TestResult(tests[0], suite, metadata, known_issues, is_duplicate, list_of_duplicates=tests)
+                results_without_duplicates[build][env] = result
+
+        self.environments = Environment.objects.filter(id__in=environments_ids).order_by('slug')
+        self.results = results_without_duplicates

squad/core/models.py

@@ -584,10 +584,11 @@ class Build(models.Model):
     def important_metadata(self):
         wanted = (self.project.important_metadata_keys or '').splitlines()
         m = self.metadata
+        metadata = self.metadata
         if len(wanted):
-            return {k: m[k] for k in wanted if k in m}
-        else:
-            return self.metadata
+            metadata = {k: m[k] for k in wanted if k in m}
+
+        return metadata
 
     @property
     def has_extra_metadata(self):
@@ -619,7 +620,7 @@ class Build(models.Model):
         # dependency on squad.ci, what in theory violates our architecture.
         testjobs = self.test_jobs
         if testjobs.count() > 0:
-            if testjobs.filter(fetched=False).count() > 0:
+            if testjobs.pending().count() > 0:
                 # a build that has pending CI jobs is NOT finished
                 reasons.append("There are unfinished CI jobs")
             else:
@@ -1025,7 +1026,7 @@ class Test(models.Model):
 
         @property
         def passes(self):
-            return sum(1 for t in self.tests if t.status == "pass")
+            return sum(1 for t in self.tests if t.result)
 
         @property
         def score(self):

squad/core/queries.py

@@ -199,7 +199,7 @@ def test_confidence(test, list_of_duplicates=None):
         return {value: count for value, count in data.items() if count == max_count}
 
     if test:
-        duplicates = models.Test.objects.filter(metadata=test.metadata, environment=test.environment, build=test.build).order_by()
+        duplicates = models.Test.objects.filter(metadata_id=test.metadata_id, environment_id=test.environment_id, build_id=test.build_id).order_by()
     else:
         duplicates = list_of_duplicates
 

squad/frontend/comparison.py

@@ -116,11 +116,11 @@ def compare_builds(request):
             baseline = get_object_or_404(project.builds, version=baseline_build)
             target = get_object_or_404(project.builds, version=target_build)
 
-            comparison_class = __get_comparison_class(comparison_type)
-            comparison = comparison_class.compare_builds(baseline, target)
-
-            if comparison_type == 'test' and len(transitions):
-                comparison.apply_transitions([t for t, checked in transitions.items() if checked])
+            if comparison_type == 'test':
+                comparison = TestComparison(baseline, target, regressions_and_fixes_only=True)
+            else:
+                comparison_class = __get_comparison_class(comparison_type)
+                comparison = comparison_class.compare_builds(baseline, target)
 
             comparison.results = __paginate(comparison.results, request)
 

squad/frontend/templates/squad/_results_table.jinja2

@@ -1,9 +1,5 @@
 {% if comparison %}
 
-{% if comparison_type == 'test' %}
-  {% include "squad/_results_transitions_filter.jinja2" %}
-{% endif %}
-
 <table class='test-results'>
   <thead>
     <tr>

squad/frontend/templates/squad/build-nav.jinja2

@@ -103,11 +103,6 @@
             {{ _('Tests') }}
         </a>
     </li>
-    <li role="presentation" {% if url_name == 'failures' %}class="active"{% endif %}>
-        <a href="{{build_section_url(build, 'failures')}}">
-            {{ _('Test failures') }}
-        </a>
-    </li>
     <li role="presentation" {% if url_name == 'build_metrics' %}class="active"{% endif %}>
         <a href="{{build_section_url(build, 'build_metrics')}}">
             {{ _('Metrics') }}

squad/frontend/templates/squad/test_history.jinja2

@@ -39,7 +39,7 @@
       <td><a href="{{project_url(build)}}">{{build.version}}</a></td>
       <td>{{build.datetime|date}}</td>
       {% for environment in history.environments %}
-        {% with result=results[environment] %}
+        {% with result=results[environment.id] %}
           {% if result %}
             {% with known_issues=result.known_issues %}
               <td class='{{result.status|slugify}}'>

squad/frontend/templatetags/squad.py

@@ -82,14 +82,12 @@ def testrun_suite_test_details_history_url(group, project, build, status, test):
 
 
 def testrun_suite_or_test_url(group, project, build, status, kind, test=None):
-    testrun = status.test_run.id
-    suite = status.suite
     args = (
         group.slug,
         project.slug,
         build.version,
-        testrun,
-        suite.slug.replace('/', '$'),
+        status.test_run_id,
+        status.suite.slug.replace('/', '$'),
     )
     if test:
         if isinstance(test, Test):