semblance-databricks 0.1.0__py3-none-any.whl

semblance_databricks/__init__.py

@@ -0,0 +1,19 @@
+"""
+Unofficial local simulation of selected Databricks workspace REST operations.
+
+Not affiliated with, endorsed by, or equivalent to Databricks.
+"""
+
+from semblance_databricks.app import DatabricksMock
+from semblance_databricks.config import DatabricksMockConfig, TokenGrant
+from semblance_databricks.fixtures.loaders import load_bundled_fixture
+from semblance_databricks.testing import DatabricksMockContext, databricks_test_client
+
+__all__ = [
+    "DatabricksMock",
+    "DatabricksMockConfig",
+    "DatabricksMockContext",
+    "TokenGrant",
+    "databricks_test_client",
+    "load_bundled_fixture",
+]

semblance_databricks/app.py

@@ -0,0 +1,104 @@
+"""DatabricksMock factory and ASGI construction."""
+
+from __future__ import annotations
+
+import random
+from collections.abc import Callable
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as pkg_version
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
+
+from semblance_databricks.auth import DatabricksMiddleware
+from semblance_databricks.compatibility import manifest_json
+from semblance_databricks.config import DatabricksMockConfig
+from semblance_databricks.errors import register_exception_handlers
+from semblance_databricks.fixtures.loaders import (
+    apply_fixture,
+    bundled_acme_path,
+    load_fixture_file,
+)
+from semblance_databricks.ids import PageTokenCodec, token_secret
+from semblance_databricks.services.clusters import create_clusters_router
+from semblance_databricks.services.dbfs import create_dbfs_router
+from semblance_databricks.services.dbsql import create_dbsql_router
+from semblance_databricks.services.jobs import create_jobs_router
+from semblance_databricks.services.permissions import create_permissions_router
+from semblance_databricks.services.secrets import create_secrets_router
+from semblance_databricks.services.workspace import create_workspace_router
+from semblance_databricks.state import DatabricksState
+
+_BUNDLED_FIXTURES = {"acme": bundled_acme_path}
+
+
+def _distribution_version() -> str:
+    try:
+        return pkg_version("semblance-databricks")
+    except PackageNotFoundError:
+        return "0.1.0"
+
+
+class DatabricksMock:
+    """Fixture-backed local simulation of selected Databricks REST operations."""
+
+    def __init__(self, config: DatabricksMockConfig | None = None) -> None:
+        self.config = config or DatabricksMockConfig()
+        self.state = DatabricksState(seed=self.config.seed)
+        self.page_token_codec = PageTokenCodec(token_secret(self.config.seed))
+        self._rng = random.Random(self.config.seed)
+
+    def load_fixture(self, path: str | Path) -> DatabricksMock:
+        self.state.clear()
+        doc = load_fixture_file(path)
+        apply_fixture(doc, self.state)
+        return self
+
+    def load_bundled_fixture(self, name: str = "acme") -> DatabricksMock:
+        """Load a fixture shipped with the package (currently ``acme``)."""
+        loader = _BUNDLED_FIXTURES.get(name)
+        if loader is None:
+            known = ", ".join(sorted(_BUNDLED_FIXTURES))
+            raise ValueError(
+                f"unknown bundled fixture {name!r}; expected one of: {known}"
+            )
+        return self.load_fixture(loader())
+
+    def tick(self) -> None:
+        """Advance virtual-clock cluster and run state machines."""
+        self.state.tick()
+
+    def register_statement(self, key: str, fn: Callable[..., Any]) -> None:
+        """Register an allow-listed callback keyed by SQL text or warehouse id."""
+        self.state.statement_callbacks[key] = fn
+
+    def as_fastapi(self) -> FastAPI:
+        app = FastAPI(
+            title="semblance-databricks",
+            description=(
+                "Unofficial local simulation of selected Databricks workspace "
+                "REST operations. Not affiliated with Databricks."
+            ),
+            version=_distribution_version(),
+        )
+        app.state.databricks_mock = self
+        register_exception_handlers(app)
+        app.add_middleware(
+            DatabricksMiddleware,
+            config=self.config,
+            rng=self._rng,
+        )
+        app.include_router(create_clusters_router())
+        app.include_router(create_jobs_router())
+        app.include_router(create_workspace_router())
+        app.include_router(create_dbsql_router())
+        app.include_router(create_secrets_router())
+        app.include_router(create_dbfs_router())
+        app.include_router(create_permissions_router())
+
+        @app.get("/.well-known/semblance-databricks-compat.json")
+        def compatibility() -> dict[str, Any]:
+            return manifest_json()
+
+        return app

