test(ci): wire jest into CI with regression specs for 2026-04-22 fixes

Previously the only CI check was `npm run build`, which type-checks but
never runs tests. This commit activates jest in CI via a scoped
`jest.config.ci.js` so the suite passes today while the broader ESM /
@ngneat/transloco migration is tackled separately.

Adds regression specs for each bug hit on the customer fire-drill:

* df-loading-spinner.service.spec.ts — rapid toggles inside one tick now
  settle to false (was stuck-on due to stale BehaviorSubject read).
* case.interceptor.spec.ts — /system/event responses pass through
  unchanged; /api_docs exemption still works; body request transforms
  still convert camelCase → snake_case.
* df-script-details.submit.spec.ts — submit fallback uses `||` (not
  `??`) so empty completeScriptName falls back to selectedRouteItem;
  template wiring verified for all three mat-selects; raw serviceName
  lookup (no re-introduction of the api_docs → apiDocs rename).

Also adds "node" to tsconfig.spec.json types so specs can `readFileSync`
the committed HTML/TS for contract assertions.

Author: nicdavidson

.github/workflows/node.js.yml

@@ -25,4 +25,9 @@ jobs:
           node-version: ${{ matrix.node-version }}
           cache: 'npm'
       - run: npm ci
+      - run: npm run lint --if-present
+      # `test:ci` runs only the specs that currently pass. The rest are
+      # quarantined by jest.config.ci.js until the @ngneat/transloco ESM
+      # migration is completed. New tests should be added to that config.
+      - run: npm run test:ci
       - run: npm run build --if-present

jest.config.ci.js

@@ -0,0 +1,35 @@
+/**
+ * CI Jest config.
+ *
+ * Extends the base jest.config.js but scopes the run to the specs that
+ * currently pass. The rest of the suite (55 suites as of 2026-04-22)
+ * fails because @ngneat/transloco now ships ESM-only (.mjs) and
+ * jest-preset-angular 13 in the current setup can't resolve it without
+ * a broader ESM migration.
+ *
+ * Tracking: "Jest ESM migration for transloco" — once done, this file
+ * can be deleted and CI can call the default `npm test`.
+ *
+ * New tests should be added to the testMatch list below as they are
+ * written, so they fail CI if they regress.
+ */
+const base = require('./jest.config');
+
+module.exports = {
+  ...base,
+  testMatch: [
+    // Regression coverage for the 2026-04-22 customer fire-drill fixes.
+    '<rootDir>/src/app/shared/services/df-loading-spinner.service.spec.ts',
+    '<rootDir>/src/app/shared/interceptors/case.interceptor.spec.ts',
+    '<rootDir>/src/app/adf-event-scripts/df-script-details/df-script-details.submit.spec.ts',
+    // Existing specs that currently pass. The rest of the suite is
+    // quarantined until the ESM/transloco migration; route.spec.ts is
+    // a separate pre-existing assertion mismatch.
+    '<rootDir>/src/app/shared/utilities/url.spec.ts',
+    '<rootDir>/src/app/shared/utilities/language.spec.ts',
+    '<rootDir>/src/app/shared/utilities/case.spec.ts',
+    '<rootDir>/src/app/shared/utilities/file.spec.ts',
+    '<rootDir>/src/app/shared/services/df-breakpoint.service.spec.ts',
+    '<rootDir>/src/app/shared/services/df-theme.service.spec.ts',
+  ],
+};

package.json

@@ -7,6 +7,7 @@
     "build": "ng build",
     "watch": "ng build --watch --configuration development",
     "test": "jest --verbose",
+    "test:ci": "jest --ci --watchAll=false --passWithNoTests --config jest.config.ci.js",
     "test:coverage": "jest --coverage",
     "test:watch": "jest --watch",
     "lint": "ng lint",

src/app/adf-event-scripts/df-script-details/df-script-details.submit.spec.ts

