@testspectra/cli 1.0.70 → 1.1.0-rc.1

package/dist/generator/__tests__/tsconfig-isolation.test.js

@@ -0,0 +1,282 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'child_process';
+import { TsConfigGenerator } from '../tsconfig-generator.js';
+import { TypeGenerator } from '../type-generator.js';
+function linkNodeModules(targetDir) {
+    let root = process.cwd();
+    while (root && root !== path.dirname(root)) {
+        if (fs.existsSync(path.join(root, 'pnpm-workspace.yaml'))) {
+            break;
+        }
+        root = path.dirname(root);
+    }
+    const pnpmNodeModules = path.join(root, 'node_modules', '.pnpm', 'node_modules');
+    fs.symlinkSync(pnpmNodeModules, path.join(targetDir, 'node_modules'), 'junction');
+}
+describe('Platform TSConfigs & Type Isolation (docs/v2/cli/tsconfig-platform-isolation.md)', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'testspectra-tsconfig-test-')));
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+    });
+    it('scaffolds all 5 solution configurations in .testspectra/tsconfig/ and dynamic master solution orchestrator', () => {
+        const written = TsConfigGenerator.scaffoldConfigs(tmpDir);
+        expect(written['tsconfig.json']).toBeDefined();
+        expect(written['.testspectra/tsconfig.json']).toBeDefined();
+        expect(written['web.json']).toBeDefined();
+        expect(written['mobile.json']).toBeDefined();
+        expect(written['android.json']).toBeDefined();
+        expect(written['ios.json']).toBeDefined();
+        expect(written['common.json']).toBeDefined();
+        // Verify root references .testspectra/tsconfig.json
+        const rootConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, 'tsconfig.json'), 'utf-8'));
+        expect(rootConfig.references).toEqual([{ path: './.testspectra/tsconfig.json' }]);
+        // Verify dynamic master solution references all 5 platform solution tsconfigs in .testspectra/tsconfig/
+        const solutionConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig.json'), 'utf-8'));
+        expect(solutionConfig.compilerOptions.noEmit).toBe(true);
+        expect(solutionConfig.references).toEqual([
+            { path: './tsconfig/web.json' },
+            { path: './tsconfig/mobile.json' },
+            { path: './tsconfig/android.json' },
+            { path: './tsconfig/ios.json' },
+            { path: './tsconfig/common.json' },
+        ]);
+    });
+    it('verifies common tsconfig enforces strict isolation (excludes web, mobile, android, ios)', () => {
+        TsConfigGenerator.scaffoldConfigs(tmpDir);
+        const commonConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig', 'common.json'), 'utf-8'));
+        expect(commonConfig.compilerOptions.composite).toBe(true);
+        expect(commonConfig.compilerOptions.noEmit).toBe(true);
+        // Includes only common.d.ts and fixtures.d.ts
+        expect(commonConfig.include).toContain('../types/common.d.ts');
+        expect(commonConfig.include).toContain('../types/fixtures.d.ts');
+        expect(commonConfig.include).not.toContain('../types/web.d.ts');
+        expect(commonConfig.include).not.toContain('../types/mobile.d.ts');
+        // Excludes platform-specific tests and page objects
+        expect(commonConfig.exclude).toContain('../../**/page-objects/**/web.ts');
+        expect(commonConfig.exclude).toContain('../../**/page-objects/**/android.ts');
+        expect(commonConfig.exclude).toContain('../../**/page-objects/**/ios.ts');
+        expect(commonConfig.exclude).toContain('../../**/page-objects/**/mobile.ts');
+        expect(commonConfig.exclude).toContain('../../**/specs/**/web.test.ts');
+        expect(commonConfig.exclude).toContain('../../**/specs/**/android.test.ts');
+        expect(commonConfig.exclude).toContain('../../**/specs/**/ios.test.ts');
+        expect(commonConfig.exclude).toContain('../../**/specs/**/mobile.test.ts');
+    });
+    it('verifies mobile tsconfig enforces strict mobile isolation (excludes web, android, ios)', () => {
+        TsConfigGenerator.scaffoldConfigs(tmpDir);
+        const mobileConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig', 'mobile.json'), 'utf-8'));
+        expect(mobileConfig.compilerOptions.composite).toBe(true);
+        expect(mobileConfig.compilerOptions.noEmit).toBe(true);
+        expect(mobileConfig.include).toContain('../types/mobile.d.ts');
+        expect(mobileConfig.include).toContain('../types/fixtures.d.ts');
+        expect(mobileConfig.include).not.toContain('../types/web.d.ts');
+        expect(mobileConfig.exclude).toContain('../../**/page-objects/**/web.ts');
+        expect(mobileConfig.exclude).toContain('../../**/page-objects/**/android.ts');
+        expect(mobileConfig.exclude).toContain('../../**/page-objects/**/ios.ts');
+        expect(mobileConfig.exclude).toContain('../../**/specs/**/web.test.ts');
+        expect(mobileConfig.exclude).toContain('../../**/specs/**/android.test.ts');
+        expect(mobileConfig.exclude).toContain('../../**/specs/**/ios.test.ts');
+    });
+    it('verifies web tsconfig includes web and common, excluding android, ios, and mobile', () => {
+        TsConfigGenerator.scaffoldConfigs(tmpDir);
+        const webConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig', 'web.json'), 'utf-8'));
+        expect(webConfig.compilerOptions.composite).toBe(true);
+        expect(webConfig.compilerOptions.noEmit).toBe(true);
+        expect(webConfig.include).toContain('../types/web.d.ts');
+        expect(webConfig.include).toContain('../types/fixtures.d.ts');
+        expect(webConfig.exclude).toContain('../../**/page-objects/**/android.ts');
+        expect(webConfig.exclude).toContain('../../**/page-objects/**/ios.ts');
+        expect(webConfig.exclude).toContain('../../**/page-objects/**/mobile.ts');
+        expect(webConfig.exclude).toContain('../../**/specs/**/android.test.ts');
+        expect(webConfig.exclude).toContain('../../**/specs/**/ios.test.ts');
+        expect(webConfig.exclude).toContain('../../**/specs/**/mobile.test.ts');
+    });
+    it('verifies android and ios tsconfigs isolate their respective native platforms', () => {
+        TsConfigGenerator.scaffoldConfigs(tmpDir);
+        const androidConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig', 'android.json'), 'utf-8'));
+        const iosConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig', 'ios.json'), 'utf-8'));
+        // Android excludes web and ios
+        expect(androidConfig.include).toContain('../types/android.d.ts');
+        expect(androidConfig.exclude).toContain('../../**/page-objects/**/web.ts');
+        expect(androidConfig.exclude).toContain('../../**/page-objects/**/ios.ts');
+        expect(androidConfig.exclude).toContain('../../**/specs/**/web.test.ts');
+        expect(androidConfig.exclude).toContain('../../**/specs/**/ios.test.ts');
+        // iOS excludes web and android
+        expect(iosConfig.include).toContain('../types/ios.d.ts');
+        expect(iosConfig.exclude).toContain('../../**/page-objects/**/web.ts');
+        expect(iosConfig.exclude).toContain('../../**/page-objects/**/android.ts');
+        expect(iosConfig.exclude).toContain('../../**/specs/**/web.test.ts');
+        expect(iosConfig.exclude).toContain('../../**/specs/**/android.test.ts');
+    });
+    it('E2E: compiles all 5 platform solution projects via tsc -b with 0 errors', () => {
+        // 1. Link node_modules for @wdio and @types resolution
+        linkNodeModules(tmpDir);
+        // 2. Scaffold all 7 solution configurations
+        TsConfigGenerator.scaffoldConfigs(tmpDir);
+        // 3. Create Page Objects for web, android, ios, mobile, common
+        const poDir = path.join(tmpDir, 'page-objects');
+        fs.mkdirSync(path.join(poDir, 'WebPO'), { recursive: true });
+        fs.writeFileSync(path.join(poDir, 'WebPO', 'web.ts'), 'export default class WebPO { static title = "web"; }');
+        fs.mkdirSync(path.join(poDir, 'MobilePO'), { recursive: true });
+        fs.writeFileSync(path.join(poDir, 'MobilePO', 'mobile.ts'), 'export default class MobilePO { static title = "mobile"; }');
+        fs.mkdirSync(path.join(poDir, 'AndroidPO'), { recursive: true });
+        fs.writeFileSync(path.join(poDir, 'AndroidPO', 'android.ts'), 'export default class AndroidPO { static title = "android"; }');
+        fs.mkdirSync(path.join(poDir, 'IosPO'), { recursive: true });
+        fs.writeFileSync(path.join(poDir, 'IosPO', 'ios.ts'), 'export default class IosPO { static title = "ios"; }');
+        fs.mkdirSync(path.join(poDir, 'CommonPO'), { recursive: true });
+        fs.writeFileSync(path.join(poDir, 'CommonPO', 'common.ts'), 'export default class CommonPO { static title = "common"; }');
+        // 4. Generate ambient types
+        TypeGenerator.generateAll(tmpDir);
+        // 5. Create valid test files respecting each platform hierarchy
+        const specsDir = path.join(tmpDir, 'specs');
+        fs.mkdirSync(specsDir, { recursive: true });
+        fs.writeFileSync(path.join(specsDir, 'web.test.ts'), 'const a: string = WebPO.title;\nconst b: string = CommonPO.title;\n');
+        fs.writeFileSync(path.join(specsDir, 'mobile.test.ts'), 'const a: string = MobilePO.title;\nconst b: string = CommonPO.title;\n');
+        fs.writeFileSync(path.join(specsDir, 'android.test.ts'), 'const a: string = AndroidPO.title;\nconst b: string = MobilePO.title;\nconst c: string = CommonPO.title;\n');
+        fs.writeFileSync(path.join(specsDir, 'ios.test.ts'), 'const a: string = IosPO.title;\nconst b: string = MobilePO.title;\nconst c: string = CommonPO.title;\n');
+        fs.writeFileSync(path.join(specsDir, 'common.test.ts'), 'const a: string = CommonPO.title;\n');
+        // 6. Execute tsc -b: MUST compile cleanly with exit code 0
+        expect(() => {
+            execSync(`npx tsc -b ${tmpDir}`, { stdio: 'pipe' });
+        }).not.toThrow();
+    });
+    it('E2E: strictly blocks type leakage from Web into common.test.ts via tsc -b', () => {
+        linkNodeModules(tmpDir);
+        TsConfigGenerator.scaffoldConfigs(tmpDir);
+        fs.mkdirSync(path.join(tmpDir, 'page-objects', 'WebPO'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, 'page-objects', 'WebPO', 'web.ts'), 'export default class WebPO { static title = "web"; }');
+        fs.mkdirSync(path.join(tmpDir, 'page-objects', 'CommonPO'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, 'page-objects', 'CommonPO', 'common.ts'), 'export default class CommonPO { static title = "common"; }');
+        TypeGenerator.generateAll(tmpDir);
+        const specsDir = path.join(tmpDir, 'specs');
+        fs.mkdirSync(specsDir, { recursive: true });
+        fs.writeFileSync(path.join(specsDir, 'web.test.ts'), 'const a: string = WebPO.title;\n');
+        // Deliberate type leak: common.test.ts references WebPO!
+        fs.writeFileSync(path.join(specsDir, 'common.test.ts'), 'const leak = WebPO.title;\n');
+        // tsc -b MUST fail with TS2304: Cannot find name 'WebPO'
+        let threw = false;
+        let errorMessage = '';
+        try {
+            execSync(`npx tsc -b ${tmpDir}`, { stdio: 'pipe' });
+        }
+        catch (err) {
+            threw = true;
+            errorMessage = (err.stdout?.toString() || '') + (err.stderr?.toString() || '');
+        }
+        expect(threw).toBe(true);
+        expect(errorMessage).toContain("Cannot find name 'WebPO'");
+    });
+    it('E2E: strictly blocks type leakage from Android into mobile.test.ts via tsc -b', () => {
+        linkNodeModules(tmpDir);
+        TsConfigGenerator.scaffoldConfigs(tmpDir);
+        fs.mkdirSync(path.join(tmpDir, 'page-objects', 'AndroidPO'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, 'page-objects', 'AndroidPO', 'android.ts'), 'export default class AndroidPO { static title = "android"; }');
+        fs.mkdirSync(path.join(tmpDir, 'page-objects', 'MobilePO'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, 'page-objects', 'MobilePO', 'mobile.ts'), 'export default class MobilePO { static title = "mobile"; }');
+        TypeGenerator.generateAll(tmpDir);
+        const specsDir = path.join(tmpDir, 'specs');
+        fs.mkdirSync(specsDir, { recursive: true });
+        fs.writeFileSync(path.join(specsDir, 'android.test.ts'), 'const a: string = AndroidPO.title;\n');
+        // Deliberate type leak: mobile.test.ts references AndroidPO!
+        fs.writeFileSync(path.join(specsDir, 'mobile.test.ts'), 'const leak = AndroidPO.title;\n');
+        // tsc -b MUST fail with TS2304: Cannot find name 'AndroidPO'
+        let threw = false;
+        let errorMessage = '';
+        try {
+            execSync(`npx tsc -b ${tmpDir}`, { stdio: 'pipe' });
+        }
+        catch (err) {
+            threw = true;
+            errorMessage = (err.stdout?.toString() || '') + (err.stderr?.toString() || '');
+        }
+        expect(threw).toBe(true);
+        expect(errorMessage).toContain("Cannot find name 'AndroidPO'");
+    });
+    it('verifies nx monorepo template contains single root entry and .testspectra/tsconfig.json dynamic orchestrator', () => {
+        let root = process.cwd();
+        while (root && root !== path.dirname(root)) {
+            if (fs.existsSync(path.join(root, 'pnpm-workspace.yaml')))
+                break;
+            root = path.dirname(root);
+        }
+        const nxTemplateDir = path.join(root, 'cli', 'templates', 'nx');
+        // Generate latest ambient types and tsconfigs
+        TypeGenerator.generateAll(nxTemplateDir);
+        expect(fs.existsSync(path.join(nxTemplateDir, 'tsconfig.json'))).toBe(true);
+        expect(fs.existsSync(path.join(nxTemplateDir, '.testspectra', 'tsconfig.json'))).toBe(true);
+        const rootConfig = JSON.parse(fs.readFileSync(path.join(nxTemplateDir, 'tsconfig.json'), 'utf-8'));
+        expect(rootConfig.references).toEqual([{ path: './.testspectra/tsconfig.json' }]);
+        const expectedSubConfigs = ['web.json', 'mobile.json', 'android.json', 'ios.json', 'common.json'];
+        for (const sub of expectedSubConfigs) {
+            const configPath = path.join(nxTemplateDir, '.testspectra', 'tsconfig', sub);
+            expect(fs.existsSync(configPath)).toBe(true);
+            const parsed = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            expect(parsed.compilerOptions?.composite).toBe(true);
+            expect(parsed.compilerOptions?.noEmit).toBe(true);
+        }
+    });
+    it('E2E: strictly enforces Directional Boundary between Shared library and Feature modules in monorepo via tsc -b', () => {
+        linkNodeModules(tmpDir);
+        // 1. Create Shared library
+        const sharedDir = path.join(tmpDir, 'shared', 'testing');
+        fs.mkdirSync(path.join(sharedDir, 'page-objects', 'SharedNavbar'), { recursive: true });
+        fs.writeFileSync(path.join(sharedDir, 'page-objects', 'SharedNavbar', 'web.ts'), 'export default class SharedNavbar { static navTitle = "shared-nav"; }');
+        // 2. Create Feature module: packages/auth/e2e
+        const featureDir = path.join(tmpDir, 'packages', 'auth', 'e2e');
+        fs.mkdirSync(path.join(featureDir, 'page-objects', 'AuthLoginPage'), { recursive: true });
+        fs.writeFileSync(path.join(featureDir, 'page-objects', 'AuthLoginPage', 'web.ts'), 'export default class AuthLoginPage { static loginTitle = "auth-login"; }');
+        // 3. Feature uses Shared -> Allowed!
+        fs.mkdirSync(path.join(featureDir, 'specs'), { recursive: true });
+        fs.writeFileSync(path.join(featureDir, 'specs', 'login.web.test.ts'), 'const a: string = SharedNavbar.navTitle;\nconst b: string = AuthLoginPage.loginTitle;\n');
+        // 4. Generate Scoped TSConfigs & Ambient Types
+        TypeGenerator.generateAll(tmpDir);
+        try {
+            execSync(`npx tsc -b ${tmpDir}`, { stdio: 'pipe' });
+        }
+        catch (err) {
+            console.log('STEP 4 ERROR:', err.stdout?.toString(), err.stderr?.toString());
+            throw err;
+        }
+        // 5. Shared illegally attempts to access Feature's AuthLoginPage -> MUST FAIL with TS2304
+        fs.mkdirSync(path.join(sharedDir, 'support', 'steps'), { recursive: true });
+        fs.writeFileSync(path.join(sharedDir, 'support', 'steps', 'illegalLeak.web.ts'), 'const leak = AuthLoginPage.loginTitle;\n');
+        TypeGenerator.generateAll(tmpDir);
+        let threw = false;
+        let errorMessage = '';
+        try {
+            execSync(`npx tsc -b ${tmpDir}`, { stdio: 'pipe' });
+        }
+        catch (err) {
+            threw = true;
+            errorMessage = (err.stdout?.toString() || '') + (err.stderr?.toString() || '');
+        }
+        expect(threw).toBe(true);
+        expect(errorMessage).toContain("Cannot find name 'AuthLoginPage'");
+    });
+    it('E2E: compiles the full Nx monorepo template via tsc -b with 0 errors', async () => {
+        let root = process.cwd();
+        while (root && root !== path.dirname(root)) {
+            if (fs.existsSync(path.join(root, 'pnpm-workspace.yaml')))
+                break;
+            root = path.dirname(root);
+        }
+        const nxTemplateDir = path.join(root, 'cli', 'templates', 'nx');
+        // Generate latest ambient types for the nx template, including env.d.ts (a separate async
+        // step — see TypeGenerator.syncEnvDeclaration — since spectra.config.ts's
+        // executionConfig.environmentVariables is what the template's EnvironmentConfig suite
+        // exercises via the typed Env global).
+        TypeGenerator.generateAll(nxTemplateDir);
+        await TypeGenerator.syncEnvDeclaration(nxTemplateDir);
+        expect(() => {
+            execSync(`npx tsc -b ${nxTemplateDir}`, { stdio: 'pipe' });
+        }).not.toThrow();
+    });
+});

package/dist/generator/__tests__/type-generator.test.d.ts

@@ -0,0 +1 @@
+export {};