test(e2e): add notifications directories, footers and webhooks e2e coverage

Cover the mixin surface each new service exposes against the live TEST
environment. Directories are read-only, so the tests cover get, 404 on a
bogus id and the filtered iterate on a stable vendor-account directory
registered as notifications.directory.id. Footers get the managed
lifecycle through the operations client and webhooks the managed
lifecycle plus enable and disable through the vendor client on the seeded
product.

Both platforms enforce a uniqueness key on create: one active footer per
language and account, one webhook per type and bound object. The fixtures
therefore treat the create call as the claim on that key: they try a list
of supported candidates in order and move on when the platform reports the
key as taken, so concurrent runs sharing the operations account or the
seeded product cannot both win the same value. Footers soft-delete, which
the delete test asserts.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: jentyk

e2e_config.test.json

@@ -67,6 +67,7 @@
   "notifications.batch.id": "MST-3638-2460-4825",
   "notifications.category.id": "NTC-6157-0397",
   "notifications.contact.id": "CTT-0001-9158",
+  "notifications.directory.id": "DIR-9614-2985",
   "notifications.message.id": "MSG-0000-6215-1019-0139",
   "notifications.subscriber.id": "NTS-0829-7123-7123",
   "integration.extension.id": "EXT-6587-4477",

tests/e2e/helper.py

@@ -58,6 +58,62 @@ def create_fixture_resource_and_delete(service, resource_data, upload_file=None)
         _delete_resource(service, resource)
 
 
