squad 1.74__tar.gz → 1.75__tar.gz

{squad-1.74 → squad-1.75}/CHANGELOG.md

@@ -1,3 +1,26 @@
+# 1.75
+
+This 1.75 release fixes an important bug that has been around unnoticed for quite some time.
+
+The bug is basically a race condition when a build is marked as finished too early, before
+all testjobs results are actually done processing. The fix should address that issue.
+
+The release also allows listing projects in group's home page by active in last N days. Within
+project settings one can determine N.
+
+There has been added support for accepting OE builds from Tuxsuite and support for squad-client
+will come soon.
+
+Complete list of changes going in:
+
+* api/rest.py: re-add suite to failures with confidence endpoint
+* ci/backend/tuxsuite.py: support oe builds
+* ci/models.py: bring pending function to TestJob
+* settings.py: support newer versions of django-allauth
+* squad/core/models.py: Change important metadata to support custom order
+* squad/frontend/views.py,squad/core/models.py: move sorting of metadata
+* squad/frontend/views.py: Add support for filtering project list by age
+
 # 1.74
 
 This 1.74 release patches a couple of pages improving overall performance.

{squad-1.74/squad.egg-info → squad-1.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: squad
-Version: 1.74
+Version: 1.75
 Summary: Software Quality Dashboard
 Home-page: https://github.com/Linaro/squad
 Author: Antonio Terceiro

{squad-1.74 → squad-1.75}/squad/api/rest.py

@@ -1400,7 +1400,6 @@ class FailuresWithConfidenceSerializer(TestSerializer):
             'has_known_issues',
             'result',
             'url',
-            'suite',
         )
 
 

{squad-1.74 → squad-1.75}/squad/ci/backend/tuxsuite.py

@@ -100,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}"')
@@ -113,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}"
@@ -257,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

{squad-1.74 → squad-1.75}/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-1.74 → squad-1.75}/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:

{squad-1.74 → squad-1.75}/squad/frontend/views.py

@@ -6,6 +6,9 @@ from django.core.paginator import Paginator, EmptyPage
 from django.contrib.auth.decorators import login_required
 from django.http import HttpResponse, Http404
 from django.shortcuts import render, get_object_or_404, redirect, reverse
+from django.utils import timezone
+
+from dateutil.relativedelta import relativedelta
 
 from squad.ci.models import TestJob
 from squad.core.models import Group, Metric, ProjectStatus, Status, MetricThreshold, KnownIssue, Test
@@ -83,24 +86,30 @@ def home(request):
     return render(request, 'squad/index.jinja2', context)
 
 
-def group_home(request, group_slug):
-    group = get_object_or_404(Group, slug=group_slug)
-
-    projects_queryset = group.projects.accessible_to(request.user)
+def get_project_list(group, user, order_by, display_all_projects):
+    projects_queryset = group.projects.accessible_to(user)
     projects_queryset = projects_queryset.annotate(latest_build_id=Max('builds__id'))
 
-    if request.user.is_authenticated:
-        projects_queryset = projects_queryset.prefetch_related(Prefetch('subscriptions', queryset=Subscription.objects.filter(user=request.user), to_attr='user_subscriptions'))
+    if user.is_authenticated:
+        projects_queryset = projects_queryset.prefetch_related(Prefetch('subscriptions', queryset=Subscription.objects.filter(user=user), to_attr='user_subscriptions'))
 
-    order_by = request.GET.get('order', 'last_updated')
     if group.get_setting('SORT_PROJECTS_BY_NAME'):
         order_by = 'by_name'
 
     elif order_by == 'last_updated':
         projects_queryset = projects_queryset.order_by('-datetime')
 
-    display_all_projects = request.GET.get('all_projects') is not None
     num_projects = group.get_setting('DEFAULT_PROJECT_COUNT')
