Test passing fixtures and minimum supported VS Code

.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.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/src/test/smoke.test.ts

@@ -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/test-fixtures/passing/src/main/java/PassingRefinement.java

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