apcore-cli 0.12.0__tar.gz → 0.12.2__tar.gz

{apcore_cli-0.12.0 → apcore_cli-0.12.2}/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to apcore-cli (Python SDK) will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.12.2] - 2026-09-29
+
+### Changed — BREAKING
+
+- **`apcli openapi scan` / `generate` module IDs follow apcore-toolkit 0.13.0's normalisation; the toolkit floor is now `apcore-toolkit[http-proxy]>=0.13.0`.** The CLI passes the scanner's IDs through unchanged, so it inherits the toolkit's new derivation: IDs derived from camelCase or hyphenated names are now snake_case — `createPets` → `create_pets`, `showPetById` → `show_pet_by_id` — and `generate`'s `.binding.yaml` file names change with them (`createPets.binding.yaml` → `create_pets.binding.yaml`). An `operationId`-derived camelCase ID used to be emitted verbatim and was rejected by apcore's registry when the generated binding was loaded; it is now loadable for the first time. Path-derived IDs with a camelCase parameter change too, although they were already loadable (`/pets/{petId}`: `pets.petid.get` → `pets.pet_id.get`). A legal ID is never rewritten, and a `--prefix` value is normalised with the rest of the ID (`Pet-Store` → `pet_store`). **Migration:** `--include` / `--exclude` patterns and scripts keyed on the old IDs or file names need updating; the filters match the emitted, normalised ID. A segment that still begins with a digit (`POST /v1/2fa` → `v1.2fa.post`) is not repaired: the module is still emitted and carries the toolkit's legality warning, which `scan` renders like any other scanner warning (exit stays `0`; pinned by new test T-OAPI-28). No CLI code changed; 23 tests re-pinned to the new IDs.
+
+## [0.12.1] - 2026-09-24
+
+Patch release. Bumps the required `apcore` floor to `0.31.0` and `apcore-toolkit` to `[http-proxy]>=0.12.0`. All 1021 tests pass (6 xfailed).
+
+### Changed
+
+- **`load_cli_acl` no longer rebuilds the ACL to attach the §4.8 audit callback.** apcore 0.31.0 (decision D-66) makes `ACL.load(path, audit_logger=…)` accept the callback directly; the `ACL(src.rules, src.default_effect, audit_logger=…)` rebuild this SDK relied on — the only lossless way to attach one before this release — is gone. `reload()` is now available on the ACL `load_cli_acl` returns whether or not `acl.audit.enabled` is set; previously it raised `ACLRuleError` on the auditing path.
+
+### Security
+
+- **`apcli openapi scan|generate` inherits apcore-toolkit 0.12.0's `$ref` sibling-key fix.** `OpenAPIScanner` (imported, never reimplemented, by `openapi_cmd.py`/`openapi_source.py`) previously discarded a `$ref` node's sibling keys during schema resolution, dropping `x-sensitive` and letting a field an OpenAPI document marked sensitive reach apcore with nothing to redact on. Fixed upstream; no code change was needed here.
+
 ## [0.12.0] - 2026-09-05
 
 Two features: **FE-14 ACL Governance** and **FE-15a OpenAPI Import**. Bumps the required `apcore` floor to `0.30.0` and `apcore-toolkit` to `[http-proxy]>=0.11.1`. Full suite: 1004 passed, 5 xfailed (815 → 1004; 189 new tests). `APCLI_SUBCOMMAND_NAMES` grows from 13 to 15.

