@streamr/trackerless-network 0.0.1-tatum.0

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -0,0 +1,132 @@
+import { NetworkNode } from '../../src/NetworkNode'
+import { range } from 'lodash'
+import { NodeType, PeerDescriptor, PeerID, Simulator, SimulatorTransport, LatencyType } from '@streamr/dht'
+import {
+    MessageID,
+    MessageRef,
+    StreamMessage,
+    StreamMessageType,
+    StreamPartIDUtils,
+    toStreamID
+} from '@streamr/protocol'
+import { EthereumAddress, waitForCondition } from '@streamr/utils'
+import { streamPartIdToDataKey } from '../../src/logic/StreamEntryPointDiscovery'
+
+describe('stream without default entrypoints', () => {
+
+    let entrypoint: NetworkNode
+    let nodes: NetworkNode[]
+    let numOfReceivedMessages: number
+    const entryPointPeerDescriptor: PeerDescriptor = {
+        kademliaId: new Uint8Array([1, 2, 3]),
+        nodeName: 'entrypoint',
+        type: NodeType.NODEJS
+    }
+
+    const STREAM_ID = StreamPartIDUtils.parse('test#0')
+    const streamMessage = new StreamMessage({
+        messageId: new MessageID(
+            toStreamID('test'),
+            0,
+            666,
+            0,
+            'peer2' as EthereumAddress,
+            'msgChainId'
+        ),
+        prevMsgRef: new MessageRef(665, 0),
+        content: {
+            hello: 'world'
+        },
+        messageType: StreamMessageType.MESSAGE,
+        signature: 'signature',
+    })
+
+    beforeEach(async () => {
+        Simulator.useFakeTimers()
+        const simulator = new Simulator(LatencyType.RANDOM)
+        nodes = []
+        numOfReceivedMessages = 0
+        const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
+        entrypoint = new NetworkNode({
+            layer0: {
+                transportLayer: entryPointTransport,
+                peerDescriptor: entryPointPeerDescriptor,
+                entryPoints: [entryPointPeerDescriptor]
+            },
+            networkNode: {}
+        })
+        await entrypoint.start()
+        await Promise.all(range(20).map(async (i) => {
+            const peerDescriptor: PeerDescriptor = {
+                kademliaId: PeerID.fromString(`${i}`).value,
+                type: NodeType.NODEJS,
+                nodeName: `${i}`
+            }
+            const transport = new SimulatorTransport(peerDescriptor, simulator)
+            const node = new NetworkNode({
+                layer0: {
+                    peerDescriptor: peerDescriptor,
+                    transportLayer: transport,
+                    entryPoints: [entryPointPeerDescriptor]
+                },
+                networkNode: {}
+            })
+            nodes.push(node)
+            await node.start()
+        }))
+    })
+
+    afterEach(async () => {
+        await entrypoint.stop()
+        await Promise.all(nodes.map((node) => node.stop()))
+        Simulator.useFakeTimers(false)
+    })
+
+    it('can join stream without configured entrypoints one by one', async () => {
+        await nodes[0].subscribeAndWaitForJoin(STREAM_ID)
+        nodes[0].addMessageListener((_msg) => {
+            numOfReceivedMessages += 1
+        })
+        await Promise.all([
+            waitForCondition(() => numOfReceivedMessages === 1, 10000),
+            nodes[1].publish(streamMessage)
+        ])
+    })
+
+    it('can join without configured entrypoints simultaneously', async () => {
+        nodes[0].addMessageListener((_msg) => {
+            numOfReceivedMessages += 1
+        })
+        await Promise.all([
+            waitForCondition(() => numOfReceivedMessages === 1, 15000),
+            nodes[0].subscribe(STREAM_ID),
+            nodes[1].publish(streamMessage),
+        ])
+    })
+
+    // TODO: can't this test make pass
+    /*it('multiple nodes can join without configured entrypoints simultaneously', async () => {
+        const numOfSubscribers = 8
+        await Promise.all(range(numOfSubscribers).map(async (i) => {
+            await nodes[i].subscribeAndWaitForJoin(STREAM_ID, undefined, 4)
+            nodes[i].addMessageListener((_msg) => {
+                numOfReceivedMessages += 1
+            })
+        }))
+        await Promise.all([
+            waitForCondition(() => numOfReceivedMessages === numOfSubscribers, 15000),
+            nodes[9].publish(streamMessage)
+        ])
+    }, 45000)*/
+
+    it('nodes store themselves as entrypoints on streamPart if number of entrypoints is low', async () => {
+        for (let i = 0; i < 10; i++) {
+            await nodes[i].subscribeAndWaitForJoin(STREAM_ID)
+        }
+        await waitForCondition(async () => {
+            const entryPointData = await nodes[15].stack.getLayer0DhtNode().getDataFromDht(streamPartIdToDataKey(STREAM_ID))
+            return entryPointData.dataEntries!.length >= 7
+        }, 15000)
+        
+    }, 90000)
+})

