Passing tests

PWA/package.json

@@ -17,5 +17,9 @@
     "@types/jest": "^29.5.11",
     "http-server": "^0.10.0",
     "jest": "^29.7.0"
+  },
+  "jest": {
+    "verbose": false,
+    "roots": ["public"]
   }
 }

PWA/public/Models/DistributionBeneficiary.js

@@ -0,0 +1,6 @@
+export class DistributionBeneficiary {
+    constructor(beneficiaryCode, distributionName) {
+        this.beneficiaryCode = beneficiaryCode;
+        this.distributionName = distributionName;
+    }
+}

PWA/public/RouteEvents.js

@@ -6,6 +6,7 @@ RouteEvents.nameDistribution = "/name_distrib.html";
 RouteEvents.listDistributions = "/list_distrib.html";
 RouteEvents.deleteDistribution = "/list_distrib_delete.html";
 RouteEvents.uploadData = "/upload_data.html";
+RouteEvents.viewData = "/view_data.html";
 RouteEvents.uploadDataError = "/upload_error.html";
 RouteEvents.template = "/template.html";
 RouteEvents.chooseBenificiaryCodeInputMethodPage = "/choose_input_method.html";

PWA/public/Services/ActiveSession.js

@@ -1,4 +1,19 @@
-class ActiveSession {
+export class ActiveSession {
+    constructor(database) {
+        console.info("ℹ️ Constructing active session, should only happen once ");
+        this.database = database;
+    }
+    get nameOfLastViewedDistribution() {
+        return this._nameOfLastViewedDistribution;
+    }
+    set nameOfLastViewedDistribution(value) {
+        console.log("ℹ️ name of last known distribution is now:");
+        console.log(value);
+        this._nameOfLastViewedDistribution = value;
+    }
+}
+export class ActiveSessionContainer {
+    constructor(activeSession) {
+        this.activeSession = activeSession;
+    }
 }
-ActiveSession.singleton = new ActiveSession();
-export { ActiveSession };

PWA/public/Services/BeneficiariesService.js

@@ -0,0 +1,34 @@
+import { ActiveSessionContainer } from "./ActiveSession.js";
+export class BeneficiariesService extends ActiveSessionContainer {
+    async beneficiariesForActiveDistribution() {
+        const database = this.activeSession.database;
+        const activeDistributionName = this.activeSession.nameOfLastViewedDistribution;
+        if (activeDistributionName) {
+            const distribution = await database.distributionWithName(activeDistributionName);
+            if (distribution) {
+                const activeDistributionBeneficiaries = (await database.benificiariesForDistribution(distribution)).filter((distributionBeneficiary) => {
+                    return distributionBeneficiary.distributionName === activeDistributionName;
+                });
+                const activeDistributionBeneficiaryCodes = activeDistributionBeneficiaries
+                    .map((distributionBeneficiary) => {
+                    return distributionBeneficiary.beneficiaryCode;
+                });
+                const allBeneficiaries = await database.readBeneficiaries();
+                const beneficiaries = allBeneficiaries
+                    .filter((beneficiary) => {
+                    return activeDistributionBeneficiaryCodes.indexOf(beneficiary.code) != -1;
+                });
+                console.log("ℹ️");
+                console.log(allBeneficiaries);
+                console.log(beneficiaries);
+                return beneficiaries;
+            }
+            else {
+                throw "Expected distribution";
+            }
+        }
+        else {
+            throw "Expected active distribution name";
+        }
+    }
+}

PWA/public/Services/BeneficiariesService.test.js

@@ -0,0 +1,62 @@
+import { describe, test, expect, beforeEach } from '@jest/globals';
+import { fail } from 'assert';
+import { BeneficiariesService } from './BeneficiariesService.js';
+import { IDBFactory } from "fake-indexeddb";
+import { ActiveSession } from './ActiveSession.js';
+import { Database } from './Database.js';
+import { Distribution } from '../Models/Distribution.js';
+import { Beneficiary } from '../Models/Beneficiary';
+describe('BeneficiariesService', () => {
+    const existingDistributionName = "ExistingDistributionName";
+    const beneficiaryCode1 = "code1";
+    const beneficiaryCode2 = "code2";
+    const existingDistribution = new Distribution("", "", "", existingDistributionName);
+    const beneficiary1 = new Beneficiary(beneficiaryCode1, [], []);
+    const beneficiary2 = new Beneficiary(beneficiaryCode2, [], []);
+    var database = new Database(new IDBFactory());
+    var activeSesion = new ActiveSession(database);
+    var sut = new BeneficiariesService(activeSesion);
+    beforeEach(() => {
+        database = new Database(new IDBFactory());
+        activeSesion = new ActiveSession(database);
+        sut = new BeneficiariesService(activeSesion);
+    });
+    test("When there's no active distribution Then error is thrown", async () => {
+        activeSesion.nameOfLastViewedDistribution = undefined;
+        try {
+            const beneficiaries = await sut.beneficiariesForActiveDistribution();
+            fail("expected other error to be thrown at this point");
+        }
+        catch (error) {
+            expect(error).toEqual("Expected active distribution name");
+        }
+    });
+    test("When active distribution doesn't exist Then error is thrown", async () => {
+        activeSesion.nameOfLastViewedDistribution = "Nonexisting distribution name";
+        try {
+            const beneficiaries = await sut.beneficiariesForActiveDistribution();
+            fail("expected other error to be thrown at this point");
+        }
+        catch (error) {
+            expect(error).toEqual("Expected distribution");
+        }
+    });
+    test("When active distribution exist without beneficiaries Then no beneficiaries are provided", async () => {
+        activeSesion.nameOfLastViewedDistribution = existingDistributionName;
+        await database.addDistribution(existingDistribution);
+        const beneficiaries = await sut.beneficiariesForActiveDistribution();
+        expect(beneficiaries.length).toEqual(0);
+    });
+    test("When active distribution exist with beneficiaries Then they beneficiaries are provided", async () => {
+        activeSesion.nameOfLastViewedDistribution = existingDistributionName;
+        const distributions = await database.readDistributions();
+        console.log(distributions);
+        await database.addDistribution(existingDistribution);
+        await database.addBeneficiaryToDistribution(beneficiary1, existingDistribution);
+        await database.addBeneficiaryToDistribution(beneficiary2, existingDistribution);
+        const beneficiaries = await sut.beneficiariesForActiveDistribution();
+        expect(beneficiaries.length).toEqual(2);
+        expect(beneficiaries[0].code).toEqual(beneficiaryCode1);
+        expect(beneficiaries[1].code).toEqual(beneficiaryCode2);
+    });
+});

PWA/public/Services/BeneficiaryDeserializationService.js

@@ -1,6 +1,6 @@
-import { Beneficiary } from "../Models/Beneficiary";
-import { FormParser } from "./FormParser";
-import { SpreadSheetFileParser } from "./SpreadSheetFileParser";
+import { Beneficiary } from "../Models/Beneficiary.js";
+import { FormParser } from "./FormParser.js";
+import { SpreadSheetFileParser } from "./SpreadSheetFileParser.js";
 export class BeneficiaryDeserializationService {
     async deserializeFormDataFromRequest(request) {
         return new Promise(async (resolve, reject) => {

PWA/public/Services/BeneficiaryEligilityService.js

@@ -42,10 +42,11 @@ export class BeneficiaryEligilityService {
         if (nameOfActiveDistribution) {
             const distribution = await this.activeSession.database.distributionWithName(nameOfActiveDistribution);
             if (distribution) {
-                const beneficiaries = await this.activeSession.database.benificiariesForDistribution(distribution);
-                console.log(beneficiaries);
-                const matchedBeneficiaries = beneficiaries.filter((beneficiary) => {
-                    beneficiary.code == beneficiaryCode;
+                const distributionBeneficiaries = await this.activeSession.database.benificiariesForDistribution(distribution);
+                console.log("🦆 there is a distribution");
+                console.log(distributionBeneficiaries);
+                const matchedBeneficiaries = distributionBeneficiaries.filter((beneficiary) => {
+                    return beneficiary.beneficiaryCode === beneficiaryCode;
                 });
                 if (matchedBeneficiaries.length == 1) {
                     return true;

PWA/public/Services/BeneficiaryEligilityService.test.js

@@ -1,45 +1,43 @@
-import { describe, test, expect } from '@jest/globals';
+import { describe, test, expect } from "@jest/globals";
 import { BeneficiaryEligilityService } from "./BeneficiaryEligilityService";
 import { Database } from "./Database";
-import { indexedDB } from "fake-indexeddb";
-import { ActiveSession } from '../SessionState/ActiveSession';
-import { Distribution } from '../Models/Distribution';
-import { Beneficiary } from '../Models/Beneficiary';
-import { fail } from 'assert';
-const activeEligibleBeneficiaryCode = "1234";
+import "fake-indexeddb/auto";
+import { IDBFactory } from "fake-indexeddb";
+import { ActiveSession } from "./ActiveSession";
+import { Distribution } from "../Models/Distribution";
+import { Beneficiary } from "../Models/Beneficiary";
+import { fail } from "assert";
+const activeEligibleBeneficiaryCode = "1234AA";
 const inActiveEligibleBeneficiaryCode = "5432";
 const eligibleActiveDistributionBeneficiary = new Beneficiary(activeEligibleBeneficiaryCode, ["code", "name"], [activeEligibleBeneficiaryCode, "henry"]);
 const eligibleInactiveDistributionBeneficiary = new Beneficiary(activeEligibleBeneficiaryCode, ["code", "name"], [inActiveEligibleBeneficiaryCode, "tedd"]);
 const activeDistribution = new Distribution("items", "date", "place", "activeDistribution");
 const inactiveDistribution = new Distribution("items", "date", "place", "inactiveDistribution");
-const database = new Database(indexedDB);
-database.addDistribution(activeDistribution);
-database.addDistribution(inactiveDistribution);
-database.addBeneficiaryToDistribution(eligibleActiveDistributionBeneficiary, activeDistribution);
-database.addBeneficiaryToDistribution(eligibleInactiveDistributionBeneficiary, inactiveDistribution);
-describe('BeneficiaryEligilityService during active distribution', () => {
-    const activeSession = new ActiveSession(database);
-    activeSession.nameOfLastViewedDistribution = activeDistribution.distrib_name;
-    const sut = new BeneficiaryEligilityService(activeSession);
-    test("When checking elible code from inactive distribution", async () => {
+async function setupDatabase() {
+    const database = new Database(new IDBFactory());
+    await database.addDistribution(activeDistribution);
+    await database.addDistribution(inactiveDistribution);
+    await database.addBeneficiaryToDistribution(eligibleActiveDistributionBeneficiary, activeDistribution);
+    await database.addBeneficiaryToDistribution(eligibleInactiveDistributionBeneficiary, inactiveDistribution);
+    return database;
+}
+describe("BeneficiaryEligilityService", () => {
+    test("When checking elible code from inactive distribution during active distrubution Then not eligible", async () => {
+        const activeSession = await new ActiveSession(await setupDatabase());
+        activeSession.nameOfLastViewedDistribution = activeDistribution.distrib_name;
+        const sut = new BeneficiaryEligilityService(activeSession);
         expect(await sut.isBenificiaryEligibleForCurrentDistribution(inActiveEligibleBeneficiaryCode)).toEqual(false);
     });
-});
-describe('BeneficiaryEligilityService during active distribution', () => {
-    const activeSession = new ActiveSession(database);
-    activeSession.nameOfLastViewedDistribution = activeDistribution.distrib_name;
-    const sut = new BeneficiaryEligilityService(activeSession);
-    test("When checking elible code from active distribution", async () => {
-        //fails expectedly since implementation isn't complete yet
+    test("When checking elible code from active distribution during active distrubtion Then eligible", async () => {
+        const activeSession = await new ActiveSession(await setupDatabase());
+        activeSession.nameOfLastViewedDistribution = activeDistribution.distrib_name;
+        const sut = new BeneficiaryEligilityService(activeSession);
         expect(await sut.isBenificiaryEligibleForCurrentDistribution(activeEligibleBeneficiaryCode)).toEqual(true);
     });
-});
-describe('BeneficiaryEligilityService during inActive distribution', () => {
-    const activeSession = new ActiveSession(database);
-    activeSession.nameOfLastViewedDistribution = undefined;
-    const sut = new BeneficiaryEligilityService(activeSession);
-    test("When checking code", async () => {
+    test("When checking code from any distribution during inactive distrubtion Then error is thrown", async () => {
+        const activeSession = await new ActiveSession(await setupDatabase());
         activeSession.nameOfLastViewedDistribution = undefined;
+        const sut = new BeneficiaryEligilityService(activeSession);
         try {
             const result = await sut.isBenificiaryEligibleForCurrentDistribution("could have been any code");
             fail("Expected error");