Tethys tenants

environment.yml

@@ -57,6 +57,7 @@ dependencies:
   - hs_restclient  # Used with HydroShare Social backend
   - python-jose # required by django-mfa2  - used for onelogin backend
   - django-oauth-toolkit
+  - django-tenants  # enables multi-tenant support
 
   # datetime dependencies for "humanize" template filter (used with MFA2)
   - arrow

tests/unit_tests/test_tethys_apps/test_base/test_handoff.py

@@ -303,13 +303,15 @@ def tear_down(self):
         self.reload_urlconf()
 
     @override_settings(PREFIX_URL="/")
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_test_app_handoff(self):
         self.reload_urlconf()
         response = self.c.get('/handoff/test-app/test_name/?csv_url=""')
 
         self.assertEqual(302, response.status_code)
 
     @override_settings(PREFIX_URL="test/prefix")
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_test_app_handoff_with_prefix(self):
         self.reload_urlconf()
         response = self.c.get('/test/prefix/handoff/test-app/test_name/?csv_url=""')

tests/unit_tests/test_tethys_portal/test_settings.py

@@ -178,12 +178,13 @@ def test_cors_config(self, _):
         reload(settings)
         self.assertListEqual(settings.CORS_ALLOWED_ORIGINS, ["http://example.com"])
 
+    @mock.patch("tethys_portal.optional_dependencies.has_module", return_value=False)
     @mock.patch(
         "tethys_portal.settings.yaml.safe_load",
         return_value={"settings": {}},
     )
     @mock.patch("tethys_apps.utilities.relative_to_tethys_home")
-    def test_db_config_default(self, mock_home, _):
+    def test_db_config_default(self, mock_home, _, __):
         name = mock.MagicMock()
         name.exists.return_value = False
         mock_home.return_value = name
@@ -196,6 +197,7 @@ def test_db_config_default(self, mock_home, _):
             },
         )
 
+    @mock.patch("tethys_portal.optional_dependencies.has_module", return_value=False)
     @mock.patch(
         "tethys_portal.settings.yaml.safe_load",
         return_value={
@@ -204,7 +206,7 @@ def test_db_config_default(self, mock_home, _):
             }
         },
     )
-    def test_db_config_postgres(self, _):
+    def test_db_config_postgres(self, _, __):
         reload(settings)
         self.assertDictEqual(
             settings.DATABASES["default"],
@@ -218,6 +220,30 @@ def test_db_config_postgres(self, _):
             },
         )
 
+    @mock.patch(
+        "tethys_portal.settings.yaml.safe_load",
+        return_value={
+            "settings": {
+                "DATABASES": {
+                    "default": {"ENGINE": "django_tenants.postgresql_backend"}
+                }
+            }
+        },
+    )
+    def test_db_config_tenants_postgres(self, _):
+        reload(settings)
+        self.assertDictEqual(
+            settings.DATABASES["default"],
+            {
+                "ENGINE": "django_tenants.postgresql_backend",
+                "NAME": "tethys_platform",
+                "USER": "tethys_default",
+                "PASSWORD": "pass",
+                "HOST": "localhost",
+                "PORT": 5436,
+            },
+        )
+
     # TODO remove compatibility code tests with Tethys5.0 (or 4.2?)
     @mock.patch(
         "tethys_portal.settings.yaml.safe_load",

tests/unit_tests/test_tethys_portal/test_views/test_api.py

@@ -30,11 +30,13 @@ def tearDown(self):
         self.reload_urlconf()
         pass
 
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_csrf_not_authenticated(self):
         """Test get_csrf API endpoint not authenticated."""
         response = self.client.get(reverse("api:get_csrf"))
         self.assertEqual(response.status_code, 401)
 
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_csrf_authenticated(self):
         """Test get_csrf API endpoint authenticated."""
         self.client.force_login(self.user)
@@ -43,11 +45,13 @@ def test_get_csrf_authenticated(self):
         self.assertIsInstance(response, HttpResponse)
         self.assertIn("X-CSRFToken", response.headers)
 
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_session_not_authenticated(self):
         """Test get_session API endpoint not authenticated."""
         response = self.client.get(reverse("api:get_session"))
         self.assertEqual(response.status_code, 401)
 
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_session_authenticated(self):
         """Test get_session API endpoint authenticated."""
         self.client.force_login(self.user)
@@ -59,11 +63,13 @@ def test_get_session_authenticated(self):
         self.assertIn("isAuthenticated", json)
         self.assertTrue(json["isAuthenticated"])
 
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_whoami_not_authenticated(self):
         """Test get_whoami API endpoint not authenticated."""
         response = self.client.get(reverse("api:get_whoami"))
         self.assertEqual(response.status_code, 401)
 
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_whoami_authenticated(self):
         """Test get_whoami API endpoint authenticated."""
         self.client.force_login(self.user)
@@ -84,6 +90,7 @@ def test_get_whoami_authenticated(self):
     @override_settings(STATIC_URL="/static")
     @override_settings(PREFIX_URL="/")
     @override_settings(LOGIN_URL="/accounts/login/")
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_app_valid_id(self):
         self.reload_urlconf()
 
@@ -122,6 +129,7 @@ def test_get_app_valid_id(self):
     @override_settings(PREFIX_URL="test/prefix")
     @override_settings(LOGIN_URL="/test/prefix/test/login/")
     @override_settings(STATIC_URL="/test/prefix/test/static/")
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_app_valid_id_with_prefix(self):
         self.reload_urlconf()
 
@@ -162,6 +170,7 @@ def test_get_app_valid_id_with_prefix(self):
     @override_settings(STATIC_URL="/static")
     @override_settings(PREFIX_URL="/")
     @override_settings(LOGIN_URL="/accounts/login/")
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_app_authenticated(self):
         self.client.force_login(self.user)
         self.reload_urlconf()
@@ -209,6 +218,7 @@ def test_get_app_authenticated(self):
             json["customSettings"],
         )
 