package/test/unit/ContentMessageTranslator.test.ts

@@ -0,0 +1,20 @@
+import { ContentMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ContentMessageTranslator } from '../../src/logic/protocol-integration/stream-message/ContentMessageTranslator'
+
+describe('ContentMessageTranslator', () => {
+    
+    const oldMessage = JSON.stringify({ hello: 'world' })
+    const newMessage: ContentMessage = {
+        body: JSON.stringify({ hello: 'world' })
+    }
+
+    it('translates old protocol to protobuf', () => {
+        const translated = ContentMessageTranslator.toProtobuf(oldMessage)
+        expect(translated).toEqual(newMessage)
+    })
+
+    it('translates protobuf to old protocol', () => {
+        const translated = ContentMessageTranslator.toClientProtocol(newMessage)
+        expect(translated).toEqual(oldMessage)
+    })
+})

package/test/unit/DuplicateMessageDetector.test.ts

@@ -0,0 +1,192 @@
+import { DuplicateMessageDetector, NumberPair, GapMisMatchError, InvalidNumberingError } from '../../src/logic/DuplicateMessageDetector'
+
+test('starts empty', () => {
+    const detector = new DuplicateMessageDetector()
+    expect(detector.toString()).toEqual('')
+})
+
+test('first check initializes default gap', () => {
+    const detector = new DuplicateMessageDetector()
+    const result = detector.markAndCheck(new NumberPair(1, 5), new NumberPair(10, 10))
+    const state = detector.toString()
+    expect(result).toEqual(true)
+    expect(state).toEqual('(10|10, Infinity|Infinity]')
+})
+
+test('checking numbers in order introduces no new gaps', () => {
+    const detector = new DuplicateMessageDetector()
+    detector.markAndCheck(null, new NumberPair(10, 0))
+    expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0))).toEqual(true)
+    expect(detector.markAndCheck(new NumberPair(20, 0), new NumberPair(30, 0))).toEqual(true)
+    expect(detector.markAndCheck(null, new NumberPair(30, 1))).toEqual(true)
+    expect(detector.markAndCheck(new NumberPair(30, 1), new NumberPair(30, 5))).toEqual(true)
+    const state = detector.toString()
+    expect(state).toEqual('(30|5, Infinity|Infinity]')
+})
+
+test('skipping next expected messages creates gaps', () => {
+    const detector = new DuplicateMessageDetector()
+    detector.markAndCheck(null, new NumberPair(10, 0))
+
+    expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 0))).toEqual(true)
+    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, Infinity|Infinity]')
+
+    expect(detector.markAndCheck(new NumberPair(30, 0), new NumberPair(40, 0))).toEqual(true)
+    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, 30|0], (40|0, Infinity|Infinity]')
+
+    expect(detector.markAndCheck(new NumberPair(40, 10), new NumberPair(80, 20))).toEqual(true)
+    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, 30|0], (40|0, 40|10], (80|20, Infinity|Infinity]')
+})
+
+test('only last gap is checked if no previous number given', () => {
+    const detector = new DuplicateMessageDetector()
+    detector.markAndCheck(null, new NumberPair(10, 0))
+    detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0))
+
+    expect(detector.markAndCheck(null, new NumberPair(15, 0))).toEqual(false)
+    expect(detector.markAndCheck(null, new NumberPair(30, 5))).toEqual(true)
+    const state = detector.toString()
+    expect(state).toEqual('(30|5, Infinity|Infinity]')
+})
+
+describe('gap handling', () => {
+    let detector: DuplicateMessageDetector
+    beforeEach(() => {
+        detector = new DuplicateMessageDetector()
+        detector.markAndCheck(null, new NumberPair(10, 0))
+        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
+        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
+        expect(detector.toString()).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
+    })
+
+    test('gap division', () => {
+        expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(18, 0)))
+        expect(detector.toString()).toEqual('(10|0, 15|0], (18|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
+
+        expect(detector.markAndCheck(new NumberPair(60, 0), new NumberPair(79, 5)))
+        expect(detector.toString()).toEqual('(10|0, 15|0], (18|0, 20|0], (40|0, 60|0], (79|5, 80|10], (100|0, Infinity|Infinity]')
+    })
+
+    test('left-side gap contraction', () => {
+        expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(15, 0))).toEqual(true)
+        expect(detector.toString()).toEqual('(15|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
+
+        expect(detector.markAndCheck(new NumberPair(40, 0), new NumberPair(80, 9))).toEqual(true)
+        expect(detector.toString()).toEqual('(15|0, 20|0], (80|9, 80|10], (100|0, Infinity|Infinity]')
+    })
+
+    test('right-side gap contraction', () => {
+        expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 0))).toEqual(true)
+        expect(detector.toString()).toEqual('(10|0, 15|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
+
+        expect(detector.markAndCheck(new NumberPair(40, 1), new NumberPair(80, 10))).toEqual(true)
+        expect(detector.toString()).toEqual('(10|0, 15|0], (40|0, 40|1], (100|0, Infinity|Infinity]')
+    })
+
+    test('full contraction', () => {
+        expect(detector.markAndCheck(new NumberPair(40, 0), new NumberPair(80, 10)))
+        expect(detector.toString()).toEqual('(10|0, 20|0], (100|0, Infinity|Infinity]')
+
+        expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0)))
+        expect(detector.toString()).toEqual('(100|0, Infinity|Infinity]')
+    })
+})
+
+describe('duplicates return false and do not change state', () => {
+    let detector: DuplicateMessageDetector
+    let expectedState: string
+    beforeEach(() => {
+        detector = new DuplicateMessageDetector()
+        detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
+        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
+        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
+        expectedState = detector.toString()
+        expect(expectedState).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
+    })
+
+    it('way below 1st gap', () => {
+        expect(detector.markAndCheck(new NumberPair(5, 0), new NumberPair(7, 0))).toEqual(false)
+        expect(detector.toString()).toEqual(expectedState)
+    })
+
+    it('number touches lower bound of 1st gap', () => {
+        expect(detector.markAndCheck(new NumberPair(8, 0), new NumberPair(10, 0))).toEqual(false)
+        expect(detector.toString()).toEqual(expectedState)
+    })
+
+    it('in-between gaps', () => {
+        expect(detector.markAndCheck(new NumberPair(25, 5), new NumberPair(30, 0))).toEqual(false)
+        expect(detector.toString()).toEqual(expectedState)
+    })
+
+    it('number touches lower bound of 2nd gap', () => {
+        expect(detector.markAndCheck(new NumberPair(25, 0), new NumberPair(40, 0))).toEqual(false)
+        expect(detector.toString()).toEqual(expectedState)
+    })
+
+    it('previous number touches upper bound of 2nd gap', () => {
+        expect(detector.markAndCheck(new NumberPair(80, 10), new NumberPair(90, 0))).toEqual(false)
+        expect(detector.toString()).toEqual(expectedState)
+    })
+
+    it('previous number not provided, number is below last gap', () => {
+        expect(detector.markAndCheck(null, new NumberPair(80, 10))).toEqual(false)
+        expect(detector.toString()).toEqual(expectedState)
+    })
+
+    it('previous number not provided, number touches lower bound of last gap', () => {
+        expect(detector.markAndCheck(null, new NumberPair(100, 0))).toEqual(false)
+        expect(detector.toString()).toEqual(expectedState)
+    })
+})
+
+describe('erroneous messages that overlap gaps', () => {
+    let detector: DuplicateMessageDetector
+    let expectedState
+    beforeEach(() => {
+        detector = new DuplicateMessageDetector()
+        detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
+        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
+        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
+        expectedState = detector.toString()
+        expect(expectedState).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
+    })
+
+    it('completely around gap', () => {
+        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(30, 0))).toThrowError(GapMisMatchError)
+    })
+
+    it('previousNumber below gap while number in gap', () => {
+        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(15, 0))).toThrowError(GapMisMatchError)
+    })
+
+    it('previousNumber in gap while number over gap', () => {
+        expect(() => detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 5))).toThrowError(GapMisMatchError)
+    })
+
+    it('completely around multiple gaps', () => {
+        expect(() => detector.markAndCheck(new NumberPair(10, 0), new NumberPair(200, 0))).toThrowError(GapMisMatchError)
+    })
+})
+
+test('checks that number > previousNumber', () => {
+    const detector = new DuplicateMessageDetector()
+    expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(1, 0)))
+        .toThrowError(InvalidNumberingError)
+    expect(() => detector.markAndCheck(new NumberPair(5, 5), new NumberPair(5, 5)))
+        .toThrowError(InvalidNumberingError)
+})
+
+test('lowest gaps get dropped when reaching maximum number of gaps', () => {
+    const detector = new DuplicateMessageDetector(3)
+    detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
+    detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
+    detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
+    expect(detector.toString()).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
+
+    detector.markAndCheck(new NumberPair(150, 0), new NumberPair(200, 0))
+    expect(detector.toString()).toEqual('(40|0, 80|10], (100|0, 150|0], (200|0, Infinity|Infinity]')
+
+    detector.markAndCheck(new NumberPair(50, 0), new NumberPair(70, 0))
+    expect(detector.toString()).toEqual('(70|0, 80|10], (100|0, 150|0], (200|0, Infinity|Infinity]')
+})

