@streamr/cli-tools 0.0.1-tatum.0

package/test/storage-node.test.ts

@@ -0,0 +1,32 @@
+import { fetchPrivateKeyWithGas } from '@streamr/test-utils'
+import 'jest-extended'
+import { StreamID } from 'streamr-client'
+import { DOCKER_DEV_STORAGE_NODE, createTestClient, runCommand } from './utils'
+
+const isStored = async (streamId: StreamID): Promise<boolean> => {
+    const output = await runCommand(`storage-node list-streams ${DOCKER_DEV_STORAGE_NODE}`)
+    return output.join().includes(streamId)
+}
+
+describe('storage node', () => {
+
+    it('add and remove stream', async () => {
+        const privateKey = await fetchPrivateKeyWithGas()
+        const client = createTestClient(privateKey)
+        const stream = await client.createStream(`/${Date.now()}`)
+        await client.destroy()
+        await runCommand(`storage-node add-stream ${DOCKER_DEV_STORAGE_NODE} ${stream.id}`, {
+            privateKey
+        })
+        expect(await isStored(stream.id)).toBeTrue()
+        await runCommand(`storage-node remove-stream ${DOCKER_DEV_STORAGE_NODE} ${stream.id}`, {
+            privateKey
+        })
+        expect(await isStored(stream.id)).toBeFalse()
+    }, 80 * 1000)
+
+    it('list nodes', async () => {
+        const outputLines = await runCommand('storage-node list')
+        expect(outputLines.join()).toMatch(DOCKER_DEV_STORAGE_NODE.toLowerCase())
+    })
+})

package/test/stream-create.test.ts

@@ -0,0 +1,26 @@
+import { Wallet } from '@ethersproject/wallet'
+import { fetchPrivateKeyWithGas } from '@streamr/test-utils'
+import { createTestClient, runCommand } from './utils'
+
+describe('create stream', () => {
+
+    it('happy path', async () => {
+        const privateKey = await fetchPrivateKeyWithGas()
+        const address = new Wallet(privateKey).address.toLowerCase()
+        const path = `/${Date.now()}`
+        const streamId = `${address}${path}`
+        const outputLines = await runCommand(`stream create ${path}`, {
+            privateKey
+        })
+        const outputJson = JSON.parse(outputLines.join(''))
+        expect(outputJson).toMatchObject({
+            id: streamId,
+            partitions: 1
+        })
+        const client = createTestClient()
+        const stream = await client.getStream(streamId)
+        expect(stream.getMetadata().partitions).toBe(1)
+        await client.destroy()
+    }, 20 * 1000)
+
+})

package/test/stream-permission.test.ts

@@ -0,0 +1,29 @@
+import { fetchPrivateKeyWithGas, randomEthereumAddress } from '@streamr/test-utils'
+import 'jest-extended'
+import { StreamPermission } from 'streamr-client'
+import { createTestClient, runCommand } from './utils'
+
+describe('permission', () => {
+
+    it('grant and revoke', async () => {
+        const privateKey = await fetchPrivateKeyWithGas()
+        const client = createTestClient(privateKey)
+        const stream = await client.createStream(`/${Date.now()}`)
+        const otherUser = randomEthereumAddress()
+        const hasPermission = () => client.hasPermission({
+            user: otherUser,
+            permission: StreamPermission.PUBLISH,
+            streamId: stream.id,
+            allowPublic: false
+        })
+        await runCommand(`stream grant-permission ${stream.id} ${otherUser} publish`, {
+            privateKey
+        })
+        expect(await hasPermission()).toBeTrue()
+        await runCommand(`stream revoke-permission ${stream.id} ${otherUser} publish`, {
+            privateKey
+        })
+        expect(await hasPermission()).toBeFalse()
+        await client.destroy()
+    }, 40 * 1000)
+})

package/test/stream-publish-subscribe.test.ts

