Test passing fixtures and minimum supported VS Code (#145)

Add an isolated passing workspace and assert the first diagnostic result
after Verify. Run both passing and failing fixtures on stable and the
minimum supported VS Code (1.82.0) for every pull request, main, and
reusable release check.

Validated fixture failure reporting, workflow coverage, lint, types, and
extension installation.

Depends on #144. Closes #132.

🤖 Generated with [Codex](https://openai.com/codex/)

---------

Co-authored-by: Codex <noreply@openai.com>

Author: rcosta358

.github/workflows/test.yml

@@ -78,8 +78,12 @@ jobs:
           if-no-files-found: error
           retention-days: 1
   integration:
-    name: VS Code integration
+    name: VS Code integration (${{ matrix.version }})
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        version: [stable, minimum]
 
     defaults:
       run:
@@ -109,15 +113,16 @@ jobs:
       - name: Build server
         run: npm run build:server
 
-      - name: Run VS Code stable smoke test
+      - name: Run VS Code fixture tests
         env:
           JAVA_HOME: ${{ steps.java.outputs.path }}
+          VSCODE_TEST_VERSION: ${{ matrix.version }}
         run: xvfb-run -a npm test
 
       - name: Upload VS Code logs
         if: failure()
         uses: actions/upload-artifact@v4
         with:
-          name: vscode-logs
+          name: vscode-logs-${{ matrix.version }}
           path: client/.vscode-test/user-data/logs
           if-no-files-found: ignore

client/.vscode-test.mjs

@@ -1,10 +1,18 @@
+import { readFileSync } from 'node:fs';
 import { defineConfig } from '@vscode/test-cli';
+import { minVersion } from 'semver';
 
-export default defineConfig({
-    files: 'out/test/**/*.test.js',
-    version: 'stable',
-    workspaceFolder: 'test-fixtures/failing',
+const { engines } = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
+const version = process.env.VSCODE_TEST_VERSION === 'minimum'
+    ? minVersion(engines.vscode).version
+    : 'stable';
+
+export default defineConfig(['failing', 'passing'].map(fixture => ({
+    label: fixture,
+    files: fixture === 'failing' ? 'out/test/**/*.test.js' : 'out/test/smoke.test.js',
+    version,
+    workspaceFolder: `test-fixtures/${fixture}`,
     extensionDevelopmentPath: '.',
     launchArgs: ['--disable-extensions', '--disable-workspace-trust'],
     mocha: { ui: 'tdd', timeout: 120_000 },
-});
+})));

client/package-lock.json

@@ -172,14 +172,15 @@
 		"@types/jsdom": "^30.0.0",
 		"@types/mocha": "^10.0.10",
 		"@types/node": "^24.7.2",
-		"@types/vscode": "^1.82.0",
+		"@types/vscode": "~1.82.0",
 		"@vscode/test-cli": "^0.0.15",
 		"@vscode/test-electron": "^3.1.0",
 		"@vscode/vsce": "^3.0.0",
 		"eslint": "^9.39.0",
 		"jsdom": "^30.1.1",
 		"jsonc-parser": "^0.4.2",
 		"minimist": "^1.2.7",
+		"semver": "^7.7.4",
 		"ts-loader": "^9.5.4",
 		"typescript": "~5.3.0",
 		"typescript-eslint": "^8.0.0",

client/package.json

@@ -5,7 +5,7 @@ import type { LJDiagnostic } from '../types/diagnostics';
 import type { LiquidJavaTestApi } from '../types/test-api';
 
 suite('Bundled LiquidJava extension', () => {
-    test('activates, becomes ready, and verifies the failing fixture', async () => {
+    test('activates, becomes ready, and verifies its isolated fixture', async () => {
         const installed = vscode.extensions.getExtension<LiquidJavaTestApi>('AlcidesFonseca.liquid-java');
         assert.ok(installed, 'LiquidJava must be loaded in the Extension Host');
         assert.equal(installed.packageJSON.main, './dist/extension.js');
@@ -16,17 +16,25 @@ suite('Bundled LiquidJava extension', () => {
         assert.notEqual(api.getState().status, 'stopped');
 
         const workspace = vscode.workspace.workspaceFolders?.[0];
-        assert.ok(workspace, 'the failing fixture must have its own workspace');
-        const uri = vscode.Uri.joinPath(workspace.uri, 'src/main/java/FailingRefinement.java');
+        assert.ok(workspace, 'the fixture must have its own workspace');
+        const passing = path.basename(workspace.uri.fsPath) === 'passing';
+        const file = passing ? 'PassingRefinement.java' : 'FailingRefinement.java';
+        const uri = vscode.Uri.joinPath(workspace.uri, `src/main/java/${file}`);
         const subscriptions: vscode.Disposable[] = [];
-        const nextFixtureDiagnostics = () => new Promise<LJDiagnostic[]>((resolve) => {
-            const subscription = api.onDiagnostics((diagnostics) => {
-                if (diagnostics.some(d => d.type === 'refinement-error' && path.resolve(d.file) === uri.fsPath)) {
-                    subscription.dispose();
-                    resolve(diagnostics);
-                }
+        const nextFixtureDiagnostics = () => new Promise<LJDiagnostic[]>((resolve, reject) => {
+            const dispose = () => {
+                diagnosticsSubscription.dispose();
+                failureSubscription.dispose();
+            };
+            const diagnosticsSubscription = api.onDiagnostics((diagnostics) => {
+                dispose();
+                resolve(diagnostics);
             });
-            subscriptions.push(subscription);
+            const failureSubscription = api.onFailure(() => {
+                dispose();
+                reject(new Error(`LiquidJava verifier crashed while checking ${file} (status: ${api.getState().status})`));
+            });
+            subscriptions.push(diagnosticsSubscription, failureSubscription);
         });
         try {
             // settle automatic verification before testing the manual command
@@ -38,12 +46,17 @@ suite('Bundled LiquidJava extension', () => {
             const manualDiagnostics = nextFixtureDiagnostics();
             await vscode.commands.executeCommand('liquidjava.verify');
             const diagnostics = await manualDiagnostics;
-            const error = diagnostics.find(d => d.type === 'refinement-error' && path.resolve(d.file) === uri.fsPath);
-            assert.ok(error);
-            assert.equal(error.category, 'error');
-            assert.equal(error.title, 'Refinement Error');
-            assert.ok(error.position, 'the diagnostic must identify the invalid assignment');
-            assert.equal(api.getState().status, 'failed');
+            if (passing) {
+                assert.deepEqual(diagnostics, [], 'correct code must emit an explicit empty result');
+                assert.equal(api.getState().status, 'passed');
+            } else {
+                const error = diagnostics.find(d => d.type === 'refinement-error' && vscode.Uri.file(path.resolve(d.file)).fsPath === uri.fsPath);
+                assert.ok(error, `expected a refinement error for ${file}; received ${JSON.stringify(diagnostics)}`);
+                assert.equal(error.category, 'error');
+                assert.equal(error.title, 'Refinement Error');
+                assert.ok(error.position, 'the diagnostic must identify the invalid assignment');
+                assert.equal(api.getState().status, 'failed');
+            }
             assert.deepEqual(api.getState().diagnostics, diagnostics);
         } finally {
             subscriptions.forEach(subscription => subscription.dispose());

client/src/test/smoke.test.ts

@@ -0,0 +1,6 @@
+import liquidjava.specification.Refinement;
+
+public class PassingRefinement {
+    @Refinement("_ > 0")
+    int positive = 1;
+}