{apcore_cli-0.12.0 → apcore_cli-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apcore-cli
-Version: 0.12.0
+Version: 0.12.2
 Summary: Terminal adapter for apcore — execute AI-Perceivable modules from the command line
 Project-URL: Homepage, https://aiperceivable.com
 Project-URL: Repository, https://github.com/aiperceivable/apcore-cli-python
@@ -21,8 +21,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
-Requires-Dist: apcore-toolkit[http-proxy]>=0.11.1
-Requires-Dist: apcore>=0.30.0
+Requires-Dist: apcore-toolkit[http-proxy]>=0.13.0
+Requires-Dist: apcore>=0.31.0
 Requires-Dist: click>=8.1
 Requires-Dist: cryptography>=41.0
 Requires-Dist: jsonschema>=4.20
@@ -89,7 +89,7 @@ Terminal adapter for apcore. Execute AI-Perceivable modules from the command lin
 pip install apcore-cli
 ```
 
-Requires Python 3.11+, `apcore >= 0.21.0`, and `apcore-toolkit >= 0.10.0` (now a **required** runtime dependency as of v0.9.0 — previously optional; see the [tech-design ADR-09](https://github.com/aiperceivable/apcore-cli/blob/main/docs/tech-design.md) for the byte-equivalent toolkit-delegated tier rationale). The `[toolkit]` extras group is retained as a no-op for backward compat:
+Requires Python 3.11+, `apcore >= 0.21.0`, and `apcore-toolkit >= 0.13.0` (now a **required** runtime dependency as of v0.9.0 — previously optional; see the [tech-design ADR-09](https://github.com/aiperceivable/apcore-cli/blob/main/docs/tech-design.md) for the byte-equivalent toolkit-delegated tier rationale). The `[toolkit]` extras group is retained as a no-op for backward compat:
 
 ```bash
 pip install "apcore-cli[toolkit]"   # equivalent to plain `pip install apcore-cli`

{apcore_cli-0.12.0 → apcore_cli-0.12.2}/README.md

@@ -48,7 +48,7 @@ Terminal adapter for apcore. Execute AI-Perceivable modules from the command lin
 pip install apcore-cli
 ```
 
-Requires Python 3.11+, `apcore >= 0.21.0`, and `apcore-toolkit >= 0.10.0` (now a **required** runtime dependency as of v0.9.0 — previously optional; see the [tech-design ADR-09](https://github.com/aiperceivable/apcore-cli/blob/main/docs/tech-design.md) for the byte-equivalent toolkit-delegated tier rationale). The `[toolkit]` extras group is retained as a no-op for backward compat:
+Requires Python 3.11+, `apcore >= 0.21.0`, and `apcore-toolkit >= 0.13.0` (now a **required** runtime dependency as of v0.9.0 — previously optional; see the [tech-design ADR-09](https://github.com/aiperceivable/apcore-cli/blob/main/docs/tech-design.md) for the byte-equivalent toolkit-delegated tier rationale). The `[toolkit]` extras group is retained as a no-op for backward compat:
 
 ```bash
 pip install "apcore-cli[toolkit]"   # equivalent to plain `pip install apcore-cli`

{apcore_cli-0.12.0 → apcore_cli-0.12.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apcore-cli"
-version = "0.12.0"
+version = "0.12.2"
 description = "Terminal adapter for apcore — execute AI-Perceivable modules from the command line"
 readme = "README.md"
 license = "Apache-2.0"
@@ -26,8 +26,8 @@ classifiers = [
     "Environment :: Console",
 ]
 dependencies = [
-    "apcore>=0.30.0",
-    "apcore-toolkit[http-proxy]>=0.11.1",
+    "apcore>=0.31.0",
+    "apcore-toolkit[http-proxy]>=0.13.0",
     "click>=8.1",
     "jsonschema>=4.20",
     "rich>=13.0",

{apcore_cli-0.12.0 → apcore_cli-0.12.2}/src/apcore_cli/acl_loader.py

@@ -210,32 +210,13 @@ def make_acl_audit_logger(*, include_denied: bool = True) -> Callable[[AuditEntr
 def load_cli_acl(root: str, *, audit_enabled: bool = True, include_denied: bool = True) -> ACL | None:
     """Load an :class:`~apcore.ACL` from *root*, or ``None`` for no enforcement.
 
-    When *audit_enabled* is true the ACL is **rebuilt** so it can carry the
-    §4.8 audit callback: ``ACL.load`` takes no ``audit_logger``, and the
-    callback is a constructor argument, so ::
-
-        src = ACL.load(resolved_path)
-        acl = ACL(src.rules, src.default_effect, audit_logger=…)
-
-    is the only lossless way to attach one. Two things about that sequence are
-    load-bearing:
-
-    1. ``default_effect`` is carried from ``src``, **never** a literal. A file
-       may legitimately declare ``default_effect: allow``, and passing the
-       constructor's own ``"deny"`` default would silently invert the governing
-       verdict for every call no rule matched — a rule set that grants by
-       default would start denying, with nothing in the output saying so.
-    2. The rebuilt ACL **loses** :meth:`~apcore.ACL.reload`, which needs the
-       ``_yaml_path`` only ``ACL.load`` sets. This is accepted rather than
-       worked around: no apcore-cli SDK calls ``reload()`` on any path, and
-       writing the private attribute to fake the provenance would make
-       ``reload()`` claim a file the object was not in fact loaded from. An
-       embedder that needs reloading passes its own ACL to
-       ``create_cli(acl=…)``, which §4.2 attaches unchanged.
-
-    With auditing disabled the ``ACL.load`` result is returned **directly** —
-    no rebuild, no callback — so the ``reload()`` caveat applies only to the
-    auditing path.
+    ``ACL.load`` takes ``audit_logger`` directly (apcore 0.31.0, D-66), so the
+    §4.8 callback is attached in the same call that parses the file — no
+    rebuild, and :meth:`~apcore.ACL.reload` stays available on the returned
+    object. (An earlier revision rebuilt the ACL via
+    ``ACL(src.rules, src.default_effect, audit_logger=…)`` to attach the
+    callback after the fact, which lost ``reload()`` in the process; that
+    workaround is gone now that apcore accepts the callback at load time.)
 
     Args:
         root: Resolved ACL root (file or directory).
@@ -259,20 +240,13 @@ def load_cli_acl(root: str, *, audit_enabled: bool = True, include_denied: bool
     if acl_file is None:
         logger.debug("No ACL at '%s' — enforcement stays off.", root)
         return None
-    src = _ACL.load(acl_file)
-    logger.info("ACL loaded from %s (%d rules).", acl_file, len(src.rules))
-    if not audit_enabled:
-        logger.debug("acl.audit.enabled is false — attaching the loaded ACL directly, no audit callback.")
-        return src
-    acl = _ACL(
-        src.rules,
-        src.default_effect,
-        audit_logger=make_acl_audit_logger(include_denied=include_denied),
-    )
-    logger.debug(
-        "ACL audit callback installed (include_denied=%s); reload() is unavailable on the rebuilt ACL.",
-        include_denied,
-    )
+    audit_logger = make_acl_audit_logger(include_denied=include_denied) if audit_enabled else None
+    acl = _ACL.load(acl_file, audit_logger=audit_logger)
+    logger.info("ACL loaded from %s (%d rules).", acl_file, len(acl.rules))
+    if audit_enabled:
+        logger.debug("ACL audit callback installed (include_denied=%s).", include_denied)
+    else:
+        logger.debug("acl.audit.enabled is false — no audit callback installed.")
     return acl
 
 

{apcore_cli-0.12.0 → apcore_cli-0.12.2}/tests/test_acl_loader.py

@@ -659,8 +659,8 @@ class TestAuditWiring:
         real_load = _ACL.load
         captured: dict[str, object] = {}
 
-        def _spy(path: str):
-            result = real_load(path)
+        def _spy(path: str, audit_logger=None):
+            result = real_load(path, audit_logger=audit_logger)
             captured["acl"] = result
             return result
 
@@ -678,14 +678,20 @@ class TestAuditWiring:
         assert acl.check_access("@external", "db.migrate", None).access == "allow"
         assert _audit_records(audit_path) == []
 
-    def test_auditing_path_rebuilds_and_documents_the_reload_cost(self, workdir):
-        """§4.8 requirement 2 — accepted, and pinned so it cannot be silent."""
-        from apcore.errors import ACLRuleError
+    def test_auditing_path_reload_works(self, workdir, audit_path):
+        """§4.8 requirement 2, updated for apcore 0.31.0 (D-66).
 
+        ``ACL.load`` now takes ``audit_logger`` directly, so the auditing path
+        no longer rebuilds the ACL — ``reload()`` stays available, and the
+        installed audit callback survives it (apcore's own §6.3.2
+        requirement 7).
+        """
         _write_acl_dir(workdir)
-        rebuilt = load_cli_acl(str(workdir / "acl"), audit_enabled=True)
-        with pytest.raises(ACLRuleError, match="was not loaded from a YAML file"):
-            rebuilt.reload()
+        acl = load_cli_acl(str(workdir / "acl"), audit_enabled=True)
+        acl.reload()
+
+        acl.check_access("@external", "system.control.disable", None)
+        assert [r["decision"] for r in _audit_records(audit_path)] == ["deny"]
 
     def test_allow_default_survives_the_rebuild(self, workdir, audit_path):
         """T-ACL-27b: `default_effect: allow` + auditing enabled.

{apcore_cli-0.12.0 → apcore_cli-0.12.2}/tests/test_openapi_cmd.py

@@ -1,9 +1,11 @@
 """FE-15a ``apcli openapi`` subcommand group.
 
-Covers T-OAPI-01..14, 18..27 — everything the CLI layer owns. Module-ID
+Covers T-OAPI-01..14, 18..28 — everything the CLI layer owns. Module-ID
 derivation itself is the toolkit's conformance corpus and is deliberately not
 re-tested here (§1.2): these assertions check that the CLI forwards options
-verbatim and renders what comes back.
+verbatim and renders what comes back. The IDs pinned below are the ones
+apcore-toolkit >= 0.13.0 derives, normalised into apcore's Canonical ID
+alphabet (``createPets`` -> ``create_pets``, ``DELETE /pets/{petId}`` -> ``pets.pet_id.delete``).
 """
 
 from __future__ import annotations
@@ -63,6 +65,28 @@ info:
 paths: {}
 """
 
+#: A path segment beginning with a digit: the one case apcore-toolkit 0.13.0's
+#: normalisation does not repair. No operationId, so the ID is path-derived.
+_TWO_FA = """\
+openapi: "3.1.0"
+info:
+  title: TwoFactor
+  version: "1.0.0"
+paths:
+  /v1/2fa:
+    post:
+      summary: Enable 2FA
+      responses:
+        "200":
+          description: ok
+"""
+
+#: The toolkit's pinned legality warning for ``POST /v1/2fa``, byte for byte.
+_TWO_FA_WARNING = (
+    "module_id 'v1.2fa.post' is not a legal apcore module ID: segment '2fa' must match "
+    "^[a-z][a-z0-9_]*$; name this operation with a derive_module_id or transform_module hook"
+)
+
 
 @pytest.fixture
 def cli() -> click.Group:
@@ -107,16 +131,26 @@ class TestOpenapiScan:
         json_path.write_text(json.dumps(doc), encoding="utf-8")
         assert _scan_json(cli, str(json_path))["modules"] == _scan_json(cli, petstore)["modules"]
 
-    def test_operation_id_case_is_preserved(self, cli, petstore):
-        """T-OAPI-03: the CLI never post-processes the toolkit's IDs."""
+    def test_ids_equal_toolkit_derive_module_id(self, cli, petstore):
+        """T-OAPI-03: IDs equal the toolkit's derive_module_id output, unmodified by the CLI."""
+        from apcore_toolkit import derive_module_id
+
         ids = [m["module_id"] for m in _scan_json(cli, petstore)["modules"]]
-        assert "listPets" in ids
-        assert "createPets" in ids
+        doc = yaml.safe_load(_PETSTORE)
+        expected = [
+            derive_module_id(path, method, operation)
+            for path, item in doc["paths"].items()
+            for method, operation in item.items()
+        ]
+        assert ids == expected
+        # operationId `listPets` / `createPets`, snake_cased by the toolkit.
+        assert "list_pets" in ids
+        assert "create_pets" in ids
 
     def test_path_and_method_algorithm_without_operation_id(self, cli, petstore):
         """T-OAPI-04."""
         ids = [m["module_id"] for m in _scan_json(cli, petstore)["modules"]]
-        assert "pets.petid.delete" in ids
+        assert "pets.pet_id.delete" in ids
 
     def test_prefix_is_applied(self, cli, petstore):
         """T-OAPI-05."""
@@ -126,11 +160,12 @@ class TestOpenapiScan:
     def test_include_filter(self, cli, petstore):
         """T-OAPI-06."""
         ids = [m["module_id"] for m in _scan_json(cli, petstore, "--include", "^pets")["modules"]]
-        assert ids == ["pets.petid.delete"]
+        assert ids == ["pets.pet_id.delete"]
 
     def test_exclude_filter(self, cli, petstore):
         ids = [m["module_id"] for m in _scan_json(cli, petstore, "--exclude", "^pets")["modules"]]
-        assert "pets.petid.delete" not in ids
+        assert "pets.pet_id.delete" not in ids
+        assert ids == ["list_pets", "create_pets", "show_pet_by_id"]
 
     @pytest.mark.parametrize("flag", ["--include", "--exclude"])
     def test_invalid_regex_exits_2(self, cli, petstore, flag):
@@ -141,9 +176,12 @@ class TestOpenapiScan:
 
     def test_no_deprecated_omits_deprecated_operations(self, cli, petstore):
         """T-OAPI-08."""
+        # Without the flag the deprecated operation is present, so its absence
+        # below is the flag's doing rather than a mismatched name.
+        assert "show_pet_by_id" in [m["module_id"] for m in _scan_json(cli, petstore)["modules"]]
         ids = [m["module_id"] for m in _scan_json(cli, petstore, "--no-deprecated")["modules"]]
-        assert "showPetById" not in ids
-        assert "listPets" in ids
+        assert "show_pet_by_id" not in ids
+        assert "list_pets" in ids
 
     def test_string_false_deprecated_is_not_deprecated(self, cli, tmp_path):
         """T-OAPI-09: `deprecated: "false"` is a malformed boolean, not True."""
@@ -163,12 +201,12 @@ class TestOpenapiScan:
         path = tmp_path / "o.json"
         path.write_text(json.dumps(doc), encoding="utf-8")
         ids = [m["module_id"] for m in _scan_json(cli, str(path), "--no-deprecated")["modules"]]
-        assert ids == ["opX"]
+        assert ids == ["op_x"]
 
     def test_no_2xx_response_warns_but_keeps_the_module(self, cli, petstore):
         """T-OAPI-10."""
         payload = _scan_json(cli, petstore)
-        delete = next(m for m in payload["modules"] if m["module_id"] == "pets.petid.delete")
+        delete = next(m for m in payload["modules"] if m["module_id"] == "pets.pet_id.delete")
         assert any("no 2xx response" in w for w in delete["warnings"])
 
     def test_external_ref_warning_is_rendered_and_not_fetched(self, cli, tmp_path):
@@ -214,7 +252,7 @@ class TestOpenapiScan:
         assert all("warnings" in m for m in payload["modules"])
         assert payload["hazards"] == [
             {
-                "module_id": "createPets",
+                "module_id": "create_pets",
                 "http_method": "POST",
                 "url_path": "/pets",
                 "parameters": ["dryRun"],
@@ -226,13 +264,13 @@ class TestOpenapiScan:
         """T-OAPI-14: ScannedModule goes straight to format_modules."""
         result = CliRunner().invoke(cli, ["openapi", "scan", petstore, "--format", style])
         assert result.exit_code == 0
-        assert "listPets" in result.output
+        assert "list_pets" in result.output
 
     @pytest.mark.parametrize("style", ["csv", "yaml", "jsonl"])
     def test_tabular_styles_render(self, cli, petstore, style):
         result = CliRunner().invoke(cli, ["openapi", "scan", petstore, "--format", style])
         assert result.exit_code == 0
-        assert "listPets" in result.output
+        assert "list_pets" in result.output
 
     def test_table_renders_banner_warnings_and_hazards(self, cli, petstore):
         result = CliRunner().invoke(cli, ["openapi", "scan", petstore], env={"COLUMNS": "200"})
@@ -242,12 +280,31 @@ class TestOpenapiScan:
         assert "GET /pets" in result.output
         assert "1 warning" in result.output
         assert "cannot be proxied by FE-15b" in result.output
-        assert "createPets" in result.output
+        assert "create_pets" in result.output
 
     def test_hazards_do_not_change_the_exit_code(self, cli, petstore):
         """A partially-understood document is still a successful scan."""
         assert CliRunner().invoke(cli, ["openapi", "scan", petstore]).exit_code == 0
 
+    def test_illegal_id_warning_is_rendered_verbatim(self, cli, tmp_path):
+        """T-OAPI-28: a segment beginning with a digit is not repaired by the
+        toolkit; the module is still listed and its legality warning is
+        rendered like any other scanner warning, byte for byte, exit 0."""
+        path = tmp_path / "openapi.yaml"
+        path.write_text(_TWO_FA, encoding="utf-8")
+
+        table = CliRunner().invoke(cli, ["openapi", "scan", str(path)], env={"COLUMNS": "200"})
+        assert table.exit_code == 0, table.output
+        listing, _, warnings_block = table.output.partition("\n1 warning:\n")
+        assert "v1.2fa.post" in listing
+        # The whole line, so a renderer that ate `[a-z]` as markup would fail.
+        assert warnings_block.splitlines()[0] == "  v1.2fa.post            " + _TWO_FA_WARNING
+
+        payload = _scan_json(cli, str(path))
+        assert payload["modules"][0]["module_id"] == "v1.2fa.post"
+        assert payload["modules"][0]["warnings"] == [_TWO_FA_WARNING]
+        assert payload["hazards"] == []
+
 
 # ---------------------------------------------------------------------------
 # apcli openapi generate (§4.4)
@@ -262,10 +319,10 @@ class TestOpenapiGenerate:
         assert result.exit_code == 0, result.output
         written = sorted(p.name for p in out.glob("*.binding.yaml"))
         assert written == [
-            "createPets.binding.yaml",
-            "listPets.binding.yaml",
-            "pets.petid.delete.binding.yaml",
-            "showPetById.binding.yaml",
+            "create_pets.binding.yaml",
+            "list_pets.binding.yaml",
+            "pets.pet_id.delete.binding.yaml",
+            "show_pet_by_id.binding.yaml",
         ]
 
     def test_dry_run_lists_paths_and_writes_nothing(self, cli, petstore, tmp_path):
@@ -273,7 +330,7 @@ class TestOpenapiGenerate:
         out = tmp_path / "out"
         result = CliRunner().invoke(cli, ["openapi", "generate", petstore, "-o", str(out), "--dry-run"])
         assert result.exit_code == 0
-        assert "listPets.binding.yaml" in result.output
+        assert "list_pets.binding.yaml" in result.output
         assert not out.exists()
 
     def test_artifact_carries_an_intact_routing_contract(self, cli, petstore, tmp_path):
@@ -283,14 +340,15 @@ class TestOpenapiGenerate:
         out = tmp_path / "out"
         CliRunner().invoke(cli, ["openapi", "generate", petstore, "-o", str(out)])
 
-        raw = yaml.safe_load((out / "createPets.binding.yaml").read_text(encoding="utf-8"))
+        raw = yaml.safe_load((out / "create_pets.binding.yaml").read_text(encoding="utf-8"))
         binding = raw["bindings"][0]
         assert binding["target"] == "POST /pets"
         assert binding["metadata"]["http_method"] == "POST"
         assert binding["metadata"]["url_path"] == "/pets"
+        # The document's raw operationId, verbatim — only the module ID is normalised.
         assert binding["metadata"]["openapi"]["operation_id"] == "createPets"
 
-        reloaded = BindingLoader().load(str(out / "createPets.binding.yaml"))
+        reloaded = BindingLoader().load(str(out / "create_pets.binding.yaml"))
         assert reloaded[0].metadata["http_method"] == "POST"
         assert reloaded[0].metadata["url_path"] == "/pets"
 
@@ -304,19 +362,24 @@ class TestOpenapiGenerate:
         """T-OAPI-21: non-destructive default, matching `apcli init`."""
         out = tmp_path / "out"
         CliRunner().invoke(cli, ["openapi", "generate", petstore, "-o", str(out)])
-        target = out / "listPets.binding.yaml"
+        target = out / "list_pets.binding.yaml"
+        # The first run wrote this very file, so the sentinel below sits on a
+        # name the second run will actually try to write.
+        assert target.is_file()
         target.write_text("SENTINEL", encoding="utf-8")
 
         result = CliRunner().invoke(cli, ["openapi", "generate", petstore, "-o", str(out)])
         assert result.exit_code == 0
         assert "already exists" in result.output
+        assert f"{target} already exists" in result.output
         assert target.read_text(encoding="utf-8") == "SENTINEL"
 
     def test_force_overwrites(self, cli, petstore, tmp_path):
         """T-OAPI-22."""
         out = tmp_path / "out"
         CliRunner().invoke(cli, ["openapi", "generate", petstore, "-o", str(out)])
-        target = out / "listPets.binding.yaml"
+        target = out / "list_pets.binding.yaml"
+        assert target.is_file()
         target.write_text("SENTINEL", encoding="utf-8")
 
         result = CliRunner().invoke(cli, ["openapi", "generate", petstore, "-o", str(out), "--force"])
@@ -392,9 +455,9 @@ class TestOpenapiGenerate:
         gen = CliRunner().invoke(
             cli, ["openapi", "generate", petstore, "-o", str(tmp_path / "out")], env={"COLUMNS": "200"}
         )
-        assert "createPets" in scan.output
+        assert "create_pets" in scan.output
         assert "cannot be proxied by FE-15b" in gen.output
-        assert "createPets" in gen.output
+        assert "create_pets" in gen.output
 
     def test_missing_source_exits_47(self, cli, tmp_path):
         result = CliRunner().invoke(
@@ -531,18 +594,18 @@ class TestOpenapiGenerateDryRunAndVerification:
     def test_dry_run_does_not_list_a_preexisting_file_as_would_write(self, cli, petstore, tmp_path):
         out = tmp_path / "out"
         out.mkdir()
-        (out / "listPets.binding.yaml").write_text("SENTINEL", encoding="utf-8")
+        (out / "list_pets.binding.yaml").write_text("SENTINEL", encoding="utf-8")
 
         result = CliRunner().invoke(cli, ["openapi", "generate", petstore, "-o", str(out), "--dry-run"])
         assert result.exit_code == 0, result.output
         would_write_lines = [line for line in result.output.splitlines() if line.startswith("Would write")]
-        assert not any("listPets.binding.yaml" in line for line in would_write_lines)
-        assert any("createPets.binding.yaml" in line for line in would_write_lines)
+        assert not any("list_pets.binding.yaml" in line for line in would_write_lines)
+        assert any("create_pets.binding.yaml" in line for line in would_write_lines)
         assert "3 file(s) would be written" in result.output
         assert "1 skipped" in result.output
         # --dry-run still writes nothing.
-        assert (out / "listPets.binding.yaml").read_text(encoding="utf-8") == "SENTINEL"
-        assert not (out / "createPets.binding.yaml").exists()
+        assert (out / "list_pets.binding.yaml").read_text(encoding="utf-8") == "SENTINEL"
+        assert not (out / "create_pets.binding.yaml").exists()
 
     def test_verification_failure_warns_and_fails_and_is_excluded_from_count(
         self, cli, petstore, tmp_path, monkeypatch

{apcore_cli-0.12.0 → apcore_cli-0.12.2}/tests/test_openapi_source.py

@@ -180,7 +180,7 @@ class TestDetectProxyHazards:
         hazards = detect_proxy_hazards(spec, modules)
         assert len(hazards) == 1
         hazard = hazards[0]
-        assert hazard.module_id == "createPets"
+        assert hazard.module_id == "create_pets"
         assert hazard.http_method == "POST"
         assert hazard.url_path == "/pets"
         assert hazard.parameters == ("dryRun", "notify")
@@ -301,7 +301,9 @@ class TestDetectProxyHazards:
     def test_filtered_out_operations_produce_no_hazard(self, tmp_path):
         """An operation with no module is nothing FE-15b could misroute."""
         spec = load_openapi_source(_write(tmp_path, "o.yaml", _PETSTORE_YAML))
-        modules = OpenAPIScanner().scan(spec, include="^listPets$")
+        modules = OpenAPIScanner().scan(spec, include="^list_pets$")
+        # The filter kept GET /pets and dropped POST /pets, the one hazard.
+        assert [m.module_id for m in modules] == ["list_pets"]
         assert detect_proxy_hazards(spec, modules) == []
 
     def test_empty_and_non_dict_specs_are_safe(self):