@sankhyalabs/core 0.0.0-bugfix-dev-KB-6165.0

package/test/util/CriteriaModel.spec.ts

@@ -0,0 +1,232 @@
+import { Criteria } from '../../src/utils/CriteriaModel';
+import { CriteriaParameter, CriteriaType } from '../../src/utils/CriteriaParameter';
+
+describe('StringUtils', function () {
+
+
+  // => CRITERIA
+  // ----------------------------------------------------------------------------------------
+
+  it('it should return the undefined and [] to Criteria Props through new class with empty constructor', async () => {
+    const ct: Criteria = new Criteria();
+
+    const parameters: Array<CriteriaParameter> = ct.parameters;
+    const expression: string | undefined = ct.expression;
+
+    expect(parameters).toEqual([]);
+    expect(expression).toEqual(undefined);
+
+  });
+
+  it('it should modify "expressions" and "parameters" properties through Setters methods', async () => {
+    const ct: Criteria = new Criteria();
+
+    const parameters: Array<CriteriaParameter> = [new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE')];
+    const expression: string = 'Expression';
+
+    ct.parameters = parameters;
+    ct.expression = expression;
+
+    expect(ct.parameters).toEqual(parameters);
+    expect(ct.expression).toEqual(expression);
+
+  });
+
+
+  it('it should return "expression" and "parameters" setted through constructor method', async () => {
+
+    const parameters: Array<CriteriaParameter> = [new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE')];
+    const expression: string = 'Expression';
+
+    const ct: Criteria = new Criteria(expression, parameters);
+
+    expect(ct.parameters).toEqual(parameters);
+    expect(ct.expression).toEqual(expression);
+
+  });
+
+  it('it should return a Criteria class with "expression" and "parameters" as needed setted through "append" method', async () => {
+
+    const parameters: Array<CriteriaParameter> = [new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE')];
+    const expression: string = 'Expression';
+
+    const ct: Criteria = new Criteria();
+
+    ct.append(expression, parameters);
+
+    expect(ct.parameters).toEqual(parameters);
+    expect(ct.expression).toEqual(expression);
+    expect(ct).toBeInstanceOf(Criteria);
+
+  });
+
+
+  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "append" method', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria();
+
+    ct1.append(expression, parameters);
+
+    const ct2: Criteria = ct1.append(ct1, parameters);
+
+    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
+    expect(ct2.expression).toEqual(`${expression}(${expression})`);
+    expect(ct2).toBeInstanceOf(Criteria);
+
+  });
+
+  it('it should return undefined as "expression" and "[]" as parameters as we use an empty criteria as first entry in the constructor', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria();
+
+    const ct2: Criteria = ct1.append(ct1, parameters);
+
+    expect(ct2.parameters).toEqual([]);
+    expect(ct2.expression).toEqual(undefined);
+    expect(ct2).toBeInstanceOf(Criteria);
+
+  });
+
+  it('it should return a Criteria class with "Expression" and "parameters" concatenaded as needed setted through "OR" method', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria(expression, parameters);
+
+    const ct2: Criteria = ct1.or(expression, parameters);
+
+    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
+    expect(ct2.expression).toEqual(`${expression} OR ${expression}`);
+    expect(ct2).toBeInstanceOf(Criteria);
+
+  });
+
+
+  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "OR" method', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria(expression, parameters);
+
+    const ct2: Criteria = ct1.or(ct1, parameters);
+
+    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
+    expect(ct2.expression).toEqual(`${expression} OR (${expression} OR )`);
+    expect(ct2).toBeInstanceOf(Criteria);
+
+  });
+
+  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "OR" method', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria(expression, parameters);
+    const ct2: Criteria = new Criteria(expression, parameters);
+
+    const ct3: Criteria = ct1.or(ct2, parameters);
+
+    expect(ct3.parameters).toEqual([criteriaParam, criteriaParam]);
+    expect(ct3.expression).toEqual(`${expression} OR (${expression})`);
+    expect(ct3).toBeInstanceOf(Criteria);
+
+  });
+
+  it('it should return a Criteria class with "Expression" and "parameters" concatenaded as needed setted through "AND" method', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria(expression, parameters);
+
+    const ct2: Criteria = ct1.and(expression, parameters);
+
+    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
+    expect(ct2.expression).toEqual(`${expression} AND ${expression}`);
+    expect(ct2).toBeInstanceOf(Criteria);
+
+  });
+
+
+  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "AND" method', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria(expression, parameters);
+
+    const ct2: Criteria = ct1.and(ct1, parameters);
+
+    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
+    expect(ct2.expression).toEqual(`${expression} AND (${expression} AND )`);
+    expect(ct2).toBeInstanceOf(Criteria);
+
+  });
+
+  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "AND" method', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria(expression, parameters);
+    const ct2: Criteria = new Criteria(expression, parameters);
+
+    const ct3: Criteria = ct1.and(ct2, parameters);
+
+    expect(ct3.parameters).toEqual([criteriaParam, criteriaParam]);
+    expect(ct3.expression).toEqual(`${expression} AND (${expression})`);
+    expect(ct3).toBeInstanceOf(Criteria);
+
+  });
+
+  it('it should return a toJSON object with "Criteria class" and "parameters" concatenaded as needed setted through "AND" method', async () => {
+
+    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
+    const parameters: Array<CriteriaParameter> = [criteriaParam];
+    const expression: string = 'Expression';
+
+    const ct1: Criteria = new Criteria(expression, parameters);
+    const ct2: Criteria = new Criteria(expression, parameters);
+
+    const ct3: Criteria = ct1.and(ct2, parameters);
+
+    expect(ct3.parameters).toEqual([criteriaParam, criteriaParam]);
+    expect(ct3.expression).toEqual(`${expression} AND (${expression})`);
+    expect(ct3.toJSON()).toEqual(
+      {
+        expression: "Expression AND (Expression)",
+        parameters: [
+          { type: "D", value: "PARAM VALUE" },
+          { type: "D", value: "PARAM VALUE" }
+        ]
+      }
+    );
+
+  });
+
+  it('it should return a toJSON object with through empty constructor', async () => {
+
+    const ct1: Criteria = new Criteria();
+
+    expect(ct1.toJSON()).toEqual(undefined);
+
+  });
+
+
+});

