refactor: Remove deprecated API usages and adding more tests

Author: hypery2k

src/commands/util.ts

@@ -23,7 +23,7 @@ export function getFiles(args: string | string[]): string[] {
 }
 
 function getFormatFromFileName(filename: string): string {
-  return path.extname(filename).substr(1).toLowerCase()
+  return path.extname(filename).substring(1).toLowerCase()
 }
 
 function decodeFile(contents: string, format: string): any {

test/compile.spec.ts

@@ -1,7 +1,7 @@
 import type {ExecException} from "child_process"
 import cli from "./cli"
-import assert = require("assert")
-import fs = require("fs")
+import assert from "assert"
+import * as fs from "fs"
 
 describe("compile", function () {
   this.timeout(10000)

test/help.spec.ts

@@ -1,5 +1,5 @@
 import cli from "./cli"
-import assert = require("assert")
+import assert from "assert"
 
 describe("help", function () {
   this.timeout(10000)

test/migrate.spec.ts

@@ -1,7 +1,7 @@
 import cli from "./cli"
-import assert = require("assert")
-import fs = require("fs")
-import path = require("path")
+import assert from "assert"
+import * as fs from "fs"
+import * as path from "path"
 import {AnySchemaObject} from "ajv"
 
 describe("migrate", function () {

test/options.spec.ts

@@ -0,0 +1,137 @@
+import assert from "assert"
+import {checkOptions, getOptions} from "../src/commands/options"
+
+// checkOptions mutates the schema it receives, so each test must use a fresh object.
+function schema(extra: object = {}): any {
+  return {type: "object", properties: {}, ...extra}
+}
+
+describe("options", function () {
+  describe("checkOptions", () => {
+    it("should return null when all required params are present", () => {
+      const result = checkOptions(
+        schema({properties: {s: {type: "string"}}, required: ["s"]}),
+        {_: [], s: "test/schema.json"}
+      )
+      assert.strictEqual(result, null)
+    })
+
+    it("should return an error string for a missing required param", () => {
+      const result = checkOptions(
+        schema({properties: {s: {type: "string"}}, required: ["s"]}),
+        {_: []}
+      )
+      assert(result !== null)
+      assert(result.includes("required"))
+      assert(result.includes("-s"))
+    })
+
+    it("should prefix single-char params with single dash", () => {
+      const result = checkOptions(
+        schema({properties: {s: {type: "string"}}, required: ["s"]}),
+        {_: []}
+      )
+      assert(result !== null)
+      assert(result.includes("-s"))
+      assert(!result.includes("--s"))
+    })
+
+    it("should prefix multi-char params with double dash", () => {
+      const result = checkOptions(
+        schema({properties: {schema: {type: "string"}}, required: ["schema"]}),
+        {_: []}
+      )
+      assert(result !== null)
+      assert(result.includes("--schema"))
+    })
+
+    it("should return an error for an unknown parameter", () => {
+      const result = checkOptions(schema(), {_: [], unknownParam: "value"})
+      assert(result !== null)
+      assert(result.includes("unknown"))
+      assert(result.includes("--unknownParam"))
+    })
+
+    it("should return an error when too many positional arguments are given", () => {
+      const result = checkOptions(schema(), {_: ["arg1", "arg2"]})
+      assert(result !== null)
+      assert(result.includes("too many arguments"))
+    })
+
+    it("should return null for exactly one positional argument", () => {
+      const result = checkOptions(schema(), {_: ["one"]})
+      assert.strictEqual(result, null)
+    })
+
+    it("should accept known ajv options when ajvOptions key is present in schema", () => {
+      const result = checkOptions(schema({ajvOptions: true}), {_: [], "all-errors": true})
+      assert.strictEqual(result, null)
+    })
+
+    it("should reject unknown options even with ajvOptions in schema", () => {
+      const result = checkOptions(schema({ajvOptions: true}), {_: [], "not-an-option": true})
+      assert(result !== null)
+      assert(result.includes("unknown"))
+    })
+  })
+
+  describe("getOptions", () => {
+    it("should return an empty code object when argv has no ajv options", () => {
+      const opts = getOptions({_: []})
+      assert.deepStrictEqual(opts.code, {})
+    })
+
+    it("should not include undefined options in the result", () => {
+      const opts = getOptions({_: []})
+      assert(!("allErrors" in opts))
+      assert(!("strict" in opts))
+    })
+
+    it("should extract allErrors from camelCase argv key", () => {
+      const opts = getOptions({_: [], allErrors: true})
+      assert.strictEqual(opts.allErrors, true)
+    })
+
+    it("should extract allErrors from dash-case argv key (--all-errors)", () => {
+      const opts = getOptions({_: [], "all-errors": true})
+      assert.strictEqual(opts.allErrors, true)
+    })
+
+    it("should map the data option to $data", () => {
+      const opts = getOptions({_: [], data: true})
+      assert.strictEqual(opts.$data, true)
+    })
+
+    it("should put code-es5 into the code sub-object", () => {
+      const opts = getOptions({_: [], "code-es5": true})
+      assert.strictEqual(opts.code.es5, true)
+    })
+
+    it("should put code-optimize into the code sub-object", () => {
+      const opts = getOptions({_: [], "code-optimize": 2})
+      assert.strictEqual(opts.code.optimize, 2)
+    })
+
+    it("should put code-lines into the code sub-object", () => {
+      const opts = getOptions({_: [], "code-lines": true})
+      assert.strictEqual(opts.code.lines, true)
+    })
+
+    it("should handle strict option (boolean)", () => {
+      const opts = getOptions({_: [], strict: true})
+      assert.strictEqual(opts.strict, true)
+    })
+
+    it("should handle strict option (string value)", () => {
+      const opts = getOptions({_: [], strict: "log"})
+      assert.strictEqual(opts.strict, "log")
+    })
+
+    it("should handle multiple options at once", () => {
+      const opts = getOptions({_: [], allErrors: true, "code-es5": true, data: true})
+      assert.strictEqual(opts.allErrors, true)
+      assert.strictEqual(opts.$data, true)
+      assert.strictEqual(opts.code.es5, true)
+    })
+  })
+})

test/test.spec.ts

@@ -1,5 +1,5 @@
 import cli from "./cli"
-import assert = require("assert")
+import assert from "assert"
 import type {DefinedError} from "ajv"
 
 describe("test", function () {

test/util.spec.ts

@@ -0,0 +1,112 @@
+import assert from "assert"
+import {getFiles, openFile, logJSON} from "../src/commands/util"
+
+describe("util", function () {
+  describe("getFiles", () => {
+    it("should return a single filename as-is (no glob magic)", () => {
+      const files = getFiles("test/schema.json")
+      assert.deepStrictEqual(files, ["test/schema.json"])
+    })
+
+    it("should expand a glob pattern to matching files", () => {
+      const files = getFiles("test/valid_data.js*")
+      assert(files.length >= 2)
+      assert(files.every((f) => /valid_data\.js/.test(f)))
+    })
+
+    it("should handle an array of plain filenames", () => {
+      const files = getFiles(["test/schema.json", "test/valid_data.json"])
+      assert.deepStrictEqual(files, ["test/schema.json", "test/valid_data.json"])
+    })
+
+    it("should handle an array mixing plain names and globs", () => {
+      const files = getFiles(["test/schema.json", "test/valid_data.js*"])
+      assert(files.length >= 3)
+      assert.strictEqual(files[0], "test/schema.json")
+    })
+
+    it("should return an empty array for a no-match glob", () => {
+      const files = getFiles("test/no_such_file_xyz_*.json")
+      assert.deepStrictEqual(files, [])
+    })
+  })
+
+  describe("openFile", () => {
+    it("should parse a JSON file", () => {
+      const data = openFile("test/valid_data.json", "data")
+      assert(Array.isArray(data))
+    })
+
+    it("should parse a .yml YAML file", () => {
+      const data = openFile("test/valid_data.yml", "data")
+      assert(data !== null && typeof data === "object")
+    })
+
+    it("should parse a .yaml YAML file", () => {
+      const data = openFile("test/valid_data.yaml", "data")
+      assert(data !== null && typeof data === "object")
+    })
+
+    it("should parse a JSON5 file", () => {
+      const data = openFile("test/valid_data.json5", "data")
+      assert(data !== null && typeof data === "object")
+    })
+
+    it("should parse a JSONC file", () => {
+      const data = openFile("test/valid_data.jsonc", "data")
+      assert(data !== null && typeof data === "object")
+    })
+
+    it("should parse a JSON schema file", () => {
+      const data = openFile("test/schema.json", "schema")
+      assert(typeof data === "object" && data !== null)
+      assert("type" in data || "$schema" in data || "properties" in data)
+    })
+
+    it("should load file content matching across all supported text formats", () => {
+      const json = openFile("test/valid_data.json", "data")
+      const yml = openFile("test/valid_data.yml", "data")
+      const yaml = openFile("test/valid_data.yaml", "data")
+      assert.deepStrictEqual(json, yml)
+      assert.deepStrictEqual(json, yaml)
+    })
+  })
+
+  describe("logJSON", () => {
+    const errors = [{keyword: "required", message: "must have required property 'foo'"}]
+
+    it('should pretty-print JSON for mode "json"', () => {
+      const result = logJSON("json", errors)
+      assert.strictEqual(result, JSON.stringify(errors, null, "  "))
+    })
+
+    it('should output compact JSON for mode "line"', () => {
+      const result = logJSON("line", errors)
+      assert.strictEqual(result, JSON.stringify(errors))
+    })
+
+    it('should return empty string for mode "no"', () => {
+      const result = logJSON("no", errors)
+      assert.strictEqual(result, "")
+    })
+
+    it('should return data unchanged for mode "text" without ajv', () => {
+      const result = logJSON("text", errors)
+      assert.strictEqual(result, errors)
+    })
+
+    it('should call ajv.errorsText for mode "text" with ajv instance', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const Ajv = require("ajv")
+      const ajv = new Ajv()
+      const result = logJSON("text", errors, ajv)
+      assert(typeof result === "string")
+      assert(result.includes("must have required property"))
+    })
+
+    it("should return data unchanged for an unrecognised mode", () => {
+      const result = logJSON("fancy", errors)
+      assert.strictEqual(result, errors)
+    })
+  })
+})

test/validate.spec.ts

@@ -1,5 +1,5 @@
 import cli from "./cli"
-import assert = require("assert")
+import assert from "assert"
 import type {DefinedError} from "ajv"
 
 describe("validate", function () {