Merge pull request #21 from codesyntax/testing

erral · web-flow · commit 0dbafddfaf35 · 2026-03-12T11:01:48.000+01:00
Testing
diff --git a/AGENTS.md b/AGENTS.md
@@ -0,0 +1,129 @@
+# Agent Instructions for `cs_dynamicpages`
+
+This document contains the guidelines, commands, and code style rules for AI coding agents operating in this repository. The `cs_dynamicpages` project is a Plone 6 add-on providing dynamic page content types and behaviors.
+
+## 1. Build, Lint, and Test Commands
+
+This project uses `make` as the primary task runner, backed by `uv` for Python environment management and `hatchling` as the build system.
+
+### Installation and Running
+- **Install the project**: 
+  ```bash
+  make install
+  ```
+  *(Always recommend `make install` to users. It handles all dependencies, `uv venv`, and setup. NEVER recommend using `pip install` or `uv pip` directly.)*
+- **Start the Plone instance**:
+  ```bash
+  make start
+  ```
+- **Clean the environment** (without removing data): `make clean`
+- **Create a new site**: `make create-site`
+
+### Linting and Formatting
+Code is checked and formatted using `ruff` (Python), `zpretty` (XML/ZCML), and `pyroma`.
+- **Format code**: `make format` (Fixes `ruff` issues, runs `ruff format`, and runs `zpretty -i src`).
+- **Lint code**: `make lint` (Runs `ruff check`, `pyroma`, `check-python-versions`, and `zpretty --check`).
+- **Check and format**: `make check` (Runs both format and lint).
+
+### Testing
+Tests are written using `pytest` and `plone.app.testing`.
+- **Run all tests**: 
+  ```bash
+  make test
+  ```
+- **Run tests with coverage**: `make test-coverage`
+- **Run a single test file**: 
+  ```bash
+  ./.venv/bin/pytest src/cs_dynamicpages/tests/test_ct_dynamic_page_folder.py
+  ```
+- **Run a specific test method/class**:
+  ```bash
+  ./.venv/bin/pytest src/cs_dynamicpages/tests/test_ct_dynamic_page_folder.py::DynamicPageFolderIntegrationTest::test_ct_dynamic_page_folder_adding
+  ```
+
+---
+
+## 2. Code Style & Guidelines
+
+### Python Formatting & Imports
+- **Line Length**: 88 characters (configured in `pyproject.toml`).
+- **Python Version**: Target Python 3.10 (`>=3.10,<3.14`).
+- **Imports**: Formatted using `ruff`'s `isort` rules.
+  - Case-insensitive sorting.
+  - Force single-line imports (`from X import Y` on separate lines for each `Y`).
+  - No sections (all imports sorted alphabetically regardless of third-party/stdlib).
+  - 2 blank lines after imports, 1 blank line between types.
+- **Exceptions**: Ignore `E731` (DoNotAssignLambda). Use `# noqa` only when absolutely necessary and document why.
+
+### Naming Conventions
+- **Classes**: `PascalCase` (e.g., `DynamicPageFolder`).
+- **Interfaces**: Prefix with `I` and use `PascalCase` (e.g., `IDynamicPageFolder`).
+- **Methods, Variables, and Functions**: `snake_case` (e.g., `dynamic_page_folder_id`).
+- **Constants**: `UPPER_SNAKE_CASE` (e.g., `TEST_USER_ID`).
+- **Filenames**: `snake_case` for Python and XML files (except specific Zope configurations like `configure.zcml` or specific profiles like `Plone_Site.xml` which follow Plone's exact casing).
+
+### Types & Schema
+- Define Dexterity schemas using `plone.supermodel.model.Schema`.
+- Apply `@implementer(IYourInterface)` to your content type classes.
+- Explicitly subclass `Container` or `Item` from `plone.dexterity.content`.
+- Avoid unnecessary types annotations if Zope schemas already enforce types (`zope.schema`).
+
+### Error Handling
+- Use standard Python exceptions or `plone.api.exc` (like `InvalidParameterError`) when using `plone.api`.
+- Do not silently `except Exception: pass`. Always log or handle exceptions explicitly.
+- Return explicit HTTP error codes where applicable in REST API endpoints.
+
+### XML, ZCML, and PT
+- **XML/ZCML**: Keep it strictly formatted with `zpretty`. Indent with 2 spaces. 
+- **Page Templates (PT)**: Ensure they are properly formed HTML/XML. Keep logic in the python views, not in the templates.
+
+---
+
+## 3. Plone-Specific Documentation and Rules
+
+These rules are strictly enforced for AI agents interacting with this Plone repository:
+
+1. **Documentation First**
+   - Before EVERY answer say: "Let me check the official documentation."
+   - Before ANY command or code, search for official Plone 6 examples.
+   - FORBIDDEN phrases: "Let me try...", "I think...", "It should be..."
+   - REQUIRED phrases: "According to the docs...", "The documentation shows..."
+   - If no docs are found, EXPLICITLY STATE: "I cannot find official documentation for this." Trial and error MUST be labeled: "This requires trial and error - not documented."
+
+2. **Terminal Commands**
+   - Provide ONE step at a time.
+   - WAIT for confirmation before moving to the next step.
+   - Include the full command with all parameters.
+   - ALWAYS recommend using `make` commands (`make install`, `make start`). NEVER recommend `pip install`, `uv add` or `uv pip` directly.
+
+3. **No Shortcuts or Hacks**
+   - Always use official Plone APIs (`plone.api`, `plone.restapi`).
+   - Follow framework best practices. No temporary workarounds.
+   - Maintain security: Always use JWT tokens (`Authorization: Bearer <token>`) for authentication, never basic auth or embedded credentials.
+
+4. **Enterprise Standards**
+   - Maintain scalable and upgradable architecture.
+   - Document WHY changes are made via inline comments, not just WHAT.
+   - When modifying README.md or docs, ALWAYS use emojis in section titles for a friendly tone.
+   - NEVER edit the "Generated using" cookieplone paragraph in docs.
+   - In README, review the code if necessary to explain features correctly (e.g. use `- Register a behavior providing additional fields representing contact information` instead of just `- Behavior`).
+
+5. **Internationalization (i18n)**
+   - All UI strings MUST be translatable.
+   - Use `cs_dynamicpages` as the i18n domain.
+   - Example: `_(u"My string")` imported from the project's MessageFactory.
+   - Run `make i18n` to update `.pot` and `.po` files.
+
+6. **Loop Detection & Uncertainty**
+   - If repeating the same pattern, STOP and state: "We are in a loop, need different approach."
+   - NEVER say "this will work" unless proven. Acknowledge uncertainty explicitly: "Let's see if this works."
+   - Never say "you're frustrated", "you're concerned", etc. Present facts only.
+
+7. **The Fun Factor & Tone**
+   - Keep interactions positive, engaging, and collaborative.
+   - Provide genuine encouragement but avoid fake/over-the-top praise (e.g., no "OMG AMAZING!!!").
+   - Acknowledge good ideas and creative solutions.
+
+8. **Definition of Success**
+   - Success is ONLY a fully functional, tested result.
+   - Never claim success for partial or broken implementations.
diff --git a/Makefile b/Makefile
@@ -129,6 +129,7 @@ test: $(VENV_FOLDER) ## run tests
 .PHONY: test-coverage
 test-coverage: $(VENV_FOLDER) ## run tests with coverage
 	@$(BIN_FOLDER)/pytest --cov=cs_dynamicpages --cov-report term-missing
+	@if [ -d "src/cs_dynamicpages/tests" ]; then $(BIN_FOLDER)/pytest src/cs_dynamicpages/tests --cov=cs_dynamicpages --cov-report term-missing --cov-append; fi
 
 ## Add bobtemplates features (check bobtemplates.plone's documentation to get the list of available features)
 add: $(VENV_FOLDER)
diff --git a/news/+tests.feature b/news/+tests.feature
@@ -0,0 +1 @@
+Add tests @erral
diff --git a/src/cs_dynamicpages/tests/test_api_apply_template_post.py b/src/cs_dynamicpages/tests/test_api_apply_template_post.py
@@ -0,0 +1,139 @@
+from cs_dynamicpages.templates import Manager
+from cs_dynamicpages.testing import CS_DYNAMICPAGES_FUNCTIONAL_TESTING
+from plone import api
+from plone.app.testing import setRoles
+from plone.app.testing import TEST_USER_ID
+from zope.publisher.browser import TestRequest
+
+import json
+import unittest
+
+
+class TestApplyTemplatePostAPI(unittest.TestCase):
+    layer = CS_DYNAMICPAGES_FUNCTIONAL_TESTING
+
+    def setUp(self):
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+
+        # In order to allow copying a DynamicPageFolder into another,
+        # we must ensure the FTI of the target allows it, or use a Folder
+        # instead of a DynamicPageFolder for the target since Plone allows
+        # anything inside a regular Folder by default.
+        self.target_folder = api.content.create(
+            container=self.portal,
+            type="Folder",
+            id="target-folder",
+            title="Target Folder",
+        )
+
+        self.source_folder = api.content.create(
+            container=self.portal,
+            type="DynamicPageFolder",
+            id="source-folder",
+            title="Source Folder",
+        )
+        self.source_uid = self.source_folder.UID()
+
+        # Register the template in the manager
+        self.manager = Manager(self.target_folder)
+        self.manager.append_template({
+            "uid": self.source_uid,
+            "name": "Source Template",
+        })
+
+    def _make_request(self, payload):
+        """Helper to simulate a REST API POST request"""
+        body = json.dumps(payload).encode("utf-8")
+        request = TestRequest(
+            environ={"CONTENT_TYPE": "application/json", "REQUEST_METHOD": "POST"},
+            body=body,
+        )
+        # Mock request.get("BODY") which is what json_body() uses
+        request.form["BODY"] = body
+        return request
+
+    def _get_service(self, request):
+        from cs_dynamicpages.api.services.apply_template.post import ApplyTemplatePost
+        from Products.Five.browser import BrowserView
+
+        class TestApplyTemplatePost(ApplyTemplatePost, BrowserView):
+            pass
+
+        return TestApplyTemplatePost(self.target_folder, request)
+
+    def test_apply_template_missing_uid(self):
+        """Test POST /@apply-template without UID fails with 400"""
+        request = self._make_request({})
+        service = self._get_service(request)
+
+        response = service.reply()
+
+        self.assertEqual(request.response.getStatus(), 400)
+        self.assertIn("error", response)
+        self.assertEqual(response["error"]["type"], "Bad Request")
+        self.assertEqual(response["error"]["message"], "UID is required")
+
+    def test_apply_template_invalid_uid_format(self):
+        """Test POST /@apply-template with template not in registry fails with 400"""
+        request = self._make_request({"uid": "not-registered-uid"})
+        service = self._get_service(request)
+
+        response = service.reply()
+
+        self.assertEqual(request.response.getStatus(), 400)
+        self.assertIn("error", response)
+        self.assertEqual(response["error"]["type"], "Bad Request")
+        self.assertEqual(response["error"]["message"], "Template name is not valid")
+
+    def test_apply_template_deleted_source(self):
+        """Test POST /@apply-template when source was deleted but registry has it"""
+        # Delete the source object so uuidToObject returns None
+        api.content.delete(self.source_folder)
+
+        request = self._make_request({"uid": self.source_uid})
+        service = self._get_service(request)
+
+        response = service.reply()
+
+        self.assertEqual(request.response.getStatus(), 400)
+        self.assertIn("error", response)
+        self.assertEqual(response["error"]["type"], "Bad Request")
+        self.assertEqual(response["error"]["message"], "Content does not exist")
+
+    def test_apply_template_success(self):
+        """Test POST /@apply-template successfully applies the template"""
+        request = self._make_request({"uid": self.source_uid})
+        service = self._get_service(request)
+
+        service.reply()
+
+        self.assertEqual(request.response.getStatus(), 204)
+
+        # The target folder should now have a copy of the source folder content inside
+        self.assertTrue(len(self.target_folder.objectIds()) > 0)
+
+    def test_apply_template_with_existing_rows(self):
+        """Test POST /@apply-template overwrites existing 'rows' object"""
+        # Note: applying a template deletes target_folder["rows"] if it exists
+        # To test this we need target_folder to allow creating an object named 'rows'
+        # Regular folders allow it.
+        api.content.create(
+            container=self.target_folder,
+            type="DynamicPageFolder",
+            id="rows",
+            title="Old Rows",
+        )
+        old_rows_uid = self.target_folder["rows"].UID()
+
+        request = self._make_request({"uid": self.source_uid})
+        service = self._get_service(request)
+
+        service.reply()
+
+        self.assertEqual(request.response.getStatus(), 204)
+
+        self.assertTrue(len(self.target_folder.objectIds()) > 0)
+        if "rows" in self.target_folder.objectIds():
+            self.assertNotEqual(self.target_folder["rows"].UID(), old_rows_uid)
diff --git a/src/cs_dynamicpages/tests/test_api_templates_delete.py b/src/cs_dynamicpages/tests/test_api_templates_delete.py
@@ -0,0 +1,88 @@
+from cs_dynamicpages.templates import Manager
+from cs_dynamicpages.testing import CS_DYNAMICPAGES_FUNCTIONAL_TESTING
+from plone import api
+from plone.app.testing import setRoles
+from plone.app.testing import TEST_USER_ID
+from zope.publisher.browser import TestRequest
+
+import json
+import unittest
+
+
+class TestTemplatesDeleteAPI(unittest.TestCase):
+    layer = CS_DYNAMICPAGES_FUNCTIONAL_TESTING
+
+    def setUp(self):
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+
+        # Create a folder to act as the context for our tests
+        self.folder = api.content.create(
+            container=self.portal, type="Folder", id="test-folder", title="Test Folder"
+        )
+
+        # Create some templates in the manager
+        self.manager = Manager(self.folder)
+        self.template_uid = "some-uuid-1234"
+        self.manager.append_template({"uid": self.template_uid, "name": "Template 1"})
+
+    def _make_request(self, payload):
+        """Helper to simulate a REST API DELETE request"""
+        body = json.dumps(payload).encode("utf-8")
+        request = TestRequest(
+            environ={"CONTENT_TYPE": "application/json", "REQUEST_METHOD": "DELETE"},
+            body=body,
+        )
+        # Mock request.get("BODY") which is what json_body() uses
+        request.form["BODY"] = body
+        return request
+
+    def _get_service(self, request):
+        from cs_dynamicpages.api.services.templates.delete import TemplatesDelete
+        from Products.Five.browser import BrowserView
+
+        class TestTemplatesDelete(TemplatesDelete, BrowserView):
+            pass
+
+        return TestTemplatesDelete(self.folder, request)
+
+    def test_delete_template_missing_uid(self):
+        """Test DELETE /@templates without UID fails with 400"""
+        request = self._make_request({"name": "Template 1"})
+        service = self._get_service(request)
+
+        response = service.reply()
+
+        self.assertEqual(request.response.getStatus(), 400)
+        self.assertIn("error", response)
+        self.assertEqual(response["error"]["type"], "Bad Request")
+        self.assertEqual(response["error"]["message"], "UID is required")
+
+    def test_delete_template_not_found(self):
+        """Test DELETE /@templates with non-existent template fails with 400"""
+        request = self._make_request({"uid": "invalid-uuid"})
+        service = self._get_service(request)
+
+        response = service.reply()
+
+        self.assertEqual(request.response.getStatus(), 400)
+        self.assertIn("error", response)
+        self.assertEqual(response["error"]["type"], "Bad Request")
+        self.assertEqual(response["error"]["message"], "Content does not exist")
+
+        # Verify the existing template was not deleted
+        self.assertEqual(len(self.manager.get_templates()), 1)
+
+    def test_delete_template_success(self):
+        """Test DELETE /@templates successfully deletes a template"""
+        request = self._make_request({"uid": self.template_uid})
+        service = self._get_service(request)
+
+        service.reply()
+
+        # In Plone tests, we check that status is NO CONTENT (204)
+        self.assertEqual(request.response.getStatus(), 204)
+
+        # Verify the template was removed from the Manager
+        self.assertEqual(len(self.manager.get_templates()), 0)
diff --git a/src/cs_dynamicpages/tests/test_api_templates_post.py b/src/cs_dynamicpages/tests/test_api_templates_post.py
diff --git a/src/cs_dynamicpages/tests/test_view_dynamic_page_folder_view.py b/src/cs_dynamicpages/tests/test_view_dynamic_page_folder_view.py