package/test/util/CriteriaParameter.spec.ts

@@ -0,0 +1,52 @@
+import { CriteriaParameter, CriteriaType } from '../../src/utils/CriteriaParameter';
+
+describe('StringUtils', function () {
+
+
+  // => CRITERIA PARAMETER
+  // ----------------------------------------------------------------------------------------
+
+  it('it should return the correct values of "value" and "type" through the getters methods initial setted by the constructor', async () => {
+
+    let paramsCriteria: string = 'A';
+    const ct: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, paramsCriteria);
+
+    const value = ct.value;
+    const type = ct.type;
+
+    expect(value).toEqual(paramsCriteria);
+    expect(type).toEqual(CriteriaType.TYPE_DATE);
+
+  });
+
+  it('it should return the correct values of "value" and "type" through the getters methods initial setted by the setters methods', async () => {
+
+    let paramsCriteria: string = 'A';
+    let paramsCriteriaNew: string = 'B';
+    const ct: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, paramsCriteria);
+
+    ct.value = paramsCriteriaNew;
+    ct.type = CriteriaType.TYPE_NUMBER;
+
+    const value = ct.value;
+    const type = ct.type;
+
+    expect(value).toEqual(paramsCriteriaNew);
+    expect(type).toEqual(CriteriaType.TYPE_NUMBER);
+
+  });
+
+
+  it('it should return the correct JSON/Object value through the buildParam method', async () => {
+
+    let paramsCriteria: string = 'A';
+    const ct: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, paramsCriteria);
+
+    const criteriaParamResult = ct.buildParam();
+
+    expect(criteriaParamResult).toEqual({ "type": "D", "value": "A" });
+
+  });
+
+
+});

package/test/util/DataUnitStorage.spec.ts