@@ -0,0 +1,99 @@
+/**
+ * Focused regressions for the submit path in DfScriptDetailsComponent.
+ *
+ * These tests do not boot the full component — Angular Router + transloco +
+ * Material make a full TestBed harness expensive. We exercise the pure
+ * fallback and grep the committed HTML/TS to prove that the wiring which
+ * broke a customer install on 2026-04-22 cannot silently regress.
+ */
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+const HTML_SRC = readFileSync(
+  join(__dirname, 'df-script-details.component.html'),
+  'utf8'
+);
+const TS_SRC = readFileSync(
+  join(__dirname, 'df-script-details.component.ts'),
+  'utf8'
+);
+
+describe('DfScriptDetailsComponent submit logic', () => {
+  it('falls back on empty completeScriptName to selectedRouteItem', () => {
+    // selectedServiceItemEvent() resets completeScriptName to '' (not null).
+    // The old code used `??` which does not treat '' as missing, so
+    // scriptItem.name became '' and the POST URL dropped the resource name
+    // producing a 400 "No record(s) detected" from the backend.
+    const completeScriptName = '';
+    const selectedRouteItem = 'test_underscore._schema.get.pre_process';
+
+    const name = completeScriptName || selectedRouteItem;
+
+    expect(name).toBe('test_underscore._schema.get.pre_process');
+  });
+
+  it('prefers completeScriptName when set by selectedTable/selectedRoute', () => {
+    const completeScriptName = 'db._schema.table_name.get.pre_process';
+    const selectedRouteItem = 'db._schema.{table_name}.get.pre_process';
+
+    const name = completeScriptName || selectedRouteItem;
+
+    expect(name).toBe('db._schema.table_name.get.pre_process');
+  });
+
+  it('submit source uses `||` (not `??`) for the name fallback', () => {
+    // Guard the exact call site — `??` would regress the empty-string bug.
+    expect(TS_SRC).toMatch(
+      /name:\s*this\.completeScriptName\s*\|\|\s*this\.selectedRouteItem/
+    );
+    expect(TS_SRC).not.toMatch(
+      /name:\s*this\.completeScriptName\s*\?\?\s*this\.selectedRouteItem/
+    );
+  });
+});
+
+describe('DfScriptDetailsComponent template wiring contract', () => {
+  // The three mat-selects must fire their change handlers. Removing any
+  // (selectionChange) binding was what broke saving on the customer call.
+  it('Script Method mat-select has (selectionChange)="selectedRoute()"', () => {
+    const methodBlock = HTML_SRC.match(
+      /scripts\.scriptMethod[\s\S]*?<\/mat-form-field>/
+    );
+    expect(methodBlock).not.toBeNull();
+    expect(methodBlock![0]).toContain('(selectionChange)="selectedRoute()"');
+  });
+
+  it('Service mat-select has (selectionChange)="selectedServiceItemEvent()"', () => {
+    const serviceBlock = HTML_SRC.match(
+      /'service' \| transloco[\s\S]*?<\/mat-form-field>/
+    );
+    expect(serviceBlock).not.toBeNull();
+    expect(serviceBlock![0]).toContain(
+      '(selectionChange)="selectedServiceItemEvent()"'
+    );
+  });
+
+  it('Script Type mat-select has (selectionChange)="selectedEventItemEvent()"', () => {
+    const typeBlock = HTML_SRC.match(
+      /scripts\.scriptType[\s\S]*?<\/mat-form-field>/
+    );
+    expect(typeBlock).not.toBeNull();
+    expect(typeBlock![0]).toContain(
+      '(selectionChange)="selectedEventItemEvent()"'
+    );
+  });
+});
+
+describe('DfScriptDetailsComponent service lookup key', () => {
+  // /system/event responses are exempt from the case interceptor
+  // (see case.interceptor.ts). The component must look up
+  // response[serviceName] with the raw service name; the hardcoded
+  // api_docs -> apiDocs rename must NOT return.
+  it('does not reintroduce the api_docs → apiDocs rename', () => {
+    expect(TS_SRC).not.toMatch(/serviceKey\s*=\s*['"]apiDocs['"]/);
+  });
+
+  it('looks up events using the raw serviceName', () => {
+    expect(TS_SRC).toMatch(/response\[serviceName\]/);
+  });
+});

src/app/shared/interceptors/case.interceptor.spec.ts

@@ -0,0 +1,91 @@
+import { TestBed } from '@angular/core/testing';
+import {
+  HttpClient,
+  provideHttpClient,
+  withInterceptors,
+} from '@angular/common/http';
+import {
+  HttpTestingController,
+  provideHttpClientTesting,
+} from '@angular/common/http/testing';
+import { caseInterceptor } from './case.interceptor';
+
+describe('caseInterceptor', () => {
+  let http: HttpClient;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(withInterceptors([caseInterceptor])),
+        provideHttpClientTesting(),
+      ],
+    });
+    http = TestBed.inject(HttpClient);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => httpMock.verify());
+
+  it('transforms snake_case response keys to camelCase for normal endpoints', done => {
+    http.get('/api/v2/system/service').subscribe((body: any) => {
+      expect(body.some_key).toBeUndefined();
+      expect(body.someKey).toBe('v');
+      done();
+    });
+    const req = httpMock.expectOne('/api/v2/system/service');
+    req.flush(
+      { some_key: 'v' },
+      { headers: { 'Content-Type': 'application/json' } }
+    );
+  });
+
+  it('passes /system/event responses through unchanged', done => {
+    // Regression: event names are response keys and the backend matches
+    // scripts by the raw string. Transforming to camelCase would break the
+    // Script Type dropdown and corrupt saved script names for any service
+    // whose name contains an underscore.
+    const raw = {
+      test_underscore: {
+        'test_underscore._schema': { endpoints: ['a.b.c'] },
+      },
+    };
+    http
+      .get('/api/v2/system/event?services_only=true')
+      .subscribe((body: any) => {
+        expect(body).toEqual(raw);
+        done();
+      });
+    const req = httpMock.expectOne('/api/v2/system/event?services_only=true');
+    req.flush(raw, { headers: { 'Content-Type': 'application/json' } });
+  });
+
+  it('passes /api_docs responses through unchanged (OpenAPI keys must survive)', done => {
+    const raw = { 'x-custom': 1, paths: { '/foo_bar': {} } };
+    http.get('/api/v2/api_docs/swagger').subscribe((body: any) => {
+      expect(body).toEqual(raw);
+      done();
+    });
+    const req = httpMock.expectOne('/api/v2/api_docs/swagger');
+    req.flush(raw, { headers: { 'Content-Type': 'application/json' } });
+  });
+
+  it('converts camelCase request bodies to snake_case', () => {
+    http
+      .post('/api/v2/system/service', { isActive: true, apiKey: 'x' })
+      .subscribe();
+    const req = httpMock.expectOne('/api/v2/system/service');
+    expect(req.request.body).toEqual({ is_active: true, api_key: 'x' });
+    req.flush({});
+  });
+
+  it('does not transform requests that fall outside /api', () => {
+    http.get('/dreamfactory/dist/assets/i18n/en.json').subscribe();
+    const req = httpMock.expectOne('/dreamfactory/dist/assets/i18n/en.json');
+    req.flush(
+      { some_key: 'v' },
+      { headers: { 'Content-Type': 'application/json' } }
+    );
+    // no assertion besides: no error, no transform applied
+  });
+});

src/app/shared/services/df-loading-spinner.service.spec.ts

@@ -49,4 +49,27 @@ describe('DfLoadingSpinnerService', () => {
 
     service.active = false;
   });
+
+  it('settles to inactive when three requests start and finish inside one tick', async () => {
+    // Regression for the stuck spinner bug: the previous setTimeout-based
+    // implementation compared shouldBeActive to active$.value, which was
+    // stale during rapid toggles and lost the final deactivate. After
+    // queuedMicrotasks run, the subject must be false.
+    const observed: boolean[] = [];
+    service.active.subscribe(v => observed.push(v));
+
+    // Simulate three concurrent requests starting and finishing in one tick.
+    service.active = true;
+    service.active = true;
+    service.active = true;
+    service.active = false;
+    service.active = false;
+    service.active = false;
+
+    // Flush all pending microtasks.
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(observed[observed.length - 1]).toBe(false);
+  });
 });

tsconfig.spec.json

@@ -4,7 +4,7 @@
   "compilerOptions": {
     "outDir": "./out-tsc/spec",
     "module": "CommonJs",
-    "types": ["jest"]
+    "types": ["jest", "node"]
   },
   "include": ["src/**/*.spec.ts", "src/**/*.d.ts"]
 }