package/test/unit/FifoMapWithTtl.test.ts

@@ -0,0 +1,229 @@
+import { FifoMapWithTTL } from '../../src/logic/propagation/FifoMapWithTTL'
+
+describe('FifoMapWithTtl', () => {
+    describe('invalid constructor arguments', () => {
+        it('cannot instantiate with negative ttl', () => {
+            expect(() => new FifoMapWithTTL({ ttlInMs: -5, maxSize: 10 }))
+                .toThrow('ttlInMs (-5) cannot be < 0')
+        })
+
+        it('cannot instantiate with negative maxSize', () => {
+            expect(() => new FifoMapWithTTL({ ttlInMs: 100, maxSize: -6 }))
+                .toThrow('maxSize (-6) cannot be < 0')
+        })
+    })
+
+    it('of maxSize=0 always remains empty', () => {
+        const fifoMap = new FifoMapWithTTL<string, string>({
+            ttlInMs: 100,
+            maxSize: 0
+        })
+        fifoMap.set('hello', 'world')
+        fifoMap.set('are', 'you empty?')
+        expect(fifoMap.get('hello')).toBeUndefined()
+        expect(fifoMap.get('are')).toBeUndefined()
+    })
+
+    describe('of maxSize=5', () => {
+        let fifoMap: FifoMapWithTTL<string, string>
+
+        beforeEach(() => {
+            fifoMap = new FifoMapWithTTL<string, string>({
+                ttlInMs: 100,
+                maxSize: 5
+            })
+        })
+
+        function setFirstFiveMessages() {
+            fifoMap.set('1st', 'foo')
+            fifoMap.set('2nd', 'bar')
+            fifoMap.set('3rd', 'hello')
+            fifoMap.set('4th', 'world')
+            fifoMap.set('5th', '!')
+        }
+
+        function set6thAnd7thMessages() {
+            fifoMap.set('6th', 'new')
+            fifoMap.set('7th', 'messages')
+        }
+
+        it('can insert 5 items and retrieve all of them', () => {
+            setFirstFiveMessages()
+            expect(fifoMap.get('1st')).toEqual('foo')
+            expect(fifoMap.get('2nd')).toEqual('bar')
+            expect(fifoMap.get('3rd')).toEqual('hello')
+            expect(fifoMap.get('4th')).toEqual('world')
+            expect(fifoMap.get('5th')).toEqual('!')
+        })
+
+        it('inserting items when full causes oldest items to get dropped', () => {
+            setFirstFiveMessages()
+            set6thAnd7thMessages()
+            expect(fifoMap.get('1st')).toBeUndefined()
+            expect(fifoMap.get('2nd')).toBeUndefined()
+            expect(fifoMap.get('3rd')).toEqual('hello')
+            expect(fifoMap.get('4th')).toEqual('world')
+            expect(fifoMap.get('5th')).toEqual('!')
+            expect(fifoMap.get('6th')).toEqual('new')
+            expect(fifoMap.get('7th')).toEqual('messages')
+        })
+
+        describe('(re-)setting an item', () => {
+            beforeEach(() => {
+                setFirstFiveMessages()
+                fifoMap.set('4th', 'modified-once')
+                fifoMap.set('4th', 'modified-twice')
+            })
+
+            it('does not cause oldest items to drop', () => {
+                expect(fifoMap.get('1st')).toEqual('foo')
+                expect(fifoMap.get('2nd')).toEqual('bar')
+                expect(fifoMap.get('3rd')).toEqual('hello')
+                expect(fifoMap.get('5th')).toEqual('!')
+            })
+
+            it('newest value stays in place', () => {
+                expect(fifoMap.get('4th')).toEqual('modified-twice')
+            })
+        })
+
+        describe('#delete', () => {
+            it('can delete an item', () => {
+                setFirstFiveMessages()
+                fifoMap.delete('4th')
+                expect(fifoMap.get('1st')).toEqual('foo')
+                expect(fifoMap.get('2nd')).toEqual('bar')
+                expect(fifoMap.get('3rd')).toEqual('hello')
+                expect(fifoMap.get('4th')).toBeUndefined()
+                expect(fifoMap.get('5th')).toEqual('!')
+            })
+
+            it('deleting items makes room for new ones', () => {
+                setFirstFiveMessages()
+                fifoMap.delete('2nd')
+                fifoMap.delete('4th')
+                set6thAnd7thMessages()
+                expect(fifoMap.get('1st')).toEqual('foo')
+                expect(fifoMap.get('2nd')).toBeUndefined()
+                expect(fifoMap.get('3rd')).toEqual('hello')
+                expect(fifoMap.get('4th')).toBeUndefined()
+                expect(fifoMap.get('5th')).toEqual('!')
+                expect(fifoMap.get('6th')).toEqual('new')
+                expect(fifoMap.get('7th')).toEqual('messages')
+            })
+
+            it('deleting a non-existing item does not throw', () => {
+                setFirstFiveMessages()
+                expect(() =>fifoMap.delete('non-existing-key')).not.toThrow()
+            })
+
+            it('deleting a non-existing item keeps existing items intact', () => {
+                setFirstFiveMessages()
+                fifoMap.delete('non-existing-key')
+                expect(fifoMap.get('1st')).toEqual('foo')
+                expect(fifoMap.get('2nd')).toEqual('bar')
+                expect(fifoMap.get('3rd')).toEqual('hello')
+                expect(fifoMap.get('4th')).toEqual('world')
+                expect(fifoMap.get('5th')).toEqual('!')
+            })
+        })
+
+        describe('TTL', () => {
+            let time: number
+
+            beforeEach(() => {
+                time = 0
+                fifoMap = new FifoMapWithTTL<string, string>({
+                    ttlInMs: 100,
+                    maxSize: 5,
+                    timeProvider: () => time
+                })
+            })
+
+            it('#get returns undefined after TTL', () => {
+                time = 0
+                fifoMap.set('hello', 'world')
+                time = 50
+                fifoMap.set('foo', 'bar')
+
+                time = 100
+                expect(fifoMap.get('hello')).toBeUndefined()
+                expect(fifoMap.get('foo')).toEqual('bar')
+
+                time = 160
+                expect(fifoMap.get('hello')).toBeUndefined()
+                expect(fifoMap.get('foo')).toBeUndefined()
+            })
+
+            it('re-setting an item resets TTL', () => {
+                time = 0
+                fifoMap.set('hello', 'world')
+
+                time = 90
+                fifoMap.set('hello', 'world')
+
+                time = 100
+                expect(fifoMap.get('hello')).toEqual('world')
+            })
+
+            it('re-setting expired resets TTL', () => {
+                time = 0
+                fifoMap.set('hello', 'world')
+
+                time = 110
+                expect(fifoMap.get('hello')).toBeUndefined() // sanity check
+                fifoMap.set('hello', 'world')
+
+                time = 150
+                expect(fifoMap.get('hello')).toEqual('world')
+            })
+        })
+
+        describe('onItemDropped callback', () => {
+            let time: number
+            let onItemDropped: jest.Mock<undefined, [string]>
+
+            beforeEach(() => {
+                time = 0
+                onItemDropped = jest.fn<undefined, [string]>()
+                fifoMap = new FifoMapWithTTL<string, string>({
+                    ttlInMs: 100,
+                    maxSize: 5,
+                    onItemDropped,
+                    timeProvider: () => time
+                })
+            })
+
+            it('invoked when deleting an item', () => {
+                setFirstFiveMessages()
+                fifoMap.delete('3rd')
+                expect(onItemDropped).toHaveBeenCalledTimes(1)
+                expect(onItemDropped).toHaveBeenCalledWith('3rd')
+            })
+
+            it('invoked when items are dropped due to being full', () => {
+                setFirstFiveMessages()
+                set6thAnd7thMessages()
+                expect(onItemDropped).toHaveBeenCalledTimes(2)
+                expect(onItemDropped).toHaveBeenNthCalledWith(1, '1st')
+                expect(onItemDropped).toHaveBeenNthCalledWith(2, '2nd')
+            })
+
+            it('invoked when re-setting an item', () => {
+                setFirstFiveMessages()
+                fifoMap.set('4th', '!!!')
+                expect(onItemDropped).toHaveBeenCalledTimes(1)
+                expect(onItemDropped).toHaveBeenNthCalledWith(1, '4th')
+            })
+
+            it('invoked when getting a stale item', () => {
+                time = 0
+                setFirstFiveMessages()
+                time = 500
+                expect(fifoMap.get('1st')).toBeUndefined()
+                expect(onItemDropped).toHaveBeenCalledTimes(1)
+                expect(onItemDropped).toHaveBeenNthCalledWith(1, '1st')
+            })
+        })
+    })
+})