@@ -0,0 +1,86 @@
+import { Wallet } from '@ethersproject/wallet'
+import { fetchPrivateKeyWithGas } from '@streamr/test-utils'
+import { collect } from '@streamr/utils'
+import { StreamPermission } from 'streamr-client'
+import { createTestClient, runCommand, startCommand } from './utils'
+
+const TIMEOUT = 30 * 1000
+
+describe('publish and subscribe', () => {
+
+    let publisherPrivateKey: string
+    let subscriberPrivateKey: string
+    let streamId: string
+
+    beforeAll(async () => {
+        publisherPrivateKey = await fetchPrivateKeyWithGas()
+        subscriberPrivateKey = await fetchPrivateKeyWithGas()
+        const client = createTestClient(publisherPrivateKey)
+        const stream = await client.createStream(`/${Date.now()}`)
+        await stream.grantPermissions({
+            user: new Wallet(subscriberPrivateKey).address,
+            permissions: [StreamPermission.SUBSCRIBE]
+        })
+        streamId = stream.id
+        await client.destroy()
+    }, TIMEOUT)
+
+    function publishViaCliCommand() {
+        setImmediate(async () => {
+            await runCommand(`stream publish ${streamId}`, {
+                inputLines: [JSON.stringify({ foo: 123 })],
+                privateKey: publisherPrivateKey
+            })
+        })
+    }
+
+    it('happy path', async () => {
+        const subscriberAbortController = new AbortController()
+        const subscriberOutputIterable = startCommand(`stream subscribe ${streamId}`, {
+            privateKey: subscriberPrivateKey,
+            abortSignal: subscriberAbortController.signal
+        })
+        publishViaCliCommand()
+        const receivedMessage = (await collect(subscriberOutputIterable, 1))[0]
+        subscriberAbortController.abort()
+        expect(JSON.parse(receivedMessage)).toEqual({
+            foo: 123
+        })
+    }, TIMEOUT)
+
+    it('raw subscription', async () => {
+        const subscriberAbortController = new AbortController()
+        const subscriberOutputIterable = startCommand(`stream subscribe ${streamId} --raw`, {
+            privateKey: subscriberPrivateKey,
+            abortSignal: subscriberAbortController.signal,
+        })
+        publishViaCliCommand()
+        const receivedMessage = (await collect(subscriberOutputIterable, 1))[0]
+        subscriberAbortController.abort()
+        expect(receivedMessage).toMatch(/^[0-9a-fA-F]+$/)
+    }, TIMEOUT)
+
+    it('with metadata', async () => {
+        const subscriberAbortController = new AbortController()
+        const subscriberOutputIterable = startCommand(`stream subscribe ${streamId} --with-metadata`, {
+            privateKey: subscriberPrivateKey,
+            abortSignal: subscriberAbortController.signal,
+        })
+        publishViaCliCommand()
+        const receivedMessage = (await collect(subscriberOutputIterable, 1))[0]
+        subscriberAbortController.abort()
+        expect(JSON.parse(receivedMessage)).toMatchObject({
+            message: {
+                foo: 123
+            },
+            metadata: {
+                streamId,
+                streamPartition: 0,
+                timestamp: expect.any(Number),
+                sequenceNumber: 0,
+                publisherId: new Wallet(publisherPrivateKey).address.toLowerCase(),
+                msgChainId: expect.stringMatching(/[0-9a-zA-Z]+/)
+            }
+        })
+    }, TIMEOUT)
+})

package/test/stream-resend.test.ts

