CCM-13342: src changes except yml from 2025-11-17/separate-workflows-for-docs-002

Author: nhsd-angel-pastor

src/cloudevents/Makefile

@@ -147,7 +147,7 @@ deploy-ci:
 	pwd && \
 	ls -la
 	@echo "from manual test tools versions file contains:"
-	cat .tool-versions
+	cat .tool-versions || echo "  -> .tool-versions file not found in this directory"
 	/usr/local/bin/asdf --version
 	@echo "Setting up asdf environment and adding plugins"
 	export ASDF_DATA_DIR=$$HOME/.asdf && \

src/cloudevents/package-lock.json

@@ -19,9 +19,11 @@ describe('schema-cache network operations', () => {
     }
   });
 
-  beforeAll((done) => {
+  beforeAll(async () => {
+    console.log('[TEST] Starting HTTP server setup...');
     // Create a local HTTP server for testing
     server = http.createServer((req, res) => {
+      console.log(`[TEST] Server received request for: ${req.url}`);
       // Handle different test scenarios based on URL path
       if (req.url === '/schema.json') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -50,15 +52,28 @@ describe('schema-cache network operations', () => {
       }
     });
 
-    server.listen(0, 'localhost', () => {
-      const address = server.address() as AddressInfo;
-      serverUrl = `http://localhost:${address.port}`;
-      done();
+    await new Promise<void>((resolve, reject) => {
+      server.listen(0, '127.0.0.1', (err?: Error) => {
+        if (err) {
+          console.error('[TEST] Server failed to start:', err);
+          reject(err);
+          return;
+        }
+        const address = server.address() as AddressInfo;
+        serverUrl = `http://127.0.0.1:${address.port}`;
+        console.log(`[TEST] Server started successfully on ${serverUrl}`);
+        resolve();
+      });
     });
   });
 
-  afterAll((done) => {
-    server.close(done);
+  afterAll(async () => {
+    await new Promise<void>((resolve, reject) => {
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
   });
 
   beforeEach(() => {

src/cloudevents/readme-index.yaml

@@ -592,10 +592,19 @@ describe('DocsGenerator', () => {
     });
 
     it('should process multiple schemas', async () => {
-      // Create multiple schema files
-      fs.writeFileSync(path.join(INPUT_DIR, 'schema1.schema.json'), JSON.stringify({ type: 'object' }));
-      fs.writeFileSync(path.join(INPUT_DIR, 'schema2.schema.json'), JSON.stringify({ type: 'string' }));
-      fs.writeFileSync(path.join(INPUT_DIR, 'schema3.schema.yml'), JSON.stringify({ type: 'number' }));
+      // Create multiple schema files with unique IDs
+      fs.writeFileSync(path.join(INPUT_DIR, 'schema1.schema.json'), JSON.stringify({
+        $id: 'schema1.json',
+        type: 'object'
+      }));
+      fs.writeFileSync(path.join(INPUT_DIR, 'schema2.schema.json'), JSON.stringify({
+        $id: 'schema2.json',
+        type: 'string'
+      }));
+      fs.writeFileSync(path.join(INPUT_DIR, 'schema3.schema.yml'), JSON.stringify({
+        $id: 'schema3.json',
+        type: 'number'
+      }));
 
       const config: DocsGeneratorConfig = {
         inputDir: INPUT_DIR,
@@ -606,6 +615,9 @@ describe('DocsGenerator', () => {
       const generator = new DocsGenerator(config);
       const result = await generator.generate();
 
+      if (!result.success) {
+        console.error('Generation failed:', result.error);
+      }
       expect(result.success).toBe(true);
       expect(result.schemasProcessed).toBe(3);
     });

src/cloudevents/tools/cache/__tests__/schema-cache-network.test.ts

@@ -132,11 +132,23 @@ export async function handleCli(args: string[]): Promise<CliResult> {
 }
 
 // Execute CLI if this module is run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  handleCli(process.argv.slice(2)).then((result) => {
-    process.exit(result.exitCode);
-  }).catch((err) => {
-    console.error('Unexpected error:', err);
-    process.exit(1);
-  });
+// Note: This uses eval to prevent Jest/CommonJS from parsing import.meta
+// istanbul ignore next - CLI entry point, difficult to test in Jest
+// @ts-ignore
+try {
+  const importMeta = eval('import.meta');
+  if (importMeta && importMeta.url === `file://${process.argv[1]}`) {
+    handleCli(process.argv.slice(2)).then((result) => {
+      process.exit(result.exitCode);
+    }).catch((err) => {
+      console.error('Unexpected error:', err);
+      process.exit(1);
+    });
+  }
+} catch {
+  // Intentionally ignoring exception: import.meta not available in CommonJS/Jest environments.
+  // This is expected when the module is imported rather than executed directly.
+  if (process.env.DEBUG) {
+    console.debug('Module loaded in CommonJS/Jest environment (import.meta not available)');
+  }
 }

src/cloudevents/tools/generator/__tests__/docs-generator.test.ts

@@ -199,20 +199,16 @@ export class ReadmeIndexGenerator {
       return this.metadata.schema_labels[baseName];
     }
 
-    let schemaType: string;
-
-    switch (category) {
-      case "profile":
-        schemaType = "Profile";
-        break;
-      case "events":
-        schemaType = this.getSchemaName(filename).toLowerCase();
-        break;
-      default:
-        schemaType = this.getSchemaName(filename);
+    if (category === "profile") return "Profile";
+    if (category === "definitions") return this.getSchemaName(filename);
+    if (category === "data") {
+      return this.getSchemaName(filename).replace(" Data", " Data");
+    }
+    if (category === "events") {
+      return this.getSchemaName(filename).replace(" Event", " Event");
     }
 
-    return schemaType;
+    return this.getSchemaName(filename);
   }
 
   /**

src/cloudevents/tools/generator/docs-generator/generate-docs-cli.ts

@@ -60,17 +60,29 @@ export async function handleCli(
 }
 
 // Execute CLI if this module is run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  // Get the root directory (3 levels up from this file: tools/generator/readme-generator)
-  const rootDir = new URL("../../../", import.meta.url).pathname;
-  const args = process.argv.slice(2);
+// Note: This uses eval to prevent Jest/CommonJS from parsing import.meta
+// istanbul ignore next - CLI entry point, difficult to test in Jest
+// @ts-ignore
+try {
+  const importMeta = eval('import.meta');
+  if (importMeta && importMeta.url === `file://${process.argv[1]}`) {
+    // Get the root directory (3 levels up from this file: tools/generator/readme-generator)
+    const rootDir = new URL("../../../", importMeta.url).pathname;
+    const args = process.argv.slice(2);
 
-  handleCli(args, rootDir)
-    .then((result) => {
-      process.exit(result.exitCode);
-    })
-    .catch((err) => {
-      console.error("Unexpected error:", err);
-      process.exit(1);
-    });
+    handleCli(args, rootDir)
+      .then((result) => {
+        process.exit(result.exitCode);
+      })
+      .catch((err) => {
+        console.error("Unexpected error:", err);
+        process.exit(1);
+      });
+  }
+} catch {
+  // Intentionally ignoring exception: import.meta not available in CommonJS/Jest environments.
+  // This is expected when the module is imported rather than executed directly.
+  if (process.env.DEBUG) {
+    console.debug("Module loaded in CommonJS/Jest environment (import.meta not available)");
+  }
 }

src/cloudevents/tools/generator/readme-generator/readme-index-generator.ts

@@ -0,0 +1,157 @@
+/**
+ * CLI tests for validate.ts
+ * Tests the command-line interface by spawning processes with tsx
+ * For faster validation tests using direct imports, see validator-integration.test.ts
+ */
+
+import { beforeEach, afterEach, describe, expect, it } from '@jest/globals';
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+
+const SCRIPT_PATH = path.join(__dirname, '..', 'validate.ts');
+const TEST_DIR = path.join(__dirname, 'temp-validate-cli-test');
+
+/**
+ * Helper to run validator CLI and handle exit codes
+ * Uses tsx for faster execution than ts-node
+ */
+function runValidator(schemaPath: string, dataPath: string, baseDir?: string): { success: boolean; output: string; error: string } {
+  try {
+    const args = baseDir ? ['--base', baseDir, schemaPath, dataPath] : [schemaPath, dataPath];
+    const result = spawnSync('npx', ['tsx', SCRIPT_PATH, ...args], {
+      encoding: 'utf-8',
+      timeout: 15000 // tsx is much faster than ts-node
+    });
+
+    return {
+      success: result.status === 0,
+      output: result.stdout || '',
+      error: result.stderr || ''
+    };
+  } catch (error) {
+    return {
+      success: false,
+      output: '',
+      error: String(error)
+    };
+  }
+}
+
+describe('validate.ts CLI', () => {
+  // Reduced timeout since tsx is much faster than ts-node
+  jest.setTimeout(20000); // 20 seconds per test
+
+  beforeEach(() => {
+    // Create test directory
+    if (!fs.existsSync(TEST_DIR)) {
+      fs.mkdirSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    // Clean up test directory
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe('command line arguments', () => {
+    it('should exit with error when no arguments provided', () => {
+      const result = spawnSync('npx', ['tsx', SCRIPT_PATH], { encoding: 'utf-8', timeout: 15000 });
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toContain('Usage:');
+    });
+
+    it('should exit with error when only schema argument provided', () => {
+      const schemaFile = path.join(TEST_DIR, 'schema.json');
+      fs.writeFileSync(schemaFile, JSON.stringify({ type: 'object' }));
+
+      const result = spawnSync('npx', ['tsx', SCRIPT_PATH, schemaFile], { encoding: 'utf-8', timeout: 15000 });
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toContain('Usage:');
+    });
+  });
+
+  describe('CLI output format', () => {
+    it('should output "Valid!" for valid data', () => {
+      const schemaFile = path.join(TEST_DIR, 'simple.schema.json');
+      const dataFile = path.join(TEST_DIR, 'data.json');
+
+      fs.writeFileSync(schemaFile, JSON.stringify({
+        type: 'object',
+        properties: { name: { type: 'string' } }
+      }));
+      fs.writeFileSync(dataFile, JSON.stringify({ name: 'test' }));
+
+      const result = runValidator(schemaFile, dataFile);
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('Valid!');
+    });
+
+    it('should output error message for invalid data', () => {
+      const schemaFile = path.join(TEST_DIR, 'required.schema.json');
+      const dataFile = path.join(TEST_DIR, 'data.json');
+
+      fs.writeFileSync(schemaFile, JSON.stringify({
+        type: 'object',
+        properties: { name: { type: 'string' } },
+        required: ['name']
+      }));
+      fs.writeFileSync(dataFile, JSON.stringify({}));
+
+      const result = runValidator(schemaFile, dataFile);
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid:');
+    });
+  });
+
+  describe('--base option', () => {
+    it('should accept --base option for schema directory', () => {
+      const schemaFile = path.join(TEST_DIR, 'schema.json');
+      const dataFile = path.join(TEST_DIR, 'data.json');
+
+      fs.writeFileSync(schemaFile, JSON.stringify({
+        type: 'object',
+        properties: { value: { type: 'string' } }
+      }));
+      fs.writeFileSync(dataFile, JSON.stringify({ value: 'test' }));
+
+      const result = runValidator(schemaFile, dataFile, TEST_DIR);
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle non-existent schema file', () => {
+      const schemaFile = path.join(TEST_DIR, 'nonexistent.schema.json');
+      const dataFile = path.join(TEST_DIR, 'data.json');
+
+      fs.writeFileSync(dataFile, JSON.stringify({ value: 'test' }));
+
+      const result = runValidator(schemaFile, dataFile);
+      expect(result.success).toBe(false);
+    });
+
+    it('should handle non-existent data file', () => {
+      const schemaFile = path.join(TEST_DIR, 'schema.json');
+      const dataFile = path.join(TEST_DIR, 'nonexistent.json');
+
+      fs.writeFileSync(schemaFile, JSON.stringify({ type: 'object' }));
+
+      const result = runValidator(schemaFile, dataFile);
+      expect(result.success).toBe(false);
+    });
+
+    it('should handle invalid JSON in data file', () => {
+      const schemaFile = path.join(TEST_DIR, 'schema.json');
+      const dataFile = path.join(TEST_DIR, 'data.json');
+
+      fs.writeFileSync(schemaFile, JSON.stringify({ type: 'object' }));
+      fs.writeFileSync(dataFile, '{ invalid json }');
+
+      const result = runValidator(schemaFile, dataFile);
+      expect(result.success).toBe(false);
+    });
+  });
+});