add test suite

Author: nuest

.github/workflows/tests.yml

@@ -0,0 +1,59 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Janeway
+        uses: actions/checkout@v4
+        with:
+          repository: BirkbeckCTP/janeway
+          ref: master
+
+      - name: Checkout geometadata plugin
+        uses: actions/checkout@v4
+        with:
+          path: src/plugins/geometadata/
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install -r dev-requirements.txt
+          pip install -r src/plugins/geometadata/requirements.txt
+
+      - name: Set environment variables
+        run: |
+          echo "DB_VENDOR=sqlite" >> "$GITHUB_ENV"
+          echo "JANEWAY_SETTINGS_MODULE=core.janeway_global_settings" >> "$GITHUB_ENV"
+
+      - name: Check code formatting
+        run: ruff format --check src/plugins/geometadata/
+
+      - name: Lint code
+        run: ruff check src/plugins/geometadata/
+        continue-on-error: true
+
+      - name: Install Janeway
+        working-directory: src
+        run: python manage.py install_janeway --use-defaults
+
+      - name: Install plugin
+        working-directory: src
+        run: python manage.py install_plugins geometadata
+
+      - name: Run tests
+        working-directory: src
+        run: python manage.py test geometadata

tests/__init__.py

@@ -0,0 +1,53 @@
+"""
+Base test case for geometadata plugin tests.
+
+Provides common fixtures and setup for all test modules.
+"""
+
+from django.test import TestCase
+
+from utils.testing import helpers
+
+from plugins.geometadata import plugin_settings
+
+
+class GeometadataTestCase(TestCase):
+    """
+    Base test case with common fixtures for geometadata tests.
+
+    Provides:
+    - press: Press instance
+    - journal: Journal instance
+    - article: Published article with owner
+    - editor: User with editor role on journal
+    - repository: Preprint repository (lazy, create via create_repository())
+    - preprint: Preprint instance (lazy, create via create_preprint())
+    """
+
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data once for the entire test class."""
+        # Install plugin settings
+        plugin_settings.install()
+
+        # Create core fixtures
+        cls.press = helpers.create_press()
+        cls.journal, _ = helpers.create_journals()
+        cls.editor = helpers.create_user(
+            "editor@test.com", ["editor"], cls.journal, is_staff=True, is_active=True
+        )
+        cls.article = helpers.create_article(cls.journal, with_author=True)
+
+    @classmethod
+    def create_repository(cls):
+        """Create repository and preprint fixtures (call when needed)."""
+        if hasattr(cls, "repository"):
+            return cls.repository, cls.preprint
+
+        cls.repository, cls.subject = helpers.create_repository(
+            cls.press, [cls.editor], [cls.editor]
+        )
+        cls.preprint = helpers.create_preprint(
+            cls.repository, cls.article.owner, cls.subject
+        )
+        return cls.repository, cls.preprint

tests/base.py

@@ -0,0 +1,65 @@
+"""
+Tests for geometadata forms.
+
+Tests WKT validation and temporal period format validation.
+"""
+
+from django.test import TestCase
+
+from plugins.geometadata.forms import ArticleGeometadataForm
+
+
+class ArticleGeometadataFormTests(TestCase):
+    """Tests for ArticleGeometadataForm validation."""
+
+    def test_valid_wkt_accepted(self):
+        """Valid WKT geometry passes validation."""
+        form = ArticleGeometadataForm(data={
+            "geometry_wkt": "POLYGON((-10 35, 40 35, 40 70, -10 70, -10 35))",
+            "place_name": "",
+            "admin_units": "",
+            "temporal_periods_json": "[]",
+        })
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_invalid_wkt_rejected(self):
+        """Malformed WKT raises validation error."""
+        form = ArticleGeometadataForm(data={
+            "geometry_wkt": "NOT_VALID_WKT(abc)",
+            "place_name": "",
+            "admin_units": "",
+            "temporal_periods_json": "[]",
+        })
+        self.assertFalse(form.is_valid())
+        self.assertIn("geometry_wkt", form.errors)
+
+    def test_temporal_periods_valid_json(self):
+        """Valid JSON array for temporal periods accepted."""
+        form = ArticleGeometadataForm(data={
+            "geometry_wkt": "",
+            "place_name": "",
+            "admin_units": "",
+            "temporal_periods_json": '[["2020-01", "2021-06"]]',
+        })
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_temporal_periods_invalid_format(self):
+        """Non-array JSON for temporal periods rejected."""
+        form = ArticleGeometadataForm(data={
+            "geometry_wkt": "",
+            "place_name": "",
+            "admin_units": "",
+            "temporal_periods_json": '{"not": "array"}',
+        })
+        self.assertFalse(form.is_valid())
+        self.assertIn("temporal_periods_json", form.errors)
+
+    def test_empty_form_valid(self):
+        """Empty form is valid (all fields optional)."""
+        form = ArticleGeometadataForm(data={
+            "geometry_wkt": "",
+            "place_name": "",
+            "admin_units": "",
+            "temporal_periods_json": "[]",
+        })
+        self.assertTrue(form.is_valid(), form.errors)

tests/test_forms.py

@@ -0,0 +1,82 @@
+"""
+Tests for geocoding functionality.
+
+Tests reverse geocoding API with mocked external services.
+"""
+
+import json
+from unittest.mock import patch, MagicMock
+
+from django.test import override_settings
+
+from plugins.geometadata.tests.base import GeometadataTestCase
+
+
+@override_settings(
+    URL_CONFIG="domain",
+    ROOT_URLCONF="plugins.geometadata.tests.urls",
+)
+class ReverseGeocodeAPITests(GeometadataTestCase):
+    """Tests for reverse geocode API endpoint."""
+
+    def setUp(self):
+        """Log in as editor for all tests."""
+        self.client.force_login(self.editor)
+
+    def _post_geocode(self, data):
+        """Helper to POST to reverse geocode endpoint."""
+        return self.client.post(
+            "/plugins/geometadata/api/reverse-geocode/",
+            data=json.dumps(data),
+            content_type="application/json",
+            SERVER_NAME=self.journal.domain,
+        )
+
+    @patch("plugins.geometadata.geocoding.reverse_geocode_wkt")
+    @patch("plugins.geometadata.views._get_plugin_setting")
+    def test_reverse_geocode_returns_place_name(self, mock_setting, mock_geocode):
+        """Successful geocode returns place_name and admin_units."""
+        # Enable geocoding
+        setting_mock = MagicMock()
+        setting_mock.value = "on"
+        mock_setting.return_value = setting_mock
+        mock_geocode.return_value = {
+            "place_name": "Berlin",
+            "admin_units": "Berlin, Germany",
+        }
+
+        response = self._post_geocode({"wkt": "POINT(13.4 52.5)"})
+
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertTrue(data["success"])
+        self.assertEqual(data["place_name"], "Berlin")
+        self.assertEqual(data["admin_units"], "Berlin, Germany")
+
+    @patch("plugins.geometadata.geocoding.reverse_geocode_wkt")
+    @patch("plugins.geometadata.views._get_plugin_setting")
+    def test_reverse_geocode_handles_api_error(self, mock_setting, mock_geocode):
+        """API failure returns 500 with error message."""
+        setting_mock = MagicMock()
+        setting_mock.value = "on"
+        mock_setting.return_value = setting_mock
+        mock_geocode.side_effect = Exception("Network error")
+
+        response = self._post_geocode({"wkt": "POINT(13.4 52.5)"})
+
+        self.assertEqual(response.status_code, 500)
+        data = response.json()
+        self.assertIn("error", data)
+
+    @patch("plugins.geometadata.views._get_plugin_setting")
+    def test_reverse_geocode_requires_geometry(self, mock_setting):
+        """Request without WKT returns 400 error."""
+        setting_mock = MagicMock()
+        setting_mock.value = "on"
+        mock_setting.return_value = setting_mock
+
+        response = self._post_geocode({"wkt": ""})
+
+        self.assertEqual(response.status_code, 400)
+        data = response.json()
+        self.assertIn("error", data)

tests/test_geocoding.py

@@ -0,0 +1,113 @@
+"""
+Tests for geometadata template hooks.
+
+Tests HTML metadata embedding (Dublin Core, Schema.org, geo.* meta tags).
+"""
+
+from django.template import Context, Template
+from django.test import RequestFactory
+
+from plugins.geometadata.models import ArticleGeometadata
+from plugins.geometadata.tests.base import GeometadataTestCase
+
+
+class MetaTagsTemplateTests(GeometadataTestCase):
+    """Tests for meta_tags.html template rendering."""
+
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        cls.geometadata = ArticleGeometadata.objects.create(
+            article=cls.article,
+            geometry_wkt="POLYGON((-10 35, 40 35, 40 70, -10 70, -10 35))",
+            place_name="Europe",
+            temporal_periods=[["2020-01-01", "2021-12-31"]],
+        )
+        cls.factory = RequestFactory()
+
+    def _render_meta_tags(self, **context_overrides):
+        """Render meta_tags.html with test context."""
+        geojson = self.geometadata.to_geojson()
+        context = {
+            "geometadata": self.geometadata,
+            "geojson_str": '{"type":"Point","coordinates":[10,50]}',
+            "geojson_geometry_str": '{"type":"Point","coordinates":[10,50]}',
+            "temporal_intervals": ["2020-01-01/2021-12-31"],
+            "temporal_interval": "2020-01-01/2021-12-31",
+            "spatial_enabled": True,
+            "temporal_enabled": True,
+            "embed_dc": True,
+            "embed_geo": True,
+            "embed_schema": True,
+            "embed_geojson": True,
+            "geojson_download_url": "/download/article/1/geojson/",
+        }
+        context.update(context_overrides)
+
+        template = Template(
+            "{% include 'geometadata/meta_tags.html' %}"
+        )
+        return template.render(Context(context))
+
+    def test_dc_spatial_coverage_contains_geojson(self):
+        """DC.SpatialCoverage meta tag contains GeoJSON geometry."""
+        html = self._render_meta_tags()
+
+        self.assertIn('name="DC.SpatialCoverage"', html)
+        self.assertIn('scheme="GeoJSON"', html)
+        self.assertIn("Point", html)
+
+    def test_dc_box_contains_bbox(self):
+        """DC.box meta tag contains bounding box coordinates."""
+        html = self._render_meta_tags()
+
+        self.assertIn('name="DC.box"', html)
+        self.assertIn("northlimit=70", html)
+        self.assertIn("southlimit=35", html)
+        self.assertIn("westlimit=-10", html)
+        self.assertIn("eastlimit=40", html)
+
+    def test_dc_temporal_rendered(self):
+        """DC.temporal meta tags rendered for temporal periods."""
+        html = self._render_meta_tags()
+
+        self.assertIn('name="DC.temporal"', html)
+        self.assertIn('scheme="ISO8601"', html)
+        self.assertIn("2020-01-01/2021-12-31", html)
+
+    def test_geo_placename_rendered(self):
+        """geo.placename meta tag contains place name."""
+        html = self._render_meta_tags()
+
+        self.assertIn('name="geo.placename"', html)
+        self.assertIn('content="Europe"', html)
+
+    def test_schema_org_jsonld_rendered(self):
+        """Schema.org JSON-LD script tag rendered with spatial coverage."""
+        html = self._render_meta_tags()
+
+        self.assertIn('type="application/ld+json"', html)
+        self.assertIn('"@context": "https://schema.org"', html)
+        self.assertIn('"spatialCoverage"', html)
+
+    def test_geojson_link_rendered(self):
+        """GeoJSON alternate link element rendered."""
+        html = self._render_meta_tags()
+
+        self.assertIn('rel="alternate"', html)
+        self.assertIn('type="application/geo+json"', html)
+        self.assertIn("/download/article/1/geojson/", html)
+
+    def test_meta_tags_respect_disabled_settings(self):
+        """Disabled embed settings suppress corresponding output."""
+        html = self._render_meta_tags(
+            embed_dc=False,
+            embed_geo=False,
+            embed_schema=False,
+            embed_geojson=False,
+        )
+
+        self.assertNotIn("DC.SpatialCoverage", html)
+        self.assertNotIn("geo.placename", html)
+        self.assertNotIn("application/ld+json", html)
+        self.assertNotIn("application/geo+json", html)