bug fixes and unit tests

examples/get_action_traces.ts

@@ -1,7 +1,7 @@
 import { socketFactory } from "./config"
-import { EOSClient, InboundMessage, InboundMessageType, ActionTrace } from "@dfuse/eosws-js"
+import { EoswsClient, InboundMessage, InboundMessageType, ActionTrace } from "@dfuse/eosws-js"
 
-const client = new EOSClient(socketFactory)
+const client = new EoswsClient(socketFactory)
 
 interface Transfer {
   from: string

examples/get_multiple.ts

@@ -1,8 +1,7 @@
 import { socketFactory } from "./config"
-import { EOSClient, OutboundMessageType } from "@dfuse/eosws-js"
-import { InboundMessageType } from "../src/client"
+import { EoswsClient, OutboundMessageType, InboundMessageType } from "@dfuse/eosws-js"
 
-const client = new EOSClient(socketFactory)
+const client = new EoswsClient(socketFactory)
 
 client.connect().then(() => {
   const requestRows = client.getTableRows({ code: "eosio", scope: "eosio", tableName: "global" })
@@ -16,7 +15,7 @@ client.connect().then(() => {
     requestRows!.unlisten()
   }, 1000)
 
-  const requestActions = client.getActions({ account: "eosio.token", actionName: "transfer" })
+  const requestActions = client.getActionTraces({ account: "eosio.token", actionName: "transfer" })
 
   requestActions!.listen((type: InboundMessageType) => {
     console.log("received message of type: ", type)

examples/get_table_rows.ts

@@ -1,7 +1,7 @@
-import { EOSClient } from "../src/client/eos-client"
+import { EoswsClient } from "../src/client/eosws-client"
 import { socketFactory } from "./config"
 
-const client = new EOSClient(socketFactory)
+const client = new EoswsClient(socketFactory)
 
 client.connect().then(() => {
   const request = client.getTableRows({ code: "eosio", scope: "eosio", tableName: "global" })

examples/get_transaction.ts

@@ -1,9 +1,13 @@
-import { EOSClient } from "../src/client/eos-client"
 import { socketFactory } from "./config"
-import { InboundMessage, InboundMessageType } from "../src/client"
-import { TransactionLifeCycle } from "../src"
+import {
+  EoswsClient,
+  OutboundMessageType,
+  InboundMessageType,
+  TransactionLifeCycle,
+  InboundMessage
+} from "@dfuse/eosws-js"
 
-const client = new EOSClient(socketFactory)
+const client = new EoswsClient(socketFactory)
 
 client.connect().then(() => {
   const request = client.getTransaction(

src/client/__tests__/client.test.ts

@@ -1,4 +1,4 @@
-import { createClient, getActionsMessage, InboundMessage, InboundMessageType } from ".."
+import { createClient, getActionTracesMessage, InboundMessage, InboundMessageType } from ".."
 
 describe("client", () => {
   let controller: ReturnType<typeof createSocketController>
@@ -145,7 +145,7 @@ describe("client", () => {
     setTimeout(() => {
       openConnection()
     }, 0)
-    await client.send(getActionsMessage({ account: "test" }))
+    await client.send(getActionTracesMessage({ account: "test" }))
 
     expect(controller.send).toHaveBeenCalledTimes(1)
   })
@@ -161,7 +161,7 @@ describe("client", () => {
       openConnection()
     }, 0)
 
-    await client.send(getActionsMessage({ account: "test" }))
+    await client.send(getActionTracesMessage({ account: "test" }))
     expect(controller.send).toHaveBeenCalledTimes(1)
   })
 
@@ -173,11 +173,11 @@ describe("client", () => {
 
     expect.hasAssertions()
     await expect(client.connect(noopListener)).resolves.toBeUndefined()
-    await client.send(getActionsMessage({ account: "test" }))
+    await client.send(getActionTracesMessage({ account: "test" }, { listen: true }))
 
     expect(controller.send).toHaveBeenCalledTimes(1)
     expect(controller.send).toHaveBeenCalledWith(
-      '{"type":"get_actions","listen":true,"data":{"account":"test"}}'
+      '{"type":"get_action_traces","listen":true,"data":{"account":"test"}}'
     )
   })
 

src/client/__tests__/eosws-client.test.ts

@@ -0,0 +1,115 @@
+import { EoswsClient } from "../eosws-client"
+import { InboundMessage } from "../inbound"
+import {
+  GetActionTracesMessageBackendParameters,
+  OutboundMessage,
+  OutboundMessageType
+} from "../outbound"
+
+describe("EoswsClient", function() {
+  let controller: ReturnType<typeof createSocketController>
+  let factory: () => WebSocket
+  let receivedMessages: Array<InboundMessage<any>>
+
+  beforeEach(() => {
+    controller = createSocketController()
+    factory = () => controller as any
+    receivedMessages = []
+  })
+
+  describe("constructor", () => {
+    it("should build the client", () => {
+      const client = new EoswsClient(factory)
+      expect(client.client).toBeDefined()
+    })
+  })
+
+  describe("connect", () => {
+    it("should add a listener", () => {
+      const client = new EoswsClient(factory)
+      spyOn(client.client, "connect")
+      client.connect()
+      expect(client.client.connect).toHaveBeenCalled()
+    })
+  })
+
+  describe("send", () => {
+    it("return a listener if listen is set to true", () => {
+      const client = new EoswsClient(factory)
+      expect(
+        client.send<OutboundMessage<GetActionTracesMessageBackendParameters>>(basicGetActionMessage)
+      ).toEqual({ requestId: "abc", listen: expect.any(Function), unlisten: expect.any(Function) })
+    })
+
+    it("should return null if listen is set to false", () => {
+      const client = new EoswsClient(factory)
+      expect(
+        client.send<OutboundMessage<GetActionTracesMessageBackendParameters>>(
+          Object.assign({}, basicGetActionMessage, { listen: false })
+        )
+      ).toEqual(null)
+    })
+  })
+
+  describe("getActionTraces", () => {
+    it("should return the same object as the basic send", () => {
+      const client = new EoswsClient(factory)
+
+      expect(
+        client.getActionTraces(
+          { receiver: "test", account: "account_name", actionName: "test" },
+          { listen: true, requestId: "abc" }
+        )
+      ).toEqual({ requestId: "abc", listen: expect.any(Function), unlisten: expect.any(Function) })
+    })
+  })
+
+  describe("getTableRows", () => {
+    it("should return the same object as the basic send", () => {
+      const client = new EoswsClient(factory)
+
+      expect(
+        client.getTableRows(
+          { scope: "test", code: "code", tableName: "test" },
+          { listen: true, requestId: "abc" }
+        )
+      ).toEqual({ requestId: "abc", listen: expect.any(Function), unlisten: expect.any(Function) })
+    })
+  })
+
+  describe("getTransaction", () => {
+    it("should return the same object as the basic send", () => {
+      const client = new EoswsClient(factory)
+
+      expect(client.getTransaction("id", { listen: true, requestId: "abc" })).toEqual({
+        requestId: "abc",
+        listen: expect.any(Function),
+        unlisten: expect.any(Function)
+      })
+    })
+  })
+})
+
+const basicGetActionMessage = {
+  type: OutboundMessageType.GET_ACTION_TRACES,
+  listen: true,
+  req_id: "abc",
+  data: { receiver: "test", account: "account_name", action_name: "test" }
+}
+
+interface WebSocketController {
+  close: jest.Mock<() => void>
+  send: jest.Mock<(data: any) => void>
+
+  onclose?: (event: CloseEvent) => void
+  onerror?: (event: Event) => void
+  onopen?: () => void
+  onmessage?: (event: MessageEvent) => void
+}
+
+function createSocketController(): WebSocketController {
+  return {
+    close: jest.fn<() => void>(),
+    send: jest.fn<(data: any) => void>()
+  }
+}

src/client/__tests__/eosws-listeners.test.ts

@@ -0,0 +1,90 @@
+import { EoswsListeners, ListenerObject } from "../eosws-listeners"
+import { InboundMessageType } from "../inbound"
+
+describe("EoswsListeners", function() {
+  describe("addListener", () => {
+    it("should add a listener to the list", () => {
+      const listenerObject: ListenerObject = {
+        requestId: "abc",
+        messageTypes: [InboundMessageType.TABLE_DELTA],
+        callback: () => {
+          console.log("test")
+        }
+      }
+
+      const listeners = new EoswsListeners()
+
+      listeners.addListener(listenerObject)
+
+      expect(listeners.registeredListeners).toEqual([listenerObject])
+    })
+  })
+
+  describe("removeListener", () => {
+    it("should add a listener to the list", () => {
+      const listenerObject1: ListenerObject = {
+        requestId: "abc",
+        messageTypes: [InboundMessageType.TABLE_DELTA],
+        callback: () => {
+          console.log("test")
+        }
+      }
+
+      const listenerObject2: ListenerObject = {
+        requestId: "abcd",
+        messageTypes: [InboundMessageType.TABLE_DELTA],
+        callback: () => {
+          console.log("test")
+        }
+      }
+
+      const listeners = new EoswsListeners()
+
+      listeners.addListener(listenerObject1)
+      listeners.addListener(listenerObject2)
+      expect(listeners.registeredListeners).toEqual([listenerObject1, listenerObject2])
+
+      listeners.removeListener("abc")
+
+      expect(listeners.registeredListeners).toEqual([listenerObject2])
+    })
+  })
+
+  describe("handleMessage", () => {
+    it("should process the callback given the right id and type", () => {
+      const listenerObject1: ListenerObject = {
+        requestId: "abc",
+        messageTypes: [InboundMessageType.TABLE_DELTA],
+        callback: () => {
+          console.log("test")
+        }
+      }
+
+      spyOn(listenerObject1, "callback")
+
+      const listenerObject2: ListenerObject = {
+        requestId: "abcd",
+        messageTypes: [InboundMessageType.TABLE_DELTA],
+        callback: () => {
+          console.log("test")
+        }
+      }
+      const listeners = new EoswsListeners()
+
+      listeners.addListener(listenerObject1)
+      listeners.addListener(listenerObject2)
+
+      listeners.handleMessage(InboundMessageType.TABLE_DELTA, {
+        type: InboundMessageType.TABLE_DELTA,
+        req_id: "abc",
+        data: { test: "foo" }
+      })
+
+      expect(listenerObject1.callback).toHaveBeenCalledWith(InboundMessageType.TABLE_DELTA, {
+        type: InboundMessageType.TABLE_DELTA,
+        req_id: "abc",
+        data: { test: "foo" }
+      })
+    })
+  })
+})

src/client/client.ts

@@ -27,11 +27,8 @@ export type ClientMessageListener = (type: InboundMessageType, message: InboundM
 
 export interface ClientOptions {
   id?: string
-
   autoReconnect?: boolean
-
   onInvalidMessage?: (message: object) => void
-
   onReconnect?: () => void
   onError?: () => void
   onClose?: () => void

src/client/eos-client.ts → src/client/eosws-client.ts

@@ -8,44 +8,36 @@ import {
   GetTableRowsMessageParameters,
   getTransactionMessage,
   OutboundMessage,
-  OutboundMessageType,
   StreamOptions,
   unlistenMessage
 } from "./outbound"
 import { InboundMessage, InboundMessageType } from "./inbound"
+import { EoswsListeners } from "./eosws-listeners"
 
-export class EOSClient {
-  private client: Client
-  private registeredListeners: ListenerObject[] = []
+export class EoswsClient {
+  public client: Client
+  public listeners: EoswsListeners
 
   constructor(socketFactory: SocketFactory, options?: ClientOptions) {
     this.client = createClient(socketFactory, options)
-  }
-
-  private registerListener(listener: ListenerObject) {
-    this.registeredListeners.push(listener)
+    this.listeners = new EoswsListeners()
   }
 
   public connect(): Promise<void> {
     const onMessage = (type: InboundMessageType, message: InboundMessage<any>) => {
-      this.registeredListeners.forEach((listener: ListenerObject) => {
-        if (listener.messageTypes.indexOf(type) > -1 && message.req_id === listener.requestId) {
-          listener.callback(type, message)
-        }
-      })
+      this.listeners.handleMessage(type, message)
     }
 
     return this.client.connect(onMessage)
   }
 
   public send<T extends OutboundMessage<{}>>(
-    type: OutboundMessageType,
     messageOptions: T,
     ...messageTypes: InboundMessageType[]
   ) {
     return this.sendAndListen<T>(
       messageOptions,
-      messageOptions.req_id === undefined ? type : messageOptions.req_id,
+      messageOptions.req_id === undefined ? messageOptions.type : messageOptions.req_id,
       messageOptions.listen === undefined ? true : messageOptions.listen,
       ...messageTypes
     )
@@ -110,7 +102,7 @@ export class EOSClient {
   ) {
     const listen = (callback: ClientMessageListener) => {
       try {
-        this.registerListener({ messageTypes, requestId, callback })
+        this.listeners.addListener({ messageTypes, requestId, callback })
       } finally {
         this.client.send(parameters)
       }
@@ -124,6 +116,7 @@ export class EOSClient {
   }
 
   private unlisten(requestId: string) {
+    this.listeners.removeListener(requestId)
     this.client.send(unlistenMessage(requestId))
   }
 }
@@ -135,9 +128,3 @@ function withDefaults(defaults: any, options: StreamOptions): StreamOptions {
 
   return Object.assign({}, { requestId: randomRequestId }, defaults, options)
 }
-
-interface ListenerObject {
-  messageTypes: InboundMessageType[]
-  requestId: string
-  callback: ClientMessageListener
-}