squad 1.72.2__py3-none-any.whl → 1.74__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,17 @@ class ConfidenceSerializer(serializers.BaseSerializer):
 
 class FailuresWithConfidenceSerializer(TestSerializer):
     confidence = ConfidenceSerializer()
+    status = None
+
+    class Meta:
+        model = Test
+        exclude = (
+            'known_issues',
+            'has_known_issues',
+            'result',
+            'url',
+            'suite',
+        )
 
 
 class TestViewSet(NestedViewSetMixin, ModelViewSet):

squad/ci/backend/lava.py

@@ -122,12 +122,12 @@ class Backend(BaseBackend):
                 start_time = data.get('start_time', None)
                 end_time = data.get('end_time', None)
                 # convert to datetime
-                if type(start_time) == str:
+                if type(start_time) is str:
                     try:
                         start_time = isoparse(start_time)
                     except ValueError:
                         start_time = None
-                if type(end_time) == str:
+                if type(end_time) is str:
                     try:
                         end_time = isoparse(end_time)
                     except ValueError:

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')
@@ -146,6 +147,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 +230,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
 
@@ -200,6 +268,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 +296,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/compat.py

@@ -2,8 +2,10 @@
 SQUAD compatibity file
 """
 from rest_framework_extensions import __version__ as DRFE_VERSION_STR
+from allauth import __version__ as DAA_VERSION_STR
 
 DRFE_VERSION = [int(n) for n in DRFE_VERSION_STR.split(".")]
+DAA_VERSION = [int(n) for n in DAA_VERSION_STR.split(".")]
 
 # Handles compatibility for django_restframework_filters
 try:
@@ -27,3 +29,15 @@ def drf_basename(name):
         return {"basename": name}
     else:
         return {"base_name": name}
+
+
+def get_socialaccount_provider(providers, socialapp, request):
+    """
+    Django-allauth 0.55 removed the function `by_id`
+    Ref: https://github.com/pennersr/django-allauth/commit/cc5279bb61dba9cf0fafb10f4ae175c018749f1f
+    """
+
+    if DAA_VERSION >= [0, 55]:
+        return socialapp.get_provider(request)
+    else:
+        return providers.registry.by_id(socialapp.provider)

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

@@ -1025,7 +1025,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/core/tasks/__init__.py

@@ -72,7 +72,7 @@ class ValidateTestRun(object):
         except json.decoder.JSONDecodeError as e:
             raise exceptions.InvalidMetadataJSON("metadata is not valid JSON: " + str(e) + "\n" + metadata_json)
 
-        if type(metadata) != dict:
+        if type(metadata) is not dict:
             raise exceptions.InvalidMetadata("metadata is not a object ({})")
 
         if "job_id" in metadata.keys():
@@ -87,7 +87,7 @@ class ValidateTestRun(object):
         except json.decoder.JSONDecodeError as e:
             raise exceptions.InvalidMetricsDataJSON("metrics is not valid JSON: " + str(e) + "\n" + metrics_file)
 
-        if type(metrics) != dict:
+        if type(metrics) is not dict:
             raise exceptions.InvalidMetricsData.type(metrics)
 
         for metric, value_dict in metrics.items():
@@ -113,7 +113,7 @@ class ValidateTestRun(object):
         except json.decoder.JSONDecodeError as e:
             raise exceptions.InvalidTestsDataJSON("tests is not valid JSON: " + str(e) + "\n" + tests_file)
 
-        if type(tests) != dict:
+        if type(tests) is not dict:
             raise exceptions.InvalidTestsData.type(tests)
 
 

squad/core/templates/squad/notification/diff.txt.jinja2

@@ -24,7 +24,7 @@ Failures
 {% if summary.failures %}
 {% for env, tests in summary.failures.items() %}{{env}}:
 {% for test in tests %}
-  * {{test.full_name}}{% for issue in known_issues %}{% if issue.test_name == test.full_name %}{% for issue_environment in issue.environment.all() %}{% if env == issue_environment.slug %}
+  * {{test.full_name}}{% for issue in known_issues %}{% if issue.test_name == test.full_name %}{% for issue_environment in issue.environments.all() %}{% if env == issue_environment.slug %}
     * Known issue: {{issue.title}}{% if issue.url %} {{issue.url}}{% endif %}{% if issue.intermittent %} (intermittent){% endif %}{% endif %}{% endfor %}{% endif %}{% endfor %}{% endfor %}
 {% endfor %}
 {% else %}

squad/core/utils.py

@@ -170,7 +170,7 @@ def log_deletion(request, object, message):
 
 def storage_save(obj, storage_field, filename, content):
     content_bytes = content or ''
-    if type(content_bytes) == str:
+    if type(content_bytes) is str:
         content_bytes = content_bytes.encode()
     filename = '%s/%s/%s' % (obj.__class__.__name__.lower(), obj.pk, filename)
     storage_field.save(filename, ContentFile(content_bytes))

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

@@ -14,6 +14,7 @@ from allauth.socialaccount import providers
 
 
 from squad import version
+from squad.compat import get_socialaccount_provider
 from squad.core.models import Test, Build
 from squad.core.utils import format_metadata
 from squad.jinja2 import register_global_function, register_filter
@@ -81,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):
@@ -272,7 +271,7 @@ def to_json(d):
 def socialaccount_providers(context):
     request = context['request']
     return_dict = {}
-    for backend in SocialApp.objects.all():
-        provider = providers.registry.by_id(backend.provider)
+    for socialapp in SocialApp.objects.all():
+        provider = get_socialaccount_provider(providers, socialapp, request)
         return_dict.update({provider: provider.get_login_url(request)})
     return return_dict