Completion tests (#50)

* start on basic tests for completion
* avoid debug logging in tests
* use Samuel's approach for mocking snippets

Co-authored-by:  Samuel Imolorhe <[email protected]>

Author: acao

src/__tests__/__helpers__/completion.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, vitest, Mock } from "vitest";
+
+import { json, jsonLanguage } from "@codemirror/lang-json";
+import { EditorState } from "@codemirror/state";
+import {
+  Completion,
+  CompletionContext,
+  CompletionResult,
+  CompletionSource,
+} from "@codemirror/autocomplete";
+import { jsonCompletion } from "../../json-completion";
+import { JSONSchema7 } from "json-schema";
+import { testSchema2 } from "../__fixtures__/schemas";
+import { EditorView } from "@codemirror/view";
+
+vitest.mock("@codemirror/autocomplete", async () => {
+  const mod = await vitest.importActual<
+    typeof import("@codemirror/autocomplete")
+  >("@codemirror/autocomplete");
+  return {
+    ...mod,
+    snippetCompletion(template: string, completion: Completion) {
+      const c = {
+        ...completion,
+        // pass the snippet template to the completion result
+        // to make it easier to test
+        TESTONLY_template: template,
+      };
+      return mod.snippetCompletion(template, c);
+    },
+  };
+});
+
+type MockedCompletionResult = CompletionResult["options"][0] & {
+  template?: string;
+};
+
+export async function expectCompletion(
+  doc: string,
+  results: MockedCompletionResult[],
+  schema?: JSONSchema7,
+  conf: { explicit?: boolean } = {}
+) {
+  let cur = doc.indexOf("|"),
+    currentSchema = schema || testSchema2;
+  doc = doc.slice(0, cur) + doc.slice(cur + 1);
+  let state = EditorState.create({
+    doc,
+    selection: { anchor: cur },
+    extensions: [
+      json(),
+      jsonLanguage.data.of({
+        autocomplete: jsonCompletion(currentSchema),
+      }),
+    ],
+  });
+  const view = new EditorView({ state });
+
+  let result = await state.languageDataAt<CompletionSource>(
+    "autocomplete",
+    cur
+  )[0](new CompletionContext(state, cur, !!conf.explicit));
+  if (!result) {
+    return expect(result).toEqual(results);
+  }
+  const filteredResults = result.options.map((item) => ({
+    detail: item.detail,
+    info: item.info,
+    label: item.label,
+    type: item.type,
+    // @ts-expect-error
+    template: item?.TESTONLY_template as string | undefined,
+  }));
+  expect(filteredResults).toEqual(results);
+}

src/__tests__/json-completion.spec.ts

@@ -1,48 +1,35 @@
-import { it, describe, expect } from "vitest";
-import { JSONCompletion } from "../json-completion";
-import { CompletionResult, autocompletion } from "@codemirror/autocomplete";
-import { testSchema } from "./__fixtures__/schemas";
-import { EditorView } from "@codemirror/view";
-import { json, jsonLanguage } from "@codemirror/lang-json";
-import { EditorState } from "@codemirror/state";
+import { describe, it } from "vitest";
 
-describe("json-completion", () => {
+import { expectCompletion } from "./__helpers__/completion";
+
+describe("jsonCompletion", () => {
+  it("should return completion data for simple types", async () => {
+    await expectCompletion('{ "f| }', [
+      {
+        label: "foo",
+        type: "property",
+        detail: "string",
+        info: "",
+        template: '"foo": "#{}"',
+      },
+    ]);
+  });
   it("should return completion data for simple types", async () => {
-    expect(true).toEqual(true);
+    await expectCompletion('{ "one| }', [
+      {
+        label: "oneOfEg",
+        type: "property",
+        detail: "",
+        info: "an example oneOf",
+        template: '"oneOfEg": ',
+      },
+      {
+        label: "oneOfEg2",
+        type: "property",
+        detail: "",
+        info: "",
+        template: '"oneOfEg2": ',
+      },
+    ]);
   });
 });
-
-// const getCompletionResult = (
-//   jsonString: string,
-//   pos: number
-// ): Promise<CompletionResult | undefined> => {
-//   return new Promise((resolve, reject) => {
-//     console.log("hello1");
-//     const completionInstance = new JSONCompletion(testSchema);
-//     const state = EditorState.create({
-//       doc: jsonString,
-//       selection: { anchor: pos, head: pos },
-//       extensions: [
-//         json(),
-//         jsonLanguage.data.of({
-//           autocomplete: () => {
-//             const result =
-//               completionInstance.doComplete.bind(completionInstance);
-//               console.log(result)
-//             resolve(result);
-//             return result;
-//           },
-//         }),
-//       ],
-//     });
-//   });
-// };
-
-// describe("json-completion", () => {
-//   console.log("hello");
-//   it("should return completion data for simple types", async () => {
-//     const completionResult = await getCompletionResult('{ "f }', 5);
-//     console.log(completionResult);
-//     expect(completionResult).toEqual(true);
-//   });
-// });

src/utils/debug.ts

@@ -1,6 +1,6 @@
 export const debug = {
   log: (...args: any[]) => {
-    if (process.env.NODE_ENV === "production") {
+    if (process.env.NODE_ENV !== "development") {
       return;
     }
     console.log(...args);