@@ -0,0 +1,66 @@
+import { fetchPrivateKeyWithGas } from '@streamr/test-utils'
+import range from 'lodash/range'
+import { Message, Stream } from 'streamr-client'
+import { DOCKER_DEV_STORAGE_NODE, createTestClient, runCommand } from './utils'
+import { wait } from '@streamr/utils'
+
+const parseJSONs = (lines: string[]): any[] => {
+    return lines.map((line) => JSON.parse(line))
+}
+
+describe('resend stream', () => {
+
+    let privateKey: string
+    let stream: Stream
+    const messages: Message[] = []
+
+    beforeAll(async () => {
+        privateKey = await fetchPrivateKeyWithGas()
+        const client = createTestClient(privateKey)
+        stream = await client.createStream(`/${Date.now()}`)
+        await stream.addToStorageNode(DOCKER_DEV_STORAGE_NODE)
+        for (const msgId of range(10)) {
+            await wait(10) // to prevent duplicate timestamps (to make test assertions simpler)
+            const msg = await stream.publish({ msgId })
+            messages.push(msg)
+        }
+        await wait(10000)
+        await client.destroy()
+    }, 30 * 1000)
+
+    it('last', async () => {
+        const outputLines = await runCommand(`stream resend last 3 ${stream.id}`, {
+            privateKey
+        })
+        expect(parseJSONs(outputLines)).toEqual([
+            { msgId: 7 },
+            { msgId: 8 },
+            { msgId: 9 }
+        ])
+    }, 20 * 1000)
+
+    it('from', async () => {
+        const minTimestamp = new Date(messages[8].timestamp).toISOString()
+        const outputLines = await runCommand(`stream resend from ${minTimestamp} ${stream.id}`, {
+            privateKey
+        })
+        expect(parseJSONs(outputLines)).toEqual([
+            { msgId: 8 },
+            { msgId: 9 }
+        ])
+    }, 20 * 1000)
+
+    it('range', async () => {
+        const minTimestamp = new Date(messages[2].timestamp).toISOString()
+        const maxTimestamp = new Date(messages[4].timestamp).toISOString()
+        const outputLines = await runCommand(`stream resend range ${minTimestamp} ${maxTimestamp} ${stream.id}`, {
+            privateKey
+        })
+        expect(parseJSONs(outputLines)).toEqual([
+            { msgId: 2 },
+            { msgId: 3 },
+            { msgId: 4 }
+        ])
+    }, 20 * 1000)
+
+})

package/test/stream-search.test.ts

@@ -0,0 +1,24 @@
+import { fetchPrivateKeyWithGas } from '@streamr/test-utils'
+import { randomString } from '@streamr/utils'
+import { createTestClient, runCommand, waitForTheGraphToHaveIndexed } from './utils'
+
+describe('search streams', () => {
+
+    it('happy path', async () => {
+        const testId = randomString(10)
+        const client = createTestClient(await fetchPrivateKeyWithGas())
+        const stream1 = await client.createStream(`/${testId}-1`)
+        const stream2 = await client.createStream(`/${testId}-2`)
+        await Promise.all([
+            waitForTheGraphToHaveIndexed(stream1, client),
+            waitForTheGraphToHaveIndexed(stream2, client)
+        ])
+        await client.destroy()
+        const outputLines = await runCommand(`stream search ${testId}`)
+        expect(outputLines).toEqual([
+            stream1.id,
+            stream2.id
+        ])
+    }, 20 * 1000)
+
+})

package/test/stream-show.test.ts

@@ -0,0 +1,31 @@
+import { Wallet } from '@ethersproject/wallet'
+import { fetchPrivateKeyWithGas } from '@streamr/test-utils'
+import { createTestClient, runCommand, waitForTheGraphToHaveIndexed } from './utils'
+
+describe('show stream', () => {
+
+    it('happy path', async () => {
+        const creatorPrivateKey = await fetchPrivateKeyWithGas()
+        const client = createTestClient(creatorPrivateKey)
+        const stream = await client.createStream(`/${Date.now()}`)
+        await waitForTheGraphToHaveIndexed(stream, client)
+        await client.destroy()
+        const outputLines = await runCommand(`stream show ${stream.id} --include-permissions`)
+        const outputJson = JSON.parse(outputLines.join(''))
+        expect(outputJson).toMatchObject({
+            id: stream.id,
+            partitions: 1,
+            permissions: [{
+                permissions: [
+                    'edit',
+                    'delete',
+                    'publish',
+                    'subscribe',
+                    'grant'
+                ],
+                user: new Wallet(creatorPrivateKey).address.toLowerCase()
+            }]
+        })
+    }, 20 * 1000)
+
+})

