mainsequence 9.0.6.dev41__tar.gz → 9.0.7.dev42__tar.gz

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 9.0.6.dev41
+Version: 9.0.7.dev42
 Summary: Main Sequence SDK
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/mainsequence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 9.0.6.dev41
+Version: 9.0.7.dev42
 Summary: Main Sequence SDK
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/mainsequence.egg-info/SOURCES.txt

@@ -66,7 +66,6 @@ tests/test_auth_bootstrap.py
 tests/test_auth_precedence.py
 tests/test_caller_assertions.py
 tests/test_canonical_api_route_contract.py
-tests/test_cli.py
 tests/test_cli_auth_contract.py
 tests/test_cli_browser_auth.py
 tests/test_cli_secure_storage.py
@@ -80,7 +79,6 @@ tests/test_dev_release_version.py
 tests/test_environment_resource_context.py
 tests/test_environment_response_contracts.py
 tests/test_fastapi_request_identity.py
-tests/test_filter_normalization.py
 tests/test_github_issues_client.py
 tests/test_http_retry_budget.py
 tests/test_independent_context.py

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "9.0.6.dev41"
+version = "9.0.7.dev42"
 description = "Main Sequence SDK"
 readme = "README.md"
 requires-python = ">=3.13"

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/tests/test_auth_precedence.py

@@ -4,68 +4,23 @@ import base64
 import importlib
 import json
 import os
-import pathlib
-import sys
 import time
-import types
 
 import pytest
 import requests
 
+from tests._support import load_sdk_submodule as _load_mainsequence_submodule
+
+pytestmark = pytest.mark.usefixtures("isolated_sdk_imports", "clean_runtime_context_environment")
+
+
 _REMOVED_DOMAIN_TOKEN = "PRO" + "JECT"
 _UNSUPPORTED_REPOSITORY_UID_ENV = "MAIN_SEQUENCE_" + _REMOVED_DOMAIN_TOKEN + "_UID"
-_UNSUPPORTED_REPOSITORY_BRANCH_UID_ENV = (
-    "MAIN_SEQUENCE_" + _REMOVED_DOMAIN_TOKEN + "_BRANCH_UID"
-)
+_UNSUPPORTED_REPOSITORY_BRANCH_UID_ENV = "MAIN_SEQUENCE_" + _REMOVED_DOMAIN_TOKEN + "_BRANCH_UID"
 _UNSUPPORTED_ENVIRONMENT_UID_ENV = (
     "MAIN_SEQUENCE_ORGANIZATION_" + _REMOVED_DOMAIN_TOKEN + "_ENVIRONMENT_UID"
 )
 
-_RUNTIME_CONTEXT_ENV_NAMES = (
-    _UNSUPPORTED_REPOSITORY_UID_ENV,
-    _UNSUPPORTED_REPOSITORY_BRANCH_UID_ENV,
-    "MAINSEQUENCE_REPOSITORY_BRANCH",
-    _UNSUPPORTED_ENVIRONMENT_UID_ENV,
-)
-
-
-@pytest.fixture(autouse=True)
-def _clear_runtime_context_environment():
-    original_modules = {
-        name: module
-        for name, module in sys.modules.items()
-        if name == "mainsequence" or name.startswith("mainsequence.")
-    }
-    for name in _RUNTIME_CONTEXT_ENV_NAMES:
-        os.environ.pop(name, None)
-    yield
-    for name in _RUNTIME_CONTEXT_ENV_NAMES:
-        os.environ.pop(name, None)
-    for name in tuple(sys.modules):
-        if name == "mainsequence" or name.startswith("mainsequence."):
-            sys.modules.pop(name, None)
-    sys.modules.update(original_modules)
-
-
-def _load_mainsequence_submodule(module_name: str):
-    repo_root = pathlib.Path(__file__).resolve().parents[1]
-    pkg_root = repo_root / "mainsequence"
-    client_pkg_root = pkg_root / "client"
-
-    for name in tuple(sys.modules):
-        if name == "mainsequence" or name.startswith("mainsequence."):
-            sys.modules.pop(name, None)
-
-    pkg = types.ModuleType("mainsequence")
-    pkg.__path__ = [str(pkg_root)]
-    sys.modules["mainsequence"] = pkg
-
-    client_pkg = types.ModuleType("mainsequence.client")
-    client_pkg.__path__ = [str(client_pkg_root)]
-    sys.modules["mainsequence.client"] = client_pkg
-
-    return importlib.import_module(module_name)
-
 
 class _FakeResponse:
     def __init__(self, status_code: int, payload: dict | None = None):
