Merge branch 'development' into chore/test-apply-to-all-use-case

.github/workflows/main.yml

@@ -0,0 +1,38 @@
+name: Application testing
+on:
+    push:
+    workflow_dispatch:
+jobs:
+    unit-tests:
+        name: Unit tests
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v2
+
+            - name: Setup Node
+              uses: actions/setup-node@v1
+              with:
+                  node-version: "16.14.0"
+
+            - name: Install yarn
+              run: npm install -g yarn
+
+            - name: Get yarn cache directory path
+              id: yarn-cache-dir-path
+              run: echo "::set-output name=dir::$(yarn cache dir)"
+
+            - name: Cache yarn dependencies
+              uses: actions/cache@v2
+              id: yarn-cache
+              with:
+                  path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+                  key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+                  restore-keys: |
+                      ${{ runner.os }}-yarn-
+
+            - name: Install dependencies
+              run: yarn install --frozen-lockfile --silent
+
+            - name: Run jest tests
+              run: yarn test

src/data/common/Dhis2DataElement.ts

@@ -8,8 +8,8 @@ import { Dhis2DataStoreDataForm } from "./Dhis2DataStoreDataForm";
 export class Dhis2DataElement {
     constructor(private api: D2Api) {}
 
-    async get(ids: Id[]): Promise<Record<Id, DataElement>> {
-        const config = await Dhis2DataStoreDataForm.build(this.api);
+    async get(ids: Id[], dataSetCode: string): Promise<Record<Id, DataElement>> {
+        const config = await Dhis2DataStoreDataForm.build(this.api, dataSetCode);
         const idGroups = _(ids).uniq().chunk(100).value();
 
         const resList = await promiseMap(idGroups, idsGroup =>

src/data/common/Dhis2DataFormRepository.ts

@@ -81,7 +81,7 @@ export class Dhis2DataFormRepository implements DataFormRepository {
             .map(dataElement => ({ id: dataElement.id, code: dataElement.code }))
             .value();
 
-        const dataElements = await new Dhis2DataElement(this.api).get(dataElementIds);
+        const dataElements = await new Dhis2DataElement(this.api).get(dataElementIds, dataSet.code);
 
         const dataElementsRulesConfig = this.buildRulesFromConfig(dataElements, configDataForm, allDataElements);
         return dataSet.sections.map((section): Section => {

src/data/common/Dhis2DataStoreDataForm.ts

@@ -314,10 +314,16 @@ export class Dhis2DataStoreDataForm {
     }
 
     static async build(api: D2Api, dataSetCode?: string): Promise<Dhis2DataStoreDataForm> {
-        if (cachedStore) return cachedStore;
-
         const dataStore = api.dataStore(Namespaces.D2_AUTOGEN_FORMS);
-        if (!dataSetCode) throw Error(`Unable to load configuration: dataSetCode not defined`);
+        if (!dataSetCode) {
+            console.warn(`Unable to load configuration: dataSetCode not defined`);
+            return new Dhis2DataStoreDataForm({
+                optionSets: [],
+                constants: [],
+                custom: defaultDataStoreConfig,
+                subNationals: [],
+            });
+        }
         const storeValue = await dataStore.get<object>(dataSetCode).getData();
         if (!storeValue)
             return new Dhis2DataStoreDataForm({
@@ -350,8 +356,7 @@ export class Dhis2DataStoreDataForm {
             },
         });
 
-        cachedStore = new Dhis2DataStoreDataForm(config);
-        return cachedStore;
+        return new Dhis2DataStoreDataForm(config);
     }
 
     private static async getOptionSets(api: D2Api, storeConfig: DataFormStoreConfig["custom"]): Promise<OptionSet[]> {
@@ -651,8 +656,6 @@ interface Constant {
     displayDescription: string;
 }
 
-let cachedStore: Dhis2DataStoreDataForm | undefined;
-
 function sectionConfig<T extends Record<string, Codec<any>>>(properties: T) {
     return optional(record(string, Codec.interface(properties)));
 }

src/data/common/Dhis2DataValueRepository.ts

@@ -27,7 +27,17 @@ export class Dhis2DataValueRepository implements DataValueRepository {
             })
             .getData();
 
-        const dataElements = await this.getDataElements(dataValues);
+        const dataSetResponse = await this.api.models.dataSets
+            .get({
+                fields: { id: true, code: true },
+                filter: { id: { eq: options.dataSetId } },
+            })
+            .getData();
+
+        const dataSetCode = dataSetResponse.objects[0]?.code;
+        if (!dataSetCode) throw new Error(`Data set not found: ${options.dataSetId}`);
+
+        const dataElements = await this.getDataElements(dataValues, dataSetCode);
 
         const dataValuesFiles = await this.getFileResourcesMapping(dataElements, dataValues);
 
@@ -161,9 +171,9 @@ export class Dhis2DataValueRepository implements DataValueRepository {
         );
     }
 
-    private async getDataElements(dataValues: DataValueSetsDataValue[]) {
+    private async getDataElements(dataValues: DataValueSetsDataValue[], dataSetCode: string) {
         const dataElementIds = dataValues.map(dv => dv.dataElement);
-        return new Dhis2DataElement(this.api).get(dataElementIds);
+        return new Dhis2DataElement(this.api).get(dataElementIds, dataSetCode);
     }
 
     async save(dataValue: DataValue): Promise<DataValue> {

src/domain/common/entities/DataValue.ts

@@ -11,7 +11,7 @@ import {
     DataElementText,
 } from "./DataElement";
 
-interface DataValueBase {
+export interface DataValueBase {
     orgUnitId: Id;
     period: Period;
     categoryOptionComboId: Id;

src/domain/common/entities/ValidationRule.ts

@@ -1,7 +1,7 @@
 import { Maybe } from "../../../utils/ts-utils";
 import { Id } from "./Base";
 
-const allowedRules = [
+export const allowedRules = [
     {
         name: "equal_to",
         operator: "=",

src/domain/common/entities/__tests__/Config.spec.ts

@@ -0,0 +1,19 @@
+import { getPath } from "../OrgUnit";
+import { getMainUserPaths } from "../Config";
+import { config } from "./configFixtures";
+import { orgUnits } from "./orgUnitFixtures";
+
+describe("Config", () => {
+    describe("getMainUserPaths", () => {
+        it("should return the compacted result of getPath", () => {
+            const result = getMainUserPaths(config);
+            expect(result).toEqual([getPath(orgUnits)]);
+        });
+
+        it("should handle empty paths correctly", () => {
+            const userWithoutOrgUnits = { ...config.currentUser, orgUnits: [] };
+            const result = getMainUserPaths({ ...config, currentUser: userWithoutOrgUnits });
+            expect(result).toEqual([]);
+        });
+    });
+});

src/domain/common/entities/__tests__/DataElement.spec.ts

@@ -0,0 +1,37 @@
+import { getDataElementWithCode, DataElement, DataElementBoolean, DataElementText } from "../DataElement";
+import { dataElementText as dataElementBase } from "./dataFixtures";
+
+describe("DataElement", () => {
+    const dataElementBoolean: DataElementBoolean = {
+        ...dataElementBase,
+        id: "1",
+        code: "DE_BOOLEAN",
+        name: "Boolean Data Element",
+        type: "BOOLEAN",
+        isTrueOnly: false,
+    };
+
+    const dataElementText: DataElementText = {
+        ...dataElementBase,
+        id: "2",
+        code: "DE_TEXT",
+        name: "Text Data Element",
+        type: "TEXT",
+    };
+
+    const dataElements: DataElement[] = [dataElementBoolean, dataElementText];
+
+    describe("getDataElementWithCode", () => {
+        it("should return the correct DataElement when a matching code is found", () => {
+            const codeToFind = "DE_BOOLEAN";
+            const result = getDataElementWithCode(dataElements, codeToFind);
+            expect(result).toEqual(dataElementBoolean);
+        });
+
+        it("should return undefined when no matching code is found", () => {
+            const codeToFind = "NON_EXISTENT_CODE";
+            const result = getDataElementWithCode(dataElements, codeToFind);
+            expect(result).toBeUndefined();
+        });
+    });
+});

src/domain/common/entities/__tests__/DataForm.spec.ts

@@ -0,0 +1,88 @@
+import { Id } from "../Base";
+import { DataFormM, DataForm, SectionWithPeriods, SectionSimple } from "../DataForm";
+import { Period } from "../DataValue";
+import { sectionBase, dataFormBase } from "./dataFixtures";
+
+describe("DataFormM", () => {
+    describe("getReferencedPeriods", () => {
+        it("should return basePeriod when there are no additional periods", () => {
+            const dataForm: DataForm = {
+                ...dataFormBase,
+                sections: [],
+            };
+
+            const basePeriod: Period = "202101";
+            const result = DataFormM.getReferencedPeriods(dataForm, basePeriod);
+
+            expect(result).toEqual([basePeriod]);
+        });
+
+        it("should return unique periods from sections and basePeriod", () => {
+            const sections: SectionWithPeriods[] = [
+                createSectionWithPeriods("1", ["202102", "202103"]),
+                createSectionWithPeriods("2", ["202104", "202105"]),
+            ];
+
+            const dataForm: DataForm = {
+                ...dataFormBase,
+                sections,
+            };
+
+            const basePeriod: Period = "202101";
+            const result = DataFormM.getReferencedPeriods(dataForm, basePeriod);
+
+            expect(result).toEqual(["202101", "202102", "202103", "202104", "202105"]);
+        });
+
+        it("should handle mixed section types", () => {
+            const sections = [createSectionWithPeriods("1", ["202102", "202103"]), createSectionSimple("2")];
+
+            const dataForm: DataForm = {
+                ...dataFormBase,
+                sections,
+            };
+
+            const basePeriod: Period = "202101";
+            const result = DataFormM.getReferencedPeriods(dataForm, basePeriod);
+
+            expect(result).toEqual(["202101", "202102", "202103"]);
+        });
+
+        it("should return sorted unique periods", () => {
+            const sections = [
+                createSectionWithPeriods("1", ["202103", "202102"]),
+                createSectionWithPeriods("2", ["202105", "202104"]),
+                createSectionWithPeriods("3", ["202101", "202106"]),
+            ];
+
+            const dataForm: DataForm = {
+                ...dataFormBase,
+                sections,
+            };
+
+            const basePeriod: Period = "202100";
+            const result = DataFormM.getReferencedPeriods(dataForm, basePeriod);
+
+            expect(result).toEqual(["202100", "202101", "202102", "202103", "202104", "202105", "202106"]);
+        });
+    });
+});
+
+function createSectionSimple(id: Id): SectionSimple {
+    return {
+        id,
+        name: `Section ${id}`,
+        viewType: "grid-with-combos",
+        ...sectionBase,
+    };
+}
+
+function createSectionWithPeriods(id: Id, periods: Period[]): SectionWithPeriods {
+    return {
+        id,
+        name: `Section ${id}`,
+        viewType: "grid-with-periods",
+        periods,
+        ...sectionBase,
+    };
+}

src/domain/common/entities/__tests__/DataValue.spec.ts

@@ -0,0 +1,48 @@
+import { DataValueStore } from "../DataValue";
+import { dataElementText, dataValues, dataValueTextSingle, dataValueBase } from "./dataFixtures";
+
+describe("DataValueStore", () => {
+    describe("DataValueStore.from", () => {
+        it("should create a DataValueStore from an array of DataValues", () => {
+            const store = DataValueStore.from(dataValues);
+            expect(store).toBeInstanceOf(DataValueStore);
+            expect(store.store).toEqual({
+                "1.202101.coc1.org1": dataValueTextSingle,
+            });
+        });
+    });
+
+    describe("DataValueStore.set", () => {
+        it("should set a DataValue in the store", () => {
+            const store = new DataValueStore({});
+            const updatedStore = store.set(dataValueTextSingle);
+            expect(updatedStore.store).toEqual({
+                "1.202101.coc1.org1": dataValueTextSingle,
+            });
+        });
+    });
+
+    describe("DataValueStore.get", () => {
+        it("should get a DataValue from the store", () => {
+            const store = DataValueStore.from(dataValues);
+            const dataValue = store.get(dataElementText, dataValueBase);
+            expect(dataValue).toEqual(dataValueTextSingle);
+        });
+    });
+
+    describe("DataValueStore.getOrEmpty", () => {
+        it("should get a DataValue from the store", () => {
+            const store = DataValueStore.from(dataValues);
+            const dataValue = store.getOrEmpty(dataElementText, dataValueBase);
+            expect(dataValue).toEqual(dataValueTextSingle);
+        });
+
+        it("should return an empty DataValue if not in the store", () => {
+            const store = new DataValueStore({});
+            const dataValue = store.getOrEmpty(dataElementText, dataValueBase);
+
+            const emptyDataValue = { ...dataValueTextSingle, value: "" };
+            expect(dataValue).toEqual(emptyDataValue);
+        });
+    });
+});

src/domain/common/entities/__tests__/Indicator.spec.ts

@@ -0,0 +1,37 @@
+import { Indicator, checkIndicatorDirection, getIndicatorRelatedToDataElement, IndicatorDirection } from "../Indicator";
+import { indicatorAfter, indicatorBefore, indicators } from "./indicatorFixtures";
+
+describe("Indicator", () => {
+    describe("checkIndicatorDirection", () => {
+        it("should return true when the indicator's direction matches the provided direction", () => {
+            const direction: IndicatorDirection = "after";
+
+            // indicatorAfter indicator contain { direction: "after" }
+            const result = checkIndicatorDirection(indicatorAfter, direction);
+            expect(result).toBe(true);
+        });
+
+        it("should return false when the indicator's direction does not match the provided direction", () => {
+            const direction: IndicatorDirection = "after";
+
+            // indicatorBefore indicator contain { direction: "before" }
+            const result = checkIndicatorDirection(indicatorBefore, direction);
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("getIndicatorRelatedToDataElement", () => {
+        it("should return the indicator related to the specified data element code", () => {
+            const codeToFind = "DE_1";
+            const result = getIndicatorRelatedToDataElement(indicators, codeToFind);
+            // indicatorAfter indicator contain dataElement: { code: "DE_1", direction: "after" }
+            expect(result).toEqual(indicatorAfter);
+        });
+
+        it("should return undefined when no indicator is related to the specified data element code", () => {
+            const codeToFind = "NON_EXISTENT_CODE";
+            const result = getIndicatorRelatedToDataElement(indicators, codeToFind);
+            expect(result).toBeUndefined();
+        });
+    });
+});