Merge pull request #1461 from Cofinity-X/fix/sig-release#1440-upstream-coverage

chore: eclipse-tractusx/sig-release#1440 increase frontend coverage

Author: ds-mwesener

frontend/src/app/modules/shared/pipes/abbreviate-number.pipe.spec.ts

@@ -0,0 +1,64 @@
+/********************************************************************************
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License, Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+import { AbbreviateNumberPipe } from './abbreviate-number.pipe';
+
+describe('AbbreviateNumberPipe', () => {
+  let pipe: AbbreviateNumberPipe;
+
+  beforeEach(() => {
+    pipe = new AbbreviateNumberPipe();
+  });
+
+  it('should create an instance', () => {
+    expect(pipe).toBeTruthy();
+  });
+
+  it('should return undefined for null value', () => {
+    expect(pipe.transform(null)).toBeUndefined();
+  });
+
+  it('should return undefined for undefined value', () => {
+    expect(pipe.transform(undefined)).toBeUndefined();
+  });
+
+  it('should return "Out of Range" for numbers greater than 9999999', () => {
+    expect(pipe.transform('10,000,000')).toBe('Out of Range');
+    expect(pipe.transform('10000000')).toBe('Out of Range');
+  });
+
+  it('should convert numbers >= 1,000,000 and <= 9,999,999 to abbreviated format', () => {
+    expect(pipe.transform('1,000,000')).toBe('1.0');
+    expect(pipe.transform('1500000')).toBe('1.5');
+    expect(pipe.transform('9,999,999')).toBe('10.0');
+  });
+
+  it('should return original string for numbers less than 1,000,000', () => {
+    expect(pipe.transform('999,999')).toBe('999,999');
+    expect(pipe.transform('500000')).toBe('500000');
+  });
+
+  it('should handle value with periods as thousand separators', () => {
+    expect(pipe.transform('1.000.000')).toBe('1.0');
+  });
+
+  it('should handle mixed comma and period', () => {
+    expect(pipe.transform('1,000.000')).toBe('1.0');
+  });
+});

frontend/src/app/modules/shared/pipes/format-date.pipe.spec.ts

@@ -1,7 +1,7 @@
 /********************************************************************************
  * Copyright (c) 2022, 2023 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
  * Copyright (c) 2022, 2023 ZF Friedrichshafen AG
- * Copyright (c) 2022, 2023 Contributors to the Eclipse Foundation
+ * Copyright (c) 2022, 2025 Contributors to the Eclipse Foundation
  *
  * See the NOTICE file(s) distributed with this work for additional
  * information regarding copyright ownership.
@@ -20,11 +20,17 @@
  ********************************************************************************/
 
 import { CalendarDateModel } from '@core/model/calendar-date.model';