@@ -363,7 +318,10 @@ def test_runtime_credential_provider_does_not_mutate_unsupported_identity_enviro
     assert first_headers["Authorization"] == "Bearer organization-runtime-access"
     assert second_headers == first_headers
     assert calls["count"] == 1
-    assert os.environ[_UNSUPPORTED_REPOSITORY_BRANCH_UID_ENV] == "caller-supplied-value-must-be-ignored"
+    assert (
+        os.environ[_UNSUPPORTED_REPOSITORY_BRANCH_UID_ENV]
+        == "caller-supplied-value-must-be-ignored"
+    )
 
 
 def test_runtime_credential_provider_force_refresh_exchanges_again(monkeypatch):

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/tests/test_cli_auth_contract.py

@@ -9,6 +9,7 @@ import requests
 from typer.testing import CliRunner
 
 from mainsequence.cli import cli as cli_mod
+from tests._support import jwt_with_expiry as _jwt
 
 runner = CliRunner()
 
@@ -32,59 +33,6 @@ def test_cli_exposes_core_and_code_repository_commands():
     assert "code-repository" in result.output
 
 
-def test_manual_jwt_login_persists_tokens(monkeypatch):
-    saved = {}
-    monkeypatch.setattr(cli_mod.cfg, "backend_url", lambda: "https://backend.example")
-    monkeypatch.setattr(
-        cli_mod.cfg,
-        "save_tokens",
-        lambda username, access, refresh: (
-            saved.update(username=username, access=access, refresh=refresh) or True
-        ),
-    )
-
-    result = runner.invoke(
-        cli_mod.app, ["login", "--access-token", "access", "--refresh-token", "refresh"]
-    )
-
-    assert result.exit_code == 0
-    assert saved == {"username": "", "access": "access", "refresh": "refresh"}
-    assert "Signed in" in result.output
-
-
-def test_browser_login_uses_existing_auth_helper(monkeypatch):
-    monkeypatch.setattr(cli_mod.cfg, "backend_url", lambda: "https://backend.example")
-    monkeypatch.setattr(cli_mod.cfg, "save_tokens", lambda *_: True)
-    monkeypatch.setattr(
-        cli_mod,
-        "login_via_browser",
-        lambda **kwargs: {"access": "browser-access", "refresh": "browser-refresh"},
-    )
-
-    result = runner.invoke(cli_mod.app, ["login", "--no-open"])
-
-    assert result.exit_code == 0
-    assert "Signed in" in result.output
-
-
-def test_mcp_login_uses_existing_handoff_helper(monkeypatch):
-    monkeypatch.setattr(cli_mod.cfg, "backend_url", lambda: "https://backend.example")
-    monkeypatch.setattr(cli_mod.cfg, "save_tokens", lambda *_: True)
-
-    def handoff(**kwargs):
-        kwargs["on_handoff"](
-            {"mcp_tool": "auth.cli_authorize", "mcp_arguments": {"handoff_uid": "h"}}
-        )
-        return {"access": "mcp-access", "refresh": "mcp-refresh"}
-
-    monkeypatch.setattr(cli_mod, "login_via_mcp_handoff", handoff)
-
-    result = runner.invoke(cli_mod.app, ["login", "--mcp"])
-
-    assert result.exit_code == 0
-    assert "auth.cli_authorize" in result.output
-
-
 def test_logout_revokes_before_clearing(monkeypatch):
     calls = []
     monkeypatch.setattr(
@@ -99,6 +47,7 @@ def test_logout_revokes_before_clearing(monkeypatch):
 
     assert result.exit_code == 0
     assert calls == ["revoke", "clear", "overrides"]
+    assert "backend session revoked" in result.output
 
 
 def test_doctor_uses_full_local_diagnostics(monkeypatch):
@@ -396,14 +345,6 @@ def _now() -> int:
     return int(time.time())
 
 
-def _jwt(expiry: int | None) -> str:
-    import base64
-
-    claims = {} if expiry is None else {"exp": expiry}
-    body = base64.urlsafe_b64encode(json.dumps(claims).encode()).decode().rstrip("=")
-    return f"e30.{body}.signature"
-
-
 def test_current_access_token_reuses_a_token_that_is_still_valid(monkeypatch):
     from mainsequence.cli import api as api_mod
 

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/tests/test_cli_secure_storage.py

@@ -7,6 +7,7 @@ import json
 from keyring import errors as keyring_errors
 
 from mainsequence.cli import config
+from tests._support import jwt_with_expiry as _jwt
 
 
 class MemoryKeyring:
@@ -897,14 +898,6 @@ def test_macos_record_updated_by_a_released_version_is_still_read(monkeypatch, t
     assert config.clear_tokens() is True
 
 
-def _jwt(expiry: int | None) -> str:
-    import base64
-
-    claims = {} if expiry is None else {"exp": expiry}
-    body = base64.urlsafe_b64encode(json.dumps(claims).encode()).decode().rstrip("=")
-    return f"e30.{body}.signature"
-
-
 def test_token_expiry_reads_the_claim_and_tolerates_other_values():
     assert config.token_expiry(_jwt(1_900_000_000)) == 1_900_000_000
     assert config.token_expiry(_jwt(None)) is None

mainsequence-9.0.7.dev42/tests/test_client.py

@@ -0,0 +1,50 @@
+import pytest
+
+import mainsequence.client as msc
+
+# Every test in this module drives a real backend over the network and needs
+# SDK credentials, so none of them can run in CI. See `[tool.pytest.ini_options]`
+# in pyproject.toml: `pytest` deselects them, `pytest -m live` runs them.
+pytestmark = pytest.mark.live
+
+
+def test_code_repository_image_filter():
+    images = msc.CodeRepositoryImage.filter()
+    if not images:
+        pytest.skip("No CodeRepository images available for filter test.")
+
+    image = images[0]
+    repo_hash = image.code_repository_commit_hash
+
+    filtered_by_hash = msc.CodeRepositoryImage.filter(code_repository_commit_hash=repo_hash)
+    assert any(img.uid == image.uid for img in filtered_by_hash)
+
+    filtered_by_hash_in = msc.CodeRepositoryImage.filter(
+        code_repository_commit_hash__in=[repo_hash]
+    )
+    assert any(img.uid == image.uid for img in filtered_by_hash_in)
+
+
+def test_code_repository_resource_filter():
+    resources = msc.CodeRepositoryResource.filter()
+    if not resources:
+        pytest.skip("No CodeRepository resources available for filter test.")
+
+    resource = resources[0]
+    filtered_by_uid = msc.CodeRepositoryResource.filter(uid=resource.uid)
+    assert any(item.uid == resource.uid for item in filtered_by_uid)
+
+    filtered_by_uid_in = msc.CodeRepositoryResource.filter(uid__in=[resource.uid])
+    assert any(item.uid == resource.uid for item in filtered_by_uid_in)
+
+    if resource.repo_commit_sha:
+        filtered_by_repo_commit = msc.CodeRepositoryResource.filter(
+            repo_commit_sha=resource.repo_commit_sha
+        )
+        assert any(item.uid == resource.uid for item in filtered_by_repo_commit)
+
+    if resource.resource_type:
+        filtered_by_resource_type = msc.CodeRepositoryResource.filter(
+            resource_type=resource.resource_type
+        )
+        assert any(item.uid == resource.uid for item in filtered_by_resource_type)

mainsequence-9.0.7.dev42/tests/test_code_repository_documentation_contract.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[1]
+SKILL_ROOT = REPOSITORY_ROOT / "agent_scaffold" / "skills"
+DOCUMENTATION_SITE_ROOT = "https://mainsequence-sdk.github.io/mainsequence-sdk"
+# The wheel ships `agent_scaffold/skills` and no `docs/`, and the CLI copies those
+# skills into a user's CodeRepository under `.agents/skills/<namespace>/`. There,
+# `docs/` is that repository's own directory, so a skill that names an SDK
+# documentation page by repository-relative path names a file the agent reading it
+# cannot open. Skills cite the published documentation site instead.
+SKILL_REPOSITORY_DOCUMENTATION_PATH = re.compile(r"`(docs/[A-Za-z0-9_./-]+\.md)`")
+SKILL_DOCUMENTATION_URL = re.compile(re.escape(DOCUMENTATION_SITE_ROOT) + r"(/[A-Za-z0-9_./-]*)")
+# Skills are copied into a CodeRepository under `.agents/skills/<namespace>/`, so
+# a cross-skill reference maps back to a shipped `agent_scaffold/skills` path.
+SKILL_CROSS_REFERENCE = re.compile(r"`\.agents/skills/[A-Za-z0-9_]+/([A-Za-z0-9_./-]+/SKILL\.md)`")
+
+
+def _shipped_scaffold_documents() -> tuple[Path, ...]:
+    """Every Markdown file the wheel ships under `agent_scaffold`.
+
+    `AGENTS.md` ships beside the skills and several skills make it their first
+    mandatory read, so it carries the same reference obligations they do.
+    """
+
+    return tuple(sorted((REPOSITORY_ROOT / "agent_scaffold").rglob("*.md")))
+
+
+def _documentation_page_for_url_path(url_path: str) -> Path | None:
+    """Resolve a documentation-site URL path to the `docs/` page that renders it.
+
+    MkDocs serves directory URLs, so `/knowledge/meta_tables/migrations/` renders
+    `docs/knowledge/meta_tables/migrations.md` and `/knowledge/meta_tables/`
+    renders that directory's `index.md`. The transform is pure, so a skill's
+    documentation links are checkable without reaching the network.
+    """
+
+    relative = url_path.strip("/")
+    if not relative:
+        return REPOSITORY_ROOT / "docs" / "index.md"
+    candidates = (
+        REPOSITORY_ROOT / "docs" / f"{relative}.md",
+        REPOSITORY_ROOT / "docs" / relative / "index.md",
+    )
+    return next((candidate for candidate in candidates if candidate.is_file()), None)
+
+
+@pytest.mark.parametrize(
+    "path",
+    _shipped_scaffold_documents(),
+    ids=lambda path: str(path.relative_to(REPOSITORY_ROOT)),
+)
+def test_skills_do_not_cite_repository_relative_documentation_paths(path: Path) -> None:
+    relative_path = path.relative_to(REPOSITORY_ROOT)
+    text = path.read_text(encoding="utf-8")
+
+    repository_paths = sorted(set(SKILL_REPOSITORY_DOCUMENTATION_PATH.findall(text)))
+
+    assert not repository_paths, (
+        f"{relative_path} cites SDK documentation by repository-relative path: "
+        f"{repository_paths}. The wheel ships no `docs/`, so cite "
+        f"{DOCUMENTATION_SITE_ROOT}/... instead."
+    )
+
+
+@pytest.mark.parametrize(
+    "path",
+    _shipped_scaffold_documents(),
+    ids=lambda path: str(path.relative_to(REPOSITORY_ROOT)),
+)
+def test_skill_documentation_urls_render_an_existing_page(path: Path) -> None:
+    relative_path = path.relative_to(REPOSITORY_ROOT)
+    text = path.read_text(encoding="utf-8")
+
+    unrendered = sorted(
+        {
+            url_path
+            for url_path in SKILL_DOCUMENTATION_URL.findall(text)
+            if _documentation_page_for_url_path(url_path) is None
+        }
+    )
+
+    assert not unrendered, (
+        f"{relative_path} links documentation-site paths that no `docs/` page "
+        f"renders: {unrendered}"
+    )
+
+
+@pytest.mark.parametrize(
+    "path",
+    _shipped_scaffold_documents(),
+    ids=lambda path: str(path.relative_to(REPOSITORY_ROOT)),
+)
+def test_skill_cross_references_resolve(path: Path) -> None:
+    relative_path = path.relative_to(REPOSITORY_ROOT)
+    text = path.read_text(encoding="utf-8")
+
+    missing = sorted(
+        {
+            reference
+            for reference in SKILL_CROSS_REFERENCE.findall(text)
+            if not (SKILL_ROOT / reference).is_file()
+        }
+    )
+
+    assert not missing, f"{relative_path} references skills that are not shipped: {missing}"

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/tests/test_dependency_extras.py

@@ -1,50 +1,11 @@
 from __future__ import annotations
 
 import pathlib
-import sys
 import tomllib
-import types
 
-import pytest
 from packaging.requirements import Requirement
 
 
-def _snapshot_mainsequence_modules() -> dict[str, types.ModuleType]:
-    return {
-        name: module
-        for name, module in sys.modules.items()
-        if name == "mainsequence" or name.startswith("mainsequence.")
-    }
-
-
-def _reset_mainsequence_modules() -> None:
-    for name in tuple(sys.modules):
-        if name == "mainsequence" or name.startswith("mainsequence."):
-            sys.modules.pop(name, None)
-
-
-@pytest.fixture(autouse=True)
-def _restore_mainsequence_modules_after_import_test():
-    snapshot = _snapshot_mainsequence_modules()
-    yield
-    _reset_mainsequence_modules()
-    sys.modules.update(snapshot)
-
-
-def _seed_mainsequence_packages() -> None:
-    repo_root = pathlib.Path(__file__).resolve().parents[1]
-    pkg_root = repo_root / "mainsequence"
-    client_pkg_root = pkg_root / "client"
-
-    pkg = types.ModuleType("mainsequence")
-    pkg.__path__ = [str(pkg_root)]
-    sys.modules["mainsequence"] = pkg
-
-    client_pkg = types.ModuleType("mainsequence.client")
-    client_pkg.__path__ = [str(client_pkg_root)]
-    sys.modules["mainsequence.client"] = client_pkg
-
-
 def test_streamlit_is_absent_from_dependency_contracts() -> None:
     repo_root = pathlib.Path(__file__).resolve().parents[1]
     project = tomllib.loads((repo_root / "pyproject.toml").read_text(encoding="utf-8"))

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/tests/test_http_retry_budget.py

@@ -43,15 +43,14 @@ def clock(monkeypatch):
     return clock
 
 
-@pytest.mark.parametrize("method", ["POST", "PUT", "PATCH", "DELETE"])
 @pytest.mark.parametrize("error", [requests.ReadTimeout, requests.ConnectionError])
-def test_write_transport_failure_is_not_replayed(monkeypatch, method, error):
+def test_write_transport_failure_is_not_replayed(monkeypatch, error):
     session = Mock(headers=requests.structures.CaseInsensitiveDict())
-    request = getattr(session, method.lower())
+    request = session.post
     request.side_effect = error("uncertain result")
     monkeypatch.setattr(utils.time, "sleep", lambda _: None)
 
-    response = utils.make_request(session, method, "https://example.test/", None, time_out=1)
+    response = utils.make_request(session, "POST", "https://example.test/", None, time_out=1)
 
     assert response.code == "expired"
     assert request.call_count == 1
@@ -72,8 +71,10 @@ def test_programming_error_is_not_retried(monkeypatch):
     assert session.get.call_count == 1
 
 
-@pytest.mark.parametrize("method", ["POST", "PUT", "PATCH", "DELETE"])
-@pytest.mark.parametrize("status", [429, 500, 502, 503, 504])
+@pytest.mark.parametrize(
+    ("method", "status"),
+    [("POST", 429), ("POST", 503), ("PUT", 503), ("PATCH", 503), ("DELETE", 503)],
+)
 def test_write_status_is_not_retried_by_adapter(monkeypatch, clock, method, status):
     send = Mock(return_value=answer(status, {"Retry-After": "60"}))
     monkeypatch.setattr(requests.adapters.HTTPAdapter, "send", send)
@@ -85,15 +86,14 @@ def test_write_status_is_not_retried_by_adapter(monkeypatch, clock, method, stat
     assert clock.sleeps == []
 
 
-@pytest.mark.parametrize("method", ["POST", "PUT", "PATCH", "DELETE"])
 @pytest.mark.parametrize(
     "error", [requests.ReadTimeout, requests.ConnectTimeout, requests.ConnectionError]
 )
-def test_adapter_never_retries_write_exceptions(monkeypatch, clock, method, error):
+def test_adapter_never_retries_write_exceptions(monkeypatch, clock, error):
     send = Mock(side_effect=error("failed"))
     monkeypatch.setattr(requests.adapters.HTTPAdapter, "send", send)
     with utils.build_session() as session, pytest.raises(error):
-        session.request(method, "https://example.test/", timeout=1)
+        session.post("https://example.test/", timeout=1)
 
     assert send.call_count == 1
     assert clock.sleeps == []
@@ -391,19 +391,6 @@ def slow_server(delay=0.15, status=200):
         server.server_close()
 
 
-@pytest.mark.parametrize("method", ["POST", "PUT", "PATCH", "DELETE"])
-def test_slow_server_receives_exactly_one_write(method):
-    with slow_server() as (url, calls), utils.build_session() as session:
-        started = time.monotonic()
-        response = utils.make_request(session, method, url, None, time_out=0.05)
-        elapsed = time.monotonic() - started
-        assert response.code == "expired"
-        assert calls == [method]
-        assert elapsed < 0.15
-        time.sleep(0.16)
-        assert calls == [method]
-
-
 def test_slow_get_uses_one_total_budget():
     with (
         slow_server(delay=0.04, status=503) as (url, calls),

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/tests/test_job_client.py

@@ -5,31 +5,7 @@ import types
 
 import pytest
 
-
-def _snapshot_mainsequence_modules() -> dict[str, types.ModuleType]:
-    return {
-        name: module
-        for name, module in sys.modules.items()
-        if name == "mainsequence" or name.startswith("mainsequence.")
-    }
-
-
-@pytest.fixture(autouse=True)
-def _restore_mainsequence_modules():
-    """Undo the stub packages this module installs into ``sys.modules``.
-
-    ``_load_models_helpers_module`` replaces the real ``mainsequence`` packages
-    with stubs so ``models_helpers`` can be imported without the heavy client
-    stack. Without this fixture the stubs leak into every test module that runs
-    afterwards, and ``monkeypatch.setattr("mainsequence.client....")`` there
-    fails with ``module 'mainsequence' has no attribute 'client'``.
-    """
-    snapshot = _snapshot_mainsequence_modules()
-    yield
-    for name in tuple(sys.modules):
-        if name == "mainsequence" or name.startswith("mainsequence."):
-            sys.modules.pop(name, None)
-    sys.modules.update(snapshot)
+pytestmark = pytest.mark.usefixtures("isolated_sdk_imports")
 
 
 def _load_models_helpers_module():
@@ -137,8 +113,7 @@ def test_job_run_job_posts_to_canonical_action(monkeypatch):
     assert captured == {
         "r_type": "POST",
         "url": (
-            "https://backend.test/api/v1/jobs/"
-            "7d0ab07c-d1c0-4b7f-9c69-3c1a41c0a4da/run-job/"
+            "https://backend.test/api/v1/jobs/" "7d0ab07c-d1c0-4b7f-9c69-3c1a41c0a4da/run-job/"
         ),
         "payload": {"json": {"command_args": ["--name", "demo-from-cli"]}},
         "timeout": 30,

{mainsequence-9.0.6.dev41 → mainsequence-9.0.7.dev42}/tests/test_logconf.py

@@ -1,66 +1,24 @@
 from __future__ import annotations
 
-import importlib
 import os
-import pathlib
-import sys
-import types
 
 import pytest
 import requests
 
+from tests._support import RETIRED_RUNTIME_CONTEXT_ENV_NAMES as _RUNTIME_CONTEXT_ENV_NAMES
+from tests._support import load_sdk_submodule as _load_mainsequence_submodule
+
+pytestmark = pytest.mark.usefixtures("isolated_sdk_imports", "clean_runtime_context_environment")
+
+
 _REMOVED_DOMAIN_TOKEN = "PRO" + "JECT"
 _UNSUPPORTED_REPOSITORY_UID_ENV = "MAIN_SEQUENCE_" + _REMOVED_DOMAIN_TOKEN + "_UID"
-_UNSUPPORTED_REPOSITORY_BRANCH_UID_ENV = (
-    "MAIN_SEQUENCE_" + _REMOVED_DOMAIN_TOKEN + "_BRANCH_UID"
-)
-_UNSUPPORTED_REPOSITORY_NUMERIC_ID_ENV = (
-    "MAIN_SEQUENCE_" + _REMOVED_DOMAIN_TOKEN + "_ID"
-)
+_UNSUPPORTED_REPOSITORY_BRANCH_UID_ENV = "MAIN_SEQUENCE_" + _REMOVED_DOMAIN_TOKEN + "_BRANCH_UID"
+_UNSUPPORTED_REPOSITORY_NUMERIC_ID_ENV = "MAIN_SEQUENCE_" + _REMOVED_DOMAIN_TOKEN + "_ID"
 _UNSUPPORTED_ENVIRONMENT_UID_ENV = (
     "MAIN_SEQUENCE_ORGANIZATION_" + _REMOVED_DOMAIN_TOKEN + "_ENVIRONMENT_UID"
 )
 
-_RUNTIME_CONTEXT_ENV_NAMES = (
-    _UNSUPPORTED_REPOSITORY_UID_ENV,
-    _UNSUPPORTED_REPOSITORY_BRANCH_UID_ENV,
-    "MAINSEQUENCE_REPOSITORY_BRANCH",
-    _UNSUPPORTED_ENVIRONMENT_UID_ENV,
-)
-
-
-@pytest.fixture(autouse=True)
-def _clear_runtime_context_environment():
-    original_modules = {
-        name: module
-        for name, module in sys.modules.items()
-        if name == "mainsequence" or name.startswith("mainsequence.")
-    }
-    for name in _RUNTIME_CONTEXT_ENV_NAMES:
-        os.environ.pop(name, None)
-    yield
-    for name in _RUNTIME_CONTEXT_ENV_NAMES:
-        os.environ.pop(name, None)
-    for name in tuple(sys.modules):
-        if name == "mainsequence" or name.startswith("mainsequence."):
-            sys.modules.pop(name, None)
-    sys.modules.update(original_modules)
-
-
-def _load_mainsequence_submodule(module_name: str):
-    repo_root = pathlib.Path(__file__).resolve().parents[1]
-    pkg_root = repo_root / "mainsequence"
-
-    for name in tuple(sys.modules):
-        if name == "mainsequence" or name.startswith("mainsequence."):
-            sys.modules.pop(name, None)
-
-    pkg = types.ModuleType("mainsequence")
-    pkg.__path__ = [str(pkg_root)]
-    sys.modules["mainsequence"] = pkg
-
-    return importlib.import_module(module_name)
-
 
 def test_is_running_in_pod_uses_job_run_uid(monkeypatch):
     runtime_flags = _load_mainsequence_submodule("mainsequence.runtime_flags")