semblance_databricks/auth.py

@@ -0,0 +1,145 @@
+"""Auth, request-id, latency, error injection, and rate-limit middleware."""
+
+from __future__ import annotations
+
+import asyncio
+import random
+import time
+from collections import defaultdict
+from collections.abc import Callable
+from threading import Lock
+from typing import Any
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+
+from semblance_databricks.config import DatabricksMockConfig
+from semblance_databricks.errors import databricks_error_body
+
+REQUEST_ID_HEADER = "x-databricks-request-id"
+ORG_ID_HEADER = "x-databricks-org-id"
+
+
+class _SlidingWindow:
+    def __init__(self) -> None:
+        self._timestamps: dict[tuple[str, str], list[float]] = defaultdict(list)
+        self._lock = Lock()
+
+    def allow(self, path: str, method: str, limit: float) -> bool:
+        if limit <= 0:
+            return True
+        now = time.monotonic()
+        key = (path, method)
+        with self._lock:
+            ts_list = self._timestamps[key]
+            ts_list[:] = [t for t in ts_list if now - t < 1.0]
+            if len(ts_list) >= limit:
+                return False
+            ts_list.append(now)
+        return True
+
+
+def _bearer_token(header: str | None) -> str | None:
+    if header is None or header == "":
+        return None
+    parts = header.split(None, 1)
+    if len(parts) != 2 or parts[0].lower() != "bearer":
+        raise ValueError("malformed")
+    token = parts[1].strip()
+    if not token:
+        raise ValueError("empty")
+    return token
+
+
+class DatabricksMiddleware(BaseHTTPMiddleware):
+    def __init__(
+        self,
+        app: Any,
+        config: DatabricksMockConfig,
+        rng: random.Random,
+    ) -> None:
+        super().__init__(app)
+        self._config = config
+        self._rng = rng
+        self._limiter = _SlidingWindow()
+        self._req_n = 0
+
+    async def dispatch(
+        self, request: Request, call_next: Callable[[Request], Any]
+    ) -> Response:
+        incoming = request.headers.get(REQUEST_ID_HEADER)
+        self._req_n += 1
+        request_id = incoming if incoming else f"req-{self._config.seed}-{self._req_n}"
+        request.state.request_id = request_id
+
+        if self._config.rate_limit is not None:
+            if not self._limiter.allow(
+                request.url.path, request.method, self._config.rate_limit
+            ):
+                response = JSONResponse(
+                    status_code=429,
+                    content=databricks_error_body(
+                        "REQUEST_LIMIT_EXCEEDED", "Rate limit exceeded"
+                    ),
+                )
+                self._stamp(response, request_id)
+                return response
+
+        auth_error = self._check_auth(request)
+        if auth_error is not None:
+            self._stamp(auth_error, request_id)
+            return auth_error
+
+        if self._config.latency_ms or self._config.jitter_ms:
+            delay = self._config.latency_ms / 1000.0
+            if self._config.jitter_ms:
+                delay += self._rng.uniform(0, self._config.jitter_ms) / 1000.0
+            if delay > 0:
+                await asyncio.sleep(delay)
+
+        if self._config.error_rate > 0 and self._rng.random() < self._config.error_rate:
+            codes = self._config.error_codes or [500]
+            status = self._rng.choice(codes)
+            response = JSONResponse(
+                status_code=status,
+                content=databricks_error_body("INTERNAL_ERROR", "Injected error"),
+            )
+            self._stamp(response, request_id)
+            return response
+
+        response = await call_next(request)
+        self._stamp(response, request_id)
+        return response  # type: ignore[no-any-return]
+
+    def _stamp(self, response: Response, request_id: str) -> None:
+        response.headers[REQUEST_ID_HEADER] = request_id
+        if self._config.org_id:
+            response.headers[ORG_ID_HEADER] = self._config.org_id
+
+    def _check_auth(self, request: Request) -> JSONResponse | None:
+        mode = self._config.auth
+        if mode == "disabled":
+            return None
+        header = request.headers.get("authorization")
+        try:
+            token = _bearer_token(header)
+        except ValueError:
+            return JSONResponse(
+                status_code=401,
+                content=databricks_error_body("UNAUTHENTICATED", "Invalid credentials"),
+            )
+        if mode == "optional":
+            return None
+        if token is None:
+            return JSONResponse(
+                status_code=401,
+                content=databricks_error_body("UNAUTHENTICATED", "Missing credentials"),
+            )
+        allowed = {g.token for g in self._config.tokens}
+        if token not in allowed:
+            return JSONResponse(
+                status_code=401,
+                content=databricks_error_body("UNAUTHENTICATED", "Invalid credentials"),
+            )
+        return None