package/test/unit/GroupKeyRequestTranslator.test.ts

@@ -0,0 +1,36 @@
+import { GroupKeyRequest as OldGroupKeyRequest } from '@streamr/protocol'
+import { EthereumAddress } from '@streamr/utils'
+import { GroupKeyRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { GroupKeyRequestTranslator } from '../../src/logic/protocol-integration/stream-message/GroupKeyRequestTranslator'
+
+describe('GroupKeyRequestTranslator', () => {
+
+    const oldGroupKeyRequest = new OldGroupKeyRequest({
+        rsaPublicKey: 'aaaaaaaa',
+        recipient: 'recipient' as EthereumAddress,
+        requestId: 'request',
+        groupKeyIds: ['id1', 'id2', 'id3']
+    })
+    const newGroupKeyRequest: GroupKeyRequest = {
+        rsaPublicKey: 'aaaaaaaa',
+        recipient: 'recipient',
+        requestId: 'request',
+        groupKeyIds: ['id1', 'id2', 'id3']
+    }
+
+    it('translates old protocol to protobuf', () => {
+        const translated = GroupKeyRequestTranslator.toProtobuf(oldGroupKeyRequest)
+        expect(translated.rsaPublicKey).toEqual(newGroupKeyRequest.rsaPublicKey)
+        expect(translated.recipient).toEqual(newGroupKeyRequest.recipient)
+        expect(translated.requestId).toEqual(newGroupKeyRequest.requestId)
+        expect(translated.groupKeyIds).toEqual(newGroupKeyRequest.groupKeyIds)
+    })
+
+    it('translates protobuf to old protocol', () => {
+        const translated = GroupKeyRequestTranslator.toClientProtocol(newGroupKeyRequest)
+        expect(translated.rsaPublicKey).toEqual(oldGroupKeyRequest.rsaPublicKey)
+        expect(translated.recipient).toEqual(oldGroupKeyRequest.recipient)
+        expect(translated.requestId).toEqual(oldGroupKeyRequest.requestId)
+        expect(translated.groupKeyIds).toEqual(oldGroupKeyRequest.groupKeyIds)
+    })
+})

package/test/unit/GroupKeyResponseTranslator.test.ts

@@ -0,0 +1,39 @@
+import { GroupKeyResponseTranslator } from '../../src/logic/protocol-integration/stream-message/GroupKeyResponseTranslator'
+import {
+    GroupKeyResponse as OldGroupKeyResponse,
+    EncryptedGroupKey as OldEncryptedGroupKey
+} from '@streamr/protocol'
+import { EthereumAddress } from '@streamr/utils'
+import { EncryptedGroupKey, GroupKeyResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+
+describe('GroupKeyResponseTranslator', () => {
+
+    const oldGroupKeyResponse = new OldGroupKeyResponse({
+        requestId: 'request',
+        recipient: 'recipient' as EthereumAddress,
+        encryptedGroupKeys: [ new OldEncryptedGroupKey('id', '0000') ]
+    })
+    const newEncryptedGroupKey: EncryptedGroupKey = {
+        groupKeyId: 'id',
+        encryptedGroupKeyHex: '0000'
+    }
+    const newGroupKeyResponse: GroupKeyResponse = {
+        requestId: 'request',
+        recipient: 'recipient',
+        encryptedGroupKeys: [ newEncryptedGroupKey ]
+    }
+
+    it('translates old protocol to protobuf', () => {
+        const translated = GroupKeyResponseTranslator.toProtobuf(oldGroupKeyResponse)
+        expect(translated.encryptedGroupKeys).toEqual(newGroupKeyResponse.encryptedGroupKeys)
+        expect(translated.recipient).toEqual(newGroupKeyResponse.recipient)
+        expect(translated.requestId).toEqual(newGroupKeyResponse.requestId)
+    })
+
+    it('translates protobuf to old protocol', () => {
+        const translated = GroupKeyResponseTranslator.toClientProtocol(newGroupKeyResponse)
+        expect(translated.encryptedGroupKeys).toEqual(oldGroupKeyResponse.encryptedGroupKeys)
+        expect(translated.recipient).toEqual(oldGroupKeyResponse.recipient)
+        expect(translated.requestId).toEqual(oldGroupKeyResponse.requestId)
+    })
+})