@fabricorg/databricks-bdd 0.3.2 → 0.5.0

package/dist/scoped-state.d.cts

@@ -0,0 +1,30 @@
+type StateScope = 'run' | 'feature' | 'scenario';
+type StateValues = Map<string, unknown>;
+/**
+ * Process-local state backing Behave-style run and feature context layers.
+ * Scenario values stay on the scenario World and are never shared.
+ */
+declare class SharedStateRegistry {
+    private readonly runValues;
+    private readonly featureValues;
+    run(): StateValues;
+    feature(featureUri: string): StateValues;
+    clear(): void;
+}
+/** Layered state lookup: scenario overrides feature, which overrides run. */
+declare class ScopedState {
+    private readonly runValues;
+    private readonly featureValues;
+    private readonly scenarioValues;
+    constructor(runValues: StateValues, featureValues: StateValues);
+    set<T>(scope: StateScope, key: string, value: T): T;
+    get<T>(key: string): T | undefined;
+    require<T>(key: string): T;
+    has(key: string): boolean;
+    delete(scope: StateScope, key: string): boolean;
+    clearScenario(): void;
+    private values;
+}
+declare const sharedState: SharedStateRegistry;
+
+export { ScopedState, SharedStateRegistry, type StateScope, sharedState };

package/dist/scoped-state.d.ts

@@ -0,0 +1,30 @@
+type StateScope = 'run' | 'feature' | 'scenario';
+type StateValues = Map<string, unknown>;
+/**
+ * Process-local state backing Behave-style run and feature context layers.
+ * Scenario values stay on the scenario World and are never shared.
+ */
+declare class SharedStateRegistry {
+    private readonly runValues;
+    private readonly featureValues;
+    run(): StateValues;
+    feature(featureUri: string): StateValues;
+    clear(): void;
+}
+/** Layered state lookup: scenario overrides feature, which overrides run. */
+declare class ScopedState {
+    private readonly runValues;
+    private readonly featureValues;
+    private readonly scenarioValues;
+    constructor(runValues: StateValues, featureValues: StateValues);
+    set<T>(scope: StateScope, key: string, value: T): T;
+    get<T>(key: string): T | undefined;
+    require<T>(key: string): T;
+    has(key: string): boolean;
+    delete(scope: StateScope, key: string): boolean;
+    clearScenario(): void;
+    private values;
+}
+declare const sharedState: SharedStateRegistry;
+
+export { ScopedState, SharedStateRegistry, type StateScope, sharedState };

package/dist/scoped-state.js

@@ -0,0 +1,3 @@
+export { ScopedState, SharedStateRegistry, sharedState } from './chunk-HTKRJLVX.js';
+//# sourceMappingURL=scoped-state.js.map
+//# sourceMappingURL=scoped-state.js.map

package/dist/scoped-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"scoped-state.js"}

package/dist/steps.cjs

@@ -323,6 +323,142 @@ function liveOnlyReason(tags, profile) {
   if (blocking.length === 0) return null;
   return `requires a live workspace (${blocking.join(", ")}); running under DBX_TEST_PROFILE=local`;
 }
