@sungen/driver-data-factory 3.2.12-beta.10 → 3.2.12-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-data-factory",
-  "version": "3.2.12-beta.10",
+  "version": "3.2.12-beta.11",
   "description": "Sungen Data Factory capability — standardized test-data generation from a field-type + security knowledge catalog (valid/boundary/invalid + traceability), the .overwrite merge layer, and (opt-in) @dataFactory runtime seeding. Design-time knowledge is runtime-free. Plugs into @sun-asterisk/sungen via the capability SPI.",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -14,7 +14,7 @@
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.12-beta.10",
+    "@sun-asterisk/sungen": "3.2.12-beta.11",
     "yaml": "^2.4.0"
   },
   "files": [

package/src/cli.ts

@@ -15,6 +15,7 @@ import { expandFieldMap, renderTestData, type FieldMap } from './generator';
 import { buildRequest, fingerprint } from './contract';
 import { loadStateRecipes, validateStateRecipe, buildStatePlan, renderPreconditionBlock, hasDatasource, scaffoldRecipe, renderRecipeYaml } from './state';
 import { crosscheckUnit, crosscheckShared } from './crosscheck';
+import { coverageUnit } from './coverage';
 import { detectPreconditionSignals } from './detect';
 import { lintFieldMap, summarize } from './lint';
 import { validateGenerated } from './validate';
@@ -238,21 +239,23 @@ export function registerDataFactoryCommand(program: any): void {
 
   data
     .command('crosscheck')
-    .description('Cross-artifact Gate (M3-B): verify the testcase and its test-data agree — no dangling {{var}}, shared datasets identical across the journey, declared state-preconditions surfaced')
+    .description('Cross-artifact + coverage Gate: testcase ↔ data agree (no dangling {{var}}, shared datasets identical) AND the authored data COVERS the required BVA + the login experience checklist')
     .option('--screen <name>', 'Cross-check one unit (default: all field-maps + all shared datasets)')
     .action((opts: { screen?: string }) => {
       const cwd = process.cwd();
       ensureDataFactoryReadme(cwd);
       const names = opts.screen ? [opts.screen] : listFieldMaps(cwd);
+      const { catalog } = loadEffectiveCatalog(cwd);
       const findings = [
         ...names.flatMap((n) => crosscheckUnit(cwd, n)),
         ...(opts.screen ? [] : crosscheckShared(cwd)),
+        ...names.flatMap((n) => coverageUnit(cwd, n, catalog)),
       ];
       const errors = findings.filter((f) => f.severity === 'error').length;
       const warns = findings.filter((f) => f.severity === 'warn').length;
       const badge = errors ? '✗' : warns ? '⚠' : '✓';
       console.log(`${badge} crosscheck: ${errors} error · ${warns} warn (${names.length} unit(s))`);
-      for (const f of findings) console.log(`  ${f.severity === 'error' ? '✗' : f.severity === 'warn' ? '⚠' : '·'} [${f.unit}] ${f.code}: ${f.message}`);
+      for (const f of findings) console.log(`  ${f.severity === 'error' ? '✗' : f.severity === 'warn' ? '⚠' : '·'} [${(f as any).unit}] ${f.code}: ${f.message}`);
       if (errors) process.exitCode = 1;
     });
 

package/src/coverage.ts

@@ -0,0 +1,165 @@
+/**
+ * Data Factory — coverage check (does the AUTHORED test-data actually cover the standardized set?).
+ *
+ * `data validate` checks the DF-generated field block is internally correct; `data crosscheck` checks
+ * testcase ↔ data agree. But `/sungen:create-test` often AUTHORS login/flow test-data by hand (seeded
+ * accounts + `@cases`) instead of merging `data gen`'s output — so the deterministic BVA the generator
+ * would produce (e.g. email length 4/5/6 for `minLength: 5`) and the experience checklist (soft-deleted
+ * login…) can be silently missed. This check reconciles the authored values against BOTH:
+ *   - the BVA the field-map's constraints REQUIRE (per bounded dimension), and
+ *   - the auth-account-states experience checklist (for a login/auth unit).
+ * It matches fuzzily (authored keys are free-form): length for length dims, numeric value for numeric
+ * dims, keyword for experience. Advisory (warn) — a visible nudge the create-test loop must address or
+ * the QA waives; never blocks. Pure + deterministic.
+ */
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { parse as parseYaml } from 'yaml';
+import type { Catalog } from './types';
+import { expandField, type FieldMap, type FieldDef } from './generator';
+
+export interface CoverageFinding {
+  unit: string;
+  severity: 'warn' | 'info';
+  code: 'BVA_UNCOVERED' | 'EXPERIENCE_UNCOVERED';
+  field?: string;
+  message: string;
+}
+
+const STR_LEN_TYPES = new Set(['email', 'string', 'password', 'phone', 'postcode', 'katakana']);
+const NUM_TYPES = new Set(['number-integer', 'number-float', 'currency']);
+
+function unitTestDataPath(cwd: string, name: string): string | null {
+  for (const kind of ['screens', 'flows']) {
+    const p = join(cwd, 'qa', kind, name, 'test-data', `${name}.yaml`);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+function unitFeatureText(cwd: string, name: string): string {
+  for (const kind of ['screens', 'flows']) {
+    const dir = join(cwd, 'qa', kind, name, 'features');
+    if (!existsSync(dir)) continue;
+    try { return readdirSync(dir).filter((f) => f.endsWith('.feature')).map((f) => readFileSync(join(dir, f), 'utf8')).join('\n'); } catch { return ''; }
+  }
+  return '';
+}
+function loadYaml(p: string): Record<string, any> {
+  if (!existsSync(p)) return {};
+  try { return (parseYaml(readFileSync(p, 'utf8')) as Record<string, any>) || {}; } catch { return {}; }
+}
+
+/** Every string value anywhere in the test-data (top-level scalars + nested + `@cases` rows). */
+function collectStrings(data: Record<string, any>): string[] {
+  const out: string[] = [];
+  const walk = (v: unknown) => {
+    if (typeof v === 'string') out.push(v);
+    else if (Array.isArray(v)) v.forEach(walk);
+    else if (v && typeof v === 'object') Object.values(v as Record<string, unknown>).forEach(walk);
+  };
+  for (const [k, v] of Object.entries(data)) { if (k.startsWith('_')) continue; walk(v); }
+  return out;
+}
+
+/** Short human label for a boundary point (from its note / id). */
+function pointLabel(p: { id: string; note?: string }): string {
+  if (p.note) { const tail = p.note.split(/·|:/).pop()?.trim(); if (tail) return tail; }
+  return p.id.replace(/^CHK-[A-Z0-9]+-/, '');
+}
+
+/** BVA coverage for one field: which required boundary points are not represented among authored values. */
+function bvaGaps(field: FieldDef, catalog: Catalog, authored: string[]): string[] {
+  if (!field.type) return [];
+  const ef = expandField(field, catalog);
+  const synth = ef.points.filter((p) => p.synthesized && p.value != null);
+  if (!synth.length) return [];
+  const gaps: string[] = [];
+  const seen = new Set<string>();
+  if (STR_LEN_TYPES.has(field.type)) {
+    // Type-aware filter so an unrelated string of the same LENGTH doesn't falsely "cover" the boundary
+    // (e.g. a 5-char URL must not count as covering an email `minLength`-5 case). Email → values with
+    // an `@`; katakana → values with kana; others (generic string) stay loose.
+    const plausible =
+      field.type === 'email' ? authored.filter((s) => s.includes('@'))
+      : field.type === 'katakana' ? authored.filter((s) => /[゠-ヿｦ-ﾟ]/.test(s))
+      : authored;
+    const authoredLens = new Set(plausible.map((s) => s.length));
+    for (const p of synth) {
+      const len = (p.value as string).length;
+      const key = `len:${len}`;
+      if (seen.has(key) || authoredLens.has(len)) { seen.add(key); continue; }
+      seen.add(key);
+      gaps.push(`${pointLabel(p)} (length ${len}, ${p.expectedValidity})`);
+    }
+  } else if (NUM_TYPES.has(field.type)) {
+    const authoredNums = new Set(authored.map((s) => Number(s)).filter((n) => Number.isFinite(n)));
+    for (const p of synth) {
+      const n = Number(p.value);
+      const key = `num:${n}`;
+      if (seen.has(key) || authoredNums.has(n)) { seen.add(key); continue; }
+      seen.add(key);
+      gaps.push(`${pointLabel(p)} (value ${p.value}, ${p.expectedValidity})`);
+    }
+  }
+  return gaps;
+}
+
+/** Keyword patterns proving an auth-account-state is covered somewhere in the data/feature. */
+const STATE_COVERED: Record<string, RegExp> = {
+  active: /valid|active|success|happy/i,
+  'wrong-password': /wrong.?pass|password.?mismatch|incorrect.?pass|bad.?pass/i,
+  'non-existent-account': /unregister|non.?exist|not.*(exist|found|in nj)|no account/i,
+  'soft-deleted': /soft.?delet|deleted.?account|marked.?deleted|deleted_at/i,
+  'locked-or-suspended': /lock|suspend|inactive|disabled account/i,
+  'unverified-email': /unverif|not.?verified|pending.?verif|email.?verification/i,
+  'password-expired': /expir/i,
+  // valid-with-surrounding-whitespace is handled by a VALUE-level check (an actual email with
+  // leading/trailing space), not this blob regex — the word "trim" alone (from the empty-trim case)
+  // must NOT count as covering the valid-after-trim case.
+};
+
+/** Coverage check for one unit — BVA gaps per field + auth-experience gaps for a login/auth unit. */
+export function coverageUnit(cwd: string, name: string, catalog: Catalog): CoverageFinding[] {
+  const fmPath = join(cwd, 'qa', 'data-factory', `${name}.fields.yaml`);
+  if (!existsSync(fmPath)) return [];
+  const map = loadYaml(fmPath) as FieldMap;
+  if (!map || !Array.isArray(map.fields)) return [];
+  const tdPath = unitTestDataPath(cwd, name);
+  const data = tdPath ? loadYaml(tdPath) : {};
+  const authored = collectStrings(data);
+  const feature = unitFeatureText(cwd, name);
+  const blob = (authored.join('\n') + '\n' + JSON.stringify(data) + '\n' + feature).toLowerCase();
+  const out: CoverageFinding[] = [];
+
+  // 1. BVA coverage per field (flatten nested groups to leaves).
+  const leaves: FieldDef[] = [];
+  const walk = (fs: FieldDef[]) => { for (const f of fs) { if (f.fields) walk(f.fields); else leaves.push(f); } };
+  walk(map.fields);
+  for (const f of leaves) {
+    const gaps = bvaGaps(f, catalog, authored);
+    if (gaps.length) {
+      out.push({ unit: name, field: f.name, severity: 'warn', code: 'BVA_UNCOVERED',
+        message: `field "${f.name}" (${f.type}): ${gaps.length} boundary case(s) not represented in test-data — ${gaps.join('; ')}. The field-map's constraints require them (e.g. minLength → a below-min & at-min value); author them or waive with a reason.` });
+    }
+  }
+
+  // 2. Auth-experience coverage — only for a login/auth unit (has an email + a password field).
+  const isLogin = leaves.some((f) => f.type === 'email') && leaves.some((f) => f.type === 'password');
+  const exp = catalog.experience?.['auth-account-states'];
+  if (isLogin && exp) {
+    // An actual email value carrying leading/trailing whitespace = the valid-after-trim case covered.
+    const hasWhitespaceEmail = authored.some((s) => s.includes('@') && s !== s.trim());
+    const missing: string[] = [];
+    for (const c of exp.cases || []) {
+      const state = String((c as any).state || c.id);
+      if (state === 'valid-with-surrounding-whitespace') { if (!hasWhitespaceEmail) missing.push(state); continue; }
+      const re = STATE_COVERED[state];
+      if (re && !re.test(blob)) missing.push(state);
+    }
+    if (missing.length) {
+      out.push({ unit: name, severity: 'warn', code: 'EXPERIENCE_UNCOVERED',
+        message: `login unit: auth-account-states not covered — ${missing.join(', ')}. Each needs a credential-state scenario (a seeded account in that state → the correct rejection/route). Add them or waive per spec (some may be N/A).` });
+    }
+  }
+  return out;
+}

package/src/index.ts

@@ -36,6 +36,8 @@ export { crosscheckUnit, crosscheckShared, crosscheckAll, referencedVars } from
 export type { CrossFinding } from './crosscheck';
 export { detectUnit, hasInputFields, hasFieldMap, detectPreconditionSignals, hasStateDeclaration } from './detect';
 export type { DetectFinding } from './detect';
+export { coverageUnit } from './coverage';
+export type { CoverageFinding } from './coverage';
 export { registerDataFactoryCommand } from './cli';
 export { generateFixture } from './fixture';
 export type { FixtureResult, FixtureExpected, ExpectedRow } from './fixture';