Add tests for version and project querysets

Related #5872

Author: stsewd

readthedocs/projects/querysets.py

@@ -99,7 +99,7 @@ def prefetch_latest_build(self):
 
     # Aliases
 
-    def dashboard(self, user=None):
+    def dashboard(self, user):
         """Get the projects for this user including the latest build."""
         return self.for_admin_user(user).prefetch_latest_build()
 

readthedocs/rtd_tests/tests/test_doc_building.py

@@ -1484,7 +1484,6 @@ def test_save_environment_json(self, load_config):
             python_env.save_environment_json()
             json_data = json.load(open(python_env.environment_json_path()))
 
-        
         expected_data = {
             'build': {
                 'image': 'readthedocs/build:2.0',

readthedocs/rtd_tests/tests/test_project_querysets.py

@@ -1,11 +1,11 @@
-# -*- coding: utf-8 -*-
-from datetime import timedelta
-
 import django_dynamic_fixture as fixture
+from django_dynamic_fixture import get
 from django.contrib.auth.models import User
 from django.test import TestCase
 
 from readthedocs.projects.models import Feature, Project
+from readthedocs.projects.constants import PRIVATE, PUBLIC, PROTECTED
+from readthedocs.builds.models import Version
 from readthedocs.projects.querysets import (
     ChildRelatedProjectQuerySet,
     ParentRelatedProjectQuerySet,
@@ -14,6 +14,85 @@
 
 class ProjectQuerySetTests(TestCase):
 
+    def setUp(self):
+        self.user = get(User)
+        self.another_user = get(User)
+
+        self.project = get(
+            Project,
+            privacy_level=PUBLIC,
+            users=[self.user],
+            main_language_project=None,
+        )
+        self.project_private = get(
+            Project,
+            privacy_level=PRIVATE,
+            users=[self.user],
+            main_language_project=None,
+        )
+        self.project_protected = get(
+            Project,
+            privacy_level=PROTECTED,
+            users=[self.user],
+            main_language_project=None,
+        )
+
+        self.another_project = get(
+            Project,
+            privacy_level=PUBLIC,
+            users=[self.another_user],
+            main_language_project=None,
+        )
+        self.another_project_private = get(
+            Project,
+            privacy_level=PRIVATE,
+            users=[self.another_user],
+            main_language_project=None,
+        )
+        self.another_project_protected = get(
+            Project,
+            privacy_level=PROTECTED,
+            users=[self.another_user],
+            main_language_project=None,
+        )
+
+        self.shared_project = get(
+            Project,
+            privacy_level=PUBLIC,
+            users=[self.user, self.another_user],
+            main_language_project=None,
+        )
+        self.shared_project_private = get(
+            Project,
+            privacy_level=PRIVATE,
+            users=[self.user, self.another_user],
+            main_language_project=None,
+        )
+        self.shared_project_protected = get(
+            Project,
+            privacy_level=PROTECTED,
+            users=[self.user, self.another_user],
+            main_language_project=None,
+        )
+
+        self.user_projects = {
+            self.project,
+            self.project_private,
+            self.project_protected,
+            self.shared_project,
+            self.shared_project_private,
+            self.shared_project_protected,
+        }
+
+        self.another_user_projects = {
+            self.another_project,
+            self.another_project_private,
+            self.another_project_protected,
+            self.shared_project,
+            self.shared_project_private,
+            self.shared_project_protected,
+        }
+
     def test_subproject_queryset_attributes(self):
         self.assertEqual(ParentRelatedProjectQuerySet.project_field, 'parent')
         self.assertTrue(ParentRelatedProjectQuerySet.use_for_related_fields)
@@ -45,6 +124,100 @@ def test_is_active(self):
         project = fixture.get(Project, skip=False, users=[user])
         self.assertFalse(Project.objects.is_active(project))
 
+    def test_dashboard(self):
+        query = Project.objects.dashboard(user=self.user)
+        self.assertEqual(query.count(), len(self.user_projects))
+        self.assertEqual(set(query), self.user_projects)
+
+        query = Project.objects.dashboard(user=self.another_user)
+        self.assertEqual(query.count(), len(self.another_user_projects))
+        self.assertEqual(set(query), self.another_user_projects)
+
+    def test_private(self):
+        query = Project.objects.private()
+        projects = {
+            self.project_private,
+            self.another_project_private,
+            self.shared_project_private,
+        }
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
+    def test_private_user(self):
+        query = Project.objects.private(user=self.user)
+        projects = (
+            self.user_projects |
+            {self.another_project_private}
+        )
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
+        query = Project.objects.private(user=self.another_user)
+        projects = (
+            self.another_user_projects |
+            {self.project_private}
+        )
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
+    def test_public(self):
+        query = Project.objects.public()
+        projects = {
+            self.project,
+            self.another_project,
+            self.shared_project,
+        }
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
+    def test_public_user(self):
+        query = Project.objects.public(user=self.user)
+        projects = (
+            self.user_projects |
+            {self.another_project}
+        )
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
+        query = Project.objects.public(user=self.another_user)
+        projects = (
+            self.another_user_projects |
+            {self.project}
+        )
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
+
+    def test_protected(self):
+        query = Project.objects.protected()
+        projects = {
+            self.project,
+            self.project_protected,
+            self.another_project,
+            self.another_project_protected,
+            self.shared_project,
+            self.shared_project_protected,
+        }
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
+    def test_protected_user(self):
+        query = Project.objects.protected(user=self.user)
+        projects = (
+            self.user_projects |
+            {self.another_project, self.another_project_protected}
+        )
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
+        query = Project.objects.protected(user=self.another_user)
+        projects = (
+            self.another_user_projects |
+            {self.project, self.project_protected}
+        )
+        self.assertEqual(query.count(), len(projects))
+        self.assertEqual(set(query), projects)
+
 
 class FeatureQuerySetTests(TestCase):