fix: added unit tests for structural and semantic parsing

Signed-off-by: Fredrik Nordlander <fredrik.nordlander@digg.se>

Author: fredriknordlander

src/app.ts

@@ -23,12 +23,11 @@ import { DiagnosticReport, RapLPDiagnostic } from './util/RapLPDiagnostic.js';
 import { AggregateError } from './util/RapLPCustomErrorInfo.js';
 import chalk from 'chalk';
 import { ExcelReportProcessor } from './util/excelReportProcessor.js';
-import { parseApiSpecInput,detectSpecFormatPreference,semanticValidate, ParseResult} from './util/validateUtil.js';
+import { parseApiSpecInput,detectSpecFormatPreference, ParseResult} from './util/validateUtil.js';
 import { SpecParseError } from './util/RapLPSpecParseError.js';
 import type { IParser } from '@stoplight/spectral-parsers';
 import { Document as SpectralDocument } from '@stoplight/spectral-core';
 import { Issue } from './util/RapLPIssueHelpers.js';
-import * as IssueHelper from './util/RapLPIssueHelpers.js';
 
 declare var AggregateError: {
   prototype: AggregateError;
@@ -91,12 +90,11 @@ async function main(): Promise<void> {
     const ruleCategories = argv.categories ? (argv.categories as string).split(',') : undefined;
     const logErrorFilePath = argv.logError as string | undefined;
     const logDiagnosticFilePath = argv.logDiagnostic as string | undefined;
-    const disableSanity = argv.disableSanity as boolean ?? false;
     const strict = argv.strict as boolean ?? false;
 
     // Schemevalidation and Spectral  Document creation ----------
     let apiSpecDocument: SpectralDocument;
-    let parseResult: any;
+    let parseResult: ParseResult;
     try {
       const prefer = detectSpecFormatPreference(apiSpecFileName,undefined,'auto');
       parseResult = await parseApiSpecInput(
@@ -109,7 +107,7 @@ async function main(): Promise<void> {
       if (parseResult.strictIssues && parseResult.strictIssues.length > 0) {
          console.error('Strict validation reported issues:');
           parseResult.strictIssues.forEach((iss: Issue) =>
-            console.error(chalk.yellow(`- ${iss.type} at ${iss.path} : ${iss.message} ${iss.line ? `(line ${iss.line})` : ''}`)),
+              console.error(chalk.yellow(`- ${iss.type} at ${iss.path} : ${iss.message} ${iss.line ? `(line ${iss.line})` : ''}`)),
           );
           process.exitCode = 2;
           return;

src/util/RapLPCustomSpectral.ts

@@ -67,7 +67,6 @@ class RapLPCustomSpectral {
     // Map properties from result ISpectralDiagnostic to CustomSpectralDiagnostic
     const { message, code, severity, path, source, range, ...rest } = result;
     // Map severity to corresponding string value for allvarlighetsgrad
-    console.log("Code is:" + code);
     let allvarlighetsgrad: string;
     switch (severity) {
       case 0:

src/util/RapLPIssueHelpers.ts

@@ -43,7 +43,7 @@ function extractJumpLinesFromPretty(prettyLines?: string[]): Set<number> {
 export function spectralDiagnosticsToIssuesSimple(
   diagnostics: SpectralCore.ISpectralDiagnostic[] | readonly SpectralCore.ISpectralDiagnostic[] | undefined,
   prettyLines?: string[],
-  fallbackAddOne = false // om ingen referens finns, välj detta
+  fallbackAddOne = false // If no ref, choose thisone
 ): Issue[] {
   const issues: Issue[] = [];
   if (!diagnostics || diagnostics.length === 0) return issues;
@@ -59,18 +59,18 @@ export function spectralDiagnosticsToIssuesSimple(
     let line: number | null = null;
     if (rawLine !== null) {
       if (useJumpRef) {
-        // Om prettifier har rawLine+1 så använd +1, annars använd rawLine (ingen annan gissning)
+        // Om prettifier har rawLine+1 så använd +1, annars använd rawLine 
         if (jumpSet.has(rawLine + 1)) {
           line = rawLine + 1;
         } else {
           line = rawLine;
         }
       } else {
-        // ingen referens — fallback baserat på param
+        // No ref  — fallback 
         line = fallbackAddOne ? rawLine + 1 : rawLine;
       }
     }
-
+    //Create Issue
     issues.push({
       type: 'Semantic',
       code: d.code ?? undefined,
@@ -207,12 +207,113 @@ export function mergeAndDedupeIssues(prettyIssues: Issue[], spectralIssues: Issu
 
   return result;
 }
+export function consolidateIssues(issues: Issue[]): Issue[] {
+  if (!issues || issues.length === 0) return [];
+
+  const normalizeMsg = (s?: string) => (s ?? '').replace(/\s+/g, ' ').trim().toLowerCase();
+  const normalizePath = (p?: string) => (p ?? '').toString().trim();
+
+  // Key now: path + line (group by location), not path+message
+  const map = new Map<string, Issue>();
+
+  const priorityScore = (type?: string) => {
+    if (!type) return 0;
+    const t = type.toLowerCase();
+    if (t === 'semantic') return 3;
+    if (t === 'structural') return 2;
+    if (t === 'info') return 1;
+    return 0;
+  };
+
+  for (const rawIss of issues) {
+    const iss: Issue = { ...rawIss }; // shallow copy
+    iss.path = normalizePath(iss.path);
+    iss.message = (iss.message ?? '').trim();
+
+    const linePart = iss.line != null ? String(iss.line) : '_noline_';
+    const key = `${iss.path}|${linePart}`;
+
+    const existing = map.get(key);
+    if (!existing) {
+      // ensure details is array
+      if (!Array.isArray(iss.details)) iss.details = [];
+      if (iss.raw && !Array.isArray(iss.raw)) iss.raw = [String(iss.raw)];
+      map.set(key, iss);
+      continue;
+    }
+
+    // If incoming has higher priority (e.g. Semantic > Structural) - replace as primary
+    if (priorityScore(iss.type) > priorityScore(existing.type)) {
+      // preserve existing as detail(s)
+      const details = new Set<string>(existing.details ?? []);
+      if (existing.message && existing.message !== iss.message) details.add(existing.message);
+      if (existing.raw && Array.isArray(existing.raw)) {
+        for (const r of existing.raw) details.add(String(r).trim());
+      }
+      // merge existing.details too
+      if (Array.isArray(existing.details)) {
+        for (const d of existing.details) details.add((d ?? '').toString().trim());
+      }
+
+      iss.details = Array.from(new Set([...(iss.details ?? []), ...Array.from(details)])).filter(Boolean);
+      // copy metadata if missing on new
+      if (!iss.documentationUrl) iss.documentationUrl = existing.documentationUrl;
+      if (!iss.source) iss.source = existing.source;
+      // keep smallest non-null line if new misses it
+      if ((iss.line == null || iss.line === 0) && (existing.line != null)) iss.line = existing.line;
+      map.set(key, iss);
+    } else {
+      // Keep existing primary; merge incoming into details
+      const details = new Set<string>(existing.details ?? []);
+      if (iss.message && iss.message !== existing.message) details.add(iss.message);
+      if (Array.isArray(iss.details)) for (const d of iss.details) details.add(d);
+      if (Array.isArray(iss.raw)) for (const r of iss.raw) details.add(String(r).trim());
+      existing.details = Array.from(details).filter(Boolean);
+      // keep smallest non-null line if existing missing
+      if ((existing.line == null || existing.line === 0) && (iss.line != null)) existing.line = iss.line;
+      existing.documentationUrl = existing.documentationUrl ?? iss.documentationUrl;
+      existing.source = existing.source ?? iss.source;
+      map.set(key, existing);
+    }
+  }
+
+  // Convert to array
+  let merged = Array.from(map.values());
+
+  // Filter: ta bort generiska oneOf-meddelanden om specifika finns i samma parent path
+  merged = merged.filter(i => {
+    if (i.message && /oneOf schema/i.test(i.message)) {
+      const parent = i.path.split('.').slice(0, -1).join('.');
+      const hasSpecific = merged.some(o => o.path.startsWith(parent) && !/oneOf schema/i.test(o.message));
+      if (hasSpecific) return false;
+    }
+    return true;
+  });
+
+  // Sort determenistic: source, line (nummer), path
+  merged.sort((a, b) => {
+    const sa = `${a.source ?? ''}|${String(a.line ?? 0).padStart(6, '0')}|${a.path ?? ''}`;
+    const sb = `${b.source ?? ''}|${String(b.line ?? 0).padStart(6, '0')}|${b.path ?? ''}`;
+    return sa.localeCompare(sb);
+  });
+
+  // Trim messages & details, dedupe details
+  for (const i of merged) {
+    i.message = (i.message ?? '').trim();
+    if (i.details && Array.isArray(i.details)) {
+      i.details = Array.from(new Set(i.details.map(d => (d ?? '').toString().trim()))).filter(Boolean);
+    }
+  }
+
+  return merged;
+}
+
 /**
  * ConsolidateIssues
  * @param issues 
  * @returns 
  */
-export function consolidateIssues(issues: Issue[]): Issue[] {
+export function consolidateIssues2(issues: Issue[]): Issue[] {
   if (!issues || issues.length === 0) return [];
 
   // Normaliseringshjälpare

src/util/validateUtil.ts

@@ -20,7 +20,6 @@ import type { IParser } from '@stoplight/spectral-parsers';
 import * as IssueHelper from './RapLPIssueHelpers.js';
 import { SpecParseError} from './RapLPSpecParseError.js';
 
-
 /**
  * Possible input types for specifications
  * - filePath: Read from filesystem

tests/unit/integration/validateRunner.mjs

@@ -0,0 +1,21 @@
+// tests/unit/integration/validateRunner.mjs
+import path from 'path';
+
+async function main() {
+  const arg = process.argv[2] || '{}';
+  const input = JSON.parse(arg);
+
+  try {
+    
+    const { parseApiSpecInput } = await import('../../../dist/util/validateUtil.js');
+
+    const res = await parseApiSpecInput(input, { strict: !!input.strict });
+    console.log(JSON.stringify({ ok: true, result: res }));
+    process.exit(0);
+  } catch (err) {
+    console.error(JSON.stringify({ ok: false, message: err?.message, stack: err?.stack }));
+    process.exit(2);
+  }
+}
+
+main();

tests/unit/issueHelper.test.ts

@@ -0,0 +1,120 @@
+import { Issue, sortIssues,consolidateIssues } from '../../src/util/RapLPIssueHelpers.js';
+import { spectralDiagnosticsToIssuesSimple } from '../../src/util/RapLPIssueHelpers.js';
+import type * as SpectralCore from '@stoplight/spectral-core';
+describe('IssueHelper.sortIssues', ()=> {
+    it('Sorterar issues efter line, path och typ', () => {
+        const issues: Issue[] = [
+        {
+            type: 'Structural',
+            path: 'components.schemas.B',
+            message: 'Missing $ref',
+            line: 50,
+            raw: [],
+        },
+        {
+            type: 'Semantic',
+            path: 'components.schemas.A',
+            message: 'Required property must not be empty',
+            line: 20,
+            code: 'oas3-schema',
+            raw: [],
+        },
+        {
+            type: 'Structural',
+            path: 'components.schemas.A',
+            message: 'Should have required property',
+            line: 20,
+            raw: [],
+        },
+        {
+            type: 'Semantic',
+            path: 'components.schemas.C',
+            message: 'Extra property not allowed',
+            line: 50,
+            code: 'oas3-schema',
+            raw: [],
+        },
+        {
+            type: 'Info',
+            path: 'components.schemas.D',
+            message: 'Some info message',
+            line: undefined,
+            raw: [],
+        },
+        ];
+        expect (issues.map(i =>i.path)).toEqual ([
+            'components.schemas.B',
+            'components.schemas.A',
+            'components.schemas.A',
+            'components.schemas.C',
+            'components.schemas.D',
+        ]);
+        const sorted = sortIssues(issues);
+
+        const expectedOrder = [
+            'components.schemas.A', // Semantic
+            'components.schemas.A', // Structural
+            'components.schemas.B', // Structural
+            'components.schemas.C', // Semantic
+            'components.schemas.D', // Info, line undefined            
+        ];
+            expect(sorted.map(i => i.path)).toEqual(expectedOrder);
+            expect(sorted[0].type).toBe('Semantic');
+            expect(sorted[1].type).toBe('Structural');
+            expect(sorted[4].line).toBeUndefined();        
+    });
+
+});
+describe('spectralDiagnosticsToIssuesSimple', () => {
+  it('konverterar ISpectralDiagnostic till Issue med fallbackAddOne=false', () => {
+    const diag: Partial<SpectralCore.ISpectralDiagnostic> = {
+      code: 'path-params',
+      message: 'Operation must define parameter "{id}"',
+      path: ['paths', '/petshamta/{id}', 'get'],
+      range: { start: { line: 196, character: 0 }, end: { line: 200, character: 0 } },
+      source: '/tmp/api.yaml',
+    } as any;
+
+    // no prettyLines -> fallback false -> line should equal rawLine (196)
+    const issues = spectralDiagnosticsToIssuesSimple([diag as any], undefined, false);
+    expect(issues.length).toBe(1);
+    expect(issues[0].line).toBe(196);
+    expect(issues[0].path).toBe('paths./petshamta/{id}.get');
+  });
+
+  it('använder prettyLines för att bestämma +1 (om jump innehåller rawLine+1)', () => {
+    const diag: Partial<SpectralCore.ISpectralDiagnostic> = {
+      code: 'X',
+      message: 'm',
+      path: ['paths', '/x', 'get'],
+      range: { start: { line: 5, character: 0 }, end: { line: 5, character: 1 } },
+    } as any;
+
+    const pretty = ['Structural error at paths./x', 'should something', 'Jump to line 6'];
+    const issues = spectralDiagnosticsToIssuesSimple([diag as any], pretty, false);
+    expect(issues[0].line).toBe(6);
+  });
+});
+describe('consolidateIssues', () => {
+  it('prioriterar semantic över structural och samlar details', () => {
+    const items: Issue[] = [
+      { type: 'Structural', path: 'c.s', message: 'x', line: 10 },
+      { type: 'Semantic', path: 'c.s', message: 'y', line: 10 }
+    ];
+    const out = consolidateIssues(items);
+    expect(out.length).toBe(1);
+    expect(out[0].type).toBe('Semantic');
+    // details should contain structural message
+    expect(out[0].details && out[0].details.some(d => d === 'x')).toBe(true);
+  });
+
+  it('tar bort oneOf när mer specifika finns', () => {
+    const items: Issue[] = [
+      { type: 'Structural', path: 'parent.child', message: 'oneOf schema', line: 1 },
+      { type: 'Structural', path: 'parent.child.specific', message: 'specific error', line: 1 }
+    ];
+    const out = consolidateIssues(items);
+    expect(out.some(i => /oneOf/i.test(i.message))).toBe(false);
+    expect(out.some(i => /specific error/i.test(i.message))).toBe(true);
+  });
+});