@fabricorg/databricks-bdd 0.1.0

package/dist/steps.cjs

@@ -0,0 +1,689 @@
+'use strict';
+
+var crypto = require('crypto');
+var promises = require('fs/promises');
+var path = require('path');
+var cucumber = require('@cucumber/cucumber');
+var databricksTestkit = require('@fabricorg/databricks-testkit');
+var databricks = require('@fabric-harness/databricks');
+
+// src/steps.ts
+var SECRET_ENV_RE = /(TOKEN|SECRET|PASSWORD|BEARER|KEY)/;
+function redactSecrets(text, env = process.env) {
+  let out = text;
+  for (const [name, value] of Object.entries(env)) {
+    if (!value || value.length < 6) continue;
+    if (!SECRET_ENV_RE.test(name)) continue;
+    out = out.split(value).join("[REDACTED]");
+  }
+  return out;
+}
+
+// src/infer.ts
+var INT_RE = /^-?\d+$/;
+var FLOAT_RE = /^-?\d+\.\d+$/;
+var TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2})?/;
+var BOOL_RE = /^(true|false)$/i;
+function inferFixture(table, raw) {
+  if (raw.length < 2) {
+    throw new Error(`Data table for ${table} needs a header row and at least one data row`);
+  }
+  const [header, ...body] = raw;
+  const types = header.map((_, col) => inferColumnType(body.map((row) => row[col] ?? "")));
+  const schema = header.map((name, i) => `"${name}" ${types[i]}`).join(", ");
+  const rows = body.map((row) => row.map((cell, i) => coerceCell(cell, types[i] ?? "STRING")));
+  return { table, schema, rows };
+}
+function coerceMatchRows(raw) {
+  if (raw.length < 2) {
+    throw new Error("Match table needs a header row and at least one data row");
+  }
+  const [header, ...body] = raw;
+  return body.map((row) => {
+    const out = {};
+    header.forEach((name, i) => {
+      out[name] = coerceCell(row[i] ?? "", inferColumnType([row[i] ?? ""]));
+    });
+    return out;
+  });
+}
+function inferColumnType(cells) {
+  const present = cells.filter((c) => c !== "");
+  if (present.length === 0) return "STRING";
+  if (present.every((c) => INT_RE.test(c))) return "BIGINT";
+  if (present.every((c) => FLOAT_RE.test(c) || INT_RE.test(c))) return "DOUBLE";
+  if (present.every((c) => TIMESTAMP_RE.test(c))) return "TIMESTAMP";
+  if (present.every((c) => BOOL_RE.test(c))) return "BOOLEAN";
+  return "STRING";
+}
+function coerceCell(cell, type) {
+  if (cell === "") return null;
+  if (type === "BIGINT" || type === "DOUBLE") return Number(cell);
+  if (type === "BOOLEAN") return /^true$/i.test(cell);
+  return cell;
+}
+async function resolveJobId(client, nameOrId) {
+  if (/^\d+$/.test(nameOrId)) return Number(nameOrId);
+  const response = await client.get(
+    "/api/2.1/jobs/list",
+    { name: nameOrId }
+  );
+  const match = (response.jobs ?? []).find((j) => j.settings?.name === nameOrId);
+  if (!match) throw new Error(`No Databricks job named '${nameOrId}' found`);
+  return match.job_id;
+}
+async function runJobToTerminal(client, nameOrId, options = {}) {
+  const jobId = await resolveJobId(client, nameOrId);
+  const submitted = await client.post("/api/2.1/jobs/run-now", {
+    job_id: jobId
+  });
+  const run = await databricks.waitForDatabricksRun(client, submitted.run_id, {
+    pollIntervalMs: options.pollIntervalMs,
+    timeoutMs: options.timeoutMs
+  });
+  const state = run.state;
+  return {
+    runId: submitted.run_id,
+    lifeCycleState: state?.life_cycle_state ?? "UNKNOWN",
+    resultState: state?.result_state ?? "UNKNOWN",
+    run
+  };
+}
+function parseDuration(value) {
+  const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(milliseconds?|ms|seconds?|s|minutes?|m)$/i);
+  if (!match) throw new Error(`Invalid duration '${value}'`);
+  const amount = Number(match[1]);
+  const unit = match[2]?.toLowerCase() ?? "";
+  if (unit === "ms" || unit.startsWith("millisecond")) return amount;
+  if (unit === "s" || unit.startsWith("second")) return amount * 1e3;
+  return amount * 6e4;
+}
+function parseTableIdentifier(value) {
+  const identifier = value.trim();
+  const part = "(?:[A-Za-z_][A-Za-z0-9_]*|`[^`]+`)";
+  if (!new RegExp(`^${part}(?:\\.${part}){0,2}$`).test(identifier)) {
+    throw new Error(`Invalid 1-3 part table identifier '${value}'`);
+  }
+  return identifier;
+}
+function registerParameterTypes() {
+  cucumber.defineParameterType({
+    name: "runState",
+    regexp: /SUCCESS|FAILED|CANCELED|TIMEDOUT/,
+    transformer: (value) => value
+  });
+  cucumber.defineParameterType({
+    name: "duration",
+    regexp: /\d+(?:\.\d+)?\s*(?:milliseconds?|ms|seconds?|s|minutes?|m)/,
+    transformer: parseDuration
+  });
+  cucumber.defineParameterType({
+    name: "table",
+    regexp: /(?:[A-Za-z_][A-Za-z0-9_]*|`[^`]+`)(?:\.(?:[A-Za-z_][A-Za-z0-9_]*|`[^`]+`)){0,2}/,
+    transformer: parseTableIdentifier
+  });
+}
+async function resolvePipelineId(client, nameOrId) {
+  if (/^[0-9a-f]{8}-[0-9a-f-]{27,}$/i.test(nameOrId)) return nameOrId;
+  const response = await client.get(
+    "/api/2.0/pipelines",
+    { filter: `name LIKE '${nameOrId}'` }
+  );
+  const match = (response.statuses ?? []).find((p) => p.name === nameOrId);
+  if (!match) throw new Error(`No Databricks pipeline named '${nameOrId}' found`);
+  return match.pipeline_id;
+}
+async function startPipelineUpdate(client, pipelineId, options = {}) {
+  const response = await client.post(
+    `/api/2.0/pipelines/${encodeURIComponent(pipelineId)}/updates`,
+    { full_refresh: options.fullRefresh ?? false }
+  );
+  return response.update_id;
+}
+
+// src/profile.ts
+var LIVE_ONLY_TAGS = [
+  "@live",
+  "@jobs",
+  "@dlt",
+  "@pipeline",
+  "@autoloader",
+  "@lakebase",
+  "@slow"
+];
+function liveOnlyReason(tags, profile) {
+  if (profile === "live") return null;
+  const blocking = tags.filter((t) => LIVE_ONLY_TAGS.includes(t));
+  if (blocking.length === 0) return null;
+  return `requires a live workspace (${blocking.join(", ")}); running under DBX_TEST_PROFILE=local`;
+}
+var DatabricksWorld = class extends cucumber.World {
+  profile;
+  /** Rows from the last `When I run the SQL` / `When I query table` step. */
+  lastRows = null;
+  /** Error captured from the last statement, for `Then the statement fails ...`. */
+  lastError = null;
+  /** Terminal run record from the last `When I run job ...` step. */
+  lastRun = null;
+  /** Pipeline update handle from `When I start a full refresh of pipeline ...`. */
+  lastPipelineUpdate = null;
+  schemaOverride;
+  catalogOverride;
+  lastSql;
+  lastStatementId;
+  lakebasePool;
+  ctx;
+  activeCtx;
+  cleanups = [];
+  constructor(options) {
+    super(options);
+    this.profile = databricksTestkit.resolveProfile();
+  }
+  async context() {
+    if (this.activeCtx) return this.activeCtx;
+    if (!this.ctx) {
+      const env = this.catalogOverride ? { ...process.env, DBX_TEST_CATALOG: this.catalogOverride } : process.env;
+      this.ctx = await databricksTestkit.createExecutionContext({
+        profile: this.profile,
+        env,
+        schema: this.schemaOverride ?? this.parameters.schema,
+        onStatement: ({ sql, statementId }) => {
+          this.lastSql = sql;
+          this.lastStatementId = statementId;
+        }
+      });
+    }
+    return this.ctx;
+  }
+  /** Route subsequent steps through a scenario-owned secondary identity. */
+  useExecutionContext(context) {
+    if (this.activeCtx) throw new Error("A secondary execution context is already active");
+    this.activeCtx = context;
+    this.addCleanup(async () => {
+      await context.close();
+      this.activeCtx = void 0;
+    });
+  }
+  /** Register scenario-scoped cleanup. Cleanups run in reverse order. */
+  addCleanup(cleanup) {
+    this.cleanups.push(cleanup);
+  }
+  /** Resolve runner userdata from worldParameters first, then DBX_TEST_USERDATA_* env. */
+  userdata(name) {
+    const configured = this.parameters.userdata?.[name];
+    if (configured !== void 0) return configured;
+    return process.env[`DBX_TEST_USERDATA_${name.replace(/[^A-Za-z0-9]/g, "_").toUpperCase()}`];
+  }
+  scopeTo(catalog, schema) {
+    if (this.ctx) {
+      throw new Error(
+        "Given catalog/schema must run before any step that touches the warehouse in the scenario"
+      );
+    }
+    this.catalogOverride = this.profile === "live" ? process.env.DBX_TEST_CATALOG ?? catalog : catalog;
+    this.schemaOverride = this.profile === "live" ? process.env.DBX_TEST_SCHEMA ?? schema : schema;
+  }
+  async dispose() {
+    const errors = [];
+    for (const cleanup of this.cleanups.splice(0).reverse()) {
+      try {
+        await cleanup();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    try {
+      await this.ctx?.close();
+    } catch (error) {
+      errors.push(error);
+    }
+    this.ctx = void 0;
+    if (errors.length > 0) throw new AggregateError(errors, "Scenario cleanup failed");
+  }
+};
+
+// src/steps.ts
+cucumber.setWorldConstructor(DatabricksWorld);
+cucumber.setDefaultTimeout(6e4);
+registerParameterTypes();
+cucumber.BeforeAll(async () => {
+  if (databricksTestkit.resolveProfile() !== "live") return;
+  const context = await databricksTestkit.createExecutionContext({ profile: "live" });
+  try {
+    const rows = await context.query("SELECT 1 AS dbx_bdd_preflight");
+    if (Number(rows[0]?.dbx_bdd_preflight) !== 1) {
+      throw new Error("Databricks BDD preflight returned an unexpected value");
+    }
+  } finally {
+    await context.close();
+  }
+});
+cucumber.Before(function({ pickle }) {
+  const tags = pickle.tags.map((t) => t.name);
+  const reason = liveOnlyReason(tags, this.profile);
+  if (reason) return "skipped";
+  return void 0;
+});
+cucumber.After(async function() {
+  await this.dispose();
+});
+cucumber.AfterStep(async function({ result, pickleStep }) {
+  if (result.status !== "FAILED") return;
+  const evidence = {
+    step: pickleStep.text,
+    ...this.lastStatementId ? { statementId: this.lastStatementId } : {},
+    ...this.lastSql ? { sql: redactSecrets(this.lastSql).slice(0, 4e3) } : {}
+  };
+  await this.attach(JSON.stringify(evidence, null, 2), "application/json");
+});
+cucumber.Given("a Databricks workspace", async function() {
+  if (this.profile === "live") await this.context();
+});
+cucumber.Given("a Lakebase database", async function() {
+  if (this.profile !== "live") {
+    throw new Error("Lakebase steps require DBX_TEST_PROFILE=live and the @lakebase tag");
+  }
+  const provider = databricksTestkit.createLakebaseTestProvider(process.env);
+  this.lakebasePool = provider.getPool();
+  this.addCleanup(async () => {
+    this.lakebasePool = void 0;
+    await provider.close();
+  });
+  await this.lakebasePool.query("SELECT 1 AS dbx_bdd_lakebase");
+});
+cucumber.Given(
+  "catalog {string} and schema {string}",
+  function(catalog, schema) {
+    this.scopeTo(catalog, schema);
+  }
+);
+cucumber.Given(
+  "a table {string} with:",
+  async function(table, data) {
+    const ctx = await this.context();
+    await ctx.loadFixture(inferFixture(table, data.raw()));
+  }
+);
+cucumber.Given(
+  "a table {string} with schema {string} and rows:",
+  async function(table, schema, data) {
+    const ctx = await this.context();
+    await ctx.loadFixture({ table, schema, rows: data.hashes() });
+  }
+);
+cucumber.Given(
+  "an empty table {string} with schema {string}",
+  async function(table, schema) {
+    const ctx = await this.context();
+    await ctx.loadFixture({ table, schema, rows: [] });
+  }
+);
+cucumber.Given(
+  "a table {string} with schema {string} from fixture {string}",
+  async function(table, schema, ndjsonFile) {
+    const ctx = await this.context();
+    await ctx.loadFixture({ table, schema, ndjsonFile });
+  }
+);
+cucumber.Given(
+  "fixture files uploaded to volume {string}:",
+  async function(configuredVolume, data) {
+    if (this.profile !== "live") {
+      throw new Error("Volume upload steps require DBX_TEST_PROFILE=live and the @live tag");
+    }
+    const volumeValue = configuredVolume.startsWith("$") ? process.env[configuredVolume.slice(1)] : configuredVolume;
+    if (!volumeValue) throw new Error(`Volume '${configuredVolume}' is not configured`);
+    const root = databricksTestkit.normalizeVolumeRoot(volumeValue);
+    const rows = data.hashes();
+    const uploadPrefix = rows[0]?.prefix?.trim() ?? "";
+    if (uploadPrefix && !/^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/.test(uploadPrefix)) {
+      throw new Error(`Invalid volume fixture prefix '${uploadPrefix}'`);
+    }
+    if (rows.some((row) => (row.prefix?.trim() ?? "") !== uploadPrefix)) {
+      throw new Error("All fixture rows in one upload step must use the same prefix");
+    }
+    const runPrefix = `${(process.env.DBX_TEST_ENV_NAME ?? "bdd").replace(/[^A-Za-z0-9_.-]/g, "_")}/${crypto.randomUUID()}`;
+    const directory = `${root}${uploadPrefix ? `/${uploadPrefix}` : ""}/${runPrefix}`;
+    await databricksTestkit.ensureVolumeDirectory(process.env, directory);
+    const paths = rows.map((row) => row.path).filter((path) => Boolean(path));
+    if (paths.length === 0) throw new Error("Fixture upload table requires a path column");
+    for (const source of paths) {
+      const absolute = path.resolve(process.cwd(), source);
+      const fromCwd = path.relative(process.cwd(), absolute);
+      if (fromCwd.startsWith("..") || path.isAbsolute(fromCwd)) {
+        throw new Error(`Fixture path escapes the feature workspace: ${source}`);
+      }
+      const destination = `${directory}/${path.basename(source)}`;
+      await databricksTestkit.uploadVolumeFile(process.env, destination, new Uint8Array(await promises.readFile(absolute)));
+      this.addCleanup(() => databricksTestkit.deleteVolumeFile(process.env, destination));
+    }
+  }
+);
+cucumber.Given(
+  "service principal {string} with grants:",
+  async function(principalKey, data) {
+    if (this.profile !== "live") {
+      throw new Error("Service-principal scenarios require DBX_TEST_PROFILE=live and @live");
+    }
+    const envPrefix = `DBX_TEST_PRINCIPAL_${principalKey.replace(/[^A-Za-z0-9]/g, "_").toUpperCase()}`;
+    const clientId = process.env[`${envPrefix}_CLIENT_ID`];
+    const clientSecret = process.env[`${envPrefix}_CLIENT_SECRET`];
+    const principalName = process.env[`${envPrefix}_NAME`] ?? principalKey;
+    if (!clientId || !clientSecret) {
+      throw new Error(`Missing ${envPrefix}_CLIENT_ID and ${envPrefix}_CLIENT_SECRET`);
+    }
+    const primary = await this.context();
+    const grants = data.hashes().map((row) => normalizeGrant(row));
+    if (grants.length === 0) throw new Error("Grant table contains no rows");
+    const quotedPrincipal = `\`${principalName.replaceAll("`", "``")}\``;
+    for (const grant of grants) {
+      await primary.exec(
+        `GRANT ${grant.privileges.join(", ")} ON ${grant.securableType} ${grant.securable} TO ${quotedPrincipal}`
+      );
+    }
+    this.addCleanup(async () => {
+      for (const grant of [...grants].reverse()) {
+        await primary.exec(
+          `REVOKE ${grant.privileges.join(", ")} ON ${grant.securableType} ${grant.securable} FROM ${quotedPrincipal}`
+        );
+      }
+    });
+    const secondaryEnv = {
+      ...process.env,
+      DATABRICKS_BEARER: void 0,
+      DATABRICKS_TOKEN: void 0,
+      DATABRICKS_CLIENT_ID: clientId,
+      DATABRICKS_CLIENT_SECRET: clientSecret
+    };
+    const secondary = await databricksTestkit.createExecutionContext({
+      profile: "live",
+      env: secondaryEnv,
+      schema: this.schemaOverride ?? this.parameters.schema,
+      onStatement: ({ sql, statementId }) => {
+        this.lastSql = sql;
+        this.lastStatementId = statementId;
+      }
+    });
+    this.useExecutionContext(secondary);
+  }
+);
+cucumber.When("I run the SQL:", async function(sql) {
+  const ctx = await this.context();
+  this.lastSql = sql;
+  this.lastError = null;
+  this.lastRows = null;
+  try {
+    this.lastRows = await ctx.query(sql);
+  } catch (error) {
+    this.lastError = error instanceof Error ? error : new Error(String(error));
+  }
+});
+cucumber.When("I query Lakebase:", async function(sql) {
+  if (!this.lakebasePool) {
+    throw new Error("No Lakebase database in this scenario \u2014 add Given a Lakebase database");
+  }
+  this.lastSql = sql;
+  this.lastError = null;
+  this.lastRows = null;
+  try {
+    const result = await this.lakebasePool.query(sql);
+    this.lastRows = result.rows;
+  } catch (error) {
+    this.lastError = error instanceof Error ? error : new Error(String(error));
+  }
+});
+cucumber.When("I query table {string}", async function(table) {
+  const ctx = await this.context();
+  this.lastRows = await ctx.query(`SELECT * FROM ${ctx.qual(table)}`);
+});
+cucumber.When("I run job {string}", async function(nameOrId) {
+  const client = databricksTestkit.createClientFromEnv(process.env);
+  const result = await runJobToTerminal(client, nameOrId);
+  this.lastRun = { result_state: result.resultState, life_cycle_state: result.lifeCycleState };
+});
+cucumber.When("I submit notebook {string}", async function(notebookPath) {
+  const client = databricksTestkit.createClientFromEnv(process.env);
+  await databricksTestkit.notebookSubmitCheck().run({
+    env: { ...process.env, DBX_TEST_NOTEBOOK_PATH: notebookPath },
+    warehouse: await this.context(),
+    client
+  });
+  this.lastRun = { result_state: "SUCCESS", life_cycle_state: "TERMINATED" };
+});
+cucumber.When("I run dbt build for {string}", async function(project) {
+  const client = databricksTestkit.createClientFromEnv(process.env);
+  await databricksTestkit.dbtBuildCheck().run({
+    env: { ...process.env, DBX_TEST_DBT_PROJECT_DIR: project },
+    warehouse: await this.context(),
+    client
+  });
+  this.lastRun = { result_state: "SUCCESS", life_cycle_state: "TERMINATED" };
+});
+cucumber.When(
+  "I start a full refresh of pipeline {string}",
+  async function(nameOrId) {
+    const isolated = process.env.DBX_TEST_AUTOLOADER_PIPELINE_ID;
+    const requested = nameOrId.startsWith("$") ? process.env[nameOrId.slice(1)] : nameOrId;
+    if (!isolated || !requested || requested !== isolated) {
+      throw new Error(
+        "Full refresh is restricted to DBX_TEST_AUTOLOADER_PIPELINE_ID; production pipelines are never full-refreshed by BDD tests"
+      );
+    }
+    const client = databricksTestkit.createClientFromEnv(process.env);
+    const pipelineId = await resolvePipelineId(client, requested);
+    const updateId = await startPipelineUpdate(client, pipelineId, { fullRefresh: true });
+    this.lastPipelineUpdate = { pipelineId, updateId };
+  }
+);
+cucumber.When(
+  "I start a refresh of pipeline {string}",
+  async function(nameOrId) {
+    const requested = nameOrId.startsWith("$") ? process.env[nameOrId.slice(1)] : nameOrId;
+    if (!requested) throw new Error(`Pipeline '${nameOrId}' is not configured`);
+    const client = databricksTestkit.createClientFromEnv(process.env);
+    const pipelineId = await resolvePipelineId(client, requested);
+    const updateId = await startPipelineUpdate(client, pipelineId, { fullRefresh: false });
+    this.lastPipelineUpdate = { pipelineId, updateId };
+  }
+);
+cucumber.Then(
+  "table {string} has {int} rows",
+  async function(table, n) {
+    await databricksTestkit.expectTable(await this.context(), table).toHaveRowCount(n);
+  }
+);
+cucumber.Then(
+  "table {string} contains rows matching:",
+  async function(table, data) {
+    await databricksTestkit.expectTable(await this.context(), table).toContainRows(coerceMatchRows(data.raw()));
+  }
+);
+cucumber.Then(
+  "table {string} contains exactly:",
+  async function(table, data) {
+    const ctx = await this.context();
+    const expected = coerceMatchRows(data.raw());
+    const header = (data.raw()[0] ?? []).join(", ");
+    const rows = await ctx.query(`SELECT ${header} FROM ${ctx.qual(table)}`);
+    if (rows.length !== expected.length) {
+      throw new Error(`Expected exactly ${expected.length} rows in ${table}, found ${rows.length}`);
+    }
+    await databricksTestkit.expectTable(ctx, table).toContainRows(expected);
+  }
+);
+cucumber.Then(
+  "table {string} matches golden {string} ordered by {string}",
+  async function(table, golden, orderBy) {
+    await databricksTestkit.expectTable(await this.context(), table).toMatchGolden(golden, { orderBy });
+  }
+);
+cucumber.Then(
+  "table {string} matches schema contract {string}",
+  async function(table, contractFile) {
+    const absolute = path.resolve(process.cwd(), contractFile);
+    const fromCwd = path.relative(process.cwd(), absolute);
+    if (fromCwd.startsWith("..") || path.isAbsolute(fromCwd)) {
+      throw new Error(`Schema contract path escapes the feature workspace: ${contractFile}`);
+    }
+    const parsed = JSON.parse(await promises.readFile(absolute, "utf8"));
+    const columns = Array.isArray(parsed) ? parsed : parsed.columns;
+    if (!columns || columns.length === 0) {
+      throw new Error(`Schema contract ${contractFile} contains no columns`);
+    }
+    const ctx = await this.context();
+    const rows = await ctx.query(`DESCRIBE TABLE ${ctx.qual(table)}`);
+    databricksTestkit.assertDeltaContract(table, rows, columns);
+  }
+);
+cucumber.Then("the result has {int} rows", function(n) {
+  requireRows(this);
+  if (this.lastRows?.length !== n) {
+    throw new Error(`Expected ${n} result rows, got ${this.lastRows?.length}`);
+  }
+});
+cucumber.Then("the result contains rows matching:", function(data) {
+  requireRows(this);
+  const rows = this.lastRows ?? [];
+  for (const partial of coerceMatchRows(data.raw())) {
+    const hit = rows.some(
+      (row) => Object.entries(partial).every(([key, value]) => cellEqual(row[key], value))
+    );
+    if (!hit) {
+      throw new Error(
+        `Result does not contain a row matching ${JSON.stringify(partial)} \u2014 rows: ${JSON.stringify(rows.slice(0, 5))}`
+      );
+    }
+  }
+});
+cucumber.Then("the result matches golden {string}", async function(golden) {
+  requireRows(this);
+  await databricksTestkit.compareToGolden(golden, this.lastRows ?? [], "result");
+});
+cucumber.Then("the statement fails with {string}", function(fragment) {
+  if (!this.lastError)
+    throw new Error(`Expected the statement to fail with '${fragment}', but it succeeded`);
+  if (!this.lastError.message.toLowerCase().includes(fragment.toLowerCase())) {
+    throw new Error(`Statement failed, but with a different error: ${this.lastError.message}`);
+  }
+});
+cucumber.Then("the statement fails with permission denied", function() {
+  if (!this.lastError) throw new Error("Expected a permission error, but the statement succeeded");
+  if (!/permission.?denied|insufficient.?priv|403|unauthoriz/i.test(this.lastError.message)) {
+    throw new Error(`Statement failed, but not with a permission error: ${this.lastError.message}`);
+  }
+});
+cucumber.Then(
+  "no rows were rescued in table {string}",
+  async function(table) {
+    const ctx = await this.context();
+    const rows = await ctx.query(
+      `SELECT COUNT(*) AS n FROM ${ctx.qual(table)} WHERE _rescued_data IS NOT NULL`
+    );
+    const n = Number(rows[0]?.n ?? Number.NaN);
+    if (n !== 0) {
+      throw new Error(`${n} rescued rows in ${table} \u2014 the ingestion contract drifted`);
+    }
+  }
+);
+cucumber.Then(
+  "configured table {string} has at least {int} rows",
+  async function(configuredTable, minimum) {
+    const table = resolveConfiguredValue(configuredTable, "table");
+    parseTableIdentifier(table);
+    const rows = await (await this.context()).query(`SELECT COUNT(*) AS n FROM ${table}`);
+    const count = Number(rows[0]?.n ?? Number.NaN);
+    if (!Number.isFinite(count) || count < minimum) {
+      throw new Error(`Expected at least ${minimum} rows in ${table}, found ${count}`);
+    }
+  }
+);
+cucumber.Then(
+  "no rows were rescued in configured table {string}",
+  async function(configuredTable) {
+    const table = resolveConfiguredValue(configuredTable, "table");
+    parseTableIdentifier(table);
+    const rows = await (await this.context()).query(
+      `SELECT COUNT(*) AS n FROM ${table} WHERE _rescued_data IS NOT NULL`
+    );
+    const count = Number(rows[0]?.n ?? Number.NaN);
+    if (count !== 0) throw new Error(`${count} rescued rows in ${table}`);
+  }
+);
+cucumber.Then(
+  "row count of {string} is within {int}% of {int}",
+  async function(table, pct, target) {
+    const ctx = await this.context();
+    const rows = await ctx.query(`SELECT COUNT(*) AS n FROM ${ctx.qual(table)}`);
+    const n = Number(rows[0]?.n ?? Number.NaN);
+    const tolerance = target * pct / 100;
+    if (Math.abs(n - target) > tolerance) {
+      throw new Error(`Row count ${n} of ${table} is outside ${target} \xB1 ${tolerance}`);
+    }
+  }
+);
+cucumber.Then("the job run reaches {runState}", function(state) {
+  if (!this.lastRun) throw new Error("No job run in this scenario \u2014 add a When I run job step");
+  if (this.lastRun.result_state !== state) {
+    throw new Error(`Job run ended in ${this.lastRun.result_state}, expected ${state}`);
+  }
+});
+cucumber.Then(
+  "the pipeline update completes within {duration}",
+  async function(durationMs) {
+    if (!this.lastPipelineUpdate) {
+      throw new Error("No pipeline update in this scenario \u2014 add a When I start ... pipeline step");
+    }
+    const client = databricksTestkit.createClientFromEnv(process.env);
+    await databricksTestkit.waitForPipelineUpdate(
+      client,
+      this.lastPipelineUpdate.pipelineId,
+      this.lastPipelineUpdate.updateId,
+      { timeoutMs: durationMs }
+    );
+  }
+);
+function requireRows(world) {
+  if (world.lastError) {
+    throw new Error(`The last statement failed: ${world.lastError.message}`);
+  }
+  if (world.lastRows === null) {
+    throw new Error("No result captured \u2014 add a When I run the SQL / I query table step first");
+  }
+}
+function cellEqual(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;
+}
+function resolveConfiguredValue(value, label) {
+  if (!value.startsWith("$")) return value;
+  const resolved = process.env[value.slice(1)];
+  if (!resolved) throw new Error(`${label} '${value}' is not configured`);
+  return resolved;
+}
+var ALLOWED_PRIVILEGES = /* @__PURE__ */ new Set([
+  "ALL PRIVILEGES",
+  "USE CATALOG",
+  "USE SCHEMA",
+  "SELECT",
+  "MODIFY",
+  "READ VOLUME",
+  "WRITE VOLUME"
+]);
+function normalizeGrant(row) {
+  const securableType = (row.securable_type ?? "SCHEMA").trim().toUpperCase();
+  if (!["CATALOG", "SCHEMA", "TABLE", "VOLUME"].includes(securableType)) {
+    throw new Error(`Unsupported securable_type '${securableType}'`);
+  }
+  const securable = parseTableIdentifier(row.securable ?? "");
+  const privileges = (row.privilege ?? row.privileges ?? "").split(",").map((value) => value.trim().toUpperCase()).filter(Boolean);
+  if (privileges.length === 0 || privileges.some((value) => !ALLOWED_PRIVILEGES.has(value))) {
+    throw new Error(`Unsupported or empty privileges '${row.privilege ?? row.privileges ?? ""}'`);
+  }
+  return { securableType, securable, privileges };
+}
+//# sourceMappingURL=steps.cjs.map
+//# sourceMappingURL=steps.cjs.map