Add uninstalled, functional-layer, and request-builder fixtures (#43)

* Add uninstalled fixture (#38)

Adds an `uninstalled` fixture that reads a user-provided `package_name`
fixture and calls `installer.uninstall_product`. Removes the per-project
boilerplate that downstream codebases duplicate in their canonical add-on
uninstall smoke test.

Closes #38

* Add functional-layer fixtures (#39)

Adds `functional_app`, `functional_portal`, and `functional_http_request`
as functional-layer counterparts to the existing integration-layer
fixtures. `functional_portal` honors `@pytest.mark.portal`, matching the
behavior of `portal`.

This eliminates the most common reason downstream codebases override
pytest-plone fixtures — aliasing `functional["portal"]` as `portal`.

Closes #39

* Add request-builder fixtures (#40)

Introduces `request_factory`, `manager_request`, and `anon_request`,
replacing the 5+ near-identical session fixtures that downstream
codebases reimplement.

`request_factory` returns a built-in `RelativeSession` (a thin
`requests.Session` subclass) bound to the functional portal. Supported
modes: `role="Manager"`, `role="Anonymous"` (default), or explicit
`basic_auth=(user, password)`. The `++api++` suffix is added by default.

The standalone `RelativeSession` avoids pulling in
`plone.restapi[test]`'s fragile import chain (`plone.app.iterate`,
`collective.MockMailHost`) while keeping the same calling convention
downstream code already expects.

Closes #40

* Silence mypy import-untyped warning for requests

CI runs `uvx mypy src` in an isolated environment that does not honor the project's `ignore_missing_imports=true` setting in pyproject.toml. Add an inline type: ignore on the `requests` import rather than broadening CI or adding `types-requests` just for a single import.

Author: ericof

README.md

@@ -139,6 +139,58 @@ def test_myproduct_controlpanel_view(portal, http_request):
 
 ```
 
+### functional_app
+
+|  |  |
+| --- | --- |
+| Description | Zope root bound to the **functional** testing layer. |
+| Required Fixture | **functional** |
+| Scope | **Function** |
+
+Use this when you need a functional-layer counterpart to `app` — typically for REST API or browser tests.
+
+```python
+def test_functional_app(functional_app):
+    """Test app title."""
+    assert functional_app.getPhysicalPath() == ("", )
+```
+
+### functional_portal
+
+|  |  |
+| --- | --- |
+| Description | Portal object bound to the **functional** testing layer. Honors `@pytest.mark.portal`. |
+| Required Fixture | **functional** |
+| Scope | **Function** |
+
+Parallel to `portal`, but bound to the functional layer. Accepts the same `@pytest.mark.portal` marker for profiles, content, and roles — see the **Markers** section.
+
+```python
+def test_functional_portal_title(functional_portal):
+    """Test portal title on the functional layer."""
+    assert functional_portal.title == "Plone site"
+```
+
+### functional_http_request
+
+|  |  |
+| --- | --- |
+| Description | HTTP Request bound to the **functional** testing layer. |
+| Required Fixture | **functional** |
+| Scope | **Function** |
+
+```python
+from plone import api
+
+
+def test_functional_view(functional_portal, functional_http_request):
+    """Test a browser view on the functional layer."""
+    view = api.content.get_view(
+        "myproduct-controlpanel", functional_portal, functional_http_request
+    )
+    assert view is not None
+```
+
 ### installer
 
 |  |  |
@@ -178,6 +230,35 @@ def test_dependency_installed(installer, package):
 
 ```
 
+### uninstalled
+
+|  |  |
+| --- | --- |
+| Description | Uninstall the add-on under test from the current portal. |
+| Required Fixture | **installer**, **package_name** (user-provided) |
+| Scope | **Function** |
+
+This fixture removes the duplicate per-project boilerplate from the canonical uninstall smoke test. You must define a `package_name` fixture in your `conftest.py` (or test module) that returns the distribution name of your add-on.
+
+```python
+import pytest
+
+
+@pytest.fixture
+def package_name() -> str:
+    """Distribution name of the add-on under test."""
+    return "collective.person"
+
+
+class TestSetupUninstall:
+    @pytest.fixture(autouse=True)
+    def _uninstalled(self, uninstalled):
+        """Uninstall the add-on before every test in this class."""
+
+    def test_product_uninstalled(self, installer, package_name):
+        assert installer.is_product_installed(package_name) is False
+```
+
 ### browser_layers
 
 |  |  |
@@ -363,6 +444,61 @@ def test_manager_action(portal, grant_roles):
     # test user now has Manager role on portal
 ```
 
+### request_factory
+
+|  |  |
+| --- | --- |
+| Description | Callable that builds a `RelativeSession` against the functional portal. |
+| Required Fixture | **functional_portal** |
+| Scope | **Function** |
+
+Replaces the 5+ near-identical request-session fixtures that downstream codebases reimplement. Returns a `RelativeSession` (a thin `requests.Session` subclass that resolves relative URLs against the portal's base URL) with sensible defaults:
+
+- `role="Manager"` — authenticate as the portal owner.
+- `role="Anonymous"` (default) — no authentication.
+- `basic_auth=(user, password)` — any other identity; takes precedence over `role`.
+- `api=True` (default) — suffix the base URL with `++api++` so relative calls hit the REST API.
+
+Sessions are closed automatically at the end of the test.
+
+```python
+def test_list_content(request_factory):
+    """Test that the Manager role can list content."""
+    session = request_factory(role="Manager")
+    response = session.get("/")
+    assert response.status_code == 200
+```
+
+### manager_request
+
+|  |  |
+| --- | --- |
+| Description | `RelativeSession` pre-authenticated as the portal owner (Manager). |
+| Required Fixture | **request_factory** |
+| Scope | **Function** |
+
+```python
+def test_controlpanels(manager_request):
+    """Test listing of control panels."""
+    response = manager_request.get("/@controlpanels")
+    assert response.status_code == 200
+```
+
+### anon_request
+
+|  |  |
+| --- | --- |
+| Description | `RelativeSession` with no authentication (Anonymous). |
+| Required Fixture | **request_factory** |
+| Scope | **Function** |
+
+```python
+def test_public_endpoint(anon_request):
+    """Test a public REST API endpoint."""
+    response = anon_request.get("/")
+    assert response.status_code == 200
+```
+
 ## Markers
 
 ### @pytest.mark.portal

news/38.feature

@@ -0,0 +1 @@
+Added the `uninstalled` fixture — reads a user-provided `package_name` fixture and calls `installer.uninstall_product`, removing boilerplate from the canonical add-on uninstall smoke test. @ericof

news/39.feature

@@ -0,0 +1 @@
+Added `functional_app`, `functional_portal`, and `functional_http_request` fixtures — functional-layer counterparts to `app`, `portal`, and `http_request`. `functional_portal` honors the `@pytest.mark.portal` marker. @ericof

news/40.feature

@@ -0,0 +1 @@
+Added `request_factory`, `manager_request`, and `anon_request` fixtures — build a `RelativeSession` against the functional portal with Manager, Anonymous, or custom basic-auth credentials. Replaces boilerplate duplicated across downstream codebases. @ericof

pyproject.toml

@@ -40,6 +40,7 @@ dependencies = [
     "plone.browserlayer",
     "plone.dexterity",
     "Products.CMFPlone[test]",
+    "requests",
     "zope.component",
     "zope.schema",
 ]

src/pytest_plone/_types.py

@@ -4,6 +4,7 @@
 from plone.dexterity.content import DexterityContent
 from plone.dexterity.fti import DexterityFTI
 from Products.CMFPlone.Portal import PloneSite
+from typing import Any
 from typing import Protocol
 from typing import TypeAlias
 from zope.schema.vocabulary import SimpleVocabulary
@@ -45,3 +46,13 @@ def __call__(
 
 class RolesGranter(Protocol):
     def __call__(self, context: DexterityContent | Item, roles: list[str]) -> None: ...
+
+
+class RequestFactory(Protocol):
+    def __call__(
+        self,
+        *,
+        role: str = ...,
+        basic_auth: tuple[str, str] | None = ...,
+        api: bool = ...,
+    ) -> Any: ...

src/pytest_plone/fixtures/__init__.py

@@ -6,35 +6,49 @@
 from .addons import installer
 from .addons import profile_last_version
 from .addons import setup_tool
+from .addons import uninstalled
 from .base import app
+from .base import functional_app
+from .base import functional_http_request
+from .base import functional_portal
 from .base import http_request
 from .base import portal
 from .content import create_content
 from .content import get_behaviors
 from .content import get_fti
 from .env import generate_mo
+from .requests import anon_request
+from .requests import manager_request
+from .requests import request_factory
 from .security import grant_roles
 from .vocabularies import get_vocabulary
 
 import pytest
 
 
 __all__ = [
+    "anon_request",
     "app",
     "apply_profiles",
     "browser_layers",
     "controlpanel_actions",
     "create_content",
+    "functional_app",
+    "functional_http_request",
+    "functional_portal",
     "generate_mo",
     "get_behaviors",
     "get_fti",
     "get_vocabulary",
     "grant_roles",
     "http_request",
     "installer",
+    "manager_request",
     "portal",
     "profile_last_version",
+    "request_factory",
     "setup_tool",
+    "uninstalled",
 ]
 
 

src/pytest_plone/fixtures/addons.py

@@ -30,6 +30,38 @@ def uninstalled(self, installer):
     return get_installer(portal)
 
 
+@pytest.fixture
+def uninstalled(installer: InstallerView, package_name: str) -> None:
+    """Uninstall the add-on under test from the current portal.
+
+    Requires a ``package_name`` fixture defined in your ``conftest.py``
+    that returns the distribution name of the add-on being tested.
+
+    Example usage:
+    ```python
+    # conftest.py
+    import pytest
+
+
+    @pytest.fixture
+    def package_name() -> str:
+        return "collective.person"
+
+
+    # tests/test_setup.py
+    class TestSetupUninstall:
+        @pytest.fixture(autouse=True)
+        def uninstalled(self, uninstalled):
+            # add-on is now uninstalled for every test in this class
+            pass
+
+        def test_product_uninstalled(self, installer, package_name):
+            assert installer.is_product_installed(package_name) is False
+    ```
+    """
+    installer.uninstall_product(package_name)
+
+
 @pytest.fixture
 def browser_layers(portal: PloneSite) -> list[InterfaceClass]:
     """List of browser layers registered in a portal.

src/pytest_plone/fixtures/base.py

@@ -59,3 +59,54 @@ def test_request(self, request):
     ```
     """
     return integration["request"]
+
+
+@pytest.fixture()
+def functional_app(functional: Layer) -> Application:
+    """Returns the root of a Zope application for a functional Layer.
+
+    Mirrors :func:`app` but bound to the ``functional`` layer. Use this in
+    REST API, browser, or other tests that require transaction-level
+    isolation instead of the integration-layer stacked-DemoStorage.
+
+    Example usage:
+    ```python
+    def test_functional_app(self, functional_app):
+        assert functional_app.title == "Zope"
+    ```
+    """
+    return functional["app"]
+
+
+@pytest.fixture()
+def functional_portal(functional: Layer, request: pytest.FixtureRequest) -> PloneSite:
+    """Returns the default Plone Site for a functional Layer.
+
+    Mirrors :func:`portal` but bound to the ``functional`` layer and also
+    honors ``@pytest.mark.portal`` for GenericSetup profiles, pre-created
+    content, and test-user roles.
+
+    Example usage:
+    ```python
+    def test_functional_portal(self, functional_portal):
+        assert functional_portal.title == "Plone site"
+    ```
+    """
+    portal: PloneSite = functional["portal"]
+    apply_portal_marker(portal, request)
+    return portal
+
+
+@pytest.fixture
+def functional_http_request(functional: Layer) -> HTTPRequest:
+    """Returns the current request object for a functional Layer.
+
+    Mirrors :func:`http_request` but bound to the ``functional`` layer.
+
+    Example usage:
+    ```python
+    def test_functional_request(self, functional_http_request):
+        assert functional_http_request.method == "GET"
+    ```
+    """
+    return functional["request"]