+
+    show_projects_active_n_days_ago = group.get_setting('SHOW_PROJECTS_ACTIVE_N_DAYS_AGO')
+    if show_projects_active_n_days_ago:
+        earilest_timestamp = timezone.now() - relativedelta(days=show_projects_active_n_days_ago)
+        latest_project_count = projects_queryset.filter(datetime__gte=earilest_timestamp).count()
+        if latest_project_count > 0:
+            projects_queryset = projects_queryset.filter(datetime__gte=earilest_timestamp)
+            # Ignore DEFAULT_PROJECT_COUNT if we are using age of project
+            num_projects = None
+
     if display_all_projects or num_projects is None:
         display_all_projects = True
         projects = projects_queryset.all()
@@ -108,6 +117,16 @@ def group_home(request, group_slug):
         display_all_projects = projects_queryset.count() <= num_projects
         projects = projects_queryset.all()[:num_projects]
 
+    return projects
+
+
+def group_home(request, group_slug):
+    group = get_object_or_404(Group, slug=group_slug)
+
+    order_by = request.GET.get('order', 'last_updated')
+    display_all_projects = request.GET.get('all_projects') is not None
+    projects = get_project_list(group, request.user, order_by, display_all_projects)
+
     has_archived_projects = False
     latest_build_ids = {}
     projects_count = 0
@@ -157,7 +176,7 @@ def project_home(request, group_slug, project_slug):
     builds = [b for b in __get_builds_with_status__(project, 11)]
     last_build = len(builds) and builds[0] or None
 
