Merge pull request #1851 from markscott-ms/timelines

Update release-1.1 from main - bad schema validation test

Author: rocketstack-matt

shared/src/commands/validate/json-schema-validator.spec.ts

@@ -2,6 +2,9 @@ import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
 import { JsonSchemaValidator } from './json-schema-validator';
 import Ajv2020 from 'ajv/dist/2020.js';
 import { SchemaDirectory } from '../../schema-directory.js';
+import { FileSystemDocumentLoader } from '../../document-loader/file-system-document-loader.js';
+import path from 'path';
+import { readFileSync } from 'fs';
 
 describe('JsonSchemaValidator', () => {
     let schemaDirectory: SchemaDirectory;
@@ -61,3 +64,17 @@ describe('JsonSchemaValidator', () => {
         expect(() => validator.validate({})).toThrowError('Validator has not been initialized. Call initialize() before validating.');
     });
 });
+
+describe('JsonSchemaValidator integration', () => {
+    const schemaDir = path.join(__dirname, '../../../../calm/release/1.0/meta/');
+    const badPatternPath = path.join(__dirname, '../../../test_fixtures/bad-schema/bad-json-schema.json');
+
+    it('throws when compiling the bad-json-schema fixture', async () => {
+        const schemaDirectory = new SchemaDirectory(new FileSystemDocumentLoader([schemaDir], true));
+        await schemaDirectory.loadSchemas();
+        const badPattern = JSON.parse(readFileSync(badPatternPath, 'utf-8'));
+        const validator = new JsonSchemaValidator(schemaDirectory, badPattern);
+
+        await expect(validator.initialize()).rejects.toThrow(/type/i);
+    });
+});

shared/src/commands/validate/validate.e2e.spec.ts

@@ -13,6 +13,10 @@ const inputPatternPath = path.join(
     __dirname,
     '../../../test_fixtures/command/validate/options/pattern.json'
 );
+const badPatternPath = path.join(
+    __dirname,
+    '../../../test_fixtures/bad-schema/bad-json-schema.json'
+);
 
 const schemaDir = path.join(__dirname, '../../../../calm/release/1.0/meta/');
 
@@ -38,6 +42,21 @@ describe('validate E2E', () => {
         expect(response.spectralSchemaValidationOutputs[1].path).toBe('/nodes/1/description');
     });
 
+    it('reports json schema compilation errors for bad-json-schema fixture', async () => {
+        schemaDirectory = new SchemaDirectory(new FileSystemDocumentLoader([schemaDir], true));
+        await schemaDirectory.loadSchemas();
+
+        const badPattern = JSON.parse(readFileSync(badPatternPath, 'utf-8'));
+        const inputArch = JSON.parse(readFileSync(inputArchPath, 'utf-8'));
+
+        const response = await validate(inputArch, badPattern, undefined, schemaDirectory, false);
+
+        expect(response.hasErrors).toBeTruthy();
+        expect(response.jsonSchemaValidationOutputs).toHaveLength(1);
+        expect(response.jsonSchemaValidationOutputs[0].message).toContain('type');
+        expect(response.jsonSchemaValidationOutputs[0].path).toBe('/');
+    });
+
     describe('applyArchitectureOptionsToPattern', () => {
         it('works with one options relationship', async () => {
             const architecture = JSON.parse(

shared/src/commands/validate/validate.ts

@@ -149,10 +149,19 @@ async function validateArchitectureAgainstPattern(architecture: object, pattern:
 
     const patternResolved = applyArchitectureOptionsToPattern(architecture, pattern, debug);
 
-    const jsonSchemaValidator = new JsonSchemaValidator(schemaDirectory, patternResolved, debug);
-    await jsonSchemaValidator.initialize();
-
     let jsonSchemaValidations = [];
+    let jsonSchemaValidator: JsonSchemaValidator;
+    try {
+        jsonSchemaValidator = new JsonSchemaValidator(schemaDirectory, patternResolved, debug);
+        await jsonSchemaValidator.initialize();
+    } catch (error) {
+        const errorMessage = toErrorMessage(error);
+        logger.error(`JSON Schema compilation failed: ${errorMessage}`);
+        jsonSchemaValidations = [
+            new ValidationOutput('json-schema', 'error', errorMessage, '/')
+        ];
+        return new ValidationOutcome(jsonSchemaValidations, spectralResult.spectralIssues, true, warnings);
+    }
 
     const schemaErrors = jsonSchemaValidator.validate(architecture);
     if (schemaErrors.length > 0) {
@@ -184,10 +193,11 @@ async function validatePatternOnly(pattern: object, schemaDirectory: SchemaDirec
 
     try {
         // Compile pattern as a schema to check if it's valid
-        new JsonSchemaValidator(schemaDirectory, pattern, debug);
+        const jsonSchemaValidator = new JsonSchemaValidator(schemaDirectory, pattern, debug);
+        await jsonSchemaValidator.initialize();
     } catch (error) {
         errors = true;
-        jsonSchemaErrors.push(new ValidationOutput('json-schema', 'error', error.message, '/'));
+        jsonSchemaErrors.push(new ValidationOutput('json-schema', 'error', toErrorMessage(error), '/'));
     }
 
     return new ValidationOutcome(jsonSchemaErrors, spectralValidationResults.spectralIssues, errors, warnings);// added spectral to return object
@@ -294,6 +304,20 @@ function prettifyJson(json) {
     return JSON.stringify(json, null, 4);
 }
 
+function toErrorMessage(error: unknown): string {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    } catch {
+        return 'Unknown error';
+    }
+}
+
 export function stripRefs(obj: object): string {
     return JSON.stringify(obj).replaceAll('$ref', 'ref');
 }
@@ -364,4 +388,4 @@ function mergeSpectralResults(spectralResultPattern: SpectralResult, spectralRes
     const warnings: boolean = spectralResultPattern.warnings || spectralResultArchitecture.warnings;
     const spectralValidations = spectralResultPattern.spectralIssues.concat(spectralResultArchitecture.spectralIssues);
     return new SpectralResult(warnings, errors, spectralValidations);
-}
+}