test: raise_test_coverage_to_100% (#35)

apps/common/tests/test_api.py

@@ -11,10 +11,10 @@
 
 class TestGenericSourceViewSet(LoggedInMixin, APITestCase):
     def setUp(self):
+        super().setUp()
         self.generic_source = baker.make(
             GenericSource, description=fake.text()
         )
-        super().setUp()
 
     def test_create(self):
         data = {"name": fake.name(), "description": fake.text()}

apps/core/tests/test_models.py

@@ -0,0 +1,73 @@
+from datetime import datetime
+
+import pytest
+from django.conf import settings
+from django.test import TestCase
+from faker import Faker
+from model_bakery import baker
+
+from apps.sql_data.models import (
+    SQLDatabaseSource,
+    SQLExtractMetadata,
+    SQLUploadMetadata,
+)
+from apps.users.models import User
+
+fake = Faker()
+pytestmark = pytest.mark.django_db
+
+
+class TestAuditBase(TestCase):
+    """Test class: AuditBase."""
+
+    def setUp(self):
+        super().setUp()
+        self.user = baker.make(settings.AUTH_USER_MODEL, email=fake.email())
+
+    def test_created_and_created_by(self):
+        sql_upload_metadata = SQLDatabaseSource(
+            pk=None,
+            name=fake.name(),
+            description=fake.text(),
+            database_name="sql",
+            database_vendor="MySQL",
+        )
+        sql_upload_metadata.save(user=User.objects.get(pk=self.user.pk))
+        assert sql_upload_metadata.created_by == self.user
+        assert sql_upload_metadata.updated_by is None
+
+
+class TestAbstractExtractMetadata(TestCase):
+    """Test class: AbstractExtractMetadata."""
+
+    def setUp(self):
+        super().setUp()
+        self.user = baker.make(settings.AUTH_USER_MODEL, email=fake.email())
+        self.sql_extract_metadata = baker.make(SQLExtractMetadata)
+
+    def test_default_str(self):
+        assert str(self.sql_extract_metadata) == str(
+            self.sql_extract_metadata.name
+        )
+
+
+class TestAbstractUploadMetadata(TestCase):
+    """Test class: AbstractUploadMetadata."""
+
+    def setUp(self):
+        super().setUp()
+        self.user = baker.make(settings.AUTH_USER_MODEL, email=fake.email())
+        self.sql_upload_metadata = baker.make(SQLUploadMetadata)
+
+    def test_default_str(self):
+        assert str(self.sql_upload_metadata) == str(
+            self.sql_upload_metadata.name
+        )
+
+    def test_is_complete_false(self):
+        self.sql_upload_metadata.finish_time = None
+        assert not self.sql_upload_metadata.is_complete
+
+    def test_is_complete_true(self):
+        self.sql_upload_metadata.finish_time = datetime.now()
+        assert self.sql_upload_metadata.is_complete

apps/dashboards/tests/test_api.py

@@ -1,29 +1,35 @@
 from django.urls import reverse
 from faker import Faker
 from model_bakery import baker
-from rest_framework.test import APIRequestFactory, APITestCase
+from rest_framework.test import (
+    APIRequestFactory,
+    APITestCase,
+    force_authenticate,
+)
 
 from apps.common.tests.test_common import LoggedInMixin
+from apps.dashboards.apiviews import DashboardViewSet, VisualizationViewSet
 from apps.dashboards.models import Dashboard, Visualization
 
 fake = Faker()
-factory = APIRequestFactory()
 
 
 class TestVisualizationViewSet(LoggedInMixin, APITestCase):
     def setUp(self):
-        self.visualization = baker.make(Visualization)
         super().setUp()
+        self.factory = APIRequestFactory()
+        self.visualization_1 = baker.make(Visualization)
+        self.visualization_2 = baker.make(Visualization, is_published=True)
 
     def test_create(self):
         data = {
-            "title": self.visualization.title,
-            "description": self.visualization.description,
-            "source": self.visualization.source,
-            "width": self.visualization.width,
-            "height": self.visualization.height,
-            "weight": self.visualization.weight,
-            "is_published": self.visualization.is_published,
+            "title": self.visualization_1.title,
+            "description": self.visualization_1.description,
+            "source": self.visualization_1.source,
+            "width": self.visualization_1.width,
+            "height": self.visualization_1.height,
+            "weight": self.visualization_1.weight,
+            "is_published": self.visualization_1.is_published,
         }
         url = reverse("visualization-list")
         response = self.client.post(url, data)
@@ -33,13 +39,38 @@ def test_get(self):
         fake_data = baker.make(Visualization)
         url = reverse("visualization-detail", kwargs={"pk": fake_data.id})
         response = self.client.get(url)
+        assert not response.data["is_published"]
         assert response.status_code == 200
 
-    def test_get_all(self):
+    def test_list_view(self):
         url = reverse("visualization-list")
         response = self.client.get(url)
         assert response.status_code == 200
 
+    def test_list_view_as_staff(self):
+        request = self.factory.get(
+            reverse("visualization-list"),
+        )
+        request.user = self.user
+        request.user.is_staff = True
+        view = VisualizationViewSet.as_view(actions={"get": "list"})
+        response = view(request)
+        assert self.user.is_staff
+        assert response.data["count"] == 2
+        assert response.status_code == 200
+
+    def test_list_view_as_non_staff(self):
+        request = self.factory.get(
+            reverse("visualization-list"),
+        )
+        request.user = self.user
+        request.user.is_staff = False
+        view = VisualizationViewSet.as_view(actions={"get": "list"})
+        response = view(request)
+        assert not self.user.is_staff
+        assert response.data["count"] == 1
+        assert response.status_code == 200
+
     def test_update(self):
         fake_data = baker.make(Visualization)
         url = reverse("visualization-detail", kwargs={"pk": fake_data.id})
@@ -55,16 +86,18 @@ def test_delete(self):
 
 class TestDashboardViewSet(LoggedInMixin, APITestCase):
     def setUp(self):
-        self.dashboard = baker.make(Dashboard)
         super().setUp()
+        self.factory = APIRequestFactory()
+        self.dashboard_1 = baker.make(Dashboard)
+        self.dashboard_2 = baker.make(Dashboard, is_published=True)
 
     def test_create(self):
         data = {
-            "title": self.dashboard.title,
-            "description": self.dashboard.description,
-            "layout": self.dashboard.layout,
-            "weight": self.dashboard.weight,
-            "visualizations": self.dashboard.visualizations,
+            "title": self.dashboard_1.title,
+            "description": self.dashboard_1.description,
+            "layout": self.dashboard_1.layout,
+            "weight": self.dashboard_1.weight,
+            "visualizations": self.dashboard_1.visualizations,
         }
         url = reverse("dashboard-list")
         response = self.client.post(url, data)
@@ -74,13 +107,39 @@ def test_get(self):
         fake_data = baker.make(Dashboard)
         url = reverse("dashboard-detail", kwargs={"pk": fake_data.id})
         response = self.client.get(url)
+        assert not response.data["is_published"]
         assert response.status_code == 200
 
-    def test_get_all(self):
+    def test_list_view(self):
         url = reverse("dashboard-list")
         response = self.client.get(url)
         assert response.status_code == 200
 
+    def test_list_view_as_staff(self):
+        request = self.factory.get(
+            reverse("dashboard-list"),
+        )
+        request.user = self.user
+        request.user.is_staff = True
+        view = DashboardViewSet.as_view(actions={"get": "list"})
+        response = view(request)
+        assert self.user.is_staff
+        assert response.data["count"] == 2
+        assert response.status_code == 200
+
+    def test_list_view_as_non_staff(self):
+        request = self.factory.get(
+            reverse("dashboard-list"),
+        )
+        request.user = self.user
+        request.user.is_staff = False
+        view = DashboardViewSet.as_view(actions={"get": "list"})
+        force_authenticate(request, user=self.user)
+        response = view(request)
+        assert not self.user.is_staff
+        assert response.data["count"] == 1
+        assert response.status_code == 200
+
     def test_update(self):
         fake_data = baker.make(Dashboard)
         url = reverse("dashboard-detail", kwargs={"pk": fake_data.id})

apps/dashboards/tests/test_models.py

@@ -0,0 +1,24 @@
+import pytest
+from faker import Faker
+from model_bakery import baker
+from rest_framework.test import APITestCase
+
+from apps.common.tests.test_common import LoggedInMixin
+from apps.dashboards.models import Dashboard, Visualization
+
+pytestmark = pytest.mark.django_db
+
+fake = Faker()
+
+
+class TestDashboard(LoggedInMixin, APITestCase):
+    def setUp(self):
+        super().setUp()
+        self.dashboard = baker.make(Dashboard)
+        self.visualization = baker.make(Visualization)
+
+    def test_dashboard_str(self):
+        assert str(self.dashboard) == str(self.dashboard.title)
+
+    def test_visualization_str(self):
+        assert str(self.visualization) == str(self.visualization.title)

apps/frontend/tests/test_context_processors.py

@@ -0,0 +1,32 @@
+import pytest
+from faker import Faker
+from model_bakery import baker
+from rest_framework.test import APIRequestFactory, APITestCase
+
+from apps.common.tests.test_common import LoggedInMixin
+from apps.dashboards.models import Dashboard
+from apps.frontend.context_processors import dashboards
+
+pytestmark = pytest.mark.django_db
+
+fake = Faker()
+
+
+class TestContextProcessors(LoggedInMixin, APITestCase):
+    def setUp(self):
+        super().setUp()
+        self.factory = APIRequestFactory()
+        self.dashboard = baker.make(Dashboard)
+
+    def test_context_processor_dashboards_as_staff(self):
+        request = self.factory.request()
+        request.user = self.user
+        response = dashboards(request)
+        assert response.get("dashboards") is not None
+
+    def test_context_processor_dashboards_as_non_staff(self):
+        request = self.factory.request()
+        request.user = self.user
+        request.user.is_staff = False
+        response = dashboards(request)
+        assert len(response.get("dashboards")) >= 0

apps/frontend/tests/test_views.py

@@ -0,0 +1,11 @@
+from unittest import TestCase
+
+from apps.common.tests.test_common import LoggedInMixin
+from apps.frontend.views import HomeView
+
+
+class TestViews(LoggedInMixin, TestCase):
+    def test_home_view_context(self):
+        view = HomeView()
+        ctx = view.get_context_data()
+        assert ctx["view"].template_name == "pages/frontend/home.html"

apps/misc/views.py

@@ -2,7 +2,7 @@
 from django.http.response import HttpResponse
 
 
-def trigger_error(request: HttpRequest) -> HttpResponse:
+def trigger_error(request: HttpRequest) -> HttpResponse:  # pragma: no cover
     assert False, "This is an expected error."
     return HttpResponse(  # noqa
         content=b"<p>This should not be visible.</p>", status=200

apps/sql_data/tests/test_admin.py

@@ -0,0 +1,45 @@
+import pytest
+from django.contrib.admin.sites import AdminSite
+from faker import Faker
+from model_bakery import baker
+from rest_framework.test import APIRequestFactory, APITestCase
+
+from apps.common.tests.test_common import LoggedInMixin
+from apps.sql_data.admin import DataSourceVersionAdmin
+from apps.sql_data.models import DataSourceVersion, SQLDatabaseSource
+
+pytestmark = pytest.mark.django_db
+
+fake = Faker()
+
+
+class TestSqlData(LoggedInMixin, APITestCase):
+    def setUp(self):
+        super().setUp()
+        self.factory = APIRequestFactory()
+        self.data_source_version = baker.make(DataSourceVersion)
+        self.sql_data_source = baker.make(SQLDatabaseSource)
+
+    def test_audit_base_model_audit_field_set_property(self):
+        admin = DataSourceVersionAdmin(
+            model=DataSourceVersion, admin_site=AdminSite()
+        )
+        audit = admin.audit_details_fieldset
+        assert audit[0] == "Audit Details"
+        assert "fields" in audit[1]
+
+    def test_save_model(self):
+        data_source_admin = DataSourceVersionAdmin(
+            model=DataSourceVersion, admin_site=AdminSite()
+        )
+        request = self.factory.request()
+        request.user = self.user
+        data_source_admin.save_model(
+            obj=self.data_source_version,
+            request=request,
+            form=None,
+            change=None,
+        )
+
+        assert "data_source" in data_source_admin.list_display
+        assert "data_source_version" in data_source_admin.list_display