test(config): simplify config composition coverage

Author: chenjiahan

packages/rstack/tests/config/compose.test.ts

@@ -1,6 +1,5 @@
 import assert from 'node:assert/strict';
 import { createRequire } from 'node:module';
-import type { Configs } from '../../src/config.ts';
 import { expect, rs, test } from 'rstack/test';
 import {
   composeConfigLayers,
@@ -19,60 +18,29 @@ rs.mock(
     ) as typeof import('../../src/rstestConfig.ts'),
 );
 
-const params = { command: 'build', env: 'production' } as const;
-
 test('preserves single definitions and leaves missing tools absent', async () => {
   const app = rs.fn(() => ({}));
-  const base: Configs = { app, lint: [] };
-  const project: Configs = { fmt: {} };
+  const base = { app };
+  const fmt = {};
 
   expect(await composeConfigLayers([])).toEqual({});
   expect(await composeConfigLayers([base])).toBe(base);
-  const configs = await composeConfigLayers([base, project]);
-  expect(configs).toEqual({ app, lint: base.lint, fmt: project.fmt });
-  expect(configs.lint).toBe(base.lint);
-  expect(configs.fmt).toBe(project.fmt);
+  const configs = await composeConfigLayers([base, { fmt }]);
+  expect(configs).toEqual({ app, fmt });
+  expect(configs.fmt).toBe(fmt);
   expect(app).not.toHaveBeenCalled();
 });
 
-test('composes tool definitions lazily and resolves each factory once', async () => {
-  const app = rs.fn(() => ({ source: { define: { APP: true } } }));
-  const lib = rs.fn(() => ({ lib: [{ format: 'esm' as const }] }));
-  const doc = rs.fn(() => Promise.resolve({ title: 'Shared' }));
-  const lint = rs.fn(() =>
-    Promise.resolve([{ rules: { 'no-debugger': 'error' as const } }]),
-  );
+test('resolves only the requested tool and preserves staged task generators', async () => {
+  const app = rs.fn(() => ({}));
   const fmt = rs.fn(() => ({ semi: false }));
   const staged = rs.fn(() => 'rs check');
   const configs = await composeConfigLayers([
-    { app, lib, doc, lint, fmt, staged: { '*.ts': 'rs lint' } },
-    {
-      app: {},
-      lib: {},
-      doc: { title: 'Project' },
-      lint: [],
-      fmt: { singleQuote: true },
-      staged,
-    },
+    { app, fmt, staged: { '*.ts': 'rs lint' } },
+    { app: {}, fmt: { singleQuote: true }, staged },
   ]);
 
-  for (const factory of [app, lib, doc, lint, fmt, staged]) {
-    expect(factory).not.toHaveBeenCalled();
-  }
-  expect(await resolveConfigLayers([configs], 'app', params)).toEqual([
-    { source: { define: { APP: true } } },
-  ]);
-  expect(lib).not.toHaveBeenCalled();
-  expect(doc).not.toHaveBeenCalled();
-  expect(await resolveConfigLayers([configs], 'lib', params)).toEqual([
-    { lib: [{ format: 'esm' }] },
-  ]);
-  expect(await resolveConfigLayers([configs], 'doc')).toEqual([
-    { title: 'Project' },
-  ]);
-  expect(await resolveConfigLayers([configs], 'lint')).toEqual([
-    [{ rules: { 'no-debugger': 'error' } }],
-  ]);
+  expect(fmt).not.toHaveBeenCalled();
   expect(
     await resolveFmtConfig({
       layers: [configs],
@@ -85,41 +53,36 @@ test('composes tool definitions lazily and resolves each factory once', async ()
     overrides: [],
     ignorePatterns: [],
   });
+  expect(fmt).toHaveBeenCalledExactlyOnceWith();
+  expect(app).not.toHaveBeenCalled();
   expect(configs.staged).toBe(staged);
   expect(staged).not.toHaveBeenCalled();
-  expect(app).toHaveBeenCalledExactlyOnceWith(params);
-  expect(lib).toHaveBeenCalledExactlyOnceWith(params);
-  for (const factory of [doc, lint, fmt]) {
-    expect(factory).toHaveBeenCalledExactlyOnceWith();
-  }
 });
 
-test('defers test inheritance until the consumer resolves the composed config', async () => {
+test('applies automatic inheritance after merging test definitions', async () => {
   const app = rs.fn(() => ({ source: { define: { SHARED: true } } }));
   const configs = await composeConfigLayers([
     { app, test: { retry: 1 } },
     {
       app: { source: { define: { PROJECT: true } } },
-      test: { projects: [{ name: 'a' }, { name: 'b' }] },
+      test: { testTimeout: 5000 },
     },
   ]);
-  const raw = await resolveConfigLayers([configs], 'test');
-  expect(raw).toEqual([{ retry: 1, projects: [{ name: 'a' }, { name: 'b' }] }]);
+
+  expect(await resolveConfigLayers([configs], 'test')).toEqual([
+    { retry: 1, testTimeout: 5000 },
+  ]);
   expect(app).not.toHaveBeenCalled();
 
+  const params = { command: 'build', env: 'production' } as const;
   const config = await resolveRstestConfig([configs], params);
-  const first = config.projects?.[0];
-  assert(
-    first && typeof first !== 'string' && typeof first.extends === 'function',
-  );
+  assert(typeof config.extends === 'function');
   expect(config).toEqual({
     retry: 1,
-    projects: [
-      { name: 'a', extends: first.extends },
-      { name: 'b', extends: first.extends },
-    ],
+    testTimeout: 5000,
+    extends: config.extends,
   });
-  expect(await first.extends(first)).toMatchObject({
+  expect(await config.extends(config)).toMatchObject({
     source: { define: { SHARED: true, PROJECT: true } },
   });
   expect(app).toHaveBeenCalledExactlyOnceWith(params);