Fix types in tests

backend/src/Model/TreeNodeFactory.ts

@@ -5,7 +5,7 @@ interface HasLength {
 }
 
 export abstract class TreeNodeFactory {
-  public static fromEdgesAndValue<T extends HasLength>(edgeNames: string[], value: T): TreeNode {
+  public static fromEdgesAndValue<T extends HasLength>(edgeNames: string[], value?: T): TreeNode {
     let currentNode: TreeNode = new Tree()
     for (const edgeName of edgeNames) {
       const edge = new Edge(edgeName)
@@ -17,7 +17,7 @@ export abstract class TreeNodeFactory {
 
     currentNode.setMessage({
       value,
-      length: value.length,
+      length: value ? value.length : 0,
       received: new Date(),
     })
     return currentNode

backend/src/Model/spec/Edge.spec.ts

@@ -1,7 +1,9 @@
-import { Edge, TreeNode, TreeNodeFactory } from '../'
-import { expect } from 'chai'
 import 'mocha'
 
+import { Edge, TreeNode, TreeNodeFactory } from '../'
+
+import { expect } from 'chai'
+
 describe('Edge', () => {
   it('should contain a name', () => {
     const e = new Edge('foo')
@@ -10,7 +12,7 @@ describe('Edge', () => {
 
   it('firstEdge should retireve the first edge', () => {
     const topics = 'foo/bar/baz'.split('/')
-    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, 5)
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, undefined)
     const bazEdge = leaf.sourceEdge
 
     if (!bazEdge) {
@@ -35,10 +37,10 @@ describe('Edge', () => {
 
   it('hash should include change if parents are different', () => {
     const topics1 = 'foo/bar/baz'.split('/')
-    const bazEdge1 = TreeNodeFactory.fromEdgesAndValue(topics1, 5).sourceEdge
+    const bazEdge1 = TreeNodeFactory.fromEdgesAndValue(topics1, undefined).sourceEdge
 
     const topics2 = 'foo/foo/baz'.split('/')
-    const bazEdge2 = TreeNodeFactory.fromEdgesAndValue(topics2, 5).sourceEdge
+    const bazEdge2 = TreeNodeFactory.fromEdgesAndValue(topics2, undefined).sourceEdge
 
     if (!bazEdge1 || !bazEdge2) {
       throw Error('should not happen')

backend/src/Model/spec/Tree.spec.ts

@@ -1,15 +1,16 @@
-import { Tree, TreeNodeFactory } from '../'
-import { expect } from 'chai'
 import 'mocha'
-
 import './TreeNode.findNode'
 
+import { Tree, TreeNodeFactory } from '../'
+
+import { expect } from 'chai'
+
 describe('Tree', () => {
   it('node can be merged into a tree', () => {
     const tree = new Tree()
 
     const topics = 'foo/bar'.split('/')
-    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, 3)
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, undefined)
 
     tree.updateWithNode(leaf.firstNode())
     const expectedNode = tree.findNode('foo/bar')

backend/src/Model/spec/TreeNode.findNode.spec.ts

@@ -1,13 +1,13 @@
+import 'mocha'
+import './TreeNode.findNode'
+
 import { TreeNodeFactory } from '../'
 import { expect } from 'chai'
-import 'mocha'
-
-import './TreeNode.findNode'
 
 describe('TreeNode.findNode', () => {
   it('findNode should retrieve node', () => {
     const topics = 'foo/bar/baz'.split('/')
-    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, 5)
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, undefined)
 
     const root = leaf.firstNode()
     expect(root.sourceEdge).to.eq(undefined)

backend/src/Model/spec/TreeNode.spec.ts

@@ -1,52 +1,53 @@
-import { TreeNodeFactory } from  '../'
 import './TreeNode.findNode'
-import { expect } from 'chai'
 import 'mocha'
 
+import { TreeNodeFactory } from  '../'
+import { expect } from 'chai'
+
 describe('TreeNode', () => {
   it('firstNode should retrieve first node', () => {
     const topics = 'foo/bar'.split('/')
-    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, 3)
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, undefined)
 
     expect(leaf.firstNode().edges['foo']).to.not.eq(undefined)
   })
 
   it('updateWithNode should update value', () => {
     const topics = 'foo/bar'.split('/')
-    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, 3)
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, '3')
-    expect(leaf.message && leaf.message.value).to.eq(3)
+    expect(leaf.message && leaf.message.value).to.eq('3')
-    const updateLeave = TreeNodeFactory.fromEdgesAndValue(topics, 5)
+    const updateLeave = TreeNodeFactory.fromEdgesAndValue(topics, '5')
 
     const root = leaf.firstNode()
     root.updateWithNode(updateLeave.firstNode())
 
     expect(root.sourceEdge).to.eq(undefined)
-    expect(leaf.message && leaf.message.value).to.eq(5)
+    expect(leaf.message && leaf.message.value).to.eq('5')
   })
 
   it('updateWithNode should update intermediate nodes', () => {
     const topics1 = 'foo/bar/baz'.split('/')
-    const leaf = TreeNodeFactory.fromEdgesAndValue(topics1, 3)
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics1, '3')
-    expect(leaf.message && leaf.message.value).to.eq(3)
+    expect(leaf.message && leaf.message.value).to.eq('3')
 
     const topics2 = 'foo/bar'.split('/')
-    const updateLeave = TreeNodeFactory.fromEdgesAndValue(topics2, 5)
+    const updateLeave = TreeNodeFactory.fromEdgesAndValue(topics2, '5')
     leaf.firstNode().updateWithNode(updateLeave.firstNode())
 
     const barNode = leaf.firstNode().findNode('foo/bar')
     expect(barNode && barNode.sourceEdge && barNode.sourceEdge.name).to.eq('bar')
-    expect(barNode && barNode.message && barNode.message.value).to.eq(5)
+    expect(barNode && barNode.message && barNode.message.value).to.eq('5')
 
     expect(leaf.sourceEdge && leaf.sourceEdge.name).to.eq('baz')
-    expect(leaf.message && leaf.message.value).to.eq(3)
+    expect(leaf.message && leaf.message.value).to.eq('3')
   })
 
   it('updateWithNode should add nodes to the tree', () => {
     const topics1 = 'foo/bar'.split('/')
-    const leaf1 = TreeNodeFactory.fromEdgesAndValue(topics1, 3)
+    const leaf1 = TreeNodeFactory.fromEdgesAndValue(topics1, undefined)
 
     const topics2 = 'foo/bar/baz'.split('/')
-    const leaf2 = TreeNodeFactory.fromEdgesAndValue(topics2, 5)
+    const leaf2 = TreeNodeFactory.fromEdgesAndValue(topics2, undefined)
 
     leaf1.firstNode().updateWithNode(leaf2.firstNode())
 

backend/src/Model/spec/TreeNodeFactory.spec.ts

@@ -1,13 +1,14 @@
-import { TreeNodeFactory } from '../'
-import { expect } from 'chai'
 import 'mocha'
 import './TreeNode.findNode'
 
+import { TreeNodeFactory } from '../'
+import { expect } from 'chai'
+
 describe('TreeNodeFactory', () => {
   it('root node must not have a sourceEdge', () => {
     const topic = 'foo/bar'
     const edges = topic.split('/')
-    const leaf = TreeNodeFactory.fromEdgesAndValue(edges, 5)
+    const leaf = TreeNodeFactory.fromEdgesAndValue(edges, undefined)
 
     expect(leaf.firstNode().sourceEdge).to.eq(undefined)
   })
@@ -15,7 +16,7 @@ describe('TreeNodeFactory', () => {
   it('should create node', () => {
     const topic = 'foo/bar'
     const edges = topic.split('/')
-    const node = TreeNodeFactory.fromEdgesAndValue(edges, 5)
+    const node = TreeNodeFactory.fromEdgesAndValue(edges, '5')
 
     if (!node.sourceEdge || !node.sourceEdge.source || !node.message) {
       expect.fail('should not happen')
@@ -24,7 +25,7 @@ describe('TreeNodeFactory', () => {
 
     expect(node).to.not.eq(undefined)
     expect(node.sourceEdge.name).to.eq('bar')
-    expect(node.message.value).to.eq(5)
+    expect(node.message.value).to.eq('5')
 
     const foo = node.firstNode().findNode('foo')
     expect(foo && foo.sourceEdge && foo.sourceEdge.name).to.eq('foo')
@@ -33,14 +34,14 @@ describe('TreeNodeFactory', () => {
   it('node should contain edges in order', () => {
     const topic = 'foo/bar/baz'
     const edges = topic.split('/')
-    const node = TreeNodeFactory.fromEdgesAndValue(edges, 5)
+    const node = TreeNodeFactory.fromEdgesAndValue(edges, '5')
 
     if (!node.sourceEdge || !node.sourceEdge.source || !node.message) {
       expect.fail('should not happen')
       return
     }
 
-    expect(node.message.value).to.eq(5)
+    expect(node.message.value).to.eq('5')
     expect(node.sourceEdge.name).to.eq('baz')
 
     const barNode = node.sourceEdge.source