Switches to @types/vscode & @vscode/test-electron

Also updates the tests to use strictEqual
Adds production, test and dev tscofig compilation

Author: gnikit

package.json

@@ -235,26 +235,31 @@
   },
   "scripts": {
     "vscode:prepublish": "npm run compile",
-    "compile": "tsc -p ./",
-    "watch": "tsc -watch -p ./",
-    "postinstall": "node ./node_modules/vscode/bin/install",
-    "test": "CODE_TESTS_WORKSPACE='./' node ./node_modules/vscode/bin/test",
+    "compile": "tsc -p tsconfig.prod.json",
+    "compile-dev": "tsc -p tsconfig.json",
+    "watch": "tsc -watch -p tsconfig.prod.json",
+    "watch-dev": "tsc -watch -p tsconfig.json",
+    "pretest": "tsc -p tsconfig.test.json",
+    "test": "node ./out/test/runTest.js",
     "test:grammar-free": "vscode-tmgrammar-snap -s source.fortran.free -g ./syntaxes/fortran_free-form.tmLanguage.json -t \"./test/**/*{.f90,F90}\"",
     "test:grammar-fixed": "vscode-tmgrammar-snap -s source.fortran.fixed -g ./syntaxes/fortran_fixed-form.tmLanguage.json -t \"./test/**/*{.f,F}\"",
     "test:grammar": "npm run test:grammar-free && npm run test:grammar-fixed",
     "test:grammar-update": "npm run test:grammar -- -u",
     "lint": "node ./node_modules/tslint/bin/tslint ./src/**/*.ts "
   },
   "devDependencies": {
-    "@types/mocha": "^2.2.32",
-    "@types/node": "^15.12.1",
+    "@types/glob": "^7.1.4",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^15.14.9",
+    "@types/vscode": "^1.30.0",
     "@types/which": "^2.0.1",
-    "husky": "^1.1.2",
-    "lint-staged": "^7.3.0",
-    "mocha": "^9.0.1",
+    "@vscode/test-electron": "^1.6.2",
+    "glob": "^7.2.0",
+    "husky": "^7.0.2",
+    "lint-staged": "^11.2.3",
+    "mocha": "^9.1.3",
     "tslint": "^5.20.1",
-    "typescript": "^3.5.1",
-    "vscode": "^1.1.37",
+    "typescript": "^3.9.10",
     "vscode-tmgrammar-test": "^0.0.11"
   },
   "husky": {

test/extension.test.ts

@@ -21,6 +21,6 @@ suite("Extension Tests", () => {
     vscode.window.showTextDocument(doc);
     const symbolProvider = new FortranDocumentSymbolProvider();
     const symbols = await symbolProvider.provideDocumentSymbols(doc, null);
-    assert.equal(symbols.length, 1);
+    assert.strictEqual(symbols.length, 1);
   });
 });

test/helper.test.ts

