[tests] Various bugfixes.

package.json

@@ -149,7 +149,9 @@
         "build": "npx ts-node src/build_lds.ts",
         "deploy": "vsce package && code --install-extension vscode-lingua-franca-*.vsix",
         "install": "npm run build && npm run deploy",
-        "test": "npx tsc --outDir out/test --inlineSourceMap && node ./out/test/test/test_runner.js --dependencies=present",
-        "test:watch": "jest --watch"
+        "compile-tests": "npx tsc --outDir out/test --inlineSourceMap",
+        "test": "npm run compile-tests && node ./out/test/test/test_runner.js --dependencies=present",
+        "test-dependencies-outdated": "npm run compile-tests && node ./out/test/test/test_runner.js --dependencies=outdated",
+        "test-dependencies-missing": "npm run compile-tests && node ./out/test/test/test_runner.js --dependencies=missing"
     }
 }

src/check_dependencies.ts

@@ -44,7 +44,7 @@ const checkDependency: UserFacingVersionCheckerMaker = (missingDependency: Missi
         (messageShower: MessageShower) => async () => {
     const checkerResult = await missingDependency.checker();
     if (checkerResult.isCorrect) return true;
-    const message: string = !checkerResult.isCorrect ? (
+    const message: string = checkerResult.isCorrect === false ? (
         missingDependency.wrongVersionMessage ?? missingDependency.message
     ) : missingDependency.message;
     if (!missingDependency.installCommand && !missingDependency.installLink) {

src/test/check_dependencies.test.ts

@@ -6,6 +6,7 @@ import spies from 'chai-spies';
 import { expect } from 'chai';
 import { after } from 'mocha';
 import { MessageShower } from '../utils';
+import { Config } from '../config';
 
 chai.use(spies);
 
@@ -29,51 +30,58 @@ suite('test dependency checking',  () => {
         );
     })();
 
-    const getMockMessageShower = () => {
-        const fn = (message: string, ...items: string[]) => Promise.resolve('');
-        return { mockMessageShower: fn, spy: chai.spy(fn) }
+    type Spy = ChaiSpies.SpyFunc1Proxy<string, Thenable<string>>;
+
+    function getMockMessageShower(): Spy {
+        const mock: MessageShower = (message: string, ...items: string[]) => Promise.resolve('');
+        return chai.spy(mock);
     };
-    
-    const expectSuccess = async (checker: UserFacingVersionChecker, mockMessageShower: MessageShower, spy) => {
-        expect(await checker(mockMessageShower)()).to.be.true;
+
+    const expectSuccess = async (checker: UserFacingVersionChecker, spy: Spy) => {
+        expect(await checker(spy)()).to.be.true;
         expect(spy).not.to.have.been.called;
     };
-    const expectFailure = async (checker: UserFacingVersionChecker, mockMessageShower: MessageShower, spy) => {
-        expect(await checker(mockMessageShower)()).to.be.false;
+    const expectFailure = async (checker: UserFacingVersionChecker, spy: Spy) => {
+        expect(await checker(spy)()).to.be.false;
         expect(spy).to.have.been.called;
-        expect(spy.arguments.join()).to.contain('Install');
     };
 
-    test('java', () => {
-        const { mockMessageShower, spy } = getMockMessageShower();
+    test('java', async () => {
+        const spy = getMockMessageShower();
         switch (dependencies) {
         case Dependencies.Present:
-            expectSuccess(checkJava, mockMessageShower, spy);
+            await expectSuccess(checkJava, spy);
             break;
         case Dependencies.Missing:
         case Dependencies.Outdated:
-            expectFailure(checkJava, mockMessageShower, spy);
-            expect(spy.arguments.join()).to.contain('Java');
+            await expectFailure(checkJava, spy);
+            expect(spy).to.have.been.called.with(
+                `Java version ${Config.javaVersion.major} is required for Lingua Franca diagrams `
+                + `and code analysis.`
+            );
             break;
         }
     });
 
-    // it('pylint', () => {
-    //     const mockMessageShower = getMockMessageShower();
-    //     switch (dependencies) {
-    //     case Dependencies.Present:
-    //         expectSuccess(checkPylint, mockMessageShower);
-    //         break;
-    //     case Dependencies.Missing:
-    //         expectFailure(checkPylint, mockMessageShower);
-    //         expect(mockMessageShower.mock.calls[0][0])
-    //             .toEqual(expect.stringContaining('recommended'));
-    //         break;
-    //     case Dependencies.Outdated:
-    //         expectFailure(checkPylint, mockMessageShower);
-    //         expect(mockMessageShower.mock.calls[0][0])
-    //             .toEqual(expect.stringContaining('version'));
-    //         break;
-    //     }
-    // });
+    test('pylint', async () => {
+        const spy = getMockMessageShower();
+        switch (dependencies) {
+        case Dependencies.Present:
+            await expectSuccess(checkPylint, spy);
+            break;
+        case Dependencies.Missing:
+            await expectFailure(checkPylint, spy);
+            expect(spy).to.have.been.called.with(
+                `Pylint is a recommended linter for Lingua Franca's Python target.`
+            );
+            break;
+        case Dependencies.Outdated:
+            await expectFailure(checkPylint, spy);
+            expect(spy).to.have.been.called.with(
+                `The Lingua Franca language server is tested with Pylint version `
+                + `${Config.pylintVersion.major}.${Config.pylintVersion.minor} and newer.`
+            );
+            break;
+        }
+    });
 });

src/version_checker.ts

@@ -11,7 +11,8 @@ export type VersionCheckResult = {
 
 export type VersionChecker = () => Promise<VersionCheckResult>;
 
-type VersionCheckerMaker = (command: string, sameMajor: boolean) => VersionChecker
+type VersionCheckerMaker = (desiredVersion: Version, command: string, sameMajor: boolean) =>
+    VersionChecker
 
 /**
  * Create a basic version checker. Note that this assumes that the first valid version number
@@ -20,19 +21,25 @@ type VersionCheckerMaker = (command: string, sameMajor: boolean) => VersionCheck
  * other text.
  * @returns A VersionChecker that checks the desired version number.
  */
-const basicVersionChecker: VersionCheckerMaker = (command, sameMajor) => async () => {
-    const {stdout} = await runCmd(command);
+const basicVersionChecker: VersionCheckerMaker = (desiredVersion, command, sameMajor) => async () => {
+    const nullResult = { version: new Version('0.0.0'), isCorrect: null };
+    let stdout: string;
+    try {
+        stdout = (await runCmd(command)).stdout;
+    } catch (error) {
+        return nullResult;
+    }
     const found = stdout.match(Version.regex);
-    if (found === null) return { version: new Version('0.0.0'), isCorrect: null };
+    if (found === null) return nullResult;
     const version = new Version(stdout);
     return {
         version: version,
-        isCorrect: version.isAtLeast(Config.javaVersion) && (
-            !sameMajor || version.isCompatibleWith(Config.javaVersion)
+        isCorrect: version.isAtLeast(desiredVersion) && (
+            !sameMajor || version.isCompatibleWith(desiredVersion)
         )
     };
 }
 
-export const javaVersionChecker: VersionChecker = basicVersionChecker('java --version', true);
-export const javacVersionChecker: VersionChecker = basicVersionChecker('javac --version', true);
-export const pylintVersionChecker: VersionChecker = basicVersionChecker('pylint --version', false);
+export const javaVersionChecker: VersionChecker = basicVersionChecker(Config.javaVersion, 'java --version', true);
+export const javacVersionChecker: VersionChecker = basicVersionChecker(Config.javacVersion, 'javac --version', true);
+export const pylintVersionChecker: VersionChecker = basicVersionChecker(Config.pylintVersion, 'pylint --version', false);