add integration testing

Author: WebFreak001

.vscode-test.mjs

@@ -1,5 +1,20 @@
-import { defineConfig } from '@vscode/test-cli';
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import { defineConfig } from "@vscode/test-cli";
+
+let cwd = fs.mkdtempSync(path.join(os.tmpdir(), "coded_project"));
+fs.writeFileSync(path.join(cwd, "dub.sdl"), 'name "codedproject"\n');
+fs.mkdirSync(path.join(cwd, "source"));
+fs.writeFileSync(
+  path.join(cwd, "source", "app.d"),
+  'import std.stdio;\n\nvoid main() {\n\twriteln("hello world");\n}\n'
+);
 
 export default defineConfig({
-	files: 'out/test/**/*.test.js',
+  files: "out/test/**/*.test.js",
+  workspaceFolder: cwd,
+  env: {
+    PROJECT_DIR: cwd,
+  },
 });

package.json

@@ -3,6 +3,7 @@
   "displayName": "DUB Editor",
   "description": "GUI editor for opening dub.sdl and dub.json files",
   "publisher": "webfreak",
+  "version": "0.1.5",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/Pure-D/dub-editor.git"
@@ -81,7 +82,7 @@
     "pretest": "npm run compile-tests && npm run compile && npm run lint",
     "check-types": "tsc",
     "lint": "eslint src",
-    "test": "vscode-test",
+    "test": "vscode-test --timeout 120000",
     "grammar": "js-yaml syntaxes/sdl.yml > syntaxes/sdl.json"
   },
   "dependencies": {

src/test/it.test.ts

@@ -0,0 +1,60 @@
+import * as assert from "assert";
+
+// You can import and use all API from the 'vscode' module
+// as well as import your extension to test it
+import * as vscode from "vscode";
+import { sleep, testCompletion } from "./utils";
+// import * as myExtension from '../../extension';
+
+suite("Integration Tests", () => {
+  vscode.window.showInformationMessage("Start all tests.");
+
+  // sanity test that we have the correct window open
+  let workspaces = vscode.workspace.workspaceFolders;
+  assert.strictEqual(workspaces?.length, 1);
+  assert.strictEqual(
+    workspaces[0].uri.fsPath.toLowerCase(),
+    process.env["PROJECT_DIR"]!.toLowerCase()
+  );
+  let workspace = workspaces[0];
+
+  test("check dub-editor installed", async () => {
+    let coded = vscode.extensions.getExtension("webfreak.dub-editor")!;
+    assert.notStrictEqual(coded, undefined, "dub-editor not installed?!");
+  });
+
+  function file(relative: string): vscode.Uri {
+    return vscode.Uri.joinPath(workspace.uri, relative);
+  }
+
+  test("Wait for dub-editor extension", async () => {
+    let coded = vscode.extensions.getExtension("webfreak.dub-editor")!;
+    await coded.activate();
+    await sleep(5000); // give sufficient startup time
+  });
+
+  test("Recipe file", async () => {
+    let recipe = await vscode.window.showTextDocument(
+      await vscode.workspace.openTextDocument(file("dub.sdl")),
+      vscode.ViewColumn.One
+    );
+
+    await recipe.edit((edit) => {
+      edit.insert(new vscode.Position(2, 0), "dep");
+    });
+
+    await testCompletion(
+      recipe,
+      new vscode.Position(2, 3),
+      new vscode.CompletionList([
+        new vscode.CompletionItem(
+          "dependency",
+          vscode.CompletionItemKind.Field
+        ),
+      ]),
+      "contains"
+    );
+  });
+
+  // test('interactive', () => new Promise((resolve, reject) => {}));
+});

src/test/utils.ts

@@ -0,0 +1,64 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+
+export function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function testCompletion(
+    editor: vscode.TextEditor,
+    position: vscode.Position,
+    expectedCompletionList: vscode.CompletionList,
+    type: "exact" | "contains",
+    testKeys: (keyof vscode.CompletionItem)[] = ["label", "kind"]
+) {
+    editor = await vscode.window.showTextDocument(editor.document, editor.viewColumn);
+    await sleep(500);
+    editor.selection = new vscode.Selection(position, position);
+    await sleep(500);
+
+    // Executing the command `vscode.executeCompletionItemProvider` to simulate triggering completion
+    const actualCompletionList = (await vscode.commands.executeCommand(
+        'vscode.executeCompletionItemProvider',
+        editor.document.uri,
+        position
+    )) as vscode.CompletionList;
+
+    if (type === "exact") {
+        assert.strictEqual(actualCompletionList.items.length, expectedCompletionList.items.length);
+        expectedCompletionList.items.forEach((expectedItem, i) => {
+            const actualItem = actualCompletionList.items[i];
+            testKeys.forEach(key => {
+                assert.strictEqual(actualItem[key], expectedItem[key],
+                    "completion "
+                    + JSON.stringify(expectedItem.label)
+                    + " mismatch on key " + JSON.stringify(key) + ":\n"
+                    + "expected = " + JSON.stringify(expectedItem[key]) + "\n"
+                    + "  actual = " + JSON.stringify(actualItem[key]));
+            });
+        });
+    } else if (type === "contains") {
+        assert.ok(actualCompletionList.items.length >= expectedCompletionList.items.length,
+            "Expected at least " + expectedCompletionList.items.length
+            + " completions, but only got " + actualCompletionList.items.length);
+        expectedCompletionList.items.forEach((expectedItem, i) => {
+            const actualItem = actualCompletionList.items.find(i => i.label == expectedItem.label);
+            if (!actualItem)
+                assert.fail("can't find completion item "
+                    + JSON.stringify(expectedItem.label)
+                    + " in "
+                    + JSON.stringify(actualCompletionList.items.map(c => c.label)));
+
+            testKeys.forEach(key => {
+                assert.strictEqual(actualItem[key], expectedItem[key],
+                    "completion "
+                    + JSON.stringify(expectedItem.label)
+                    + " mismatch on key " + JSON.stringify(key) + ":\n"
+                    + "expected = " + JSON.stringify(expectedItem[key]) + "\n"
+                    + "  actual = " + JSON.stringify(actualItem[key]));
+            });
+        });
+    } else {
+        throw new Error("invalid type");
+    }
+}