참고소스 수정본

참고/playwright-main/tests/playwright-test/config.spec.ts

@@ -0,0 +1,790 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { test, expect } from './playwright-test-fixtures';
+
+test('should be able to define config', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { timeout: 12345 };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        expect(testInfo.timeout).toBe(12345);
+      });
+    `
+  });
+
+  expect(result.exitCode).toBe(0);
+  expect(result.passed).toBe(1);
+});
+
+test('should prioritize project timeout', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { timeout: 500, projects: [{ timeout: 10000}, {}] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        await new Promise(f => setTimeout(f, 1500));
+      });
+    `
+  });
+
+  expect(result.exitCode).toBe(1);
+  expect(result.passed).toBe(1);
+  expect(result.failed).toBe(1);
+  expect(result.output).toContain('Test timeout of 500ms exceeded.');
+});
+
+test('should prioritize command line timeout over project timeout', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [{ timeout: 10000}] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        await new Promise(f => setTimeout(f, 1500));
+      });
+    `
+  }, { timeout: '500' });
+
+  expect(result.exitCode).toBe(1);
+  expect(result.failed).toBe(1);
+  expect(result.output).toContain('Test timeout of 500ms exceeded.');
+});
+
+test('should support failOnFlakyTests config option', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+        module.exports = {
+          failOnFlakyTests: true,
+          retries: 1
+        };
+    `,
+    'a.test.js': `
+      import { test, expect } from '@playwright/test';
+      test('flake', async ({}, testInfo) => {
+        expect(testInfo.retry).toBe(1);
+      });
+    `,
+  }, { 'retries': 1 });
+  expect(result.exitCode).not.toBe(0);
+  expect(result.flaky).toBe(1);
+});
+
+test('should read config from --config, resolve relative testDir', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'my.config.ts': `
+      import * as path from 'path';
+      module.exports = {
+        testDir: 'dir',
+      };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('ignored', async ({}) => {
+      });
+    `,
+    'dir/b.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('run', async ({}) => {
+      });
+    `,
+  }, { config: 'my.config.ts' });
+
+  expect(result.exitCode).toBe(0);
+  expect(result.passed).toBe(1);
+  expect(result.report.suites.length).toBe(1);
+  expect(result.report.suites[0].file).toBe('b.test.ts');
+});
+
+test('should default testDir to the config file', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'dir/my.config.ts': `
+      module.exports = {};
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('ignored', async ({}) => {
+      });
+    `,
+    'dir/b.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('run', async ({}) => {
+      });
+    `,
+  }, { config: path.join('dir', 'my.config.ts') });
+
+  expect(result.exitCode).toBe(0);
+  expect(result.passed).toBe(1);
+  expect(result.report.suites.length).toBe(1);
+  expect(result.report.suites[0].file).toBe('b.test.ts');
+});
+
+test('should be able to set reporters', async ({ runInlineTest }, testInfo) => {
+  const reportFile = testInfo.outputPath('my-report.json');
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = {
+        reporter: [
+          ['json', { outputFile: ${JSON.stringify(reportFile)} }],
+          ['list'],
+        ]
+      };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async () => {
+      });
+    `
+  }, { reporter: '' });
+  expect(result.exitCode).toBe(0);
+  expect(result.passed).toBe(1);
+  const report = JSON.parse(fs.readFileSync(reportFile).toString());
+  expect(report.suites[0].file).toBe('a.test.ts');
+});
+
+test('should support different testDirs', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      import * as path from 'path';
+      module.exports = { projects: [
+        { testDir: __dirname },
+        { testDir: 'dir' },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('runs once', async ({}) => {
+      });
+    `,
+    'dir/b.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('runs twice', async ({}) => {
+      });
+    `,
+  });
+
+  expect(result.exitCode).toBe(0);
+  expect(result.passed).toBe(3);
+
+  expect(result.report.suites[0].specs[0].tests.length).toBe(1);
+  expect(result.report.suites[0].specs[0].title).toBe('runs once');
+
+  expect(result.report.suites[1].specs[0].tests.length).toBe(2);
+  expect(result.report.suites[1].specs[0].title).toBe('runs twice');
+});
+
+
+test('should allow root testDir and use it for relative paths', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'config/config.ts': `
+      import * as path from 'path';
+      module.exports = {
+        testDir: path.join(__dirname, '..'),
+        projects: [{ testDir: path.join(__dirname, '..', 'dir') }]
+      };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('fails', async ({}, testInfo) => {
+        expect(1 + 1).toBe(3);
+      });
+    `,
+    'dir/a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('fails', async ({}, testInfo) => {
+        expect(1 + 1).toBe(3);
+      });
+    `,
+  }, { config: path.join('config', 'config.ts') });
+
+  expect(result.exitCode).toBe(1);
+  expect(result.passed).toBe(0);
+  expect(result.skipped).toBe(0);
+  expect(result.failed).toBe(1);
+  expect(result.output).toContain(`1) ${path.join('dir', 'a.test.ts')}:3:11 › fails`);
+});
+
+test('should throw when test() is called in config file', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      import { test, expect } from '@playwright/test';
+      test('hey', () => {});
+      module.exports = {};
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('test', async ({}) => {
+      });
+    `,
+  });
+  expect(result.output).toContain('Playwright Test did not expect test() to be called here');
+});
+
+test('should filter by project, case-insensitive', async ({ runInlineTest }) => {
+  const { passed, failed, outputLines, skipped } = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [
+        { name: 'suite1' },
+        { name: 'suite2' },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        console.log('%%' + test.info().project.name);
+      });
+    `
+  }, { project: 'SUite2' });
+  expect(passed).toBe(1);
+  expect(failed).toBe(0);
+  expect(skipped).toBe(0);
+  expect(new Set(outputLines)).toEqual(new Set([
+    'suite2',
+  ]));
+});
+
+test('should filter by project wildcard', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.js': `
+      module.exports = {
+        projects: [
+         { name: 'project-name' },
+         { name: 'foobar' }
+        ]
+      };
+    `,
+    'a.test.js': `
+      const { test } = require('@playwright/test');
+      test('one', async ({}) => {
+        console.log('%%' + test.info().project.name);
+      });    `
+  }, { '--project': '*oj*t-Na*e' });
+  expect(result.exitCode).toBe(0);
+  expect(result.output).toContain('Running 1 test using 1 worker');
+  expect(new Set(result.outputLines)).toEqual(new Set([
+    'project-name',
+  ]));
+});
+
+test('should print nice error when the project wildcard does not match anything', async ({ runInlineTest }) => {
+  const { output, exitCode } = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [
+        { name: 'suite1' },
+        { name: 'suite2' },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        console.log(testInfo.project.name);
+      });
+    `
+  }, { '--project': ['not*found'] });
+  expect(exitCode).toBe(1);
+  expect(output).toContain('Error: No projects matched. Available projects: "suite1", "suite2"');
+});
+
+test('should filter by project wildcard and exact name', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.js': `
+      module.exports = {
+        projects: [
+         { name: 'first' },
+         { name: 'fooBar' },
+         { name: 'foobarBaz' },
+         { name: 'prefix' },
+         { name: 'prefixEnd' },
+        ]
+      };
+    `,
+    'a.test.js': `
+      const { test } = require('@playwright/test');
+      test('one', async ({}) => {
+        console.log('%%' + test.info().project.name);
+      });    `
+  }, { '--project': ['first', '*bar', 'pref*x'] });
+  expect(result.exitCode).toBe(0);
+  expect(new Set(result.outputLines)).toEqual(new Set(['first', 'fooBar', 'prefix']));
+});
+
+test('should print nice error when project is unknown', async ({ runInlineTest }) => {
+  const { output, exitCode } = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [
+        { name: 'suite1' },
+        { name: 'suite2' },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {});
+    `
+  }, { project: 'suite3' });
+  expect(exitCode).toBe(1);
+  expect(output).toContain('Project(s) "suite3" not found. Available projects: "suite1", "suite2"');
+});
+
+test('should print nice error when project is unknown and launching UI mode', async ({ runInlineTest }) => {
+  // Prevent UI mode from opening and the test never finishing
+  test.setTimeout(5000);
+  const { output, exitCode } = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [
+        { name: 'suite1' },
+        { name: 'suite2' },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {});
+    `
+  }, { project: 'suite3', ui: true });
+  expect(exitCode).toBe(1);
+  expect(output).toContain('Project(s) "suite3" not found. Available projects: "suite1", "suite2"');
+});
+
+test('should filter by project list, case-insensitive', async ({ runInlineTest }) => {
+  const { passed, failed, outputLines, skipped } = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [
+        { name: 'suite1' },
+        { name: 'suite2' },
+        { name: 'suite3' },
+        { name: 'suite4' },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        console.log('%%' + test.info().project.name);
+      });
+    `
+  }, { project: ['SUite2',  'Suite3'] });
+  expect(passed).toBe(2);
+  expect(failed).toBe(0);
+  expect(skipped).toBe(0);
+  expect(new Set(outputLines)).toEqual(new Set(['suite3', 'suite2']));
+});
+
+test('should filter when duplicate project names exist', async ({ runInlineTest }) => {
+  const { passed, failed, outputLines, skipped } = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [
+        { name: 'suite1' },
+        { name: 'suite2' },
+        { name: 'suite1' },
+        { name: 'suite4' },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        console.log('%%' + test.info().project.name);
+      });
+    `
+  }, { project: ['suite1',  'sUIte4'] });
+  expect(passed).toBe(3);
+  expect(failed).toBe(0);
+  expect(skipped).toBe(0);
+  expect(new Set(outputLines)).toEqual(new Set(['suite1', 'suite1', 'suite4']));
+});
+
+test('should print nice error when some of the projects are unknown', async ({ runInlineTest }) => {
+  const { output, exitCode } = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [
+        { name: 'suite1' },
+        { name: 'suite2' },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        console.log(testInfo.project.name);
+      });
+    `
+  }, { project: ['suitE1', 'suIte3', 'SUite4'] });
+  expect(exitCode).toBe(1);
+  expect(output).toContain('Project(s) "suIte3", "SUite4" not found. Available projects: "suite1", "suite2"');
+});
+
+test('should print nice error when project name is not stable', async ({ runInlineTest }) => {
+  const { output, exitCode } = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = { projects: [
+        { name: \`calculated \$\{Date.now()\}\` },
+      ] };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        console.log(testInfo.project.name);
+      });
+    `
+  });
+  expect(exitCode).toBe(1);
+  expect(output).toContain('not found in the worker process. Make sure project name does not change.');
+});
+
+test('should work without config file', async ({ runInlineTest }) => {
+  const { exitCode, passed, failed, skipped } = await runInlineTest({
+    'playwright.config.ts': `
+      throw new Error('This file should not be required');
+    `,
+    'dir/a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}) => {
+        test.expect(1 + 1).toBe(2);
+      });
+    `
+  }, { config: 'dir' });
+  expect(exitCode).toBe(0);
+  expect(passed).toBe(1);
+  expect(failed).toBe(0);
+  expect(skipped).toBe(0);
+});
+
+test('should inherit use options in projects', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = {
+        use: { foo: 'config' },
+        projects: [{
+          use: { bar: 'project' },
+        }]
+      };
+    `,
+    'a.test.ts': `
+      import { test as base, expect } from '@playwright/test';
+      const test = base.extend({ foo: ['', {option:true}], bar: ['', {option: true}] });
+      test('pass', async ({ foo, bar  }, testInfo) => {
+        test.expect(foo).toBe('config');
+        test.expect(bar).toBe('project');
+      });
+    `
+  });
+
+  expect(result.exitCode).toBe(0);
+  expect(result.passed).toBe(1);
+});
+
+test('should support ignoreSnapshots config option', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = {
+        ignoreSnapshots: true,
+        projects: [
+          { name: 'p1' },
+          { name: 'p2', ignoreSnapshots: false },
+        ]
+      };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        testInfo.snapshotSuffix = '';
+        expect(testInfo.project.name).toMatchSnapshot();
+      });
+    `
+  });
+
+  expect(result.exitCode).toBe(1);
+  expect(result.passed).toBe(1);
+  expect(result.failed).toBe(1);
+  expect(result.output).not.toContain(`pass-1-p1.txt, writing actual.`);
+  expect(result.output).toContain(`pass-1-p2.txt, writing actual.`);
+});
+
+test('should validate workers option set to percent', async ({ runInlineTest }, testInfo) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = {
+        workers: '50%'
+      };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async () => {
+      });
+    `
+  });
+  expect(result.exitCode).toBe(0);
+  expect(result.passed).toBe(1);
+});
+
+test('should throw when workers option is invalid', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+        module.exports = {
+          workers: ''
+        };
+      `,
+    'a.test.ts': `
+        import { test, expect } from '@playwright/test';
+        test('pass', async () => {
+        });
+      `
+  });
+
+  expect(result.exitCode).toBe(1);
+  expect(result.output).toContain('config.workers must be a number or percentage');
+});
+
+test('should throw when workers is negative via CLI (regression for #39938)', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `module.exports = {};`,
+    'a.test.ts': `
+      import { test } from '@playwright/test';
+      test('pass', () => {});
+    `,
+  }, { workers: -1 });
+  expect(result.exitCode).toBe(1);
+  expect(result.output).toContain('Workers must be a positive number');
+});
+
+test('should work with undefined values and base', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      module.exports = {
+        updateSnapshots: undefined,
+      };
+    `,
+    'a.test.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', async ({}, testInfo) => {
+        expect(testInfo.config.updateSnapshots).toBe('missing');
+      });
+    `
+  });
+
+  expect(result.exitCode).toBe(0);
+  expect(result.passed).toBe(1);
+});
+
+test('should have correct types for the config', async ({ runTSC }) => {
+  const result = await runTSC({
+    'playwright.config.ts': `
+      import { defineConfig } from '@playwright/test';
+
+      export default defineConfig({
+        webServer: [
+          {
+            command: 'echo 123',
+            env: { PORT: '123' },
+            port: 123,
+          },
+          {
+            command: 'echo 123',
+            env: { NODE_ENV: 'test' },
+            port: 8082,
+          },
+        ],
+        globalSetup: './globalSetup',
+        // @ts-expect-error
+        globalTeardown: null,
+        projects: [
+          {
+            name: 'project name',
+          }
+        ],
+      });
+  `
+  });
+  expect(result.exitCode).toBe(0);
+});
+
+test('should not allow tracesDir in launchOptions', async ({ runTSC }) => {
+  const result = await runTSC({
+    'playwright.config.ts': `
+      import { defineConfig } from '@playwright/test';
+
+      export default defineConfig({
+        use: {
+          launchOptions: {
+            tracesDir: 'foo',
+          },
+        },
+      });
+  `
+  });
+  expect(result.exitCode).not.toBe(0);
+});
+
+test('should merge configs', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      import { defineConfig, expect } from '@playwright/test';
+      const baseConfig = defineConfig({
+        timeout: 10,
+        use: {
+          foo: 1,
+        },
+        expect: {
+          timeout: 11,
+        },
+        projects: [
+          {
+            name: 'A',
+            timeout: 20,
+          }
+        ],
+      });
+      const derivedConfig = defineConfig(baseConfig, {
+        timeout: 30,
+        use: {
+          bar: 2,
+        },
+        expect: {
+          timeout: 12,
+        },
+        projects: [
+          { name: 'B', timeout: 40 },
+          { name: 'A', timeout: 50 },
+        ],
+        webServer: {
+          command: 'echo 123',
+        }
+      });
+
+      expect(derivedConfig).toEqual(expect.objectContaining({
+        timeout: 30,
+        use: { foo: 1, bar: 2 },
+        expect: { timeout: 12 },
+        projects: [
+          { name: 'A', timeout: 50, use: {} },
+          { name: 'B', timeout: 40 },
+        ],
+        webServer: [{
+          command: 'echo 123',
+        }]
+      }));
+
+      // Should not add an empty project list.
+      expect(defineConfig({}, {}).projects).toBeUndefined();
+    `,
+    'a.test.ts': `
+      import { test } from '@playwright/test';
+      test('pass', async ({}) => {});
+    `
+  });
+  expect(result.exitCode).toBe(0);
+});
+
+test('should merge projects in the config', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      import { defineConfig, expect } from '@playwright/test';
+      const baseConfig = defineConfig({
+        projects: [{ name: 'A', timeout: 5_000 }, { name: 'B', timeout: 6_000 }],
+      });
+      const derivedConfig = defineConfig(baseConfig, {
+        projects: [{ name: 'A', timeout: 7_000 }, { name: 'C', timeout: 8_000 }],
+      });
+
+      expect(derivedConfig).toEqual(expect.objectContaining({
+        projects: [
+          { name: 'A', timeout: 7_000, use: {} },
+          { name: 'B', timeout: 6_000 },
+          { name: 'C', timeout: 8_000 },
+        ],
+      }));
+    `,
+    'a.test.ts': `
+      import { test } from '@playwright/test';
+      test('pass', async ({}) => {});
+    `
+  });
+  expect(result.exitCode).toBe(0);
+});
+
+test('should merge ct configs', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      import { defineConfig, expect } from '@playwright/experimental-ct-react';
+      const baseConfig = defineConfig({
+        timeout: 10,
+        use: {
+          foo: 1,
+        },
+      });
+      const derivedConfig = defineConfig(baseConfig, {
+        grep: 'hi',
+        use: {
+          bar: 2,
+        },
+      });
+
+      // Make sure ct-specific properties are preserved
+      // and config properties are merged.
+      expect(derivedConfig).toEqual(expect.objectContaining({
+        use: { foo: 1, bar: 2 },
+        grep: 'hi',
+        '@playwright/test': expect.objectContaining({
+          babelPlugins: [[expect.stringContaining('tsxTransform.js')]]
+        }),
+        '@playwright/experimental-ct-core': expect.objectContaining({
+          registerSourceFile: expect.stringContaining('registerSource'),
+        }),
+      }));
+    `,
+    'a.test.ts': `
+      import { test } from '@playwright/experimental-ct-react';
+      test('pass', async ({}) => {});
+    `
+  });
+  expect(result.exitCode).toBe(0);
+});
+
+test('should throw on invalid config.tsconfig option', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      export default {
+        tsconfig: true,
+      };
+    `,
+  });
+
+  expect(result.exitCode).toBe(1);
+  expect(result.output).toContain(`config.tsconfig must be a string`);
+});
+
+test('should throw on nonexistant config.tsconfig', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'playwright.config.ts': `
+      export default {
+        tsconfig: './does-not-exist.json',
+      };
+    `,
+  });
+
+  expect(result.exitCode).toBe(1);
+  expect(result.output).toContain(`config.tsconfig does not exist`);
+});
+
+test('should throw on invalid --tsconfig', async ({ runInlineTest }) => {
+  const result = await runInlineTest({}, { 'tsconfig': 'does-not-exist.json' });
+  expect(result.exitCode).toBe(1);
+  expect(result.output).toContain(`--tsconfig "does-not-exist.json" does not exist`);
+});