feat: support for muliple websocket responses

Author: Insmael

lib/cryptomarket/websocket/callbackCache.rb

@@ -1,8 +1,10 @@
+require_relative "reusableCallback"
+
 module Cryptomarket
     module Websocket
         class CallbackCache 
             def initialize() 
-                @callbacks = Hash.new
+                @reusable_callbacks = Hash.new
                 @next_id = 1
             end
 
@@ -15,35 +17,37 @@ def get_next_id
                 return _next_id
             end
 
-            def store_callback(callback)
+            def store_callback(callback, call_count=1)
                 id = get_next_id()
-                @callbacks[id] = callback
+                @reusable_callbacks[id] = ReusableCallback.new(callback, call_count)
                 return id
             end
 
-            def pop_callback(id)
-                if not @callbacks.has_key? id
+            def get_callback(id)
+                if not @reusable_callbacks.has_key? id
                     return nil
                 end
-                callback = @callbacks[id]
-                @callbacks.delete(id)
+                callback, done_using = @reusable_callbacks[id].get_callback()
+                if done_using 
+                    @reusable_callbacks.delete(id)
+                end
                 return callback
             end
 
             def store_subscription_callback(key, callback) 
-                @callbacks[key] = callback
+                @reusable_callbacks[key] = callback
             end
 
             def get_subscription_callback(key)
-                if not @callbacks.has_key? key
+                if not @reusable_callbacks.has_key? key
                     return nil
                 end
-                return @callbacks[key]
+                return @reusable_callbacks[key]
             end
 
             def delete_subscription_callback(key) 
-                if @callbacks.has_key? key
-                    @callbacks.delete(key)
+                if @reusable_callbacks.has_key? key
+                    @reusable_callbacks.delete(key)
                 end
             end
         end

lib/cryptomarket/websocket/reusableCallback.rb

@@ -0,0 +1,19 @@
+module Cryptomarket
+  module Websocket
+      class ReusableCallback 
+          def initialize(callback, call_count) 
+              @call_count =  call_count
+              @callback = callback
+          end
+
+          def get_callback()
+            if  @call_count < 1
+              return [nil, false]
+            end
+            @call_count -= 1
+            done_using = @call_count < 1
+            return [@callback, done_using]
+          end
+      end
+  end
+end

lib/cryptomarket/websocket/tradingClient.rb

@@ -204,9 +204,11 @@ def create_spot_order_list(
               callback:nil
             )
               send_by_id('spot_new_order_list', callback, {
-                orders:orders,
-                contingency_type:contingency_type,
-                order_list_id:order_list_id})
+                  orders:orders,
+                  contingency_type:contingency_type,
+                  order_list_id:order_list_id
+                },
+                call_count=orders.count)
             end
 
             # cancels a spot order

lib/cryptomarket/websocket/wsClientBase.rb

@@ -80,17 +80,17 @@ def send_unsubscription(method, callback, params)
                 store_and_send(method, params, callback)
             end
 
-            def send_by_id(method, callback, params={})
-                store_and_send(method, params, callback)
+            def send_by_id(method, callback, params={}, call_count=1)
+                store_and_send(method, params, callback, call_count)
             end
 
-            def store_and_send(method, params, callback_to_store=nil)
+            def store_and_send(method, params, callback_to_store=nil, call_count=1)
                 if !params.nil?
                   params = params.compact
                 end
                 payload = {'method' => method, 'params' => params}
                 if not callback_to_store.nil?
-                  id = @callback_cache.store_callback(callback_to_store)
+                  id = @callback_cache.store_callback(callback_to_store, call_count)
                   payload['id'] = id
                 end
                 @ws_manager.send(payload)
@@ -121,7 +121,7 @@ def handle_response(response)
                 if id.nil?
                     return
                 end
-                callback = @callback_cache.pop_callback(id)
+                callback = @callback_cache.get_callback(id)
                 if callback.nil?
                     return
                 end

tests/websocket/trading.rb

@@ -14,7 +14,7 @@ def teardown
     sleep(2)
   end
 
