OZG-6170 prefix always welcome at getFieldPath()

alfa-client/libs/tech-shared/src/lib/validation/tech.validation.util.spec.ts

@@ -35,10 +35,8 @@ import {
   getControlForInvalidParam,
   getControlForIssue,
   getFieldPath,
-  getLastPart,
   getMessageForInvalidParam,
   getMessageForIssue,
-  getPartsAfterPrefix,
   setInvalidParamValidationError,
   setIssueValidationError,
 } from './tech.validation.util';
@@ -154,13 +152,13 @@ describe('ValidationUtils', () => {
     });
   });
 
-  describe.skip('invalid param', () => {
-    const formPrefixes: string[] = ['', 'some-prefix'];
+  describe('invalid param', () => {
+    const formPrefixes: string[] = ['', 'somePrefix'];
     const fieldNames: string[] = ['baseField1', 'baseField2', 'subGroup.subGroupField1'];
-    const prefixNameCombinations: string[][] = formPrefixes.flatMap((prefix) =>
-      fieldNames.map((name) => [prefix, name]),
-    );
-    const unknownName = 'unknown-field';
+    const prefixNameCombinations: string[][] = formPrefixes
+      .flatMap((prefix) => fieldNames.map((name) => [prefix, name]))
+      .filter((el) => existingPrefixAndFieldCombination(el[0], el[1]));
+
     const fieldLabel: string = faker.lorem.word();
 
     describe.each(prefixNameCombinations)(
@@ -180,7 +178,7 @@ describe('ValidationUtils', () => {
           it('should return', () => {
             const msg: string = getMessageForInvalidParam(fieldLabel, invalidParam);
 
-            expect(msg).toEqual(`Bitte ${fieldName} ausfüllen`);
+            expect(msg).toEqual(`Bitte ${fieldLabel} ausfüllen`);
           });
         });
 
@@ -194,12 +192,11 @@ describe('ValidationUtils', () => {
 
         describe('set invalid param validation error', () => {
           it('should assign invalidParam to form control error without prefix', () => {
-            const message: string = getMessageForInvalidParam(fieldLabel, invalidParam);
-
             setInvalidParamValidationError(form, invalidParam, prefix);
 
-            const errorMessage: string = form.getError(invalidParam.reason, fieldName);
-            expect(errorMessage).toBe(message);
+            const result: InvalidParam = form.getError(invalidParam.reason, fieldName);
+
+            expect(result).toBe(invalidParam);
           });
 
           it('should mark form as touched', () => {
@@ -210,93 +207,32 @@ describe('ValidationUtils', () => {
         });
       },
     );
-
-    describe.each([
-      ['', '', 'unknown-field'],
-      ['valid-prefix', 'valid-prefix', 'unknown-field'],
-      ['valid-prefix', 'valid-prefix', 'subGroup.unknown-field'],
-      ['unknown-prefix', 'valid-prefix', 'unknown-field'],
-      ['unknown-prefix', 'valid-prefix', 'baseField1'],
-    ])(
-      'with pathPrefix "%s", paramPrefix "%s", and field-name "%s"',
-      (pathPrefix, paramPrefix, fieldName) => {
-        let invalidParam: InvalidParam;
-
-        beforeEach(() => {
-          form.reset();
-          invalidParam = createInvalidParam();
-          invalidParam.name = paramPrefix.length > 0 ? `${paramPrefix}.${fieldName}` : fieldName;
-        });
-
-        it('should not find form control', () => {
-          const control: AbstractControl = getControlForInvalidParam(
-            form,
-            invalidParam,
-            pathPrefix,
-          );
-
-          expect(control).toBeFalsy();
-        });
-
-        it('should not assign to field control error', () => {
-          setInvalidParamValidationError(form, invalidParam, pathPrefix);
-
-          const errorMessage = form.getError(invalidParam.reason, unknownName);
-          expect(errorMessage).toBeFalsy();
-        });
-
-        it('should not mark as touched', () => {
-          setInvalidParamValidationError(form, invalidParam, pathPrefix);
-
-          expect(form.touched).toBeFalsy();
-        });
-      },
-    );
   });
 
   describe('getFieldPath', () => {
-    const resourcePath: string = 'resource';
+    const resource: string = 'resource';
     const backendClassName: string = 'class';
 
-    it('should return simple field path', () => {
+    it('should return field path ', () => {
       const fieldPath: string = 'field1';
-      const fullPath: string = `${backendClassName}.${resourcePath}.${fieldPath}`;
+      const fullPath: string = `${backendClassName}.${resource}.${fieldPath}`;
 
-      const result: string = getFieldPath(fullPath);
+      const result: string = getFieldPath(fullPath, resource);
 
       expect(result).toBe(fieldPath);
     });
 
-    it('should return hierarchical field path ', () => {
-      const fieldPath: string = 'fieldGroup.field1';
-      const fullPath: string = `${backendClassName}.${resourcePath}.${fieldPath}`;
+    it('should get all parts after the prefix', () => {
+      const fieldPath: string = 'group.field1';
+      const fullPath: string = `${backendClassName}.${resource}.${fieldPath}`;
 
-      const result: string = getFieldPath(fullPath, resourcePath);
+      const result: string = getFieldPath(fullPath, resource);
 
       expect(result).toBe(fieldPath);
     });
   });
-
-  describe('getLastPart', () => {
-    it('should get last term in string of terms', () => {
-      const lastPart: string = 'field';
-      const allParts: string = 'class.resource.' + lastPart;
-
-      const result: string = getLastPart(allParts);
-
-      expect(result).toBe(lastPart);
-    });
 });
 
-  describe('getPartsAfterPrefix', () => {
-    it('should get all parts after the prefix', () => {
-      const lastParts: string = 'group.field';
-      const prefix: string = 'resource';
-      const allParts: string = 'class.' + prefix + '.' + lastParts;
-
-      const result: string = getPartsAfterPrefix(allParts, prefix);
-
-      expect(result).toBe(lastParts);
-    });
-  });
-});
+function existingPrefixAndFieldCombination(prefix: string, field: string): boolean {
+  return !(prefix === '' && field === 'subGroup.subGroupField1');
+}

alfa-client/libs/tech-shared/src/lib/validation/tech.validation.util.ts

@@ -22,7 +22,7 @@
  * unter der Lizenz sind dem Lizenztext zu entnehmen.
  */
 import { AbstractControl, UntypedFormGroup } from '@angular/forms';
-import { isEmpty, isNil } from 'lodash-es';
+import { isNil } from 'lodash-es';
 import { ApiError, InvalidParam, Issue, IssueParam } from '../tech.model';
 import { replacePlaceholder } from '../tech.util';
 import { VALIDATION_MESSAGES, ValidationMessageCode } from './tech.validation.messages';
@@ -114,15 +114,7 @@ export function getMessageForInvalidParam(label: string, invalidParam: InvalidPa
   return msg;
 }
 
-export function getFieldPath(name: string, pathPrefix?: string): string {
-  return isEmpty(pathPrefix) ? getLastPart(name) : getPartsAfterPrefix(name, pathPrefix);
-}
-
-export function getLastPart(name: string): string {
-  return name.split('.').pop();
-}
-
-export function getPartsAfterPrefix(name: string, pathPrefix: string): string {
+export function getFieldPath(name: string, pathPrefix: string): string {
   pathPrefix = `${pathPrefix}.`;
   const indexField = name.lastIndexOf(pathPrefix) + pathPrefix.length;
   return name.slice(indexField);