@@ -14,46 +14,46 @@ import {
 
 suite("function helper test", () => {
   test("validVariableName does not allow variables starting with number", () => {
-    assert.equal(false, validVariableName("1as"));
+    assert.strictEqual(false, validVariableName("1as"));
   });
 
   test("validVariableName returns true  with correct variable", () => {
-    assert.equal(true, validVariableName("matA"));
+    assert.strictEqual(true, validVariableName("matA"));
   });
 
   test("validVariableName returns true for variables starting with uppercase", () => {
-    assert.equal(true, validVariableName("MatA"));
+    assert.strictEqual(true, validVariableName("MatA"));
   });
 
   test("validVariableName return true for variable starting with _", () => {
-    assert.equal(true, validVariableName("_matA"));
+    assert.strictEqual(true, validVariableName("_matA"));
   });
 
   test("parseFuntion return undefined on empty line", () => {
-    // assert.equal(undefined, parseFunction({text: ""}));
+    // assert.strictEqual(undefined, parseFunction({text: ""}));
   });
 
   test("parseFuntion return undefined if function keyword is missing", () => {
-    // assert.equal(undefined, parseFunction({"hello"));
+    // assert.strictEqual(undefined, parseFunction({"hello"));
   });
 
   test("parseFuntion return correct function name", () => {
-    // assert.equal("hello", parseFunction("function hello()").name);
+    // assert.strictEqual("hello", parseFunction("function hello()").name);
   });
 
   test("parseFuntion return correct number of args", () => {
-    // assert.equal(2, parseFunction("function hello( a, b)").args.length);
+    // assert.strictEqual(2, parseFunction("function hello( a, b)").args.length);
   });
 
   test("parseArgs return the correct number of args", () => {
-    assert.equal(2, parseArgs("a,b").length);
+    assert.strictEqual(2, parseArgs("a,b").length);
   });
 
   test("parseArgs handle spaces well", () => {
-    assert.equal(2, parseArgs(" a, b").length);
+    assert.strictEqual(2, parseArgs(" a, b").length);
   });
 
   test("parseArgs handle empty args", () => {
-    assert.equal(0, parseArgs("").length);
+    assert.strictEqual(0, parseArgs("").length);
   });
 });

test/index.ts

@@ -1,25 +1,38 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for details.
+import * as path from 'path';
+import * as Mocha from 'mocha';
+import * as glob from 'glob';
 
-// This file is used by VS Code's default test runner to configure Mocha before the test run.
+export function run(): Promise<void> {
+  // Create the mocha test
+  const mocha = new Mocha({
+    ui: 'tdd',
+    color: true
+  });
 
-/* tslint:disable:no-var-keyword no-var-requires */
-var testRunner = require("vscode/lib/testrunner");
-/* tslint:enable:no-var-keyword no-var-requires */
+  const testsRoot = __dirname;
 
-let mochaOptions: any = {
-  ui: "tdd",
-  useColors: true,
-  invert: true,
-  grep: "debuggerContext" // Do not run tests intended for the debuggerContext
-};
+  return new Promise((c, e) => {
+    glob('**/**.test.js', { cwd: testsRoot }, (err, files) => {
+      if (err) {
+        return e(err);
+      }
 
-// Look for the env variable to decide wheter to use the TeamCity reporter or not
-if (process.env.VSCODE_REACT_NATIVE_TEAMCITY_TEST) {
-  mochaOptions.reporter = "mocha-teamcity-reporter";
-}
-
-// Register Mocha options
-testRunner.configure(mochaOptions);
+      // Add files to the test suite
+      files.forEach(f => mocha.addFile(path.resolve(testsRoot, f)));
 
-module.exports = testRunner;
+      try {
+        // Run the mocha test
+        mocha.timeout(100000);
+        mocha.run(failures => {
+          if (failures > 0) {
+            e(new Error(`${failures} tests failed.`));
+          } else {
+            c();
+          }
+        });
+      } catch (err) {
+        e(err);
+      }
+    });
+  });
+}

test/runTest.ts

@@ -0,0 +1,25 @@
+import * as path from 'path';
+
+import { runTests } from '@vscode/test-electron';
+
+async function main() {
+  try {
+    // The folder containing the Extension Manifest package.json
+    // Passed to `--extensionDevelopmentPath`
+    const extensionDevelopmentPath = path.resolve(__dirname, '../');
+
+    // The path to the extension test runner script
+    // Passed to --extensionTestsPath
+    const extensionTestsPath = path.resolve(__dirname, './index');
+
+    const launchArgs = ["--disable-extensions", "--install-extension ms-vscode.cpptools"];
+    // Download VS Code, unzip it and run the integration test
+    await runTests({ launchArgs, extensionDevelopmentPath, extensionTestsPath });
+  } catch (err) {
+    console.error(err);
+    console.error('Failed to run tests');
+    process.exit(1);
+  }
+}
+
+main();

test/tokenizer.test.ts

@@ -6,12 +6,12 @@ import { Tokenizer, TokenType } from '../src/lib/tokenizer';
 
 suite("fortran tokenizer", () => {
 
-    test("get correct amount of tokens", () => {
-        const fortranTokenizer = constructFortranTokenizer();
-        fortranTokenizer.tokenize("function a( m, n)\n 2 + 3\nend");
-        let tokens = fortranTokenizer.tokens;
-        assert.equal(tokens.length, 11);
-    });
+  test("get correct amount of tokens", () => {
+    const fortranTokenizer = constructFortranTokenizer();
+    fortranTokenizer.tokenize("function a( m, n)\n 2 + 3\nend");
+    let tokens = fortranTokenizer.tokens;
+    assert.strictEqual(tokens.length, 11);
+  });
 });
 
 function constructFortranTokenizer() {
@@ -28,4 +28,4 @@ function constructFortranTokenizer() {
   tokenizer.add(/^,\s*/, TokenType.COMMA); // comma separator
   tokenizer.add(/[+\-*\/]\s*/, TokenType.BINARY_OPERATOR); // operators
   return tokenizer;
-}
+}

tsconfig.json

@@ -13,7 +13,6 @@
     "include": [
         "src/**/*.ts",
         "src/docs/**/*.json",
-        "test/**/*.ts"
     ],
     "exclude": [
         "node_modules",

tsconfig.prod.json

@@ -0,0 +1,22 @@
+{
+   "compilerOptions": {
+       "module": "commonjs",
+       "target": "es6",
+       "outDir": "out",
+       "lib": [
+           "es6"
+       ],
+       "sourceMap": false,
+       "removeComments": true,
+       "rootDir": ".",
+       "resolveJsonModule": true
+   },
+   "include": [
+       "src/**/*.ts",
+       "src/docs/**/*.json",
+   ],
+   "exclude": [
+       "node_modules",
+       ".vscode-test"
+   ]
+}

tsconfig.test.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "outDir": "out",
+        "lib": [
+            "es6"
+        ],
+        "sourceMap": true,
+        "rootDir": ".",
+        "resolveJsonModule": true
+    },
+    "include": [
+        "test/**/*.ts",
+        "syntaxes/*.json",
+    ],
+    "exclude": [
+        "node_modules",
+        ".vscode-test"
+    ]
+}