@@ -0,0 +1,63 @@
+import DataUnit from "../../src/dataunit/DataUnit.js";
+import { DataUnitStorage } from "../../src/dataunit/DataUnitStorage.js";
+
+describe("DataUnitStorage", () => {
+  let dataUnit1: DataUnit;
+  let dataUnit2: DataUnit;
+
+  beforeEach(() => {
+    dataUnit1 = new DataUnit("dataUnit1");
+    dataUnit2 = new DataUnit("dataUnit2");
+  });
+
+  afterEach(() => {
+    DataUnitStorage.remove(dataUnit1);
+    DataUnitStorage.remove(dataUnit2);
+  });
+
+  describe("put", () => {
+    test("should store a DataUnit instance in the DataUnitStorage", () => {
+      DataUnitStorage.put(dataUnit1);
+      expect(DataUnitStorage.get(dataUnit1.name)).toBe(dataUnit1);
+    });
+  });
+
+  describe("get", () => {
+    test("should return the stored DataUnit instance from the DataUnitStorage", () => {
+      DataUnitStorage.put(dataUnit1);
+      const retrievedDataUnit = DataUnitStorage.get(dataUnit1.name);
+      expect(retrievedDataUnit).toBe(dataUnit1);
+    });
+
+    test("should return undefined if the DataUnit instance is not found in the DataUnitStorage", () => {
+      const retrievedDataUnit = DataUnitStorage.get("nonExistentDataUnit");
+      expect(retrievedDataUnit).toBeUndefined();
+    });
+  });
+
+  describe("remove", () => {
+    test("should remove the specified DataUnit instance from the DataUnitStorage", () => {
+      DataUnitStorage.put(dataUnit1);
+      DataUnitStorage.remove(dataUnit1);
+      const retrievedDataUnit = DataUnitStorage.get(dataUnit1.name);
+      expect(retrievedDataUnit).toBeUndefined();
+    });
+
+    test("should remove the DataUnit instance with the specified name from the DataUnitStorage", () => {
+      DataUnitStorage.put(dataUnit1);
+      DataUnitStorage.remove(dataUnit1.name);
+      const retrievedDataUnit = DataUnitStorage.get(dataUnit1.name);
+      expect(retrievedDataUnit).toBeUndefined();
+    });
+
+    test("should not remove any DataUnit instance if the specified DataUnit instance or name is not found in the DataUnitStorage", () => {
+      DataUnitStorage.put(dataUnit1);
+      DataUnitStorage.remove(dataUnit2);
+      DataUnitStorage.remove("nonExistentDataUnit");
+      const retrievedDataUnit1 = DataUnitStorage.get(dataUnit1.name);
+      const retrievedDataUnit2 = DataUnitStorage.get(dataUnit2.name);
+      expect(retrievedDataUnit1).toBe(dataUnit1);
+      expect(retrievedDataUnit2).toBeUndefined();
+    });
+  });
+});

package/test/util/ElementIDUtils.spec.ts

