create-vedats 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# create-vscode-ui-test
+
+Scaffold Workbench UI tests for VS Code extensions.
+
+```bash
+npx create-vedats@latest
+```
+
+Flags:
+
+- `--target <path>`

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "create-vedats",
+  "version": "0.1.0",
+  "description": "Scaffold Workbench UI tests for VS Code extensions",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/futouyiba/vedats.git"
+  },
+  "bin": {
+    "create-vedats": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+
+type PackageJson = {
+  scripts?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+};
+
+const DEFAULT_DEV_DEPS: Record<string, string> = {
+  '@wdio/cli': '^8.32.2',
+  '@wdio/globals': '^8.32.2',
+  '@wdio/local-runner': '^8.32.2',
+  '@wdio/mocha-framework': '^8.32.2',
+  '@wdio/spec-reporter': '^8.32.2',
+  '@wdio/types': '^8.32.2',
+  'expect-webdriverio': '^4.12.4',
+  'ts-node': '^10.9.2',
+  'vedats-harness': '^0.1.0',
+  'wdio-vscode-service': '^6.1.4',
+  'webdriverio': '^8.32.2'
+};
+
+function parseArgs(argv: string[]): { targetDir: string } {
+  const targetFlagIndex = argv.findIndex((arg) => arg === '--target');
+  if (targetFlagIndex !== -1 && argv[targetFlagIndex + 1]) {
+    return { targetDir: path.resolve(argv[targetFlagIndex + 1]) };
+  }
+  return { targetDir: process.cwd() };
+}
+
+function ensureFile(filePath: string): void {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Required file not found: ${filePath}`);
+  }
+}
+
+function copyTemplate(targetDir: string): void {
+  const templateDir = path.resolve(__dirname, '..', 'templates');
+  if (!fs.existsSync(templateDir)) {
+    throw new Error(`Template directory missing: ${templateDir}`);
+  }
+  fs.cpSync(templateDir, targetDir, { recursive: true, errorOnExist: false });
+}
+
+function updatePackageJson(targetDir: string): void {
+  const packageJsonPath = path.join(targetDir, 'package.json');
+  ensureFile(packageJsonPath);
+
+  const raw = fs.readFileSync(packageJsonPath, 'utf8');
+  const pkg = JSON.parse(raw) as PackageJson;
+
+  pkg.scripts ??= {};
+  pkg.devDependencies ??= {};
+
+  pkg.scripts['test:ui'] ??= 'wdio run ./tests/ui/wdio.conf.ts';
+  pkg.scripts['test:ui:headed'] ??= 'wdio run ./tests/ui/wdio.conf.ts';
+
+  if (pkg.scripts.compile && !pkg.scripts['pretest:ui']) {
+    pkg.scripts['pretest:ui'] = 'npm run compile';
+  }
+
+  for (const [dep, version] of Object.entries(DEFAULT_DEV_DEPS)) {
+    if (!pkg.devDependencies[dep]) {
+      pkg.devDependencies[dep] = version;
+    }
+  }
+
+  fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2), 'utf8');
+}
+
+function updateTsconfig(targetDir: string): void {
+  const tsconfigPath = path.join(targetDir, 'tsconfig.json');
+  if (!fs.existsSync(tsconfigPath)) {
+    return;
+  }
+
+  const raw = fs.readFileSync(tsconfigPath, 'utf8');
+  const config = JSON.parse(raw) as { exclude?: string[] };
+  const exclude = new Set(config.exclude ?? []);
+  exclude.add('tests');
+  config.exclude = Array.from(exclude);
+  fs.writeFileSync(tsconfigPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+function updateGitignore(targetDir: string): void {
+  const gitignorePath = path.join(targetDir, '.gitignore');
+  const entry = '**/artifacts/vscode-ui/';
+
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, `${entry}
+    return;
+  }
+
+  const content = fs.readFileSync(gitignorePath, 'utf8');
+  if (!content.includes(entry)) {
+    const updated = `${content.trimEnd()}
+
+${entry}
+    fs.writeFileSync(gitignorePath, updated, 'utf8');
+  }
+}
+
+function main(): void {
+  const { targetDir } = parseArgs(process.argv);
+  try {
+    copyTemplate(targetDir);
+    updatePackageJson(targetDir);
+    updateTsconfig(targetDir);
+    updateGitignore(targetDir);
+    process.stdout.write(`UI test scaffold added to ${targetDir}\n`);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+}
+
+main();

package/templates/.github/workflows/ui-tests.yml

@@ -0,0 +1,53 @@
+name: UI Tests
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  ui-tests:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: package-lock.json
+
+      - name: Cache VS Code downloads
+        uses: actions/cache@v4
+        with:
+          path: .vscode-test
+          key: ${{ runner.os }}-vscode-${{ hashFiles('package-lock.json') }}
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run UI tests (Linux)
+        if: runner.os == 'Linux'
+        run: xvfb-run -a npm run test:ui
+
+      - name: Run UI tests (Windows)
+        if: runner.os == 'Windows'
+        run: npm run test:ui
+
+      - name: Run UI tests (macOS)
+        if: runner.os == 'macOS'
+        run: npm run test:ui
+
+      - name: Upload UI artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: vscode-ui-artifacts-${{ runner.os }}
+          path: artifacts/vscode-ui

package/templates/tests/ui/README.md

@@ -0,0 +1,20 @@
+# VS Code UI Tests (Workbench)
+
+Run:
+
+```bash
+npm run test:ui
+```
+
+Artifacts:
+
+```
+artifacts/vscode-ui/<runId>/
+```
+
+Required contents include:
+
+- `steps.json`
+- `screenshots/`
+- `logs/`
+- `ui-dump/diagnostics.json`

package/templates/tests/ui/dsl/workbench.ts

@@ -0,0 +1 @@
+export * from 'vedats-harness';

package/templates/tests/ui/specs/ui.e2e.ts

@@ -0,0 +1 @@
+import './workbench.e2e';

package/templates/tests/ui/specs/workbench.e2e.ts

@@ -0,0 +1,13 @@
+import { expect, browser } from '@wdio/globals';
+import { waitForNotification } from '../dsl/workbench';
+
+describe('Workbench UI smoke test', () => {
+  it('shows a VS Code notification', async () => {
+    await browser.executeWorkbench((vscode) => {
+      vscode.window.showInformationMessage('UI test ready');
+    });
+
+    await waitForNotification('UI test ready');
+    expect(true).toBe(true);
+  });
+});

package/templates/tests/ui/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "types": [
+      "node",
+      "webdriverio/async",
+      "@wdio/mocha-framework",
+      "expect-webdriverio",
+      "wdio-vscode-service"
+    ],
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "strict": true
+  },
+  "include": ["./**/*.ts"]
+}

package/templates/tests/ui/wdio.conf.ts

@@ -0,0 +1,76 @@
+import path from 'path';
+import type { Options } from '@wdio/types';
+import { initRunContext, captureFailureArtifacts } from 'vedats-harness';
+
+const rootDir = path.resolve(__dirname, '..', '..');
+const runContext = initRunContext(rootDir);
+
+const vscodeVersion = process.env.VSCODE_UI_VERSION ?? 'stable';
+const logLevel = (process.env.WDIO_LOG_LEVEL ?? 'info') as Options.Testrunner['logLevel'];
+
+export const config: Options.Testrunner = {
+  runner: 'local',
+  specs: [path.join(__dirname, 'specs', 'ui.e2e.ts')],
+  maxInstances: 1,
+  maxInstancesPerCapability: 1,
+  logLevel,
+  outputDir: runContext.logsDir,
+  framework: 'mocha',
+  reporters: ['spec'],
+  mochaOpts: {
+    timeout: 120000
+  },
+  autoCompileOpts: {
+    autoCompile: true,
+    tsNodeOpts: {
+      project: path.join(__dirname, 'tsconfig.json'),
+      transpileOnly: true
+    }
+  },
+  services: [
+    ['vscode', { cachePath: path.join(rootDir, '.vscode-test') }]
+  ],
+  capabilities: [
+    {
+      maxInstances: 1,
+      browserName: 'vscode',
+      browserVersion: vscodeVersion,
+      'wdio:vscodeOptions': {
+        extensionPath: rootDir,
+        workspacePath: rootDir,
+        storagePath: runContext.storageDir,
+        verboseLogging: true,
+        userSettings: {
+          'extensions.autoUpdate': false,
+          'extensions.ignoreRecommendations': true,
+          'security.workspace.trust.enabled': false,
+          'security.workspace.trust.startupPrompt': 'never',
+          'telemetry.telemetryLevel': 'off',
+          'update.mode': 'none',
+          'workbench.enableExperiments': false,
+          'workbench.startupEditor': 'none',
+          'workbench.tips.enabled': false,
+          'workbench.welcomePage.walkthroughs.openOnInstall': false
+        }
+      }
+    }
+  ],
+  beforeSession: (_config, capabilities, _specs, cid) => {
+    const rawCapabilities = capabilities as Record<string, unknown>;
+    const options = rawCapabilities['wdio:vscodeOptions'];
+    if (options && typeof options === 'object') {
+      (options as Record<string, unknown>).storagePath = path.join(
+        runContext.storageDir,
+        cid.replace(/[^a-zA-Z0-9_-]/g, '_')
+      );
+    }
+  },
+  before: async () => {
+    process.env.VSCODE_UI_RUN_ID = runContext.runId;
+  },
+  afterTest: async (_test, _context, result) => {
+    if (!result.passed) {
+      await captureFailureArtifacts(result.error);
+    }
+  }
+};

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}