Refactor tests and parsing

Author: 3timeslazy

src/customizations.test.ts

@@ -0,0 +1,108 @@
+import { describe } from 'mocha'
+import { Customizations, Settings, Extension,  parseCustomizations } from './customizations'
+import assert from 'node:assert'
+
+interface TestCase<T> {
+    desc: string,
+    configFile: string,
+    expect: T | string,
+}
+
+function runTests<T, S = keyof Customizations>(key: S, testCases: TestCase<T>[]) {
+    for (const testCase of testCases) {
+        it(testCase.desc, () => {
+            const actual = parseCustomizations(testCase.configFile);
+            if (actual instanceof Error) {
+                assert.deepEqual(actual.message, testCase.expect);
+            } else {
+                const full: any = {
+                    settings: {},
+                    extensions: [],
+                };
+                full[key] = testCase.expect;
+                assert.deepEqual(actual, full);
+            }
+        })
+    }
+}
+
+describe("'customizations' format", () => {
+
+    describe("*.settings", () => {
+        const cases: TestCase<Settings>[] = [
+            {
+                desc: "empty",
+                configFile: "{}",
+                expect: {},
+            },
+            {
+                desc: "invalid jsonc format",
+                configFile: "}",
+                expect: "devcontainer.json must be a valid jsonc file",
+            },
+            {
+                desc: "base types are supported",
+                configFile: `
+                {
+                    "customizations": {
+                        "EDITOR": {
+                            "settings": {
+                                "number": 1.1,
+                                "boolean": true,
+                                "string": "devcontainer",
+                                "object": {
+                                    "number": 1,
+                                }
+                            }
+                        }
+                    }
+                }
+                `,
+                expect: {
+                    number: 1.1,
+                    boolean: true,
+                    string: "devcontainer",
+                    object: {
+                        number: 1
+                    }
+                }
+            }
+        ];
+        runTests("settings", cases.map(tc => ({
+            ...tc,
+            desc: `(vscode) ${tc.desc}`,
+            configFile: tc.configFile.replaceAll("EDITOR", "vscode"),
+        })));
+        // runTests(cases.map(tc => ({
+        //     ...tc,
+        //     desc: `(codium) ${tc.desc}`,
+        //     configFile: tc.configFile.replaceAll("EDITOR", "vscodium"),
+        // })));
+    });
+
+    describe("vscode.extensions", () => {
+        runTests<Extension[]>("extensions", [
+            {
+                desc: "empty",
+                configFile: "{}",
+                expect: []
+            },
+            {
+                desc: "valid list",
+                configFile: `
+                {
+                    "customizations": {
+                        "vscode": {
+                            "extensions": ["golang.Go"]
+                        }
+                    }
+                }
+                `,
+                expect: [{
+                    id: "golang.Go"
+                }]
+            }
+        ])
+    })
+})
+

src/customizations.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import * as jsonc from "jsonc-parser";
+
+// Type definitions according to devcontainer specification
+
+const SpecSettings = z.object({}).catchall(z.any()).default({});
+type SpecSettings = z.infer<typeof SpecSettings>;
+
+const VsCodeExtensions = z.array(z.string()).default([]);
+type VsCodeExtensions = z.infer<typeof VsCodeExtensions>;
+
+// const CodiumRegistry = z.object({
+//   url: z.string().url(),
+//   headers: z.object({}).catchall(z.string()),
+// });
+// type CodiumRegistry = z.infer<typeof CodiumRegistry>;
+
+const SpecCustomizations = z.object({
+  vscode: z.optional(
+    z.object({
+      settings: SpecSettings,
+      extensions: VsCodeExtensions,
+    }),
+  ),
+});
+type SpecCustomizations = z.infer<typeof SpecCustomizations>;
+
+const DevContainerConfig = z.object({
+  customizations: SpecCustomizations.default({}),
+});
+type DevContainerConfig = z.infer<typeof DevContainerConfig>;
+
+// Internal type definitions
+
+export type Settings = SpecSettings;
+
+export type Extension = {
+  id: string;
+  registry?: string;
+  version?: string;
+};
+
+export type Customizations = {
+  settings: Settings;
+  //   registries: Record<string, Registry>;
+  extensions: Extension[];
+};
+
+const emptyCustomuzations = { settings: {}, extensions: [] };
+
+export function parseCustomizations(configContent: string): Customizations | Error {
+  let errors: jsonc.ParseError[] = [];
+  const parsed = jsonc.parse(configContent, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    return new Error("devcontainer.json must be a valid jsonc file");
+  }
+  const validated = DevContainerConfig.safeParse(parsed);
+  if (validated.error) {
+    return validated.error;
+  }
+
+  const vscode = validated.data.customizations.vscode;
+  if (vscode) {
+    return {
+      settings: vscode.settings,
+      extensions: vscode.extensions.map(id => ({ id: id })),
+    };
+  }
+
+  return emptyCustomuzations;
+}