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, when, anything } from 'ts-mockito';
 import { Model, WeightsContainer } from "./index.js";
 import {
   Aggregator,
@@ -20,10 +20,53 @@
   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", async () => {
+      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 @@
           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/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",