+function capabilitiesFromEnv(profile, env = process.env) {
+  const capabilities = { profile };
+  const builtins = [
+    ["cloud", env.DBX_TEST_CLOUD],
+    ["compute", env.DBX_TEST_COMPUTE_MODE ?? env.DBX_TEST_COMPUTE],
+    ["stage", env.DBX_TEST_STAGE]
+  ];
+  for (const [key, value] of builtins) {
+    if (value !== void 0 && value !== "") capabilities[key] = value;
+  }
+  for (const [name, value] of Object.entries(env)) {
+    if (!name.startsWith("DBX_TEST_CAPABILITY_") || value === void 0) continue;
+    capabilities[normalizeCapabilityKey(name.slice("DBX_TEST_CAPABILITY_".length))] = value;
+  }
+  return capabilities;
+}
+function capabilityTagReason(tags, capabilities) {
+  const normalized = new Map(
+    Object.entries(capabilities).map(([key, value]) => [
+      normalizeCapabilityKey(key),
+      String(value).toLowerCase()
+    ])
+  );
+  for (const tag of tags) {
+    const predicate = parseCapabilityTag(tag);
+    if (!predicate) continue;
+    const actual = normalized.get(normalizeCapabilityKey(predicate.key));
+    const matches = predicate.expected ? actual === predicate.expected.toLowerCase() : actual !== void 0 && !["", "0", "false", "no", "off"].includes(actual);
+    if (predicate.kind === "requires" && !matches) {
+      return `${tag} requires capability ${predicate.key}${predicate.expected ? `=${predicate.expected}` : ""}; actual ${actual ?? "unset"}`;
+    }
+    if (predicate.kind === "excludes" && matches) {
+      return `${tag} excludes capability ${predicate.key}${predicate.expected ? `=${predicate.expected}` : ""}`;
+    }
+  }
+  return null;
+}
+function scenarioSkipReason(tags, profile, env = process.env) {
+  return liveOnlyReason(tags, profile) ?? capabilityTagReason(tags, capabilitiesFromEnv(profile, env));
+}
+function parseCapabilityTag(tag) {
+  const direct = tag.match(/^@(requires|excludes)\.([^=]+)(?:=(.+))?$/i);
+  if (direct?.[1] && direct[2]) {
+    return {
+      kind: direct[1].toLowerCase(),
+      key: direct[2],
+      ...direct[3] ? { expected: direct[3] } : {}
+    };
+  }
+  const behave = tag.match(/^@(use|not)\.with_([^=]+)=(.+)$/i);
+  if (behave?.[1] && behave[2] && behave[3]) {
+    return {
+      kind: behave[1].toLowerCase() === "use" ? "requires" : "excludes",
+      key: behave[2],
+      expected: behave[3]
+    };
+  }
+  return void 0;
+}
+function normalizeCapabilityKey(key) {
+  return key.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_");
+}
+
+// src/scoped-state.ts
+var SharedStateRegistry = class {
+  runValues = /* @__PURE__ */ new Map();
+  featureValues = /* @__PURE__ */ new Map();
+  run() {
+    return this.runValues;
+  }
+  feature(featureUri) {
+    if (!featureUri) throw new Error("Feature state requires a feature URI");
+    let values = this.featureValues.get(featureUri);
+    if (!values) {
+      values = /* @__PURE__ */ new Map();
+      this.featureValues.set(featureUri, values);
+    }
+    return values;
+  }
+  clear() {
+    this.runValues.clear();
+    this.featureValues.clear();
+  }
+};
+var ScopedState = class {
+  constructor(runValues, featureValues) {
+    this.runValues = runValues;
+    this.featureValues = featureValues;
+  }
+  runValues;
+  featureValues;
+  scenarioValues = /* @__PURE__ */ new Map();
+  set(scope, key, value) {
+    this.values(scope).set(validateKey(key), value);
+    return value;
+  }
+  get(key) {
+    const validKey = validateKey(key);
+    if (this.scenarioValues.has(validKey)) return this.scenarioValues.get(validKey);
+    if (this.featureValues.has(validKey)) return this.featureValues.get(validKey);
+    return this.runValues.get(validKey);
+  }
+  require(key) {
+    const value = this.get(key);
+    if (value === void 0) throw new Error(`Required BDD state '${key}' is not set`);
+    return value;
+  }
+  has(key) {
+    const validKey = validateKey(key);
+    return this.scenarioValues.has(validKey) || this.featureValues.has(validKey) || this.runValues.has(validKey);
+  }
+  delete(scope, key) {
+    return this.values(scope).delete(validateKey(key));
+  }
+  clearScenario() {
+    this.scenarioValues.clear();
+  }
+  values(scope) {
+    if (scope === "run") return this.runValues;
+    if (scope === "feature") return this.featureValues;
+    return this.scenarioValues;
+  }
+};
+function validateKey(key) {
+  const trimmed = key.trim();
+  if (!trimmed) throw new Error("BDD state key must not be empty");
+  return trimmed;
+}
+var sharedState = new SharedStateRegistry();
+
+// src/actions.ts
+async function runAction(world, action, ...args) {
+  return await action(world, ...args);
+}
+
+// src/world.ts
 var DatabricksWorld = class extends cucumber.World {
   profile;
   /** Rows from the last `When I run the SQL` / `When I query table` step. */
@@ -338,10 +474,13 @@ var DatabricksWorld = class extends cucumber.World {
   lastSql;
   lastStatementId;
   featureUri;
+  scenarioName;
+  effectiveTags = [];
   stepOutputCapture;
   lakebasePool;
   ctx;
   activeCtx;
+  scopedState;
   cleanups = [];
   constructor(options) {
     super(options);
@@ -376,6 +515,29 @@ var DatabricksWorld = class extends cucumber.World {
   addCleanup(cleanup) {
     this.cleanups.push(cleanup);
   }
+  /** Initialize Behave-style feature/scenario metadata and layered state. */
+  initializeScenario(featureUri, scenarioName, tags) {
+    this.featureUri = featureUri;
+    this.scenarioName = scenarioName;
+    this.effectiveTags = [...tags];
+    this.scopedState = new ScopedState(sharedState.run(), sharedState.feature(featureUri));
+  }
+  /** Set typed state at run, feature, or scenario scope. */
+  setState(scope, key, value) {
+    return this.state().set(scope, key, value);
+  }
+  /** Resolve state using scenario → feature → run precedence. */
+  getState(key) {
+    return this.state().get(key);
+  }
+  /** Resolve required layered state or fail with a useful message. */
+  requireState(key) {
+    return this.state().require(key);
+  }
+  /** Compose a reusable typed action without reparsing textual Gherkin. */
+  runAction(action, ...args) {
+    return runAction(this, action, ...args);
+  }
   /** Setup a resource once for this Cucumber run and clean it up in AfterAll. */
   runFixture(key, setup) {
     return sharedFixtures.runFixture(key, setup);
@@ -422,8 +584,16 @@ var DatabricksWorld = class extends cucumber.World {
       errors.push(error);
     }
     this.ctx = void 0;
+    this.scopedState?.clearScenario();
+    this.scopedState = void 0;
     if (errors.length > 0) throw new AggregateError(errors, "Scenario cleanup failed");
   }
+  state() {
+    if (!this.scopedState) {
+      throw new Error("BDD scoped state is only available after the scenario Before hook");
+    }
+    return this.scopedState;
+  }
 };
 
 // src/steps.ts
@@ -443,14 +613,18 @@ cucumber.BeforeAll(async () => {
   }
 });
 cucumber.Before(function({ pickle }) {
-  this.featureUri = pickle.uri;
   const tags = pickle.tags.map((t) => t.name);
-  const reason = liveOnlyReason(tags, this.profile);
+  this.initializeScenario(pickle.uri, pickle.name, tags);
+  const reason = scenarioSkipReason(tags, this.profile);
   if (reason) return "skipped";
   return void 0;
 });
 cucumber.AfterAll(async () => {
-  await sharedFixtures.dispose();
+  try {
+    await sharedFixtures.dispose();
+  } finally {
+    sharedState.clear();
+  }
 });
 cucumber.BeforeStep(function() {
   const captureMode = process.env.DBX_TEST_CAPTURE_OUTPUT?.toLowerCase();
@@ -642,6 +816,49 @@ cucumber.When("I run job {string}", async function(nameOrId) {
   const result = await runJobToTerminal(client, nameOrId);
   this.lastRun = { result_state: result.resultState, life_cycle_state: result.lifeCycleState };
 });
+cucumber.When("I submit the job orchestration:", async function(json) {
+  const spec = databricksTestkit.parseJobOrchestrationLiveSpec(json);
+  const adapter = new databricksTestkit.DatabricksJobsAdapter(databricksTestkit.createClientFromEnv(process.env));
+  const runId = await adapter.submit(spec.request);
+  const run = await adapter.wait(runId, {
+    timeoutMs: Number(process.env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+    pollIntervalMs: Number(process.env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+  });
+  this.lastRun = {
+    run_id: run.runId,
+    result_state: run.resultState,
+    life_cycle_state: run.lifeCycleState,
+    tasks: run.tasks
+  };
+});
+cucumber.When("I cancel the current job run", async function() {
+  const runId = Number(this.lastRun?.run_id);
+  if (!Number.isFinite(runId)) {
+    throw new Error("No submitted job run in this scenario");
+  }
+  const adapter = new databricksTestkit.DatabricksJobsAdapter(databricksTestkit.createClientFromEnv(process.env));
+  await adapter.cancel(runId);
+});
+cucumber.When("I repair failed tasks in the current job run", async function() {
+  const runId = Number(this.lastRun?.run_id);
+  const tasks = Array.isArray(this.lastRun?.tasks) ? this.lastRun.tasks : [];
+  if (!Number.isFinite(runId)) {
+    throw new Error("No submitted job run in this scenario");
+  }
+  const failed = tasks.filter((task) => task.resultState === "FAILED" && task.taskKey).map((task) => task.taskKey);
+  const adapter = new databricksTestkit.DatabricksJobsAdapter(databricksTestkit.createClientFromEnv(process.env));
+  await adapter.repair(runId, { rerunTasks: failed.length > 0 ? failed : void 0 });
+  const repaired = await adapter.wait(runId, {
+    timeoutMs: Number(process.env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+    pollIntervalMs: Number(process.env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+  });
+  this.lastRun = {
+    run_id: repaired.runId,
+    result_state: repaired.resultState,
+    life_cycle_state: repaired.lifeCycleState,
+    tasks: repaired.tasks
+  };
+});
 cucumber.When("I submit notebook {string}", async function(notebookPath) {
   const client = databricksTestkit.createClientFromEnv(process.env);
   await databricksTestkit.notebookSubmitCheck().run({
@@ -828,6 +1045,25 @@ cucumber.Then("the job run reaches {runState}", function(state) {
     throw new Error(`Job run ended in ${this.lastRun.result_state}, expected ${state}`);
   }
 });
+cucumber.Then(
+  "task {string} reaches {runState}",
+  function(taskKey, state) {
+    const tasks = Array.isArray(this.lastRun?.tasks) ? this.lastRun.tasks : [];
+    const task = tasks.find((candidate) => candidate.taskKey === taskKey);
+    if (!task) throw new Error(`Job run does not contain task '${taskKey}'`);
+    if (task.resultState !== state) {
+      throw new Error(
+        `Task '${taskKey}' ended in ${task.resultState ?? "UNKNOWN"}, expected ${state}`
+      );
+    }
+  }
+);
+cucumber.Then("the job run has {int} tasks", function(count) {
+  const tasks = Array.isArray(this.lastRun?.tasks) ? this.lastRun.tasks : [];
+  if (tasks.length !== count) {
+    throw new Error(`Job run has ${tasks.length} tasks, expected ${count}`);
+  }
+});
 cucumber.Then(
   "the pipeline update completes within {duration}",
   async function(durationMs) {