Basic Testing for Discojs

discojs/src/aggregator.spec.ts

@@ -1,6 +1,6 @@
 import { expect } from "chai";
 import { Map, Range, Set } from "immutable";
-
+import { mock, instance } from 'ts-mockito';
 import { Model, WeightsContainer } from "./index.js";
 import {
   Aggregator,
@@ -20,10 +20,53 @@ AGGREGATORS.forEach(([name, Aggregator]) =>
   describe(`${name} implements Aggregator contract`, () => {
     it("starts at round zero", () => {
       const aggregator = new Aggregator();
-
+      
       expect(aggregator.round).to.equal(0);
     });
 
+    it("starts with no contributions", () => {
+      const aggregator = new Aggregator();
+
+      expect(aggregator.size).to.equal(0);
+    })
+
+    it("model correctly initialized", () => {
+      const aggregator = new Aggregator();
+
+      const model = mock(Model);
+
+      aggregator.setModel(instance(model));
+      expect(aggregator.model).to.equal(instance(model));
+    });
+
+    it("is full when created with no nodes", () => {
+      const aggregator = new Aggregator();
+
+      expect(aggregator.isFull());
+    });
+
+    it("is not full when created with more than no nodes and empty", () => {
+      const aggregator = new Aggregator();
+      aggregator.setNodes(Set.of("client 0"));
+
+      expect(aggregator.isFull()).to.be.false;
+    });
+
+
+
+    it("is full when enough contributions", () => {
+      const aggregator = new Aggregator();
+      aggregator.setNodes(Set.of("client 0", "client 1", "client 2"));
+
+      for (let i = 0; i < 3; i++)
+        for (let r = 0; r < aggregator.communicationRounds; r++)
+          aggregator.add(`client ${i}`, WeightsContainer.of([i]), 0, r);
+
+      expect(aggregator.isFull()).to.be.true;
+    });
+
+
+
     it("moves forward with enough contributions", async () => {
       const aggregator = new Aggregator();
       aggregator.setNodes(Set.of("client 0", "client 1", "client 2"));
@@ -35,10 +78,36 @@ AGGREGATORS.forEach(([name, Aggregator]) =>
           aggregator.add(`client ${i}`, WeightsContainer.of([i]), 0, r);
 
       await results; // nothing to test
-
+    
       expect(aggregator.round).to.equal(1);
     });
 
+    it("does not move forward with not enough contributions", async () => {
+      const aggregator = new Aggregator();
+      aggregator.setNodes(Set.of("client 0", "client 1", "client 2"));
+
+      const results = aggregator.receiveResult();
+
+      for (let i = 0; i < 2; i++)
+        for (let r = 0; r < aggregator.communicationRounds; r++)
+          aggregator.add(`client ${i}`, WeightsContainer.of([i]), 0, r);
+
+      await results; 
+
+      expect(aggregator.round).to.equal(0);
+    });
+
+    it("Adding at the wrong round does not count", () => {
+      const aggregator = new Aggregator();
+      aggregator.setNodes(Set.of("client 0", "client 1", "client 2"));
+
+      for (let i = 0; i < 3; i++)
+        for (let r = 0; r < aggregator.communicationRounds; r++)
+          aggregator.add(`client ${i}`, WeightsContainer.of([i]), aggregator.round+1, r);
+
+      expect(aggregator.size).to.equal(0);
+    });
+
     it("gives same results on each node", async () => {
       const network = setupNetwork(Aggregator);
 

discojs/src/client/federated/base.ts

@@ -76,6 +76,8 @@ export class Base extends Client {
     const received = await waitMessageWithTimeout(
       this.server,
       type.AssignNodeID,
+      undefined,
+      "Timeout waiting for own id"
     );
     console.info(`[${received.id}] assign id generated by the server`);
     this._ownId = received.id;
@@ -121,6 +123,8 @@ export class Base extends Client {
       const { payload, round } = await waitMessageWithTimeout(
         this.server,
         type.ReceiveServerPayload,
+        undefined,
+        "Timeout waiting for server payload"
       );
       const serverRound = round;
 
@@ -162,6 +166,8 @@ export class Base extends Client {
     const received = await waitMessageWithTimeout(
       this.server,
       type.ReceiveServerMetadata,
+      undefined,
+      "Timeout waiting for metadata map",
     );
     if (received.metadataMap !== undefined) {
       this.metadataMap = Map(

discojs/src/weights/aggregation.spec.ts

@@ -4,33 +4,68 @@ import { WeightsContainer, aggregation } from './index.js'
 
 describe('weights aggregation', () => {
   it('avg of weights with two operands', () => {
-    const actual = aggregation.avg([
+    const expected = aggregation.avg([
       WeightsContainer.of([1, 2, 3, -1], [-5, 6]),
       WeightsContainer.of([2, 3, 7, 1], [-10, 5]),
       WeightsContainer.of([3, 1, 5, 3], [-15, 19])
     ])
-    const expected = WeightsContainer.of([2, 2, 5, 1], [-10, 10])
+    const actual = WeightsContainer.of([2, 2, 5, 1], [-10, 10])
 
-    assert.isTrue(actual.equals(expected))
+    assert.isTrue(expected.equals(actual))
   })
 
   it('sum of weights with two operands', () => {
-    const actual = aggregation.sum([
+    const expected = aggregation.sum([
       [[3, -4], [9]],
       [[2, 13], [0]]
     ])
-    const expected = WeightsContainer.of([5, 9], [9])
+    const actual = WeightsContainer.of([5, 9], [9])
 
-    assert.isTrue(actual.equals(expected))
+    assert.isTrue(expected.equals(actual))
   })
 
   it('diff of weights with two operands', () => {
-    const actual = aggregation.diff([
+    const expected = aggregation.diff([
       [[3, -4, 5], [9, 1]],
       [[2, 13, 4], [0, 1]]
     ])
-    const expected = WeightsContainer.of([1, -17, 1], [9, 0])
+    const actual = WeightsContainer.of([1, -17, 1], [9, 0])
 
-    assert.isTrue(actual.equals(expected))
+    assert.isTrue(expected.equals(actual))
   })
+
+  it('avg of weights with no operands throws an error', () => {
+    assert.throws(() => aggregation.avg([]))
+  })
+
+  it('sum of weights with no operands throws an error', () => {
+    assert.throws(() => aggregation.sum([]))
+  })
+
+  it('diff of weights with no operands throws an error', () => {
+    assert.throws(() => aggregation.diff([]))
+  })
+
+  it('avg of weights with different dimensions throws an error', () => {
+    assert.throws(() => aggregation.avg([
+      [[3, -4], [9]],
+      [[2, 13, 4], [0, 1]]
+    ]))
+  })
+
+  it('sum of weights with different dimensions throws an error', () => {
+    assert.throws(() => aggregation.sum([
+      [[3, -4], [9]],
+      [[2, 13, 4], [0, 1]]
+    ]))
+  })
+
+  it('diff of weights with different dimensions throws an error', () => {
+    assert.throws(() => aggregation.diff([
+      [[3, -4], [9]],
+      [[2, 13, 4], [0, 1]]
+    ]))
+  })
+
+
 })

package.json

@@ -11,7 +11,8 @@
     "webapp"
   ],
   "dependencies": {
-    "immutable": "4"
+    "immutable": "4",
+    "ts-mockito": "^2.6.1"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "7",

server/src/router/decentralized/server.ts

@@ -31,14 +31,37 @@
   public isValidUrl (url: string | undefined): boolean {
     const splittedUrl = url?.split('/')
 
-    return (
-      splittedUrl !== undefined &&
-      splittedUrl.length === 3 &&
-      splittedUrl[0] === '' &&
-      this.isValidTask(splittedUrl[1]) &&
-      this.isValidWebSocket(splittedUrl[2])
-    )
-  }
+    // Assuming this code is inside a method of a class
+    console.log("Evaluating URL validation...");
+
+    if (splittedUrl === undefined) {
+      console.log("Failure: URL is undefined.");
+      return false;
+    }
+
+    if (splittedUrl.length !== 3) {
+      console.log(`Failure: URL does not have exactly 3 segments. Found ${splittedUrl.length} segments: ${splittedUrl}`);
+      return false;
+    }
+
+    if (splittedUrl[0] !== '') {
+      console.log("Failure: URL does not start with a '/'.");
+      return false;
+    }
+
+    if (!this.isValidTask(splittedUrl[1])) {
+      console.log(`Failure: '${splittedUrl[1]}' is not a valid task.`);
+      return false;
+    }
+
+    if (!this.isValidWebSocket(splittedUrl[2])) {
+      console.log(`Failure: '${splittedUrl[2]}' is not a valid WebSocket.`);
+      return false;
+    }
+
+    console.log("URL is valid.");
+    return true;
+    }
 
   protected initTask (): void {}
 

server/src/router/router.ts

@@ -23,15 +23,17 @@ export class Router {
     const decentralized = new Decentralized(wsApplier, this.tasksAndModels)
 
     this.ownRouter = express.Router()
-    wsApplier.applyTo(this.ownRouter)
+    wsApplier.applyTo(this.ownRouter) 
 
     process.nextTick(() =>
       wsApplier.getWss().on('connection', (ws, req) => {
         if (!federated.isValidUrl(req.url) && !decentralized.isValidUrl(req.url)) {
           console.log('Connection refused')
+          ws.send('404')
           ws.terminate()
           ws.close()
         }
+        ws.send('200')
       })
     )