-    metadata = last_build and sorted(last_build.important_metadata.items()) or ()
+    metadata = last_build and last_build.important_metadata.items() or ()
     context = {
         'project': project,
         'builds': builds,
@@ -379,7 +398,7 @@ def build(request, group_slug, project_slug, version):
         'build': build,
         'test_results': test_results,
         'results_layout': results_layout,
-        'metadata': sorted(build.important_metadata.items()),
+        'metadata': build.important_metadata.items(),
         'has_extra_metadata': build.has_extra_metadata,
         'failures_only': failures_only,
         'testjobs_progress': testjobs_progress,

{squad-1.74 → squad-1.75}/squad/settings.py

@@ -81,6 +81,14 @@ except ImportError:
     pass
 
 
+django_allauth_middleware = None
+try:
+    import allauth.account.middleware  # noqa: F401
+    django_allauth_middleware = 'allauth.account.middleware.AccountMiddleware'
+except ImportError:
+    pass
+
+
 __apps__ = [
     'django.contrib.admin',
     'django.contrib.auth',
@@ -146,6 +154,7 @@ __middlewares__ = [
     'django.contrib.messages.middleware.MessageMiddleware',
     'django.middleware.clickjacking.XFrameOptionsMiddleware',
     django_toolbar_middleware,  # OPTIONAL
+    django_allauth_middleware,
 ]
 
 MIDDLEWARE = [middleware for middleware in __middlewares__ if middleware]

squad-1.75/squad/version.py

@@ -0,0 +1 @@
+__version__ = '1.75'

{squad-1.74 → squad-1.75/squad.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: squad
-Version: 1.74
+Version: 1.75
 Summary: Software Quality Dashboard
 Home-page: https://github.com/Linaro/squad
 Author: Antonio Terceiro

{squad-1.74 → squad-1.75}/test/ci/backend/test_tuxsuite.py

@@ -52,6 +52,10 @@ class TuxSuiteTest(TestCase):
                         "toolchain",
                         "does_not_exist"
                     ],
+                    "OEBUILD_METADATA_KEYS": [
+                        "download_url",
+                        "sources",
+                    ],
                     "TEST_METADATA_KEYS": [
                         "does_not_exist"
                     ],
@@ -1041,3 +1045,87 @@ class TuxSuiteTest(TestCase):
         returned_testjob = self.tuxsuite.process_callback(json.dumps(payload), self.build, self.environment.slug, self.backend)
         self.assertEqual(testjob.id, returned_testjob.id)
         self.assertEqual(json.dumps(payload["status"]), returned_testjob.input)
+
+    @patch("squad.ci.backend.tuxsuite.Backend.fetch_from_results_input")
+    def test_fetch_oe_build_results(self, mock_fetch_from_results_input):
+        job_id = 'OEBUILD:tuxgroup@tuxproject#123'
+        testjob = self.build.test_jobs.create(target=self.project, backend=self.backend, job_id=job_id)
+        build_url = urljoin(TUXSUITE_URL, '/groups/tuxgroup/projects/tuxproject/oebuilds/123')
+        build_download_url = 'http://builds.tuxbuild.com/123'
+
+        # Only fetch when finished
+        with requests_mock.Mocker() as fake_request:
+            fake_request.get(build_url, json={'state': 'running'})
+            results = self.tuxsuite.fetch(testjob)
+            self.assertEqual(None, results)
+
+        build_logs = 'dummy build log'
+        build_results = {
+            "artifacts": [],
+            "bblayers_conf": [],
+            "container": "ubuntu-20.04",
+            "download_url": build_download_url,
+            "environment": {},
+            "errors_count": 0,
+            "extraconfigs": [],
+            "is_canceling": False,
+            "is_public": True,
+            "local_conf": [],
+            "name": "",
+            "no_cache": False,
+            "plan": "2UyDaiGYNeHEYPD7hGjuuqmgZIn",
+            "project": "linaro/lkft",
+            "provisioning_time": "2023-09-05T08:36:32.853409",
+            "result": "pass",
+            "sources": {
+                "android": {
+                    "bazel": True,
+                    "branch": "common-android-mainline",
+                    "build_config": "//common:kernel_aarch64_dist",
+                    "manifest": "default.xml",
+                    "url": "https://android.googlesource.com/kernel/manifest"
+                }
+            },
+            "state": "finished",
+            "token_name": "lkft-android-bot",
+            "uid": "2UyDaslU6koW0a85VVEh3Pc2LNW",
+            "user": "lkft@linaro.org",
+            "user_agent": "tuxsuite/1.25.1",
+            "waited_by": [],
+            "warnings_count": 0
+        }
+
+        expected_metadata = {
+            'download_url': build_download_url,
+            'sources': {
+                'android': {
+                    'bazel': True,
+                    'branch': 'common-android-mainline',
+                    'build_config': '//common:kernel_aarch64_dist',
+                    'manifest': 'default.xml',
+                    'url': 'https://android.googlesource.com/kernel/manifest'
+                }
+            },
+            'job_url': build_url,
+            'job_id': job_id,
+        }
+
+        expected_tests = {
+            'build/build': 'pass',
+        }
+
+        expected_metrics = {}
+
+        with requests_mock.Mocker() as fake_request:
+            fake_request.get(build_url, json=build_results)
+            fake_request.get(urljoin(build_download_url, 'build.log'), text=build_logs)
+
+            status, completed, metadata, tests, metrics, logs = self.tuxsuite.fetch(testjob)
+            self.assertEqual('Complete', status)
+            self.assertTrue(completed)
+            self.assertEqual(sorted(expected_metadata.items()), sorted(metadata.items()))
+            self.assertEqual(sorted(expected_tests.items()), sorted(tests.items()))
+            self.assertEqual(sorted(expected_metrics.items()), sorted(metrics.items()))
+            self.assertEqual(build_logs, logs)
+
+        mock_fetch_from_results_input.assert_not_called()

{squad-1.74 → squad-1.75}/test/ci/test_tasks.py

@@ -10,6 +10,7 @@ from celery.exceptions import Retry
 
 from squad.ci import models
 from squad.core import models as core_models
+from squad.core.tasks import ReceiveTestRun
 from squad.ci.tasks import poll, fetch, submit
 from squad.ci.utils import task_id
 from squad.ci.exceptions import SubmissionIssue, TemporarySubmissionIssue
@@ -164,6 +165,85 @@ class FetchTestRaceCondition(TransactionTestCase):
         self.assertEqual(1, fetch_method.call_count)
 
 
+__sleeping__ = False
+
+
+class FetchTestRaceConditionWaitAllJobsToBeFetched(TransactionTestCase):
+    """
+    If another testjob for this build is finished, it'll trigger UpdateProjectStatus
+    which will invoke Build.finished and will see that all testjobs for this build
+    are finished. Except that if this current test job is still running plugins, like
+    VTS/CTS which take long time, the build will be considered to be finished
+    and finishing events will be triggered such as email reports and callbacks
+    """
+
+    def setUp(self):
+        group = core_models.Group.objects.create(slug='test')
+        project = group.projects.create(slug='test')
+        self.build = project.builds.create(version='test-build')
+        backend = models.Backend.objects.create()
+        self.testjob1 = models.TestJob.objects.create(
+            backend=backend,
+            target=project,
+            target_build=self.build,
+            job_id='job-1',
+        )
+        self.testjob2 = models.TestJob.objects.create(
+            backend=backend,
+            target=project,
+            target_build=self.build,
+            job_id='job-2',
+        )
+
+    def mock_backend_fetch(test_job):
+        status = ''
+        completed = True
+        metadata = {}
+        tests = {}
+        metrics = {}
+        logs = ''
+        return status, completed, metadata, tests, metrics, logs
+
+    def mock_receive_testrun(target, update_project_status):
+        global __sleeping__
+        # Let's present job1 takes a bit longer
+        if __sleeping__ is False:
+            time.sleep(2)
+            __sleeping__ = True
+        return ReceiveTestRun(target, update_project_status=update_project_status)
+
+    @tag('skip_sqlite')
+    @patch('squad.ci.backend.null.Backend.job_url')
+    @patch('squad.ci.models.ReceiveTestRun', side_effect=mock_receive_testrun)
+    @patch('squad.ci.backend.null.Backend.fetch', side_effect=mock_backend_fetch)
+    def test_race_condition_on_fetch(self, fetch_method, mock_receive, mock_url):
+        mock_url.return_value = "job-url"
+
+        def thread(testjob_id):
+            fetch(testjob_id)
+            connection.close()
+
+        parallel_task_1 = threading.Thread(target=thread, args=(self.testjob1.id,))
+        parallel_task_2 = threading.Thread(target=thread, args=(self.testjob2.id,))
+
+        parallel_task_1.start()
+        parallel_task_2.start()
+
+        time.sleep(1)
+
+        self.testjob1.refresh_from_db()
+        self.testjob2.refresh_from_db()
+
+        finished, _ = self.build.finished
+        self.assertFalse(finished)
+
+        parallel_task_1.join()
+        parallel_task_2.join()
+
+        finished, _ = self.build.finished
+        self.assertTrue(finished)
+
+
 class SubmitTest(TestCase):
 
     def setUp(self):

{squad-1.74 → squad-1.75}/test/core/test_build.py

@@ -293,6 +293,15 @@ class BuildTest(TestCase):
         with patch('squad.core.models.Build.metadata', m):
             self.assertEqual({'my key': 'my value'}, build.important_metadata)
 
+    def test_important_metadata_order(self):
+        project = Project(important_metadata_keys='key2\nkey1\nkey3\n')
+        build = Build(project=project)
+
+        m = {'key3': 'val3', 'key1': 'val1', 'key2': 'val2'}
+        with patch('squad.core.models.Build.metadata', m):
+            self.assertEqual({'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}, build.important_metadata)
+            self.assertEqual(['key2', 'key1', 'key3'], list(build.important_metadata.keys()))
+
     def test_metadata(self):
         build = Build.objects.create(project=self.project, version='build-metadata')
         env1 = self.project.environments.create(slug='env1')

{squad-1.74 → squad-1.75}/test/frontend/test_basics.py

@@ -2,12 +2,15 @@ import re
 from django.test import TestCase
 from django.test import Client
 from django.contrib.auth.models import User
+from django.utils import timezone
 
+from dateutil.relativedelta import relativedelta
 
 from squad.ci.models import Backend
 from squad.core import models
 from squad.core.tasks import ReceiveTestRun
 from squad.core.tasks import cleanup_build
+from squad.frontend.views import get_project_list
 from test.performance import count_queries
 
 
@@ -281,6 +284,66 @@ class FrontendTest(TestCase):
         self.assertEqual(404, response.status_code)
 
 
+class FrontendTestProjectList(TestCase):
+
+    def setUp(self):
+
+        self.group = models.Group.objects.create(slug='mygroup')
+        self.two_day_old_project = self.group.projects.create(slug='two_day_old_project', datetime=timezone.now() - relativedelta(days=2))
+        self.ten_day_old_project = self.group.projects.create(slug='ten_day_old_project', datetime=timezone.now() - relativedelta(days=10))
+        self.thirty_day_old_project = self.group.projects.create(slug='thirty_day_old_project', datetime=timezone.now() - relativedelta(days=30))
+        self.user = User.objects.create(username='theuser')
+        self.group.add_admin(self.user)
+
+        self.client = Client()
+        self.client.force_login(self.user)
+
+    def test_get_project_list_show_projects_active_n_days_ago_some_projects(self):
+        # test that only the projects that are new enough are returned when
+        # SHOW_PROJECTS_ACTIVE_N_DAYS_AGO is provided
+        self.group.settings = "SHOW_PROJECTS_ACTIVE_N_DAYS_AGO: 3\nDEFAULT_PROJECT_COUNT: 2"
+        order_by = 'last_updated'
+        display_all_projects = False
+
+        projects = get_project_list(self.group, self.user, order_by, display_all_projects)
+
+        self.assertEqual(len(projects), 1)
+
+    def test_get_project_list_show_projects_active_n_days_ago_no_projects(self):
+        # test if there are no projects new enough when
+        # SHOW_PROJECTS_ACTIVE_N_DAYS_AGO is provided that
+        # DEFAULT_PROJECT_COUNT is used instead
+        self.group.settings = "SHOW_PROJECTS_ACTIVE_N_DAYS_AGO: 1\nDEFAULT_PROJECT_COUNT: 2"
+        order_by = 'last_updated'
+        display_all_projects = False
+
+        projects = get_project_list(self.group, self.user, order_by, display_all_projects)
+
+        self.assertEqual(len(projects), 2)
+
+    def test_get_project_list_show_projects_active_n_days_ago_only_no_projects(self):
+        # test case where SHOW_PROJECTS_ACTIVE_N_DAYS_AGO but no projects are
+        # new enough and DEFAULT_PROJECT_COUNT is not provided that all
+        # projects will be shown
+        self.group.settings = "SHOW_PROJECTS_ACTIVE_N_DAYS_AGO: 1"
+        order_by = 'last_updated'
+        display_all_projects = False
+
+        projects = get_project_list(self.group, self.user, order_by, display_all_projects)
+
+        self.assertEqual(len(projects), 3)
+
+    def test_get_project_list_no_parameters(self):
+        # test case where SHOW_PROJECTS_ACTIVE_N_DAYS_AGO and
+        # DEFAULT_PROJECT_COUNT are not provided - all projects should be shown
+        order_by = 'last_updated'
+        display_all_projects = False
+
+        projects = get_project_list(self.group, self.user, order_by, display_all_projects)
+
+        self.assertEqual(len(projects), 3)
+
+
 class FrontendTestAnonymousUser(TestCase):
 
     def setUp(self):

squad-1.74/squad/version.py

@@ -1 +0,0 @@
-__version__ = '1.74'