semblance_databricks/cli.py

@@ -0,0 +1,112 @@
+"""CLI: serve, validate, fixture init, operations."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from semblance_databricks.app import DatabricksMock
+from semblance_databricks.config import DatabricksMockConfig
+from semblance_databricks.fixtures.loaders import bundled_acme_path, load_fixture_file
+from semblance_databricks.registry import registered_operations
+
+
+def cmd_serve(args: argparse.Namespace) -> None:
+    seed = (
+        args.seed
+        if args.seed is not None
+        else int(os.environ.get("SEMBLANCE_DATABRICKS_SEED", "42"))
+    )
+    host = os.environ.get("SEMBLANCE_DATABRICKS_HOST", args.host)
+    config = DatabricksMockConfig(seed=seed, auth=args.auth)
+    mock = DatabricksMock(config)
+    mock.load_fixture(args.fixture or bundled_acme_path())
+    app = mock.as_fastapi()
+    try:
+        import uvicorn
+    except ImportError as exc:
+        raise SystemExit(
+            "uvicorn not found. Install semblance (pulls uvicorn)."
+        ) from exc
+    uvicorn.run(app, host=host, port=args.port)
+
+
+def cmd_validate(args: argparse.Namespace) -> None:
+    try:
+        load_fixture_file(args.fixture)
+    except Exception as exc:
+        raise SystemExit(f"Invalid fixture: {exc}") from exc
+    print("OK")
+
+
+def cmd_fixture_init(args: argparse.Namespace) -> None:
+    dest = Path(args.output)
+    if dest.exists() and not args.force:
+        raise SystemExit(f"{dest} already exists (use --force to overwrite)")
+    dest.write_text(bundled_acme_path().read_text(encoding="utf-8"), encoding="utf-8")
+    print(f"Wrote {dest}")
+
+
+def cmd_operations(_args: argparse.Namespace) -> None:
+    rows = registered_operations()
+    width = max((len(op.operation_id) for op in rows), default=8)
+    print(f"{'operation':<{width}}  {'level':<16}  method  path")
+    for op in rows:
+        print(
+            f"{op.operation_id:<{width}}  {op.support_level:<16}  "
+            f"{op.method:<6}  {op.path}"
+        )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="semblance-databricks",
+        description=(
+            "Unofficial local Databricks workspace REST mock. "
+            "Not affiliated with Databricks."
+        ),
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    serve = sub.add_parser("serve", help="Run a local mock server")
+    serve.add_argument(
+        "--fixture",
+        default=None,
+        help="YAML or JSON fixture path (default: bundled acme example)",
+    )
+    serve.add_argument("--host", default="127.0.0.1")
+    serve.add_argument("--port", type=int, default=8766)
+    serve.add_argument("--seed", type=int, default=None)
+    serve.add_argument(
+        "--auth",
+        default="optional",
+        choices=["disabled", "optional", "strict"],
+    )
+    serve.set_defaults(func=cmd_serve)
+
+    validate = sub.add_parser("validate", help="Validate a fixture without serving")
+    validate.add_argument("fixture")
+    validate.set_defaults(func=cmd_validate)
+
+    init = sub.add_parser("fixture", help="Fixture helpers")
+    init_sub = init.add_subparsers(dest="fixture_command", required=True)
+    init_cmd = init_sub.add_parser("init", help="Write the bundled example fixture")
+    init_cmd.add_argument("--output", required=True)
+    init_cmd.add_argument("--force", action="store_true")
+    init_cmd.set_defaults(func=cmd_fixture_init)
+
+    ops = sub.add_parser("operations", help="Print the compatibility table")
+    ops.set_defaults(func=cmd_operations)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

semblance_databricks/compatibility.py

@@ -0,0 +1,30 @@
+"""Load and publish the per-operation compatibility manifest."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+_MANIFEST_PATH = Path(__file__).resolve().parent / "compatibility.yaml"
+
+
+@lru_cache(maxsize=1)
+def load_manifest() -> dict[str, Any]:
+    data = yaml.safe_load(_MANIFEST_PATH.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError("compatibility.yaml must be a mapping")
+    return data
+
+
+def manifest_json() -> dict[str, Any]:
+    return load_manifest()
+
+
+def operations_table() -> list[dict[str, Any]]:
+    ops = load_manifest().get("operations", [])
+    if not isinstance(ops, list):
+        return []
+    return [op for op in ops if isinstance(op, dict)]

semblance_databricks/compatibility.yaml

@@ -0,0 +1,269 @@
+packageVersion: "0.1.0"
+documentedAt: "2026-08-19"
+source: "https://docs.databricks.com/api/workspace/"
+operations:
+  - operationId: ListClusters
+    method: GET
+    path: /api/2.1/clusters/list
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/clusters/list
+    tests:
+      - tests/contract/test_clusters.py::test_list_clusters
+  - operationId: GetCluster
+    method: GET
+    path: /api/2.1/clusters/get
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/clusters/get
+    tests:
+      - tests/contract/test_clusters.py::test_get_cluster
+  - operationId: ListJobs
+    method: GET
+    path: /api/2.2/jobs/list
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/list
+    tests:
+      - tests/contract/test_jobs.py::test_list_jobs
+  - operationId: GetJob
+    method: GET
+    path: /api/2.2/jobs/get
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/get
+    tests:
+      - tests/contract/test_jobs.py::test_get_job
+  - operationId: GetRun
+    method: GET
+    path: /api/2.2/jobs/runs/get
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/getrun
+    tests:
+      - tests/contract/test_runs.py::test_get_run
+  - operationId: GetStatus
+    method: GET
+    path: /api/2.0/workspace/get-status
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/workspace/getstatus
+    tests:
+      - tests/contract/test_workspace.py::test_get_status
+  - operationId: CurrentUserMe
+    method: GET
+    path: /api/2.0/preview/scim/v2/Me
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/currentuser/
+    tests:
+      - tests/contract/test_workspace.py::test_me
+  - operationId: CreateCluster
+    method: POST
+    path: /api/2.1/clusters/create
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/clusters/create
+    tests:
+      - tests/contract/test_clusters.py::test_create_cluster_virtual_clock
+  - operationId: EditCluster
+    method: POST
+    path: /api/2.1/clusters/edit
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/clusters/edit
+    tests:
+      - tests/contract/test_clusters.py::test_edit_cluster
+  - operationId: DeleteCluster
+    method: POST
+    path: /api/2.1/clusters/delete
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/clusters/delete
+    tests:
+      - tests/contract/test_clusters.py::test_delete_cluster
+  - operationId: RestartCluster
+    method: POST
+    path: /api/2.1/clusters/restart
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/clusters/restart
+    tests:
+      - tests/contract/test_clusters.py::test_restart_cluster
+  - operationId: PermanentDeleteCluster
+    method: POST
+    path: /api/2.1/clusters/permanent-delete
+    supportLevel: stub
+    docsUrl: https://docs.databricks.com/api/workspace/clusters/permanentdelete
+    tests:
+      - tests/contract/test_unsupported.py::test_permanent_delete_strict_501
+  - operationId: CreateJob
+    method: POST
+    path: /api/2.2/jobs/create
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/create
+    tests:
+      - tests/contract/test_jobs.py::test_create_job
+  - operationId: ResetJob
+    method: POST
+    path: /api/2.2/jobs/reset
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/reset
+    tests:
+      - tests/contract/test_jobs.py::test_reset_job
+  - operationId: DeleteJob
+    method: POST
+    path: /api/2.2/jobs/delete
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/delete
+    tests:
+      - tests/contract/test_jobs.py::test_delete_job
+  - operationId: SubmitRun
+    method: POST
+    path: /api/2.2/jobs/runs/submit
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/submit
+    tests:
+      - tests/contract/test_runs.py::test_submit_and_cancel
+  - operationId: CancelRun
+    method: POST
+    path: /api/2.2/jobs/runs/cancel
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/cancelrun
+    tests:
+      - tests/contract/test_runs.py::test_submit_and_cancel
+  - operationId: ListWarehouses
+    method: GET
+    path: /api/2.0/sql/warehouses
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/warehouses/list
+    tests:
+      - tests/contract/test_warehouses.py::test_list_warehouses
+  - operationId: GetWarehouse
+    method: GET
+    path: /api/2.0/sql/warehouses/{id}
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/warehouses/get
+    tests:
+      - tests/contract/test_warehouses.py::test_get_warehouse
+  - operationId: CreateWarehouse
+    method: POST
+    path: /api/2.0/sql/warehouses
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/warehouses/create
+    tests:
+      - tests/contract/test_warehouses.py::test_create_delete_warehouse
+  - operationId: DeleteWarehouse
+    method: DELETE
+    path: /api/2.0/sql/warehouses/{id}
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/warehouses/delete
+    tests:
+      - tests/contract/test_warehouses.py::test_create_delete_warehouse
+  - operationId: PutSecret
+    method: POST
+    path: /api/2.0/secrets/put
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/secrets/putsecret
+    tests:
+      - tests/contract/test_secrets.py::test_put_and_list_keys_only
+  - operationId: ListSecrets
+    method: GET
+    path: /api/2.0/secrets/list
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/secrets/listsecrets
+    tests:
+      - tests/contract/test_secrets.py::test_list_secret_keys
+  - operationId: ListSecretScopes
+    method: GET
+    path: /api/2.0/secrets/scopes/list
+    supportLevel: exact
+    docsUrl: https://docs.databricks.com/api/workspace/secrets/listscopes
+    tests:
+      - tests/contract/test_secrets.py::test_list_scopes
+  - operationId: InstallLibraries
+    method: POST
+    path: /api/2.0/libraries/install
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/libraries/installlibraries
+    tests:
+      - tests/contract/test_libraries.py::test_install_uninstall
+  - operationId: UninstallLibraries
+    method: POST
+    path: /api/2.0/libraries/uninstall
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/libraries/uninstalllibraries
+    tests:
+      - tests/contract/test_libraries.py::test_install_uninstall
+  - operationId: GetRunOutput
+    method: GET
+    path: /api/2.2/jobs/runs/get-output
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/jobs/getrunoutput
+    tests:
+      - tests/contract/test_runs.py::test_get_output
+  - operationId: ListClusterEvents
+    method: POST
+    path: /api/2.1/clusters/events
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/clusters/events
+    tests:
+      - tests/contract/test_events.py::test_cluster_events
+  - operationId: ListDbfs
+    method: GET
+    path: /api/2.0/dbfs/list
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/dbfs/list
+    tests:
+      - tests/contract/test_dbfs.py::test_list_dbfs
+  - operationId: ReadDbfs
+    method: GET
+    path: /api/2.0/dbfs/read
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/dbfs/read
+    tests:
+      - tests/contract/test_dbfs.py::test_read_dbfs
+  - operationId: AddBlock
+    method: POST
+    path: /api/2.0/dbfs/add-block
+    supportLevel: stub
+    docsUrl: https://docs.databricks.com/api/workspace/dbfs/addblock
+    tests:
+      - tests/contract/test_unsupported.py::test_add_block_strict_501
+  - operationId: GetPermissions
+    method: GET
+    path: /api/2.0/permissions/{object_type}/{object_id}
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/permissions/
+    tests:
+      - tests/contract/test_permissions.py::test_get_permissions
+  - operationId: UpdatePermissions
+    method: PATCH
+    path: /api/2.0/permissions/{object_type}/{object_id}
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/permissions/
+    tests:
+      - tests/contract/test_permissions.py::test_patch_permissions
+  - operationId: ExecuteStatement
+    method: POST
+    path: /api/2.0/sql/statements
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/statementexecution/execute
+    tests:
+      - tests/contract/test_sql.py::test_execute_statement
+  - operationId: GetStatement
+    method: GET
+    path: /api/2.0/sql/statements/{statement_id}
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/statementexecution/getstatement
+    tests:
+      - tests/contract/test_sql.py::test_get_statement
+  - operationId: ListJobs21
+    method: GET
+    path: /api/2.1/jobs/list
+    supportLevel: representative
+    notes: Jobs 2.1 alias of 2.2
+    tests:
+      - tests/contract/test_jobs.py::test_jobs_21_alias
+  - operationId: PutDbfs
+    method: POST
+    path: /api/2.0/dbfs/put
+    supportLevel: representative
+    docsUrl: https://docs.databricks.com/api/workspace/dbfs/put
+    tests:
+      - tests/contract/test_dbfs.py::test_put_and_read_base64
+  - operationId: Jobs20Unsupported
+    method: GET
+    path: /api/2.0/jobs/list
+    supportLevel: unsupported
+    tests:
+      - tests/contract/test_unsupported.py::test_unknown_path_404