-  def gen_checker_callback(checker)
+  def gen_list_checker_callback(checker)
     msg = ""
     callback = Proc.new {|error, result|
       if not error.nil?
@@ -29,7 +29,7 @@ def gen_checker_callback(checker)
     return {msg:msg, callback:callback}
   end
 
-  def gen_not_list_checker_callback(checker)
+  def gen_checker_callback(checker)
     msg = ""
     callback = Proc.new {|error, result|
       if not error.nil?
@@ -43,15 +43,15 @@ def gen_not_list_checker_callback(checker)
   end
 
   def test_get_spot_trading_balance
-    hash = gen_not_list_checker_callback(->(balance) {goodBalance(balance)})
+    hash = gen_checker_callback(->(balance) {goodBalance(balance)})
     @wsclient.get_spot_trading_balance(callback:hash[:callback], currency:"EOS")
     sleep(3)
     assert(hash[:msg] == "", hash[:msg])
   end
 
 
   def test_get_spot_trading_balances
-    hash = gen_checker_callback(->(balance) {
+    hash = gen_list_checker_callback(->(balance) {
       puts balance
       return goodBalance(balance)
     })
@@ -63,7 +63,7 @@ def test_get_spot_trading_balances
   def test_order_work_flow
     timestamp = Time.now.to_i.to_s
     symbol = 'EOSETH'
-    hash = gen_not_list_checker_callback(->(order) {goodOrder(order)})
+    hash = gen_checker_callback(->(order) {goodOrder(order)})
     @wsclient.create_spot_order(
       client_order_id:timestamp,
       symbol: symbol,
@@ -74,7 +74,7 @@ def test_order_work_flow
     )
     sleep(3)
     assert(hash[:msg] == "", hash[:msg])
-    hash2 = gen_not_list_checker_callback(->(result) {
+    hash2 = gen_checker_callback(->(result) {
       for order in result
         if order['client_order_id'] == timestamp
           return true
@@ -96,7 +96,7 @@ def test_order_work_flow
     )
     sleep(3)
     assert(hash[:msg] == "", hash[:msg])
-    hash3 = gen_not_list_checker_callback(->(result) {
+    hash3 = gen_checker_callback(->(result) {
       for order in result
         if order['client_order_id'] == new_timestamp
           return true
@@ -172,16 +172,47 @@ def test_cancel_spot_orders
   end
 
   def test_get_spot_commissions
-    hash = gen_checker_callback(->(commission) {goodTradingCommission(commission)})
+    hash = gen_list_checker_callback(->(commission) {goodTradingCommission(commission)})
     @wsclient.get_spot_commissions(callback:hash[:callback])
     sleep(3)
     assert(hash[:msg] == "", hash[:msg])
   end
 
   def test_get_spot_commission_of_symbol
-    hash = gen_not_list_checker_callback(->(commission) {goodTradingCommission(commission)})
+    hash = gen_checker_callback(->(commission) {goodTradingCommission(commission)})
     @wsclient.get_spot_commission_of_symbol(symbol:'EOS', callback:hash[:callback])
     sleep(3)
     assert(hash[:msg] == "", hash[:msg])
   end
+
+  def test_create_spot_order_list
+    firstOrderID = Time.now.to_s
+    @wsclient.create_spot_order_list(
+      order_list_id: firstOrderID,
+      contingency_type: Cryptomarket::Args::Contingency::AON,
+      orders: [
+        {
+          'symbol'=>'EOSETH',
+          'side'=>Cryptomarket::Args::Side::SELL,
+          'quantity'=>'0.1',
+          'time_in_force'=> Cryptomarket::Args::TimeInForce::FOK,
+          'price'=> '1000'
+        },
+        {
+          'symbol'=>'EOSUSDT',
+          'side'=>Cryptomarket::Args::Side::SELL,
+          'quantity'=>'0.1',
+          'time_in_force'=> Cryptomarket::Args::TimeInForce::FOK,  
+          'price'=> '1000'
+        }
+      ],
+      callback: Proc.new {|error, result|
+        if not error.nil?
+          puts error
+          return
+        end
+        puts result
+      })
+    sleep(5)
+  end 
 end