Use jest for testing

Author: anthony-c-martin

.github/dependabot.yml

@@ -1,19 +1,17 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
 version: 2
 updates:
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+      day: "sunday"
   - package-ecosystem: "npm"
     directory: "/generator"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+      day: "sunday"
   - package-ecosystem: "npm"
     directory: "/tools"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+      day: "sunday"

tools/jest.config.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+module.exports = {
+  verbose: true,
+  moduleFileExtensions: [
+    "ts",
+    "js"
+  ],
+  transform: {
+    '^.+\\.(ts|tsx)$': 'ts-jest'
+  },
+  testMatch: [
+    '**/test/**/*.test.(ts)'
+  ],
+  testEnvironment: 'node',
+};

tools/package-lock.json

@@ -9,25 +9,23 @@
   },
   "scripts": {
     "build": "tsc -p .",
-    "test": "mocha -r ts-node/register tests.ts",
+    "test": "jest",
     "serve": "ts-node server.ts",
     "lint": "eslint . --ext ts",
     "lint:fix": "eslint . --ext ts --fix"
   },
   "devDependencies": {
-    "@types/chai": "^4.3.14",
     "@types/express": "^4.17.21",
-    "@types/mocha": "^10.0.6",
+    "@types/jest": "^29.5.12",
     "@types/node": "^20.12.7",
     "@typescript-eslint/eslint-plugin": "^7.7.1",
     "@typescript-eslint/parser": "^7.7.1",
     "ajv": "^6.12.6",
-    "chai": "^5.1.0",
     "eslint": "^8.56.0",
     "eslint-plugin-header": "^3.1.1",
     "express": "^4.19.2",
-    "mocha": "^10.4.0",
-    "mocha-junit-reporter": "^2.2.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.4.5",
     "vscode-json-languageservice": "^5.3.11",

tools/package.json

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { expect } from 'chai';
 import Ajv from 'ajv';
 import * as url from 'url';
 import path from 'path';
@@ -9,12 +8,11 @@ import { readFile } from 'fs/promises';
 import { getLanguageService } from 'vscode-json-languageservice';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import draft4MetaSchema from 'ajv/lib/refs/json-schema-draft-04.json';
-import 'mocha';
-import { findCycle } from './cycleCheck';
+import { findCycle } from '../src/cycleCheck';
 
-const schemasFolder = __dirname + '/../schemas/';
-const testSchemasFolder = __dirname + '/schemas/';
-const templateTestsFolder = __dirname + '/templateTests/';
+const schemasFolder = path.join(__dirname, '../../schemas/');
+const testSchemasFolder = path.join(__dirname, '../testSchemas/');
+const templateTestsFolder = path.join(__dirname, '../templateTests/');
 const armSchemasPrefix = /^https?:\/\/schema\.management\.azure\.com\/schemas\//
 const jsonSchemaDraft4Prefix = /^https?:\/\/json-schema\.org\/draft-04\/schema/
 
@@ -140,60 +138,62 @@ const schemasToSkip = [
 
 const schemaPaths = listSchemaPaths(schemasFolder).filter(path => schemasToSkip.indexOf(path) == -1);
 const templateTestPaths = listSchemaPaths(templateTestsFolder);
+const TIMEOUT_1_MINUTE = 60000;
 
 describe('Validate individual resource schemas', () => {
   it(`can be parsed with JSON.parse`, async function () {
-    this.timeout(60000);
     for (const schemaPath of schemaPaths) {
       const schema = await loadRawSchema(schemaPath);
 
-      expect(() => JSON.parse(schema), `Parsing ${schemaPath}`).not.to.throw();
+      expect(() => JSON.parse(schema)).not.toThrow();
     }
-  });
+  }, TIMEOUT_1_MINUTE);
 
   for (const metaSchemaPath of metaSchemaPaths) {
     it(`validates against '${metaSchemaPath}'`, async function () {
-      this.timeout(60000);
       for (const schemaPath of schemaPaths) {
         const schema = await loadSchema(schemaPath);
         const metaSchema = await loadSchema(metaSchemaPath);
 
         const validate = await ajvInstance.compileAsync(metaSchema);
         const result = await validate(schema);
 
-        expect(result, `Validating ${schemaPath} failed with errors ${JSON.stringify(validate.errors, null, 2)}`).to.be.true;
+        if (!result) {
+          console.error(`Validating ${schemaPath} failed with errors ${JSON.stringify(validate.errors, null, 2)}`);
+        }
+        expect(result).toBeTruthy();
       }
-    });
+    }, TIMEOUT_1_MINUTE);
   }
 
   it(`can be compiled`, async function () {
-    this.timeout(60000);
     for (const schemaPath of schemaPaths) {
       const schema = await loadSchema(schemaPath);
 
-      expect(() => ajvInstance.compile(schema), `Compiling ${schemaPath}`).not.to.throw();
+      expect(() => ajvInstance.compile(schema)).not.toThrow();
     }
-  });
+  }, TIMEOUT_1_MINUTE);
 
   it(`does not contain any cycles`, async function () {
 
     for (const schemaPath of schemaPaths) {
       if (!schemasToSkipForCyclicValidation.has(schemaPath)) {
-        this.timeout(60000);
         const schema = await loadSchema(schemaPath);
 
         const cycle = findCycle(schema);
-        expect(cycle, `Found ${schemaPath} cycle ${cycle?.join(' -> ')}`).to.be.undefined;
+
+        if (cycle) {
+          console.error(`Found ${schemaPath} cycle ${cycle?.join(' -> ')}`);
+        }
+        expect(cycle).toBeUndefined();
       }
     }
-  });
+  }, TIMEOUT_1_MINUTE);
 });
 
 describe('Validate test templates against VSCode language service', () => {
   for (const templateTestFile of templateTestPaths) {
     it(`running schema validation on '${templateTestFile}'`, async function () {
-      this.timeout(60000);
-
       const service = getLanguageService({
         schemaRequestService: loadRawSchema,
         workspaceContext: {
@@ -206,7 +206,7 @@ describe('Validate test templates against VSCode language service', () => {
       const jsonDocument = service.parseJSONDocument(textDocument);
 
       const result = await service.doValidation(textDocument, jsonDocument);
-      expect(result).to.deep.equal([]);
-    });
+      expect(result).toEqual([]);
+    }, TIMEOUT_1_MINUTE);
   }
 });

tools/cycleCheck.ts renamed to tools/src/cycleCheck.ts

@@ -1,23 +1,27 @@
 {
   "compilerOptions": {
     "skipLibCheck": true,
+    "alwaysStrict": true,
+    "forceConsistentCasingInFileNames": false,
     "module": "commonjs",
     "noEmitOnError": true,
+    "noImplicitAny": true,
     "noImplicitReturns": true,
+    "noImplicitThis": true,
     "sourceMap": true,
     "declarationMap": true,
     "strict": true,
     "declaration": true,
     "stripInternal": true,
     "noEmitHelpers": false,
     "target": "es2019",
-    "types": ["node"],
+    "types": ["node", "jest"],
     "esModuleInterop": true,
     "lib": ["es2020"],
     "newLine": "LF",
     "outDir": "out",
     "rootDir": ".",
     "resolveJsonModule": true
   },
-  "exclude": ["out", "node_modules"]
+  "exclude": ["out", "node_modules", "**/*.d.ts"]
 }