+    @override_settings(SHOW_PUBLIC_IF_NO_TENANT_FOUND=True)
     def test_get_app_invalid_id(self):
         """Test get_app API endpoint with invalid app id."""
         response = self.client.get(reverse("api:get_app", kwargs={"app": "foo-bar"}))

tests/unit_tests/test_tethys_tenants/test_admin.py

@@ -0,0 +1,113 @@
+import importlib
+from unittest import mock
+from django.test import TestCase, RequestFactory
+from django.contrib import admin
+from django.http import Http404
+from django.contrib.admin.sites import AdminSite
+
+from tethys_tenants import models
+from tethys_tenants import admin as tethys_tenants_admin
+
+
+class TethysTenantsAdminTest(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.site = AdminSite()
+
+    def test_is_public_schema_function(self):
+        # Mock request with public tenant
+        public_request = mock.MagicMock()
+        public_request.tenant.schema_name = "public"
+        self.assertTrue(tethys_tenants_admin.is_public_schema(public_request))
+
+        # Mock request with non-public tenant
+        tenant_request = mock.MagicMock()
+        tenant_request.tenant.schema_name = "tenant1"
+        self.assertFalse(tethys_tenants_admin.is_public_schema(tenant_request))
+
+    def test_public_schema_only_decorator(self):
+        @tethys_tenants_admin.public_schema_only
+        def dummy_view(self, request):
+            return "success"
+
+        # Test with public schema
+        public_request = mock.MagicMock()
+        public_request.tenant.schema_name = "public"
+        result = dummy_view(None, public_request)
+        self.assertEqual(result, "success")
+
+        # Test with tenant schema - should raise Http404
+        tenant_request = mock.MagicMock()
+        tenant_request.tenant.schema_name = "tenant1"
+        with self.assertRaises(Http404):
+            dummy_view(None, tenant_request)
+
+    def test_domain_admin_registration(self):
+        registry = admin.site._registry
+        self.assertIn(models.Domain, registry)
+        self.assertIsInstance(registry[models.Domain], tethys_tenants_admin.DomainAdmin)
+
+    def test_tenant_admin_registration(self):
+        registry = admin.site._registry
+        self.assertIn(models.Tenant, registry)
+        self.assertIsInstance(registry[models.Tenant], tethys_tenants_admin.TenantAdmin)
+
+    def test_tenant_admin_configuration(self):
+        admin_instance = tethys_tenants_admin.TenantAdmin(models.Tenant, self.site)
+        self.assertEqual(admin_instance.list_display, ("name",))
+
+    def test_domain_admin_has_module_permission(self):
+        admin_instance = tethys_tenants_admin.DomainAdmin(models.Domain, self.site)
+
+        # Test with public schema
+        public_request = mock.MagicMock()
+        public_request.tenant.schema_name = "public"
+        self.assertTrue(admin_instance.has_module_permission(public_request))
+
+        # Test with tenant schema
+        tenant_request = mock.MagicMock()
+        tenant_request.tenant.schema_name = "tenant1"
+        self.assertFalse(admin_instance.has_module_permission(tenant_request))
+
+    def test_tenant_admin_has_module_permission(self):
+        admin_instance = tethys_tenants_admin.TenantAdmin(models.Tenant, self.site)
+
+        # Test with public schema
+        public_request = mock.MagicMock()
+        public_request.tenant.schema_name = "public"
+        self.assertTrue(admin_instance.has_module_permission(public_request))
+
+        # Test with tenant schema
+        tenant_request = mock.MagicMock()
+        tenant_request.tenant.schema_name = "tenant1"
+        self.assertFalse(admin_instance.has_module_permission(tenant_request))
+
+    def test_domain_admin_changelist_view_public_schema(self):
+        admin_instance = tethys_tenants_admin.DomainAdmin(models.Domain, self.site)
+
+        public_request = mock.MagicMock()
+        public_request.tenant.schema_name = "public"
+
+        with mock.patch(
+            "django.contrib.admin.ModelAdmin.changelist_view"
+        ) as mock_super:
+            mock_super.return_value = "success"
+            result = admin_instance.changelist_view(public_request)
+            self.assertEqual(result, "success")
+            mock_super.assert_called_once_with(public_request, None)
+
+    def test_domain_admin_changelist_view_tenant_schema(self):
+        admin_instance = tethys_tenants_admin.DomainAdmin(models.Domain, self.site)
+
+        tenant_request = mock.MagicMock()
+        tenant_request.tenant.schema_name = "tenant1"
+
+        with self.assertRaises(Http404):
+            admin_instance.changelist_view(tenant_request)
+
+    @mock.patch("tethys_portal.optional_dependencies.has_module", return_value=False)
+    def test_admin_graceful_handling_without_django_tenants(self, mock_has_module):
+        importlib.reload(tethys_tenants_admin)
+
+        # Verify has_module was called
+        mock_has_module.assert_called()

tests/unit_tests/test_tethys_tenants/test_apps.py

@@ -0,0 +1,24 @@
+import importlib
+from unittest import mock
+from django.test import TestCase
+from django.apps import apps
+
+from tethys_tenants import apps as tenant_apps
+
+
+class TethysTenantsAppsTest(TestCase):
+    def test_tethys_tenants_config(self):
+        app_config = apps.get_app_config("tethys_tenants")
+        name = app_config.name
+        verbose_name = app_config.verbose_name
+
+        self.assertEqual("tethys_tenants", name)
+        self.assertEqual("Tethys Tenants", verbose_name)
+        self.assertTrue(isinstance(app_config, tenant_apps.TethysTenantsConfig))
+
+    @mock.patch("tethys_portal.optional_dependencies.has_module", return_value=False)
+    def test_tethys_tenants_config_unavailable(self, mock_has_module):
+        importlib.reload(tenant_apps)
+
+        # Verify has_module was called
+        mock_has_module.assert_called()

tests/unit_tests/test_tethys_tenants/test_models.py

@@ -0,0 +1,23 @@
+import importlib
+from unittest import mock
+from django.test import TestCase
+
+from tethys_tenants import models
+
+
+class TethysTenantsModelsTest(TestCase):
+    def test_tenant_model_exists(self):
+        self.assertTrue(hasattr(models.Tenant, "name"))
+        self.assertTrue(hasattr(models.Tenant, "created_on"))
+        self.assertTrue(hasattr(models.Tenant, "auto_create_schema"))
+        self.assertTrue(models.Tenant.auto_create_schema)
+
+    def test_domain_model_exists(self):
+        # Domain inherits from DomainMixin, so just checking it exists
+        self.assertIsNotNone(models.Domain)
+
+    @mock.patch("tethys_portal.optional_dependencies.has_module", return_value=False)
+    def test_models_not_imported_when_django_tenants_unavailable(self, mock_has_module):
+        importlib.reload(models)
+
+        mock_has_module.assert_called()

tethys_portal/settings.py

@@ -359,6 +359,51 @@
 
 ROOT_URLCONF = "tethys_portal.urls"
 
+# Django Tenants settings
+if has_module("django_tenants"):
+    TENANTS_CONFIG = portal_config_settings.pop("TENANTS", {})
+
+    # Tethys Tenants requires "django_tenants.postgresql_backend" as the database engine
+    # Set up in portal_config.yml
+    DATABASES["default"]["ENGINE"] = TENANTS_CONFIG.pop(
+        "DATABASE_ENGINE", "django_tenants.postgresql_backend"
+    )
+
+    DATABASE_ROUTERS = ("django_tenants.routers.TenantSyncRouter",)
+
+    TENANT_LIMIT_SET_CALLS = TENANTS_CONFIG.pop("TENANT_LIMIT_SET_CALLS", False)
+
+    TENANT_MODEL = "tethys_tenants.Tenant"
+    TENANT_DOMAIN_MODEL = "tethys_tenants.Domain"
+
+    TENANT_APPS = TENANTS_CONFIG.pop(
+        "TENANT_APPS_OVERRIDE",
+        [
+            "django.contrib.admin",
+            "django.contrib.auth",
+            "django.contrib.contenttypes",
+            "django.contrib.sessions",
+            "django.contrib.messages",
+            "django.contrib.staticfiles",
+        ],
+    )
+
+    SHARED_APPS = ("django_tenants", "tethys_tenants") + INSTALLED_APPS
+    TENANT_APPS = tuple(TENANT_APPS + TENANTS_CONFIG.pop("TENANT_APPS", []))
+
+    INSTALLED_APPS = tuple(
+        list(SHARED_APPS) + [app for app in TENANT_APPS if app not in SHARED_APPS]
+    )
+
+    MIDDLEWARE = list(MIDDLEWARE)
+    MIDDLEWARE.insert(0, "django_tenants.middleware.main.TenantMainMiddleware")
+    MIDDLEWARE = tuple(MIDDLEWARE)
+
+    SHOW_PUBLIC_IF_NO_TENANT_FOUND = TENANTS_CONFIG.pop(
+        "SHOW_PUBLIC_IF_NO_TENANT_FOUND",
+        False,
+    )
+
 # Internationalization
 LANGUAGE_CODE = "en-us"
 
@@ -429,7 +474,6 @@
     }
 ]
 
-
 # Static files (CSS, JavaScript, Images)
 STATIC_URL = portal_config_settings.pop("STATIC_URL", "/static/")