@elisra-devops/docgen-skins 0.23.0 → 0.25.0

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>');
+  });
+});

package/src/test/JSONTableCell.test.ts

@@ -0,0 +1,181 @@
+import JSONTableCell from '../models/json/table/JSONTableCell';
+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;
+  };
+
+const baseStyles = {
+  isBold: false,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 10,
+  Uri: null as string | null,
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: true,
+};
+
+describe('JSONTableCell', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('creates picture attachment when value contains picture link and respects isFlattened', () => {
+    const shading = { color: 'auto', fill: 'FF0000', themeFillShade: 'BF' } as any;
+
+    const data: any = {
+      name: 'AttachmentCell',
+      value: [
+        {
+          attachmentLink: 'http://server/image.png',
+          tableCellAttachmentLink: 'http://server/image-render.png',
+          attachmentFileName: 'image.png',
+        },
+      ],
+      attachmentType: 'asEmbedded',
+      includeAttachmentContent: true,
+      width: '50%',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, shading, true);
+    const json = cell.getJsonCell() as any;
+
+    expect(json.shading).toEqual(shading);
+    expect(json.attachments).toHaveLength(1);
+    expect(json.attachments[0]).toMatchObject({
+      type: 'Picture',
+      path: 'http://server/image-render.png',
+      name: 'image',
+      isFlattened: true,
+    });
+  });
+
+  test('creates file attachment with link flags for non-picture attachment', () => {
+    const data: any = {
+      name: 'AttachmentCell',
+      value: [
+        {
+          attachmentLink: 'http://server/doc1.pdf',
+          attachmentFileName: 'doc1.pdf',
+        },
+      ],
+      attachmentType: 'asLink',
+      includeAttachmentContent: false,
+      width: '50%',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, undefined, true);
+    const json = cell.getJsonCell() as any;
+
+    expect(json.attachments).toHaveLength(1);
+    expect(json.attachments[0]).toMatchObject({
+      type: 'File',
+      path: 'http://server/doc1.pdf',
+      name: 'doc1',
+      isLinkedFile: true,
+      includeAttachmentContent: false,
+      isFlattened: true,
+    });
+  });
+
+  test('creates HTML cell when value contains HTML markup', () => {
+    const shading = { color: 'auto', fill: '00FF00' } as any;
+
+    const data: any = {
+      name: 'HtmlCell',
+      value: '<p>Hello</p>',
+      width: '30%',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, shading, false);
+    const json = cell.getJsonCell() as any;
+
+    expect(json.Html).toMatchObject({
+      type: 'html',
+      Html: '<p>Hello</p>',
+      font: 'Arial',
+      fontSize: 10,
+    });
+    expect(json.shading).toEqual(shading);
+    expect(json.attachments).toHaveLength(0);
+  });
+
+  test('creates text runs when value is simple text', () => {
+    const data: any = {
+      name: 'TextCell',
+      value: 'Plain text',
+      width: '20%',
+      url: 'http://example.com/field',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, undefined, false);
+    const json = cell.getJsonCell() as any;
+
+    expect(json.Html).toBeUndefined();
+    expect(json.attachments).toHaveLength(0);
+    expect(json.Paragraphs[0].Runs.length).toBeGreaterThan(0);
+    const text = json.Paragraphs[0].Runs.map((r: any) => r.text).join('');
+    expect(text).toContain('Plain text');
+  });
+
+  test('logs error and falls back to error run when value is invalid non-array object', () => {
+    const data: any = {
+      name: 'BadCell',
+      value: { not: 'an array' },
+      width: '10%',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, undefined, false);
+    const json = cell.getJsonCell() as any;
+
+    expect(getMockLogger().error).toHaveBeenCalled();
+    const text = json.Paragraphs[0].Runs.map((r: any) => r.text).join('');
+    expect(text).toContain('Docgen Error: Invalid data value');
+  });
+
+  test('threads sectionRefId from data to run SectionRefId', () => {
+    const data: any = {
+      name: 'Test Case ID',
+      value: '123',
+      sectionRefId: '123',
+      url: 'http://tfs/link',
+      shading: { color: 'auto', fill: 'FFFFFF' },
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, undefined, false);
+    const json = cell.getJsonCell() as any;
+    const runs = json.Paragraphs[0].Runs;
+
+    expect(runs.length).toBeGreaterThan(0);
+    expect(runs[0].SectionRefId).toBe('123');
+  });
+
+  test('SectionRefId is null when not provided on data', () => {
+    const data: any = {
+      name: 'Req ID',
+      value: '456',
+      shading: { color: 'auto', fill: 'FFFFFF' },
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, undefined, false);
+    const json = cell.getJsonCell() as any;
+    const runs = json.Paragraphs[0].Runs;
+
+    expect(runs[0].SectionRefId).toBeNull();
+  });
+});

package/src/test/JSONTableRow.test.ts

@@ -0,0 +1,42 @@
+import JSONTableRow from '../models/json/table/JSONTableRow';
+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 baseStyles = {
+  isBold: false,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 10,
+  Uri: null as string | null,
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: true,
+};
+
+describe('JSONTableRow', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('throws error when WIData has no fields', () => {
+    const data: any = {
+      url: '',
+      level: 0,
+      Source: 1,
+      // fields is intentionally missing to trigger the error path
+    };
+
+    expect(() => new JSONTableRow(data, { ...baseStyles } as any)).toThrow(
+      'no fields to add for the table row'
+    );
+  });
+});

package/src/test/JSONTestSuiteHeaderParagraph.test.ts

@@ -0,0 +1,64 @@
+import JSONTestSuiteHeaderParagraph from '../models/json/paragraph/JSONTestSuiteHeaderParagraph';
+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 baseStyles = {
+  isBold: true,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 14,
+  Uri: null as string | null,
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: true,
+};
+
+describe('JSONTestSuiteHeaderParagraph', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('creates runs for non-title/id/description fields and sets heading level', () => {
+    const fields: any[] = [{ name: 'Custom', value: 'Value', url: 'http://example.com' }];
+
+    const paragraph = new JSONTestSuiteHeaderParagraph(fields, { ...baseStyles }, 1, 2);
+    const json = paragraph.getJSONParagraph() as any;
+
+    expect(json.type).toBe('paragraph');
+    expect(json.headingLevel).toBe(2);
+    expect(json.runs.length).toBeGreaterThan(0);
+  });
+
+  test('emits bookmarkName when wiId is truthy', () => {
+    const fields: any[] = [{ name: 'Custom', value: 'Value' }];
+    const paragraph = new JSONTestSuiteHeaderParagraph(fields, { ...baseStyles }, 42, 2);
+    const json = paragraph.getJSONParagraph();
+
+    expect(json.bookmarkName).toBe('_WI42');
+  });
+
+  test('does not emit bookmarkName when wiId is 0 or falsy', () => {
+    const fields: any[] = [{ name: 'Custom', value: 'Value' }];
+    const paragraph = new JSONTestSuiteHeaderParagraph(fields, { ...baseStyles }, 0, 2);
+    const json = paragraph.getJSONParagraph();
+
+    expect(json.bookmarkName).toBeUndefined();
+  });
+
+  test('does not emit bookmarkName when wiId is undefined', () => {
+    const fields: any[] = [{ name: 'Custom', value: 'Value' }];
+    const paragraph = new JSONTestSuiteHeaderParagraph(fields, { ...baseStyles }, undefined as any, 2);
+    const json = paragraph.getJSONParagraph();
+
+    expect(json.bookmarkName).toBeUndefined();
+  });
+});