@fabricorg/databricks-testkit 0.1.0

package/dist/index.js

@@ -0,0 +1,690 @@
+import { compareToGolden } from './chunk-MLBZCHRM.js';
+export { compareToGolden } from './chunk-MLBZCHRM.js';
+export { createDuckDbContext, normalizeRow } from './chunk-7JVDOSBO.js';
+import { createClientFromEnv, createWorkspaceContext, resolveTokenProvider } from './chunk-FBADA7LQ.js';
+export { createClientFromEnv, createWorkspaceContext, parseStatementRows, resolveTokenProvider, toNamedParameters } from './chunk-FBADA7LQ.js';
+export { parseFixtureColumns, resolveFixtureRows } from './chunk-F3KU6VZS.js';
+import { mkdir, writeFile, readFile } from 'fs/promises';
+import { dirname, resolve, basename } from 'path';
+import { waitForDatabricksRun } from '@fabric-harness/databricks';
+export { waitForDatabricksRun, waitForDatabricksStatement } from '@fabric-harness/databricks';
+import { LakebaseDatabaseProvider, exchangeLakebaseCredential } from '@fabricorg/experiments-db-pool';
+import { randomUUID } from 'crypto';
+
+// src/context.ts
+function resolveProfile(env = process.env) {
+  const profile = env.DBX_TEST_PROFILE ?? "local";
+  if (profile !== "local" && profile !== "live") {
+    throw new Error(`DBX_TEST_PROFILE must be 'local' or 'live', got '${profile}'`);
+  }
+  if (profile === "live" && env.DBX_TEST_LIVE !== "1") {
+    throw new Error(
+      "DBX_TEST_PROFILE=live requires DBX_TEST_LIVE=1 (live suites are always gated)"
+    );
+  }
+  return profile;
+}
+async function createExecutionContext(options = {}) {
+  const env = options.env ?? process.env;
+  const profile = options.profile ?? resolveProfile(env);
+  if (profile === "local") {
+    const { createDuckDbContext: createDuckDbContext2 } = await import('./duckdb-context-FX23RUBV.js');
+    return createDuckDbContext2({ schema: options.schema });
+  }
+  const { createWorkspaceContext: createWorkspaceContext2 } = await import('./workspace-context-AIUYISUS.js');
+  return createWorkspaceContext2({
+    env,
+    schema: options.schema,
+    ...options.onStatement ? { onStatement: options.onStatement } : {}
+  });
+}
+
+// src/assert.ts
+function expectTable(ctx, table) {
+  const target = ctx.qual(table);
+  return {
+    async toHaveRowCount(expected) {
+      const rows = await ctx.query(`SELECT COUNT(*) AS n FROM ${target}`);
+      const actual = Number(rows[0]?.n ?? Number.NaN);
+      if (actual !== expected) {
+        throw new Error(`Expected ${target} to have ${expected} rows, found ${actual}`);
+      }
+    },
+    /** Every partial row must match at least one table row on its own keys. */
+    async toContainRows(partials) {
+      const rows = await ctx.query(`SELECT * FROM ${target}`);
+      for (const partial of partials) {
+        const hit = rows.some(
+          (row) => Object.entries(partial).every(([key, value]) => looselyEqual(row[key], value))
+        );
+        if (!hit) {
+          throw new Error(
+            `Expected ${target} to contain a row matching ${JSON.stringify(partial)}; have ${rows.length} rows: ${JSON.stringify(rows.slice(0, 5))}${rows.length > 5 ? " \u2026" : ""}`
+          );
+        }
+      }
+    },
+    /**
+     * Compare `SELECT * ORDER BY <orderBy>` against a committed golden JSON
+     * file. Set DBX_TEST_UPDATE_GOLDEN=1 to (re)write the golden instead —
+     * a reviewable, versioned event.
+     */
+    async toMatchGolden(goldenPath, options = {}) {
+      const orderBy = options.orderBy ? ` ORDER BY ${options.orderBy}` : "";
+      const rows = await ctx.query(`SELECT * FROM ${target}${orderBy}`);
+      await compareToGolden(goldenPath, rows, `table ${target}`);
+    }
+  };
+}
+async function expectQueryToMatchGolden(ctx, sql, params, goldenPath) {
+  const rows = await ctx.query(sql, params);
+  await compareToGolden(goldenPath, rows, "query");
+}
+function looselyEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a === "number" && typeof b === "number") return Math.abs(a - b) < 1e-9;
+  if (typeof a === "string" && typeof b === "string") {
+    return a.replace("T", " ").replace(/(\.\d+)?Z?$/, "") === b.replace("T", " ").replace(/(\.\d+)?Z?$/, "");
+  }
+  return false;
+}
+
+// src/mock-client.ts
+function createMockDatabricksClient() {
+  const queues = { GET: [], POST: [] };
+  const calls = [];
+  function take(method, path) {
+    const index = queues[method].findIndex((q) => path.startsWith(q.pathPrefix));
+    if (index === -1) {
+      throw new Error(
+        `MockDatabricksClient: no queued ${method} response for ${path}. Queued prefixes: ${queues[method].map((q) => q.pathPrefix).join(", ") || "(none)"}`
+      );
+    }
+    return queues[method].splice(index, 1)[0];
+  }
+  const client = {
+    async get(path, query) {
+      calls.push({ method: "GET", path, query });
+      const queued = take("GET", path);
+      if (queued.error) throw queued.error;
+      return queued.response;
+    },
+    async post(path, body, query) {
+      calls.push({ method: "POST", path, body, query });
+      const queued = take("POST", path);
+      if (queued.error) throw queued.error;
+      return queued.response;
+    },
+    queue(method, pathPrefix, response) {
+      queues[method].push({ pathPrefix, response });
+      return client;
+    },
+    queueError(method, pathPrefix, error) {
+      queues[method].push({ pathPrefix, error });
+      return client;
+    },
+    calls,
+    callsTo(method, pathPrefix) {
+      return calls.filter((c) => c.method === method && c.path.startsWith(pathPrefix));
+    }
+  };
+  return client;
+}
+function defineLiveSuite(spec) {
+  return { run: (runtime) => runLiveSuite(spec, runtime) };
+}
+async function runLiveSuite(spec, runtime = {}) {
+  const env = spec.env ?? process.env;
+  if (env.DBX_TEST_LIVE !== "1") return void 0;
+  const required2 = [...spec.required ?? []];
+  const known = new Set(spec.checks.map((check) => check.id));
+  for (const id of required2) {
+    if (!known.has(id)) throw new Error(`Required live check '${id}' is not defined`);
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const ownedWarehouse = runtime.warehouse === void 0;
+  const client = runtime.client ?? createClientFromEnv(env);
+  const warehouse = runtime.warehouse ?? await createWorkspaceContext({ env, client });
+  const results = [];
+  try {
+    for (const check of spec.checks) {
+      if (check.configured && !check.configured(env)) {
+        results.push({
+          id: check.id,
+          description: check.description,
+          status: "not-configured",
+          durationMs: 0
+        });
+        continue;
+      }
+      const before = performance.now();
+      try {
+        const details = await check.run({ env, warehouse, client });
+        results.push({
+          id: check.id,
+          description: check.description,
+          status: "pass",
+          durationMs: Math.round(performance.now() - before),
+          ...details === void 0 ? {} : { details: redactValue(details, env) }
+        });
+      } catch (error) {
+        results.push({
+          id: check.id,
+          description: check.description,
+          status: "fail",
+          durationMs: Math.round(performance.now() - before),
+          error: redactText(error instanceof Error ? error.message : String(error), env)
+        });
+      }
+    }
+  } finally {
+    if (ownedWarehouse) await warehouse.close();
+  }
+  const success = required2.every(
+    (id) => results.find((result) => result.id === id)?.status === "pass"
+  );
+  const evidence = {
+    schemaVersion: 1,
+    kind: "databricks-live-suite",
+    startedAt,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    success,
+    required: required2,
+    results
+  };
+  if (spec.evidencePath)
+    await writeReport(spec.evidencePath, `${JSON.stringify(evidence, null, 2)}
+`);
+  if (spec.junitPath) await writeReport(spec.junitPath, renderJUnit(evidence));
+  return evidence;
+}
+async function writeReport(path, contents) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, contents, "utf8");
+}
+function redactText(text, env) {
+  let output = text;
+  for (const [name, value] of Object.entries(env)) {
+    if (!value || value.length < 6 || !/(TOKEN|SECRET|PASSWORD|BEARER|KEY)/i.test(name)) continue;
+    output = output.split(value).join("[REDACTED]");
+  }
+  return output;
+}
+function redactValue(value, env) {
+  return JSON.parse(redactText(JSON.stringify(value), env));
+}
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function renderJUnit(evidence) {
+  const failures = evidence.results.filter((result) => result.status === "fail").length;
+  const skipped = evidence.results.filter((result) => result.status === "not-configured").length;
+  const seconds = evidence.results.reduce((sum, result) => sum + result.durationMs, 0) / 1e3;
+  const cases = evidence.results.map((result) => {
+    const body = result.status === "fail" ? `<failure message="${xml(result.error ?? "check failed")}"/>` : result.status === "not-configured" ? '<skipped message="not configured"/>' : "";
+    return `  <testcase classname="databricks-live" name="${xml(result.id)}" time="${result.durationMs / 1e3}">${body}</testcase>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<testsuite name="databricks-live" tests="${evidence.results.length}" failures="${failures}" skipped="${skipped}" time="${seconds}">
+${cases}
+</testsuite>
+`;
+}
+
+// src/pollers.ts
+var TERMINAL_PIPELINE_STATES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "CANCELED"]);
+async function waitForPipelineUpdate(client, pipelineId, updateId, options = {}) {
+  const deadline = Date.now() + (options.timeoutMs ?? 9e5);
+  const interval = options.pollIntervalMs ?? 1e4;
+  const path = `/api/2.0/pipelines/${encodeURIComponent(pipelineId)}/updates/${encodeURIComponent(updateId)}`;
+  let update = await client.get(path);
+  while (!TERMINAL_PIPELINE_STATES.has(update.update?.state ?? "") && Date.now() < deadline) {
+    if (options.signal?.aborted) throw new Error(`Pipeline update ${updateId} was aborted`);
+    await abortableDelay(interval, options.signal);
+    update = await client.get(path);
+  }
+  const state = update.update?.state ?? "UNKNOWN";
+  if (state !== "COMPLETED") {
+    throw new Error(`Pipeline update ${updateId} ended in ${state} (wanted COMPLETED)`);
+  }
+  return update;
+}
+function abortableDelay(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Polling aborted"));
+      return;
+    }
+    const timer = setTimeout(resolve2, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new Error("Polling aborted"));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/live-checks.ts
+function sqlRoundTripCheck() {
+  return {
+    id: "sql",
+    description: "SQL Statement Execution round-trip",
+    async run({ warehouse }) {
+      const rows = await warehouse.query("SELECT 1 AS dbx_test_ok");
+      if (Number(rows[0]?.dbx_test_ok) !== 1)
+        throw new Error("SQL round-trip returned an unexpected value");
+      return { rows: rows.length };
+    }
+  };
+}
+function assertDeltaContract(table, rows, columns) {
+  for (const expected of columns) {
+    const actual = rows.find((row) => String(row.col_name ?? row.column_name) === expected.name);
+    if (!actual) throw new Error(`Delta contract missing column '${expected.name}' in ${table}`);
+    const actualType = String(actual.data_type ?? actual.column_type ?? "").toLowerCase();
+    if (expected.type && actualType !== expected.type.toLowerCase()) {
+      throw new Error(
+        `Delta column ${expected.name} has type ${actualType}, expected ${expected.type}`
+      );
+    }
+  }
+}
+function deltaContractCheck(tableEnv = "DBX_TEST_DELTA_TABLE", columns = []) {
+  return {
+    id: "delta-contract",
+    description: "Delta table schema contract",
+    configured: (env) => Boolean(env[tableEnv]),
+    async run({ env, warehouse }) {
+      const table = env[tableEnv];
+      const rows = await warehouse.query(`DESCRIBE TABLE ${table}`);
+      assertDeltaContract(table, rows, columns);
+      return { table, columns: rows.length };
+    }
+  };
+}
+function unityCatalogAccessCheck() {
+  return {
+    id: "uc-grants",
+    description: "Unity Catalog allow/deny access assertions",
+    configured: (env) => Boolean(env.DBX_TEST_UC_ALLOWED_TABLE && env.DBX_TEST_UC_DENIED_TABLE),
+    async run({ env, warehouse }) {
+      await warehouse.query(`SELECT * FROM ${env.DBX_TEST_UC_ALLOWED_TABLE} LIMIT 1`);
+      try {
+        await warehouse.query(`SELECT * FROM ${env.DBX_TEST_UC_DENIED_TABLE} LIMIT 1`);
+      } catch (error) {
+        if (/permission.?denied|insufficient.?priv|403|unauthoriz/i.test(String(error))) {
+          return { allowed: env.DBX_TEST_UC_ALLOWED_TABLE, denied: env.DBX_TEST_UC_DENIED_TABLE };
+        }
+        throw error;
+      }
+      throw new Error(`Expected access to ${env.DBX_TEST_UC_DENIED_TABLE} to be denied`);
+    }
+  };
+}
+function jobRunCheck() {
+  return {
+    id: "jobs",
+    description: "Databricks Job run-now reaches SUCCESS",
+    configured: (env) => Boolean(env.DBX_TEST_JOB_ID),
+    async run({ env, client }) {
+      const jobId = Number(env.DBX_TEST_JOB_ID);
+      if (!Number.isFinite(jobId)) throw new Error("DBX_TEST_JOB_ID must be numeric");
+      const submitted = await client.post("/api/2.1/jobs/run-now", {
+        job_id: jobId
+      });
+      const run = await waitForDatabricksRun(client, submitted.run_id, {
+        timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+        pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+      });
+      const result = run.state?.result_state;
+      if (result !== "SUCCESS") throw new Error(`Job ${jobId} ended in ${result ?? "UNKNOWN"}`);
+      return { jobId, runId: submitted.run_id };
+    }
+  };
+}
+function pipelineRefreshCheck() {
+  return {
+    id: "pipeline",
+    description: "Lakeflow telemetry pipeline refresh reaches COMPLETED",
+    configured: (env) => Boolean(env.DBX_TEST_PIPELINE_ID),
+    async run({ env, client }) {
+      const pipelineId = env.DBX_TEST_PIPELINE_ID;
+      const submitted = await client.post(
+        `/api/2.0/pipelines/${encodeURIComponent(pipelineId)}/updates`,
+        { full_refresh: false }
+      );
+      if (!submitted.update_id) {
+        throw new Error(`Pipeline ${pipelineId} did not return an update_id`);
+      }
+      await waitForPipelineUpdate(client, pipelineId, submitted.update_id, {
+        timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+        pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+      });
+      return { pipelineId, updateId: submitted.update_id };
+    }
+  };
+}
+function notebookSubmitCheck() {
+  return {
+    id: "notebook",
+    description: "Databricks notebook submit run reaches SUCCESS",
+    configured: (env) => Boolean(env.DBX_TEST_NOTEBOOK_PATH && env.DBX_TEST_CLUSTER_ID),
+    async run({ env, client }) {
+      if (!env.DBX_TEST_NOTEBOOK_PATH || !env.DBX_TEST_CLUSTER_ID) {
+        throw new Error("Notebook submit requires DBX_TEST_NOTEBOOK_PATH and DBX_TEST_CLUSTER_ID");
+      }
+      const submitted = await client.post("/api/2.1/jobs/runs/submit", {
+        run_name: `fabric-experiments-notebook-${Date.now()}`,
+        tasks: [
+          {
+            task_key: "notebook",
+            existing_cluster_id: env.DBX_TEST_CLUSTER_ID,
+            notebook_task: { notebook_path: env.DBX_TEST_NOTEBOOK_PATH }
+          }
+        ]
+      });
+      if (!submitted.run_id) throw new Error("Notebook submit returned no run_id");
+      const run = await waitForDatabricksRun(client, submitted.run_id, {
+        timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+        pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+      });
+      const result = run.state?.result_state;
+      if (result !== "SUCCESS") throw new Error(`Notebook run ended in ${result ?? "UNKNOWN"}`);
+      return { runId: submitted.run_id, notebookPath: env.DBX_TEST_NOTEBOOK_PATH };
+    }
+  };
+}
+function dbtBuildCheck() {
+  return {
+    id: "dbt",
+    description: "Databricks dbt task reaches SUCCESS",
+    configured: (env) => Boolean(env.DBX_TEST_DBT_GIT_URL && env.DATABRICKS_WAREHOUSE_ID),
+    async run({ env, client }) {
+      if (!env.DBX_TEST_DBT_GIT_URL || !env.DATABRICKS_WAREHOUSE_ID) {
+        throw new Error("dbt build requires DBX_TEST_DBT_GIT_URL and DATABRICKS_WAREHOUSE_ID");
+      }
+      const submitted = await client.post("/api/2.1/jobs/runs/submit", {
+        run_name: `fabric-experiments-dbt-${Date.now()}`,
+        git_source: {
+          git_url: env.DBX_TEST_DBT_GIT_URL,
+          git_provider: env.DBX_TEST_DBT_GIT_PROVIDER ?? "gitHub",
+          git_branch: env.DBX_TEST_DBT_GIT_BRANCH ?? "main"
+        },
+        tasks: [
+          {
+            task_key: "dbt_build",
+            dbt_task: {
+              commands: ["dbt deps", "dbt build"],
+              warehouse_id: env.DATABRICKS_WAREHOUSE_ID,
+              ...env.DBX_TEST_DBT_PROJECT_DIR ? { project_directory: env.DBX_TEST_DBT_PROJECT_DIR } : {}
+            }
+          }
+        ]
+      });
+      if (!submitted.run_id) throw new Error("dbt submit returned no run_id");
+      const run = await waitForDatabricksRun(client, submitted.run_id, {
+        timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+        pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+      });
+      const result = run.state?.result_state;
+      if (result !== "SUCCESS") throw new Error(`dbt run ended in ${result ?? "UNKNOWN"}`);
+      return { runId: submitted.run_id, gitUrl: env.DBX_TEST_DBT_GIT_URL };
+    }
+  };
+}
+function customLiveCheck(id, description, run, configured) {
+  return { id, description, run, ...configured ? { configured } : {} };
+}
+function required(env, name) {
+  const value = env[name]?.trim();
+  if (!value) throw new Error(`${name} is required`);
+  return value;
+}
+function createLakebaseTestProvider(env, options = {}) {
+  return new LakebaseDatabaseProvider({
+    host: required(env, "DBX_TEST_LAKEBASE_HOST"),
+    database: required(env, "DBX_TEST_LAKEBASE_DATABASE"),
+    user: required(env, "DBX_TEST_LAKEBASE_USER"),
+    workspaceHost: required(env, "DATABRICKS_HOST"),
+    endpoint: required(env, "DBX_TEST_LAKEBASE_ENDPOINT"),
+    token: resolveTokenProvider(required(env, "DATABRICKS_HOST"), env, options.fetchImpl),
+    fetchImpl: options.fetchImpl,
+    poolFactory: options.poolFactory,
+    max: 1
+  });
+}
+async function workspaceToken(env, fetchImpl) {
+  const host = required(env, "DATABRICKS_HOST");
+  const provider = resolveTokenProvider(host, env, fetchImpl);
+  return typeof provider === "string" ? provider : provider();
+}
+function lakebaseCredentialCheck(options = {}) {
+  return {
+    id: "lakebase-credential",
+    description: "Lakebase OAuth credential exchange",
+    configured: (env) => Boolean(env.DBX_TEST_LAKEBASE_ENDPOINT),
+    async run({ env }) {
+      const credential = await exchangeLakebaseCredential({
+        workspaceHost: required(env, "DATABRICKS_HOST"),
+        endpoint: required(env, "DBX_TEST_LAKEBASE_ENDPOINT"),
+        workspaceToken: await workspaceToken(env, options.fetchImpl),
+        fetchImpl: options.fetchImpl
+      });
+      if (credential.expiresAt <= Date.now()) {
+        throw new Error("Lakebase credential is already expired");
+      }
+      return { expiresAt: new Date(credential.expiresAt).toISOString() };
+    }
+  };
+}
+function lakebaseRoundTripCheck(options = {}) {
+  return {
+    id: "lakebase",
+    description: "Lakebase provider query and credential refresh round-trip",
+    configured: (env) => Boolean(
+      env.DBX_TEST_LAKEBASE_ENDPOINT && env.DBX_TEST_LAKEBASE_HOST && env.DBX_TEST_LAKEBASE_DATABASE && env.DBX_TEST_LAKEBASE_USER
+    ),
+    async run({ env }) {
+      const provider = createLakebaseTestProvider(env, options);
+      try {
+        const first = await provider.getPool().query("SELECT 1 AS dbx_test_ok");
+        if (Number(first.rows[0]?.dbx_test_ok) !== 1) {
+          throw new Error("Lakebase round-trip returned an unexpected value");
+        }
+        await provider.refreshCredentials();
+        const second = await provider.getPool().query("SELECT 1 AS dbx_test_ok");
+        if (Number(second.rows[0]?.dbx_test_ok) !== 1) {
+          throw new Error("Lakebase post-refresh round-trip returned an unexpected value");
+        }
+        return { queries: 2, refreshed: true };
+      } finally {
+        await provider.close();
+      }
+    }
+  };
+}
+
+// src/databricks-http.ts
+async function databricksFetch(env, pathOrUrl, init = {}, fetchImpl = fetch) {
+  const host = env.DATABRICKS_HOST?.replace(/\/$/, "");
+  if (!host) throw new Error("DATABRICKS_HOST is required");
+  const provider = resolveTokenProvider(host, env, fetchImpl);
+  const token = typeof provider === "string" ? provider : await provider();
+  const headers = new Headers(init.headers);
+  headers.set("authorization", `Bearer ${token}`);
+  const response = await fetchImpl(
+    /^https?:\/\//.test(pathOrUrl) ? pathOrUrl : `${host}${pathOrUrl}`,
+    {
+      ...init,
+      headers
+    }
+  );
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(
+      `Databricks request failed: ${response.status} ${response.statusText}: ${body.slice(0, 500)}`
+    );
+  }
+  return response;
+}
+
+// src/platform-checks.ts
+function csv(value) {
+  return (value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+}
+function secretScopeCheck() {
+  return {
+    id: "secrets",
+    description: "Databricks secret scope contains expected keys",
+    configured: (env) => Boolean(env.DBX_TEST_SECRET_SCOPE && env.DBX_TEST_SECRET_KEYS),
+    async run({ env, client }) {
+      const scope = env.DBX_TEST_SECRET_SCOPE;
+      const expected = csv(env.DBX_TEST_SECRET_KEYS);
+      const response = await client.get("/api/2.0/secrets/list", {
+        scope
+      });
+      const actual = new Set((response.secrets ?? []).map((secret) => secret.key).filter(Boolean));
+      const missing = expected.filter((key) => !actual.has(key));
+      if (missing.length > 0) {
+        throw new Error(`Secret scope ${scope} is missing keys: ${missing.join(", ")}`);
+      }
+      return { scope, expectedKeys: expected.length };
+    }
+  };
+}
+function appHealthCheck(options = {}) {
+  return {
+    id: "app",
+    description: "Databricks App is running, bound, and healthy",
+    configured: (env) => Boolean(env.DBX_TEST_APP_NAME),
+    async run({ env, client }) {
+      const name = env.DBX_TEST_APP_NAME;
+      const app = await client.get(`/api/2.0/apps/${encodeURIComponent(name)}`);
+      if (app.app_status?.state !== "RUNNING") {
+        throw new Error(`Databricks App ${name} is ${app.app_status?.state ?? "UNKNOWN"}`);
+      }
+      const expected = csv(env.DBX_TEST_APP_RESOURCES);
+      const actual = new Set(
+        (app.resources ?? []).map((resource) => resource.name).filter(Boolean)
+      );
+      const missing = expected.filter((resource) => !actual.has(resource));
+      if (missing.length > 0) {
+        throw new Error(
+          `Databricks App ${name} is missing resource bindings: ${missing.join(", ")}`
+        );
+      }
+      const appUrl = env.DBX_TEST_APP_URL ?? app.url ?? app.app_url;
+      if (!appUrl) throw new Error(`Databricks App ${name} returned no URL`);
+      const healthUrl = new URL("/api/healthz", appUrl).toString();
+      const response = await databricksFetch(env, healthUrl, {}, options.fetchImpl);
+      const health = await response.json();
+      if (health.ok !== true && health.status !== "ok") {
+        throw new Error(`Databricks App ${name} health probe did not report ok`);
+      }
+      return { name, bindings: actual.size, health: "ok" };
+    }
+  };
+}
+function normalizeVolumeRoot(value) {
+  const normalized = value.replace(/\/$/, "");
+  if (!/^\/Volumes\/[^/]+\/[^/]+\/[^/]+$/.test(normalized)) {
+    throw new Error("DBX_TEST_VOLUME must be /Volumes/<catalog>/<schema>/<volume>");
+  }
+  return normalized;
+}
+async function ensureVolumeDirectory(env, directory, fetchImpl) {
+  await databricksFetch(env, `/api/2.0/fs/directories${directory}`, { method: "PUT" }, fetchImpl);
+}
+async function uploadVolumeFile(env, path, body, fetchImpl) {
+  await databricksFetch(
+    env,
+    `/api/2.0/fs/files${path}`,
+    { method: "PUT", body },
+    fetchImpl
+  );
+}
+async function deleteVolumeFile(env, path, fetchImpl) {
+  await databricksFetch(env, `/api/2.0/fs/files${path}`, { method: "DELETE" }, fetchImpl);
+}
+function volumeIOCheck(options = {}) {
+  return {
+    id: "volume-io",
+    description: "Unity Catalog volume Files API round-trip",
+    configured: (env) => Boolean(env.DBX_TEST_VOLUME),
+    async run({ env }) {
+      const root = normalizeVolumeRoot(env.DBX_TEST_VOLUME);
+      const prefix = (env.DBX_TEST_ENV_NAME ?? "fx-live").replace(/[^A-Za-z0-9_.-]/g, "_");
+      const id = (options.randomId ?? randomUUID)();
+      const directory = `${root}/${prefix}`;
+      const file = `${directory}/probe-${id}.txt`;
+      const filePath = `/api/2.0/fs/files${file}`;
+      const body = new TextEncoder().encode(`fabric-experiments-volume-probe:${id}`);
+      await ensureVolumeDirectory(env, directory, options.fetchImpl);
+      try {
+        await uploadVolumeFile(env, file, body, options.fetchImpl);
+        const downloaded = await databricksFetch(env, filePath, {}, options.fetchImpl);
+        const actual = new Uint8Array(await downloaded.arrayBuffer());
+        if (actual.length !== body.length || actual.some((value, index) => value !== body[index])) {
+          throw new Error("Volume round-trip returned different bytes");
+        }
+        return { volume: root, bytes: body.length };
+      } finally {
+        await deleteVolumeFile(env, file, options.fetchImpl).catch(() => void 0);
+      }
+    }
+  };
+}
+function autoLoaderIngestionCheck(options = {}) {
+  return {
+    id: "autoloader",
+    description: "Isolated Auto Loader fixture ingestion reaches Delta without rescued rows",
+    configured: (env) => Boolean(
+      env.DBX_TEST_AUTOLOADER_PIPELINE_ID && env.DBX_TEST_AUTOLOADER_TABLE && env.DBX_TEST_AUTOLOADER_FIXTURE && env.DBX_TEST_VOLUME
+    ),
+    async run({ env, client, warehouse }) {
+      const pipelineId = env.DBX_TEST_AUTOLOADER_PIPELINE_ID;
+      if (pipelineId === env.DBX_TEST_PIPELINE_ID) {
+        throw new Error("DBX_TEST_AUTOLOADER_PIPELINE_ID must not be the production pipeline");
+      }
+      const root = normalizeVolumeRoot(env.DBX_TEST_VOLUME);
+      const fixturePath = env.DBX_TEST_AUTOLOADER_FIXTURE;
+      const body = options.fixtureBody ?? new Uint8Array(await readFile(resolve(fixturePath)));
+      const id = (options.randomId ?? randomUUID)();
+      const runName = (env.DBX_TEST_ENV_NAME ?? "autoloader").replace(/[^A-Za-z0-9_.-]/g, "_");
+      const directory = `${root}/exposures/${runName}/${id}`;
+      const destination = `${directory}/${basename(fixturePath)}`;
+      await ensureVolumeDirectory(env, directory, options.fetchImpl);
+      try {
+        await uploadVolumeFile(env, destination, body, options.fetchImpl);
+        const submitted = await client.post(
+          `/api/2.0/pipelines/${encodeURIComponent(pipelineId)}/updates`,
+          { full_refresh: true }
+        );
+        if (!submitted.update_id) throw new Error("Auto Loader pipeline returned no update_id");
+        await waitForPipelineUpdate(client, pipelineId, submitted.update_id, {
+          timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+          pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+        });
+        const table = env.DBX_TEST_AUTOLOADER_TABLE;
+        const rows = await warehouse.query(
+          `SELECT COUNT(*) AS n, SUM(CASE WHEN _rescued_data IS NOT NULL THEN 1 ELSE 0 END) AS rescued FROM ${table}`
+        );
+        const count = Number(rows[0]?.n ?? 0);
+        const rescued = Number(rows[0]?.rescued ?? 0);
+        if (count < 1) throw new Error(`Auto Loader produced no rows in ${table}`);
+        if (rescued !== 0)
+          throw new Error(`Auto Loader produced ${rescued} rescued rows in ${table}`);
+        return { pipelineId, table, rows: count, rescued };
+      } finally {
+        await deleteVolumeFile(env, destination, options.fetchImpl).catch(() => void 0);
+      }
+    }
+  };
+}
+
+export { appHealthCheck, assertDeltaContract, autoLoaderIngestionCheck, createExecutionContext, createLakebaseTestProvider, createMockDatabricksClient, customLiveCheck, dbtBuildCheck, defineLiveSuite, deleteVolumeFile, deltaContractCheck, ensureVolumeDirectory, expectQueryToMatchGolden, expectTable, jobRunCheck, lakebaseCredentialCheck, lakebaseRoundTripCheck, normalizeVolumeRoot, notebookSubmitCheck, pipelineRefreshCheck, renderJUnit, resolveProfile, runLiveSuite, secretScopeCheck, sqlRoundTripCheck, unityCatalogAccessCheck, uploadVolumeFile, volumeIOCheck, waitForPipelineUpdate };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map