@fabricorg/databricks-bdd 0.3.1 → 0.4.0

package/dist/steps.cjs

@@ -21,6 +21,65 @@ function redactSecrets(text, env = process.env) {
   return out;
 }
 
+// src/fixtures.ts
+function isFixtureResult(value) {
+  return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, "value") && typeof value.cleanup === "function";
+}
+var SharedFixtureRegistry = class {
+  runEntries = /* @__PURE__ */ new Map();
+  featureEntries = /* @__PURE__ */ new Map();
+  cleanupOrder = [];
+  runFixture(key, setup) {
+    return this.resolve(this.runEntries, key, setup);
+  }
+  featureFixture(featureUri, key, setup) {
+    if (!featureUri) throw new Error("featureFixture requires a feature URI");
+    let feature = this.featureEntries.get(featureUri);
+    if (!feature) {
+      feature = /* @__PURE__ */ new Map();
+      this.featureEntries.set(featureUri, feature);
+    }
+    return this.resolve(feature, key, setup);
+  }
+  resolve(entries, key, setup) {
+    if (!key.trim()) throw new Error("Fixture key must not be empty");
+    const existing = entries.get(key);
+    if (existing) return existing.value;
+    const entry = {
+      value: Promise.resolve().then(setup).then((result) => {
+        if (isFixtureResult(result)) {
+          entry.cleanup = result.cleanup;
+          return result.value;
+        }
+        return result;
+      }).catch((error) => {
+        entries.delete(key);
+        const index = this.cleanupOrder.indexOf(entry);
+        if (index >= 0) this.cleanupOrder.splice(index, 1);
+        throw error;
+      })
+    };
+    entries.set(key, entry);
+    this.cleanupOrder.push(entry);
+    return entry.value;
+  }
+  async dispose() {
+    const errors = [];
+    for (const entry of this.cleanupOrder.splice(0).reverse()) {
+      try {
+        await entry.value.catch(() => void 0);
+        await entry.cleanup?.();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    this.runEntries.clear();
+    this.featureEntries.clear();
+    if (errors.length > 0) throw new AggregateError(errors, "Shared fixture cleanup failed");
+  }
+};
+var sharedFixtures = new SharedFixtureRegistry();
+
 // src/infer.ts
 var INT_RE = /^-?\d+$/;
 var FLOAT_RE = /^-?\d+\.\d+$/;
@@ -264,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. */
@@ -278,10 +473,14 @@ var DatabricksWorld = class extends cucumber.World {
   catalogOverride;
   lastSql;
   lastStatementId;
+  featureUri;
+  scenarioName;
+  effectiveTags = [];
   stepOutputCapture;
   lakebasePool;
   ctx;
   activeCtx;
+  scopedState;
   cleanups = [];
   constructor(options) {
     super(options);
@@ -316,6 +515,43 @@ 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);
+  }
+  /**
+   * Setup a resource once per feature file. It is isolated by feature URI and
+   * cleaned in AfterAll because cucumber-js has no reliable after-feature hook.
+   */
+  featureFixture(key, setup) {
+    if (!this.featureUri) {
+      throw new Error("featureFixture is only available after the scenario Before hook");
+    }
+    return sharedFixtures.featureFixture(this.featureUri, key, setup);
+  }
   /** Resolve runner userdata from worldParameters first, then DBX_TEST_USERDATA_* env. */
   userdata(name) {
     const configured = this.parameters.userdata?.[name];
@@ -348,13 +584,21 @@ 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
 cucumber.setWorldConstructor(DatabricksWorld);
-cucumber.setDefaultTimeout(6e4);
+cucumber.setDefaultTimeout(databricksTestkit.resolveProfile() === "live" ? 20 * 6e4 : 6e4);
 registerParameterTypes();
 cucumber.BeforeAll(async () => {
   if (databricksTestkit.resolveProfile() !== "live") return;
@@ -370,10 +614,18 @@ cucumber.BeforeAll(async () => {
 });
 cucumber.Before(function({ pickle }) {
   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 () => {
+  try {
+    await sharedFixtures.dispose();
+  } finally {
+    sharedState.clear();
+  }
+});
 cucumber.BeforeStep(function() {
   const captureMode = process.env.DBX_TEST_CAPTURE_OUTPUT?.toLowerCase();
   if (captureMode === "off") return;