+import { FlattenObjectPipe } from '@shared/pipes/flatten-object.pipe';
 import { screen } from '@testing-library/angular';
 import { renderComponent } from '@tests/test-render.utils';
 import { SharedModule } from '..';
 
 describe('FormatDatePipe', () => {
+  let pipe: FlattenObjectPipe;
+
+  beforeEach(() => {
+    pipe = new FlattenObjectPipe();
+  });
   it('should format date having the 1970 value for the year', async () => {
     const date = new CalendarDateModel(null);
     await renderComponent(`{{ date | formatDate }}`, {
@@ -62,4 +68,73 @@ describe('FormatDatePipe', () => {
 
     expect(screen.getByText('--')).toBeInTheDocument();
   });
+  it('should create an instance', () => {
+    expect(pipe).toBeTruthy();
+  });
+
+  it('should return non-object input as is', () => {
+    expect(pipe.transform(null)).toBe(null);
+    expect(pipe.transform(undefined)).toBe(undefined);
+    expect(pipe.transform(123)).toBe(123);
+    expect(pipe.transform('test')).toBe('test');
+    expect(pipe.transform(true)).toBe(true);
+  });
+
+  it('should flatten a simple nested object', () => {
+    const input = { a: { b: { c: 1 } } };
+    const result = pipe.transform(input);
+    expect(result).toEqual({ 'a.b.c': 1 });
+  });
+
+  it('should handle objects with arrays', () => {
+    const input = { a: [1, 2, 3] };
+    const result = pipe.transform(input);
+    expect(result).toEqual({
+      a: [
+        { 'a[0]': 1 },
+        { 'a[1]': 2 },
+        { 'a[2]': 3 }
+      ]
+    });
+  });
+
+  it('should preserve "children" and "parents" properties', () => {
+    const input = {
+      name: 'node',
+      children: [{ id: 1 }],
+      parents: [{ id: 0 }],
+      details: { type: 'leaf' }
+    };
+    const result = pipe.transform(input);
+    expect(result.children).toEqual([{ id: 1 }]);
+    expect(result.parents).toEqual([{ id: 0 }]);
+    expect(result['details.type']).toEqual('leaf');
+  });
+
+  it('should skip undefined properties', () => {
+    const input = { a: undefined, b: 2 };
+    const result = pipe.transform(input);
+    expect(result).toEqual({ 'b': 2 });
+  });
+
+  it('should flatten mixed content correctly', () => {
+    const input = {
+      a: 1,
+      b: {
+        c: 'text',
+        d: [true, false],
+        e: { f: null }
+      }
+    };
+    const result = pipe.transform(input);
+    expect(result).toEqual({
+      'a': 1,
+      'b.c': 'text',
+      'b.d': [
+        { 'b.d[0]': true },
+        { 'b.d[1]': false }
+      ],
+      'b.e.f': null
+    });
+  });
 });

frontend/src/app/modules/shared/pipes/format-pagination-semantic-data-model-to-camelcase.pipe.spec.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 Contributors to the Eclipse Foundation
+ * Copyright (c) 2023, 2025 Contributors to the Eclipse Foundation
  *
  * See the NOTICE file(s) distributed with this work for additional
  * information regarding copyright ownership.
@@ -17,68 +17,101 @@
  * SPDX-License-Identifier: Apache-2.0
  ********************************************************************************/
 
-import { TestBed } from '@angular/core/testing';
+
+import { SemanticDataModelInCamelCase } from '@page/parts/model/parts.model';
 import { Pagination } from '@core/model/pagination.model';
-import { MainAspectType } from '@page/parts/model/mainAspectType.enum';
-import { SemanticDataModel } from '@page/parts/model/parts.model';
-import { PartsAssembler } from '@shared/assembler/parts.assembler';
 import { FormatPaginationSemanticDataModelToCamelCasePipe } from '@shared/pipes/format-pagination-semantic-data-model-to-camelcase.pipe';
-import { MOCK_part_1, MOCK_part_2 } from '../../../mocks/services/parts-mock/partsAsPlanned/partsAsPlanned.test.model';
 
 describe('FormatPaginationSemanticDataModelToCamelCasePipe', () => {
-  let formatPaginationSemanticDataModelToCamelCasePipe: FormatPaginationSemanticDataModelToCamelCasePipe;
+  let pipe: FormatPaginationSemanticDataModelToCamelCasePipe;
 
   beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [
-        FormatPaginationSemanticDataModelToCamelCasePipe,
+    pipe = new FormatPaginationSemanticDataModelToCamelCasePipe();
+  });
+
+  it('should create an instance', () => {
+    expect(pipe).toBeTruthy();
+  });
+
+  it('should transform all known semanticDataModel values to camel case', () => {
+    const input: Pagination<any> = {
+      content: [
+        { semanticDataModel: 'batch' },
+        { semanticDataModel: 'SerialPart' },
+        { semanticDataModel: 'partAsPlanned' },
+        { semanticDataModel: 'JUSTINSEQUENCE' }
       ],
-    });
-    formatPaginationSemanticDataModelToCamelCasePipe = TestBed.inject(FormatPaginationSemanticDataModelToCamelCasePipe);
+      page: 0,
+      pageCount: 1,
+      pageSize: 10,
+      totalItems: 4
+    };
+
+    const result = pipe.transform(input);
+
+    expect(result.content[0].semanticDataModel).toBe(SemanticDataModelInCamelCase.BATCH);
+    expect(result.content[1].semanticDataModel).toBe(SemanticDataModelInCamelCase.SERIALPART);
+    expect(result.content[2].semanticDataModel).toBe(SemanticDataModelInCamelCase.PARTASPLANNED);
+    expect(result.content[3].semanticDataModel).toBe(SemanticDataModelInCamelCase.JUSTINSEQUENCE);
+  });
+
+  it('should convert unknown semanticDataModel values to UNKNOWN', () => {
+    const input: Pagination<any> = {
+      content: [{ semanticDataModel: 'undefinedModel' }],
+      page: 1,
+      pageCount: 1,
+      pageSize: 5,
+      totalItems: 1
+    };
+
+    const result = pipe.transform(input);
+
+    expect(result.content[0].semanticDataModel).toBe(SemanticDataModelInCamelCase.UNKNOWN);
+  });
+
+  it('should preserve non-semanticDataModel properties', () => {
+    const input: Pagination<any> = {
+      content: [{ semanticDataModel: 'batch', id: '123', name: 'TestPart' }],
+      page: 0,
+      pageCount: 1,
+      pageSize: 1,
+      totalItems: 1
+    };
+
+    const result = pipe.transform(input);
+
+    expect(result.content[0].id).toBe('123');
+    expect(result.content[0].name).toBe('TestPart');
+    expect(result.content[0].semanticDataModel).toBe(SemanticDataModelInCamelCase.BATCH);
   });
 
-  [
-    {
-      option: SemanticDataModel.BATCH,
-      expected: 'Batch',
-    },
-    {
-      option: SemanticDataModel.SERIALPART,
-      expected: 'SerialPart',
-    },
-    {
-      option: SemanticDataModel.PARTASPLANNED,
-      expected: 'PartAsPlanned',
-    },
-  ].forEach(object => {
-
-    it(`should transform semanticDataModel from ${ object.option } to ${ object.expected }`, function() {
-
-      let partList = [ PartsAssembler.assemblePart(MOCK_part_1, MainAspectType.AS_BUILT), PartsAssembler.assemblePart(MOCK_part_2, MainAspectType.AS_BUILT) ];
-
-      let paginationData: Pagination<any> = {
-        page: 0,
-        pageCount: 1,
-        pageSize: 50,
-        totalItems: 1,
-        content: partList,
-      };
-
-      paginationData.content.forEach(part => {
-        part.semanticDataModel = object.option;
-      });
-
-      partList.map(part => {
-        expect(part.semanticDataModel).toEqual(object.option);
-      });
-
-
-      let transformedPartData = formatPaginationSemanticDataModelToCamelCasePipe.transform(paginationData);
-
-      transformedPartData.content.map(part => {
-        expect(part.semanticDataModel).toEqual(object.expected);
-      });
-
-    });
+  it('should return unchanged pagination metadata', () => {
+    const input: Pagination<any> = {
+      content: [{ semanticDataModel: 'serialpart' }],
+      page: 2,
+      pageCount: 5,
+      pageSize: 10,
+      totalItems: 50
+    };
+
+    const result = pipe.transform(input);
+
+    expect(result.page).toBe(2);
+    expect(result.pageCount).toBe(5);
+    expect(result.pageSize).toBe(10);
+    expect(result.totalItems).toBe(50);
+  });
+
+  it('should handle empty content arrays gracefully', () => {
+    const input: Pagination<any> = {
+      content: [],
+      page: 0,
+      pageCount: 0,
+      pageSize: 10,
+      totalItems: 0
+    };
+
+    const result = pipe.transform(input);
+    expect(result.content).toEqual([]);
   });
 });