+async def _async_create_first_free(service, candidates, is_taken):
+    remaining = list(candidates)
+    while remaining:
+        candidate = remaining.pop(0)
+        try:
+            return await service.create(candidate)
+        except MPTAPIError as error:
+            if not is_taken(error):
+                raise
+    raise RuntimeError(f"Every candidate payload is already taken: {candidates}")
+
+
+def _create_first_free(service, candidates, is_taken):
+    for candidate in candidates:
+        try:
+            return service.create(candidate)
+        except MPTAPIError as error:
+            if not is_taken(error):
+                raise
+    raise RuntimeError(f"Every candidate payload is already taken: {candidates}")
+
+
+@asynccontextmanager
+async def async_create_first_free_fixture_and_delete(service, candidates, is_taken):
+    """Create the first candidate the platform accepts, then delete it on teardown.
+
+    ``candidates`` are payloads that differ only in a server-enforced uniqueness key and
+    ``is_taken(error)`` tells whether a rejected create means that key is already in use.
+    The create call itself is the claim, so two runs that race for the same key cannot both
+    succeed and the loser moves on to the next candidate instead of failing.
+    """
+    resource = await _async_create_first_free(service, candidates, is_taken)
+
+    try:
+        yield resource
+    finally:
+        await _delete_async_resource(service, resource)
+
+
+@contextmanager
+def create_first_free_fixture_and_delete(service, candidates, is_taken):
+    """Create the first candidate the platform accepts, then delete it on teardown.
+
+    ``candidates`` are payloads that differ only in a server-enforced uniqueness key and
+    ``is_taken(error)`` tells whether a rejected create means that key is already in use.
+    The create call itself is the claim, so two runs that race for the same key cannot both
+    succeed and the loser moves on to the next candidate instead of failing.
+    """
+    resource = _create_first_free(service, candidates, is_taken)
+
+    try:
+        yield resource
+    finally:
+        _delete_resource(service, resource)
+
+
 @asynccontextmanager
 async def async_create_fixture_resource_and_finalize(service, resource_data, finalize, logger):
     """Create a resource, then transition it to a terminal state on teardown.

tests/e2e/notifications/directories/__init__.py

@@ -0,0 +1,16 @@
+import pytest
+
+
+@pytest.fixture
+def directories_service(mpt_ops):
+    return mpt_ops.notifications.directories
+
+
+@pytest.fixture
+def async_directories_service(async_mpt_ops):
+    return async_mpt_ops.notifications.directories
+
+
+@pytest.fixture(scope="session")
+def directory_id(e2e_config):
+    return e2e_config["notifications.directory.id"]

tests/e2e/notifications/directories/conftest.py

@@ -0,0 +1,25 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+from tests.e2e.helper import assert_async_service_filter_with_iterate
+
+pytestmark = [pytest.mark.flaky]
+
+
+async def test_get_directory(async_directories_service, directory_id):
+    result = await async_directories_service.get(directory_id)
+
+    assert result.id == directory_id
+
+
+async def test_get_directory_not_found(async_directories_service):
+    bogus_id = "DIR-0000-0000"
+
+    with pytest.raises(MPTAPIError, match=r"404 Not Found"):
+        await async_directories_service.get(bogus_id)
+
+
+async def test_filter_directories(async_directories_service, directory_id):
+    await assert_async_service_filter_with_iterate(
+        async_directories_service, directory_id, None
+    )  # act

tests/e2e/notifications/directories/test_async_directories.py

@@ -0,0 +1,23 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+from tests.e2e.helper import assert_service_filter_with_iterate
+
+pytestmark = [pytest.mark.flaky]
+
+
+def test_get_directory(directories_service, directory_id):
+    result = directories_service.get(directory_id)
+
+    assert result.id == directory_id
+
+
+def test_get_directory_not_found(directories_service):
+    bogus_id = "DIR-0000-0000"
+
+    with pytest.raises(MPTAPIError, match=r"404 Not Found"):
+        directories_service.get(bogus_id)
+
+
+def test_filter_directories(directories_service, directory_id):
+    assert_service_filter_with_iterate(directories_service, directory_id, None)  # act

tests/e2e/notifications/directories/test_sync_directories.py

@@ -0,0 +1,52 @@
+import pytest
+
+from tests.e2e.helper import (
+    async_create_first_free_fixture_and_delete,
+    create_first_free_fixture_and_delete,
+)
+
+# The platform allows one active footer per language and per account and only accepts the
+# cultures it ships with. The create call is the claim on a language: a run tries these
+# supported codes in order and moves on when the platform reports the language as taken, so
+# concurrent runs sharing the operations account cannot both win the same code.
+FOOTER_LANGUAGE_CODES = ("hu-HU", "nb-NO", "pt-PT", "ja-JP", "nl-NL", "it-IT", "fr-FR", "cs-CZ")
+
+
+def _is_language_taken(error):
+    return "already exists" in str(error)
+
+
+@pytest.fixture
+def footers_service(mpt_ops):
+    return mpt_ops.notifications.footers
+
+
+@pytest.fixture
+def async_footers_service(async_mpt_ops):
+    return async_mpt_ops.notifications.footers
+
+
+@pytest.fixture
+def footer_data(short_uuid):
+    return {"content": f"e2e footer - please delete {short_uuid}"}
+
+
+@pytest.fixture
+def footer_candidates(footer_data):
+    return [{**footer_data, "languageCode": code} for code in FOOTER_LANGUAGE_CODES]
+
+
+@pytest.fixture
+def created_footer(footers_service, footer_candidates):
+    with create_first_free_fixture_and_delete(
+        footers_service, footer_candidates, _is_language_taken
+    ) as footer:
+        yield footer
+
+
+@pytest.fixture
+async def async_created_footer(async_footers_service, footer_candidates):
+    async with async_create_first_free_fixture_and_delete(
+        async_footers_service, footer_candidates, _is_language_taken
+    ) as footer:
+        yield footer

tests/e2e/notifications/footers/__init__.py

@@ -0,0 +1,57 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+from tests.e2e.helper import (
+    assert_async_service_filter_with_iterate,
+    assert_async_update_resource,
+)
+
+pytestmark = [pytest.mark.flaky]
+
+
+def test_create_footer(async_created_footer, footer_data):
+    result = async_created_footer.content
+
+    assert result == footer_data["content"]
+
+
+async def test_get_footer(async_footers_service, async_created_footer):
+    result = await async_footers_service.get(async_created_footer.id)
+
+    assert result.id == async_created_footer.id
+
+
+async def test_get_footer_not_found(async_footers_service):
+    bogus_id = "FLV-0000-0000"
+
+    with pytest.raises(MPTAPIError, match=r"404 Not Found"):
+        await async_footers_service.get(bogus_id)
+
+
+async def test_update_footer(async_footers_service, async_created_footer, short_uuid):
+    new_content = f"e2e footer updated {short_uuid}"
+
+    await assert_async_update_resource(  # act
+        async_footers_service, async_created_footer.id, "content", new_content
+    )
+
+
+async def test_delete_footer(async_footers_service, async_created_footer):
+    await async_footers_service.delete(async_created_footer.id)
+
+    result = await async_footers_service.get(async_created_footer.id)
+
+    assert result.status == "Deleted"
+
+
+async def test_delete_footer_not_found(async_footers_service):
+    bogus_id = "FLV-0000-0000"
+
+    with pytest.raises(MPTAPIError):
+        await async_footers_service.delete(bogus_id)
+
+
+async def test_filter_footers(async_footers_service, async_created_footer):
+    await assert_async_service_filter_with_iterate(  # act
+        async_footers_service, async_created_footer.id, None
+    )

tests/e2e/notifications/footers/conftest.py

@@ -0,0 +1,50 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+from tests.e2e.helper import assert_service_filter_with_iterate, assert_update_resource
+
+pytestmark = [pytest.mark.flaky]
+
+
+def test_create_footer(created_footer, footer_data):
+    result = created_footer.content
+
+    assert result == footer_data["content"]
+
+
+def test_get_footer(footers_service, created_footer):
+    result = footers_service.get(created_footer.id)
+
+    assert result.id == created_footer.id
+
+
+def test_get_footer_not_found(footers_service):
+    bogus_id = "FLV-0000-0000"
+
+    with pytest.raises(MPTAPIError, match=r"404 Not Found"):
+        footers_service.get(bogus_id)
+
+
+def test_update_footer(footers_service, created_footer, short_uuid):
+    new_content = f"e2e footer updated {short_uuid}"
+
+    assert_update_resource(footers_service, created_footer.id, "content", new_content)  # act
+
+
+def test_delete_footer(footers_service, created_footer):
+    footers_service.delete(created_footer.id)
+
+    result = footers_service.get(created_footer.id)
+
+    assert result.status == "Deleted"
+
+
+def test_delete_footer_not_found(footers_service):
+    bogus_id = "FLV-0000-0000"
+
+    with pytest.raises(MPTAPIError):
+        footers_service.delete(bogus_id)
+
+
+def test_filter_footers(footers_service, created_footer):
+    assert_service_filter_with_iterate(footers_service, created_footer.id, None)  # act