@elisra-devops/docgen-skins 0.22.0 → 0.24.0

package/src/index.ts

@@ -20,7 +20,11 @@ export default class Skins {
   SKIN_TYPE_TRACE = 'trace-table';
   SKIN_TYPE_TABLE_STR = 'str-table';
   SKIN_TYPE_PARAGRAPH = 'paragraph';
+  SKIN_TYPE_COVER_PAGE = 'cover-page';
   SKIN_TYPE_TEST_PLAN = 'test-plan';
+  SKIN_TYPE_TEST_STD = 'test-std';
+  SKIN_TYPE_TEST_STP = 'test-stp';
+  SKIN_TYPE_TEST_STR = 'test-str';
   SKIN_TYPE_SYSTEM_OVERVIEW = 'system-overview';
   SKIN_TYPE_INSTALLATION = 'installation';
   SKIN_TYPE_TEST_REPORTER = 'test-reporter';
@@ -37,6 +41,16 @@ export default class Skins {
     this.skinFormat = skinFormat;
   }
 
+  private resolveSkinTypeAlias(skinType: string) {
+    if (skinType === this.SKIN_TYPE_TEST_STD || skinType === this.SKIN_TYPE_TEST_STP) {
+      return this.SKIN_TYPE_TEST_PLAN;
+    }
+    if (skinType === this.SKIN_TYPE_TEST_STR) {
+      return this.SKIN_TYPE_TABLE_STR;
+    }
+    return skinType;
+  }
+
   async addNewContentToDocumentSkin(
     contentControlTitle: string,
     skinType: string,
@@ -50,8 +64,10 @@ export default class Skins {
   ): Promise<any[]> {
     try {
       let populatedSkin: any[] = [];
+      const isStpTestSkin = skinType === this.SKIN_TYPE_TEST_STP;
+      const normalizedSkinType = this.resolveSkinTypeAlias(skinType);
 
-      switch (skinType) {
+      switch (normalizedSkinType) {
         case this.SKIN_TYPE_TABLE:
           populatedSkin = this.generateQueryBasedTable(data, headerStyles, styles, headingLvl);
 
@@ -73,6 +89,9 @@ export default class Skins {
         case this.SKIN_TYPE_PARAGRAPH:
           populatedSkin = this.generateQueryBasedParagraphs(data, styles, headingLvl);
           break;
+        case this.SKIN_TYPE_COVER_PAGE:
+          populatedSkin = this.generateCoverPageParagraphs(data, styles, headingLvl);
+          break;
         case this.SKIN_TYPE_TEST_PLAN:
           populatedSkin = this.generateTestBasedSkin(
             data,
@@ -80,7 +99,8 @@ export default class Skins {
             styles,
             headingLvl,
             includeAttachments,
-            isFlattened
+            isFlattened,
+            isStpTestSkin ? 1 : 0
           );
           break;
         case this.SKIN_TYPE_SYSTEM_OVERVIEW:
@@ -327,49 +347,63 @@ export default class Skins {
     }
   }
 
+  private generateParagraphsFromData(data: any, styles: StyleOptions, headingLvl: number = 0): any[] {
+    const paragraphs: any[] = [];
+
+    data.forEach((wi: WIData) => {
+      wi.fields.forEach((field: WIProperty) => {
+        // Description and Test Description are handled via rich-text handler
+        if (field.name === 'Description: ' || field.name === 'Test Description:') {
+          const paragraphSkin = new JSONRichTextParagraph(field, styles, wi.Source, headingLvl + wi.level);
+          paragraphs.push(paragraphSkin.getJSONRichTextParagraph());
+        }
+
+        // Exclude ID / Description / Test Description from the normal paragraph path
+        if (field.name !== 'ID' && field.name !== 'Description: ' && field.name !== 'Test Description:') {
+          const paragraphSkin = new JSONParagraph(field, styles, wi.Source, headingLvl + wi.level);
+          paragraphs.push(paragraphSkin.getJSONParagraph());
+        }
+      });
+    });
+
+    return paragraphs;
+  }
+
+  generateCoverPageParagraphs(data: any, styles: StyleOptions, headingLvl: number = 0): any[] {
+    logger.debug(`Generating cover-page paragraphs as ${this.skinFormat}`);
+    try {
+      switch (this.skinFormat) {
+        case 'json':
+          return this.generateParagraphsFromData(data, styles, headingLvl);
+        case 'html':
+          logger.info(`Generating html cover-page paragraphs!`);
+          return [];
+        default:
+          throw new Error(`Invalid skin format ${this.skinFormat}`);
+      }
+    } catch (error: any) {
+      logger.error(`Error occurred in generateCoverPageParagraphs: ${error.message}`);
+      throw error;
+    }
+  }
+
   generateQueryBasedParagraphs(data: any, styles: StyleOptions, headingLvl: number = 0): any[] {
     logger.debug(`Generating paragraph as ${this.skinFormat}`);
     try {
       switch (this.skinFormat) {
         case 'json':
-          let paragraphs: any[] = [];
-          data.forEach((wi: WIData) => {
-            wi.fields.forEach((field: WIProperty) => {
-              //Description and Test Description are handled in richText handler
-              if (field.name === 'Description: ' || field.name === 'Test Description:') {
-                let paragraphSkin = new JSONRichTextParagraph(
-                  field,
-                  styles,
-                  wi.Source,
-                  headingLvl + wi.level
-                );
-                paragraphs.push(paragraphSkin.getJSONRichTextParagraph());
-              }
-
-              //making sure ID is not printed
-              //excluding Description and Test Description are handled in richText handler
-              if (
-                field.name !== 'ID' &&
-                field.name !== 'Description: ' &&
-                field.name !== 'Test Description:'
-              ) {
-                let paragraphSkin = new JSONParagraph(field, styles, wi.Source, headingLvl + wi.level);
-                paragraphs.push(paragraphSkin.getJSONParagraph());
-              }
-            });
-          });
-          return paragraphs;
+          return this.generateParagraphsFromData(data, styles, headingLvl);
         case 'html':
           logger.info(`Generating html paragraphs!`);
           return [];
         default:
           throw new Error(`Invalid skin format ${this.skinFormat}`);
-      } //switch
-    } catch (error) {
+      }
+    } catch (error: any) {
       logger.error(`Error occurred in generateQueryBasedParagraphs: ${error.message}`);
       throw error;
     }
-  } //generateParagraph
+  }
 
   generateTraceTable(
     data: any,
@@ -397,7 +431,8 @@ export default class Skins {
               undefined,
               undefined,
               false,
-              groupedHeader
+              groupedHeader,
+              true
             );
             traceSkin.push(tableSkin.getJSONTable());
           } else if (errorMessage !== null) {
@@ -423,7 +458,8 @@ export default class Skins {
     styles: StyleOptions,
     headingLvl: number = 0,
     includeAttachments: boolean = true,
-    isFlattened = false
+    isFlattened = false,
+    headingLevelOffset = 0
   ): any[] {
     logger.debug(`Generating testSkin as ${this.skinFormat}`);
     let aggregatedErrors: string[] = [];
@@ -450,7 +486,7 @@ export default class Skins {
                 testSuite?.suiteSkinData?.fields && testSuite.suiteSkinData.fields.length > 1
                   ? Number(testSuite.suiteSkinData.fields[1]?.value)
                   : undefined;
-              
+
               // Check if suite should be included (not flattened)
               if (testSuite.suiteSkinData) {
                 let SuiteStyles = {
@@ -468,10 +504,10 @@ export default class Skins {
                   SuiteStyles,
                   suiteId || 0,
                   testSuite.suiteSkinData.level
-                    ? headingLvl + testSuite.suiteSkinData.level
+                    ? headingLvl + testSuite.suiteSkinData.level + headingLevelOffset
                     : headingLvl
-                    ? headingLvl
-                    : 1
+                    ? headingLvl + headingLevelOffset
+                    : 1 + headingLevelOffset
                 );
                 testSkin.push(testSuiteParagraphSkin.getJSONParagraph());
               }
@@ -497,10 +533,10 @@ export default class Skins {
                   TestCaseStyles,
                   testcase.id || 0,
                   testcase.testCaseHeaderSkinData.level
-                    ? headingLvl + testcase.testCaseHeaderSkinData.level
+                    ? headingLvl + testcase.testCaseHeaderSkinData.level + headingLevelOffset
                     : headingLvl
-                    ? headingLvl
-                    : 1
+                    ? headingLvl + headingLevelOffset
+                    : 1 + headingLevelOffset
                 );
                 testSkin.push(testCaseParagraphSkin.getJSONParagraph());
 
@@ -521,6 +557,23 @@ export default class Skins {
                 let richTextSkin: any[] = testDescriptionParagraph.getJSONRichTextParagraph();
                 testSkin = [...testSkin, ...richTextSkin];
 
+                const additionalTestCaseFields = Array.isArray(testcase.testCaseHeaderSkinData?.fields)
+                  ? testcase.testCaseHeaderSkinData.fields.slice(3)
+                  : [];
+                additionalTestCaseFields.forEach((field: any) => {
+                  const name = String(field?.name || '').trim();
+                  const value = String(field?.value ?? '').trim();
+                  if (!value) return;
+                  const combinedValue = name ? `${name}: ${value}` : value;
+                  const paragraph = new JSONParagraph(
+                    { name: '', value: combinedValue },
+                    styles,
+                    testcase.id || 0,
+                    0
+                  );
+                  testSkin.push(paragraph.getJSONParagraph());
+                });
+
                 if (testcase.testCaseRequirements) {
                   if (testcase.testCaseRequirements.length > 0) {
                     let testDescriptionTitleParagraph = new JSONParagraph(

package/src/models/json/table/JSONTable.ts

@@ -12,6 +12,7 @@ import JSONTableRow from './JSONTableRow';
 export default class JSONTable {
   tableTemplate: Table;
   tableStyles: StyleOptions;
+  private readonly enableVerticalMerge: boolean;
 
   constructor(
     data: WIQueryResults,
@@ -29,8 +30,10 @@ export default class JSONTable {
       shading?: Shading;
       leftShading?: Shading;
       rightShading?: Shading;
-    }
+    },
+    enableVerticalMerge: boolean = false
   ) {
+    this.enableVerticalMerge = enableVerticalMerge;
     this.tableStyles = tableStyles;
     this.tableTemplate = {
       type: 'table',
@@ -106,8 +109,10 @@ export default class JSONTable {
       rows.push(row.getRow());
     });
 
-    // Apply vertical merging for grouped source cells (first row shows value; subsequent are empty)
-    this.applyVerticalMerges(rows);
+    if (this.enableVerticalMerge) {
+      // Apply vertical merging for grouped source cells (first row shows value; subsequent are empty)
+      this.applyVerticalMerges(rows);
+    }
 
     return rows;
   } //generateJsonRows
@@ -179,6 +184,17 @@ export default class JSONTable {
 
     const getCellText = (cell: any): string => {
       try {
+        const htmlRaw = String(cell?.Html?.Html || '').trim();
+        if (htmlRaw) {
+          const htmlText = htmlRaw
+            .replace(/<[^>]*>/g, ' ')
+            .replace(/&nbsp;/gi, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+          if (htmlText) {
+            return htmlText;
+          }
+        }
         const runs = cell?.Paragraphs?.[0]?.Runs || [];
         return runs.map((r: any) => (r?.text ?? '')).join('').trim();
       } catch {

package/src/test/JSONFile.test.ts

@@ -0,0 +1,59 @@
+import JSONFile from '../models/json/file/JSONFile';
+import logger from '../services/logger';
+
+jest.mock('../services/logger', () => ({
+  __esModule: true,
+  default: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const getMockLogger = () =>
+  logger as unknown as {
+    debug: jest.Mock;
+    info: jest.Mock;
+    warn: jest.Mock;
+    error: jest.Mock;
+  };
+
+describe('JSONFile', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('removeFileExtension returns original name when there is no dot', () => {
+    const data: any = {
+      attachmentLink: 'http://server/file',
+      attachmentFileName: 'file',
+      attachmentType: 'asEmbedded',
+      includeAttachmentContent: true,
+    };
+
+    const jsonFile = new JSONFile(data);
+    const attachment = jsonFile.getFileAttachment as any;
+
+    expect(attachment.type).toBe('File');
+    expect(attachment.name).toBe('file');
+  });
+
+  test('isPictureUri handles invalid uri and logs error', () => {
+    const data: any = {
+      attachmentLink: undefined,
+      attachmentFileName: 'file.docx',
+      attachmentType: 'asEmbedded',
+      includeAttachmentContent: true,
+    };
+
+    const jsonFile = new JSONFile(data);
+    const attachment = jsonFile.getFileAttachment as any;
+
+    expect(attachment.type).toBe('File');
+    expect(attachment.name).toBe('file');
+    expect(getMockLogger().error).toHaveBeenCalledWith(
+      expect.stringContaining('error parsing file extension for')
+    );
+  });
+});

package/src/test/JSONRun.test.ts

@@ -0,0 +1,118 @@
+import JSONRun from '../models/json/JSONRun';
+import { defaultJsonRun } from '../models/json/default';
+import logger from '../services/logger';
+
+jest.mock('../services/logger', () => ({
+  __esModule: true,
+  default: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    silly: jest.fn(),
+  },
+}));
+
+const getMockLogger = () =>
+  logger as unknown as {
+    debug: jest.Mock;
+    info: jest.Mock;
+    warn: jest.Mock;
+    error: jest.Mock;
+    silly: jest.Mock;
+  };
+
+const baseStyles = {
+  isBold: true,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 12,
+  Uri: 'http://example.com',
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: true,
+  InsertPageBreak: false as boolean | undefined,
+};
+
+describe('JSONRun', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('splits multi-line text into separate runs with correct line breaks', () => {
+    const value = 'line1\nline2\nline3';
+
+    const jsonRun = new JSONRun(value, { ...baseStyles });
+    const runs = jsonRun.getRun();
+
+    expect(runs).toHaveLength(3);
+
+    expect(runs[0].InsertLineBreak).toBe(true);
+    expect(runs[1].InsertLineBreak).toBe(true);
+    expect(runs[2].InsertLineBreak).toBe(baseStyles.InsertLineBreak);
+
+    runs.forEach((r) => {
+      expect(r.Bold).toBe(baseStyles.isBold);
+      expect(r.Italic).toBe(baseStyles.IsItalic);
+      expect(r.Underline).toBe(baseStyles.IsUnderline);
+      expect(r.Size).toBe(baseStyles.Size);
+      expect(r.Font).toBe(baseStyles.Font);
+      expect(r.InsertSpace).toBe(baseStyles.InsertSpace);
+    });
+  });
+
+  test('uses striphtml replaceBr callback to convert <br> to newline', () => {
+    const value = 'Hello<br>World';
+
+    const jsonRun = new JSONRun(value, { ...baseStyles });
+    const runs = jsonRun.getRun();
+
+    expect(runs).toHaveLength(1);
+    expect(runs[0].text).toContain('\n');
+  });
+
+  test('sets Uri to null when default run Uri is empty string in normal flow', () => {
+    const prevUri = defaultJsonRun.Uri;
+    defaultJsonRun.Uri = '' as any;
+
+    const jsonRun = new JSONRun('plain text', { ...baseStyles });
+    const runs = jsonRun.getRun();
+
+    runs.forEach((r) => {
+      expect(r.Uri).toBeNull();
+    });
+
+    defaultJsonRun.Uri = prevUri;
+  });
+
+  test('does not strip HTML when fieldtype is SuiteHeaderParagraphTitle', () => {
+    const value = '<b>Bold Title</b>';
+
+    const jsonRun = new JSONRun(value, { ...baseStyles }, 'SuiteHeaderParagraphTitle');
+    const runs = jsonRun.getRun();
+
+    expect(runs).toHaveLength(1);
+    expect(runs[0].text).toContain('<b>Bold Title</b>');
+  });
+
+  test('falls back to default run and logs when value cannot be split', () => {
+    const badValue: any = null;
+
+    const prevUri = defaultJsonRun.Uri;
+    defaultJsonRun.Uri = '' as any;
+
+    const jsonRun = new JSONRun(badValue, { ...baseStyles });
+    const runs = jsonRun.getRun();
+
+    expect(getMockLogger().silly).toHaveBeenCalled();
+    expect(runs).toHaveLength(1);
+    expect(runs[0].text).toBe('');
+    expect(runs[0].Bold).toBe(baseStyles.isBold);
+    expect(runs[0].Italic).toBe(baseStyles.IsItalic);
+    expect(runs[0].Underline).toBe(baseStyles.IsUnderline);
+    expect(runs[0].Size).toBe(baseStyles.Size);
+    expect(runs[0].Uri).toBeNull();
+
+    defaultJsonRun.Uri = prevUri;
+  });
+});

package/src/test/JSONTable.test.ts

@@ -0,0 +1,126 @@
+import JSONTable from '../models/json/table/JSONTable';
+
+const baseStyles = {
+  isBold: false,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 10,
+  Uri: null as string | null,
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: false,
+};
+
+const headerStyles = {
+  ...baseStyles,
+  isBold: true,
+};
+
+const buildData = (secondColValue: string) => [
+  {
+    url: '',
+    Source: 1,
+    level: 1,
+    fields: [
+      { name: '#', value: 1, width: '8%' },
+      { name: 'Description', value: 'No description' },
+    ],
+  },
+  {
+    url: '',
+    Source: 2,
+    level: 1,
+    fields: [
+      { name: '#', value: 2, width: '8%' },
+      { name: 'Description', value: secondColValue },
+    ],
+  },
+];
+
+describe('JSONTable vertical merge behavior', () => {
+  test('uses explicit grouped-header column spans when provided', () => {
+    const table = new JSONTable(
+      [
+        {
+          url: '',
+          Source: 1,
+          level: 1,
+          fields: [
+            { name: 'Req ID', value: 1 },
+            { name: 'Title', value: 'Req' },
+            { name: 'Customer ID', value: 'C1' },
+            { name: 'Test Case ID', value: 11 },
+            { name: 'Title', value: 'TC' },
+          ],
+        },
+      ] as any,
+      headerStyles as any,
+      baseStyles as any,
+      0,
+      false,
+      false,
+      false,
+      {
+        leftLabel: 'Requirement',
+        rightLabel: 'Test Case',
+        leftColumns: 3,
+        rightColumns: 2,
+      },
+      false
+    ).getJSONTable() as any;
+
+    expect(table.Rows[0].Cells[0].gridSpan).toBe(3);
+    expect(table.Rows[0].Cells[1].gridSpan).toBe(2);
+  });
+
+  test('does not merge empty cells when vertical merge is disabled', () => {
+    const table = new JSONTable(
+      buildData('') as any,
+      headerStyles as any,
+      baseStyles as any,
+      0,
+      false,
+      false,
+      false,
+      undefined,
+      false
+    ).getJSONTable() as any;
+
+    expect(table.Rows[1].Cells[1].vMerge).toBeUndefined();
+    expect(table.Rows[2].Cells[1].vMerge).toBeUndefined();
+  });
+
+  test('merges empty cells when vertical merge is enabled', () => {
+    const table = new JSONTable(
+      buildData('') as any,
+      headerStyles as any,
+      baseStyles as any,
+      0,
+      false,
+      false,
+      false,
+      undefined,
+      true
+    ).getJSONTable() as any;
+
+    expect(table.Rows[1].Cells[1].vMerge).toBe('restart');
+    expect(table.Rows[2].Cells[1].vMerge).toBe('continue');
+  });
+
+  test('does not treat HTML cell content as empty during merge detection', () => {
+    const table = new JSONTable(
+      buildData('<div>Some Description for suite</div>') as any,
+      headerStyles as any,
+      baseStyles as any,
+      0,
+      false,
+      false,
+      false,
+      undefined,
+      true
+    ).getJSONTable() as any;
+
+    expect(table.Rows[2].Cells[1].vMerge).toBeUndefined();
+    expect(table.Rows[2].Cells[1].Html?.Html).toBe('<div>Some Description for suite</div>');
+  });
+});