package/test/utils.ts

@@ -0,0 +1,85 @@
+import { collect, waitForCondition } from '@streamr/utils'
+import { spawn } from 'child_process'
+import merge2 from 'merge2'
+import { CONFIG_TEST, Stream, StreamrClient } from 'streamr-client'
+
+export const DOCKER_DEV_STORAGE_NODE = '0xde1112f631486CfC759A50196853011528bC5FA0'
+
+export interface StartCommandOptions {
+    privateKey?: string
+    devEnvironment?: boolean
+    inputLines?: string[]
+    abortSignal?: AbortSignal
+}
+
+export const runCommand = async (commandLine: string, opts?: StartCommandOptions): Promise<string[]> => {
+    const lines = startCommand(commandLine, opts)
+    return await collect(lines)
+}
+
+export async function* startCommand(commandLine: string, opts?: StartCommandOptions): AsyncGenerator<string> {
+    const args: string[] = ['dist/bin/streamr.js']
+    args.push(...commandLine.split(' '))
+    if (opts?.privateKey !== undefined) {
+        args.push('--private-key', opts.privateKey)
+    }
+    if (opts?.devEnvironment !== false) {
+        args.push('--dev')
+    }
+    const executable = spawn(`node`, args, {
+        signal: opts?.abortSignal,
+        env: {
+            PATH: process.env.PATH,
+            STREAMR_DOCKER_DEV_HOST: process.env.STREAMR_DOCKER_DEV_HOST
+        }
+    })
+    executable.on('error', (err: any) => {
+        // expected error when AbortSignal#abort is called
+        if (err.code !== 'ABORT_ERR') {
+            console.error(err)
+        }
+    })
+    const outputs = merge2(executable.stdout, executable.stderr)
+    if (opts?.inputLines !== undefined) {
+        setImmediate(() => {
+            executable.stdin.write(opts.inputLines!.join('\n') + '\n')
+        })
+    }
+    yield* lines(outputs[Symbol.asyncIterator]())
+}
+
+async function* lines(src: AsyncIterable<Buffer>): AsyncGenerator<string, any, any> {
+    let buffer = ''
+    for await (const chunk of src) {
+        buffer += chunk.toString('utf-8')
+        while (true) {
+            const delimeterPos = buffer.indexOf('\n')
+            if (delimeterPos === -1) {
+                break
+            }
+            const line = buffer.substring(0, delimeterPos)
+            yield line
+            buffer = buffer.substring(delimeterPos + 1)
+        }
+    }
+    if (buffer !== '') {
+        yield buffer
+    }
+}
+
+export const createTestClient = (privateKey?: string): StreamrClient => {
+    return new StreamrClient({
+        ...CONFIG_TEST,
+        auth: (privateKey !== undefined) ? { privateKey } : undefined
+    })
+}
+
+export const waitForTheGraphToHaveIndexed = async (stream: Stream, client: StreamrClient): Promise<void> => {
+    await waitForCondition(async () => {
+        // eslint-disable-next-line no-underscore-dangle
+        for await (const _msg of client.searchStreams(stream.id, undefined)) {
+            return true
+        }
+        return false
+    }, 15 * 1000, 600)
+}

package/test/wallet.test.ts

@@ -0,0 +1,11 @@
+import { runCommand } from './utils'
+
+describe('wallet', () => {
+
+    it('whoami', async () => {
+        const outputLines = await runCommand('wallet whoami')
+        expect(outputLines.length).toBe(1)
+        expect(outputLines[0]).toMatch(/^0x[0-9a-f]{40}$/)
+    })
+
+})

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "extends": "../../tsconfig.node.json",
+    "compilerOptions": {
+        "composite": true,
+        "outDir": "dist"
+    },
+    "include": [
+        "package.json",
+        "src/**/*",
+        "bin/**/*"
+    ],
+    "references": [
+        { "path": "../utils/tsconfig.node.json" },
+        { "path": "../client/tsconfig.node.json" }
+    ]
+}