@@ -0,0 +1,272 @@
+import { ElementIDUtils, IElementIDInfo } from '../../src/utils/ElementIDUtils';
+import { describe, expect, beforeEach, test } from '@jest/globals';
+import DataUnit from '../../src/dataunit/DataUnit'
+import { DataType } from '../../src/dataunit/metadata/DataType';
+import { UserInterface } from '../../src/dataunit/metadata/UnitMetadata';
+import { StringUtils } from '../../src/utils/StringUtils';
+
+type IDInfo = {
+  id?: string,
+  dataUnit?: DataUnit
+};
+
+type AssertElementIdNameProps = {
+  result: string,
+  iDInfo?: IDInfo,
+  suffix?: string,
+  dataElementIdAttributeName?: string
+}
+
+describe('addIDInfo', () => {
+
+  let element: HTMLElement;
+  const dataUnit = new DataUnit("dataunit-financeiro");
+
+  beforeEach(() => {
+    element = document.createElement('snk-application');
+
+    dataUnit.metadata = {
+      name: "dd://br.com.sankhya.fin.cad.movimentacaoFinanceira/Financeiro",
+      label: "Parceiro",
+      fields: [
+        {
+          name: "CODPARC",
+          label: "Parceiro",
+          dataType: DataType.NUMBER,
+          userInterface: UserInterface.SEARCH,
+          required: true,
+          properties: { ENTITYNAME: "Parceiro" }
+        }
+      ]
+    };
+  });
+  
+  const assertElementIdName = ({ result, iDInfo, suffix, dataElementIdAttributeName = "" }: AssertElementIdNameProps) => {
+    const formattedResult = StringUtils.replaceAccentuatedChars(result || "", true).toLowerCase();
+    const formattedDataElementIdAttributeName = StringUtils.replaceAccentuatedChars(dataElementIdAttributeName || "", true).toLowerCase();
+    const formattedSuffix  = StringUtils.replaceAccentuatedChars(suffix || "", true).toLowerCase();
+    const formattedDataUnitId = StringUtils.replaceAccentuatedChars(iDInfo?.dataUnit?.dataUnitId || "", true).toLowerCase();
+    
+    if (formattedDataUnitId) expect(formattedResult).toContain(formattedDataUnitId);
+    if (formattedSuffix) expect(formattedResult).toContain(formattedSuffix);
+    expect(
+      StringUtils.replaceAccentuatedChars(element.getAttribute(ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME) || '', true).toLowerCase()
+    ).toBe(formattedDataElementIdAttributeName); 
+  }
+
+  test('1 - should add data-element-id with valid id "movFinanceira_snkApplication"', () => {
+    element.setAttribute(ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME, "movFinanceira");
+
+    const result = ElementIDUtils.addIDInfo(element);
+    const dataElementIdAttributeName = "movFinanceira_snkApplication";
+    
+    assertElementIdName({ dataElementIdAttributeName, result });
+  });
+  
+  test('2 - should add data-element-id with valid id "brComSankhyaFinCadMovimentacaofinanceira_snkApplication"', () => {
+    const iDInfo = { id: "br.com.sankhya.fin.cad.movimentacaoFinanceira" };
+
+    const result = ElementIDUtils.addIDInfo(element, undefined, iDInfo);
+    const dataElementIdAttributeName = "brComSankhyaFinCadMovimentacaofinanceira_snkApplication";
+    
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result });
+  });
+
+  test('3 - should add data-element-id with valid id "movFinanceira_br.com.sankhya.fin.cad.movimentacaoFinanceira"', () => {
+    element.setAttribute("data-field-name", "movFinanceira");
+    const suffix = "br.com.sankhya.fin.cad.movimentacaoFinanceira";
+    const result = ElementIDUtils.addIDInfo(element, suffix);
+    const dataElementIdAttributeName = "movFinanceira_brComSankhyaFinCadMovimentacaofinanceira";
+    
+    assertElementIdName({ dataElementIdAttributeName, result, suffix });
+  });
+
+  test('4 - should add data-element-id with valid id "meuID2_snkApplication"', () => {
+    element.setAttribute("id", "movFinanceira");
+    
+    const iDInfo = {id: "meuID2"};
+    const result = ElementIDUtils.addIDInfo(element, undefined, iDInfo);
+    const dataElementIdAttributeName = "meuID2_snkApplication";    
+
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result });
+  });
+
+  test('5 - should add data-element-id with valid id "movFinanceira_snkApplication"', () => {
+    element.setAttribute("id", "movFinanceira");
+    element.setAttribute("name", "componenteNameTest");
+
+    const result = ElementIDUtils.addIDInfo(element);
+    const dataElementIdAttributeName = "movFinanceira_snkApplication";
+    
+    assertElementIdName({ dataElementIdAttributeName, result });
+  });
+
+  test('6 - should add data-element-id with valid id "movFinanceira_snkApplication"', () => {
+    element.setAttribute("id", "movFinanceira");
+    element.setAttribute("label", "componenteLabelTest");
+
+    const result = ElementIDUtils.addIDInfo(element);
+    const dataElementIdAttributeName = "movFinanceira_snkApplication";
+    
+    assertElementIdName({ dataElementIdAttributeName, result });
+  });
+
+  test('7 - should add data-element-id with valid id "componenteNameTest_snkApplication"', () => {
+    element.setAttribute("name", "componenteNameTest");
+
+    const result = ElementIDUtils.addIDInfo(element);
+    const dataElementIdAttributeName = "componenteNameTest_snkApplication";
+    
+    assertElementIdName({ dataElementIdAttributeName, result });
+  });
+
+  
+  test('8 - should add data-element-id with valid id "componentLabel_snkApplication"', () => {
+    element.setAttribute("label", "componentLabel");
+
+    const result = ElementIDUtils.addIDInfo(element);
+    const dataElementIdAttributeName = "componentLabel_snkApplication";
+    
+    assertElementIdName({ dataElementIdAttributeName, result });
+  });
+
+  test('9 - should add data-element-id with valid id "dataunitFinanceiro_br.com.sankhya.fin.cad.movimentacaoFinanceira"', () => {
+    const iDInfo = {dataUnit: dataUnit};
+    const suffix = "br.com.sankhya.fin.cad.movimentacaoFinanceira";
+    const dataElementIdAttributeName = `dataunitFinanceiro?uuid=${iDInfo.dataUnit.dataUnitId}_br.com.sankhya.fin.cad.movimentacaoFinanceira`;
+    const result = ElementIDUtils.addIDInfo(element, suffix, iDInfo);
+    
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result, suffix });
+  });
+
+  test('10 - should add data-element-id with valid id "dataunitFinanceiro_meuIDTeste_br.com.sankhya.fin.cad.movimentacaoFinanceira"', () => {
+    const iDInfo = {id: "meuIDTeste", dataUnit: dataUnit};
+    const suffix = "br.com.sankhya.fin.cad.movimentacaoFinanceira";
+    const result = ElementIDUtils.addIDInfo(element, suffix, iDInfo);
+    const dataElementIdAttributeName = `dataunitFinanceiro?uuid=${iDInfo.dataUnit.dataUnitId}_meuIDTeste_br.com.sankhya.fin.cad.movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result, suffix });
+  });
+
+  test('11 - should add data-element-id with valid id "dataunitFinanceiro_meuIDTeste_movimentacaoFinanceira"', () => {
+    const iDInfo = {id: "meuIDTeste", dataUnit: dataUnit};
+    const suffix = "movimentacaoFinanceira";
+    const dataElementIdAttributeName = `dataunitFinanceiro?uuid=${iDInfo.dataUnit.dataUnitId}_meuIDTeste_movimentacaoFinanceira`;
+    const result = ElementIDUtils.addIDInfo(element, suffix, iDInfo);
+    
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result, suffix });
+  });
+
+  test('12 - should add data-element-id with valid id "dataunitFinanceiro_movFinanceira_movimentacaoFinanceira"', () => {
+    element.setAttribute(ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME, "movFinanceira");
+    
+    const iDInfo = {id: "meuIDTeste", dataUnit: dataUnit};
+    const suffix = "movimentacaoFinanceira";
+    const result = ElementIDUtils.addIDInfo(element, suffix, iDInfo);
+    const dataElementIdAttributeName = `dataunitFinanceiro?uuid=${iDInfo.dataUnit.dataUnitId}_movFinanceira_movimentacaoFinanceira`;
+
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result, suffix });
+  });
+
+  test('13 - should add data-element-id with valid id "dataunitFinanceiro_meuIDTeste_movimentacaoFinanceira"', () => {
+    element.setAttribute("id", "movFinanceira");
+    
+    const iDInfo = {id: "meuIDTeste", dataUnit: dataUnit};
+    const suffix = "movimentacaoFinanceira";
+    const result = ElementIDUtils.addIDInfo(element, suffix, iDInfo);
+    const dataElementIdAttributeName = `dataunitFinanceiro?uuid=${iDInfo.dataUnit.dataUnitId}_meuIDTeste_movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result, suffix });
+  });
+
+  test('14 - should add data-element-id with valid id "dataunitFinanceiro_meuIdTeste_movimentacaoFinanceira"', () => {
+    element.setAttribute("id", "mov-financeira-snk");
+    
+    const iDInfo = {id: "meu-id-teste", dataUnit: dataUnit};
+    const suffix = "movimentacao Financeira";
+    const result = ElementIDUtils.addIDInfo(element, suffix, iDInfo);
+    const dataElementIdAttributeName = `dataunitFinanceiro?uuid=${iDInfo.dataUnit.dataUnitId}_meuIdTeste_movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result, suffix });
+  });
+
+  test('15 - should add data-element-id with valid id "dataunitFinanceiro_meuIdTeste_snkApplication"', () => {
+    element.setAttribute("id", "mov-financeira-snk");
+    
+    const iDInfo = {id: "meu-id-teste", dataUnit: dataUnit};
+    const result = ElementIDUtils.addIDInfo(element, undefined, iDInfo);
+    const dataElementIdAttributeName = `dataunitFinanceiro?uuid=${iDInfo.dataUnit.dataUnitId}_meuIdTeste_snkApplication`;
+    
+    assertElementIdName({ dataElementIdAttributeName, iDInfo, result });
+  });
+
+  test('16 - should add data-element-id with valid id "dataunitFinanceiro_meuIdTeste_snkApplication"', () => {
+    const iDInfo = {id: "meu-id-teste", dataUnit: dataUnit};
+    const result = ElementIDUtils.addIDInfo(element, undefined, iDInfo);
+    const dataElementIdAttributeName = `dataunitFinanceiro?uuid=${iDInfo.dataUnit.dataUnitId}_meuIdTeste_snkApplication`;    
+    
+    assertElementIdName({ iDInfo, result, dataElementIdAttributeName });
+  });
+
+  test('17 - should add data-element-id with valid id "movFinanceira_movimentacaoFinanceira"', () => {
+    const suffix = "movimentacao-financeira";
+    element.setAttribute("id", "mov-financeira");
+
+    const result = ElementIDUtils.addIDInfo(element, suffix);
+    const dataElementIdAttributeName = `movFinanceira_movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, result, suffix });
+  });
+
+  test('18 - should add data-element-id with valid id "movFinanceira_movimentacaoFinanceira"', () => {
+    const suffix = "movimentacao-financeira";
+    element.setAttribute(ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME, "mov-financeira");
+
+    const result = ElementIDUtils.addIDInfo(element, suffix);
+    const dataElementIdAttributeName = `movFinanceira_movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, result, suffix });
+  });
+
+  
+  test('19 - should add data-element-id with valid id "movFinanceira_movimentacaoFinanceira"', () => {
+    const suffix = "movimentacao-financeira";
+    element.setAttribute("data-field-name", "mov-financeira");
+
+    const result = ElementIDUtils.addIDInfo(element, suffix);
+    const dataElementIdAttributeName = `movFinanceira_movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, result, suffix });
+  });
+  
+  test('20 - should add data-element-id with valid id "movFinanceira_movimentacaoFinanceira"', () => {
+    const suffix = "movimentacao-financeira";
+    element.setAttribute("name", "mov-financeira");
+
+    const result = ElementIDUtils.addIDInfo(element, suffix);
+    const dataElementIdAttributeName = `movFinanceira_movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, result, suffix });
+  });
+
+  test('21 - should add data-element-id with valid id "movFinanceira_movimentacaoFinanceira"', () => {
+    const suffix = "movimentacao-financeira";
+    element.setAttribute("label", "mov-financeira");
+
+    const result = ElementIDUtils.addIDInfo(element, suffix);
+    const dataElementIdAttributeName = `movFinanceira_movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, result, suffix });
+  });
+
+  test('22 - should add data-element-id with valid id "bancoObrigatorio_movimentacaoFinanceira"', () => {
+    const suffix = "movimentacao-financeira";
+    element.setAttribute("name", "Banco (obrigatório) *");
+
+    const result = ElementIDUtils.addIDInfo(element, suffix);
+    const dataElementIdAttributeName = `bancoObrigatorio_movimentacaoFinanceira`;
+    
+    assertElementIdName({ dataElementIdAttributeName, result, suffix });
+  });
+
+});