test: fix websocket tests

Author: Insmael

Gemfile.lock

@@ -56,12 +56,12 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
-  eventmachine
-  faye-websocket
-  openssl
-  rest-client
-  rubocop
-  test-unit
+  eventmachine (= 1.2.7)
+  faye-websocket (= 0.11.3)
+  openssl (= 3.2.0)
+  rest-client (= 2.1.0)
+  rubocop (= 1.60.2)
+  test-unit (= 3.6.2)
 
 BUNDLED WITH
    2.3.5

lib/cryptomarket/http_manager.rb

@@ -35,7 +35,7 @@ def make_request(method:, endpoint:, params: nil, public: false)
     def make_post_request(method:, endpoint:, params: nil)
       uri = URI(@@API_URL + @@API_VERSION + endpoint)
       payload = build_payload(params)
-      do_request(method, uri, payload, build_post_headers(endpoint, payload), is_json: true)
+      do_request(method, uri, payload, build_post_headers(endpoint, payload))
     end
 
     def build_headers(method, endpoint, params, public)
@@ -52,11 +52,10 @@ def build_payload(params)
       payload
     end
 
-    def do_request(method, uri, payload, headers, is_json: false)
+    def do_request(method, uri, payload, headers)
       response = RestClient::Request.execute(
         method: method.downcase.to_sym, url: uri.to_s, payload: payload.to_json, headers: headers
       )
-      response[:content_type] = :json if is_json
       handle_response(response)
     rescue RestClient::ExceptionWithResponse => e
       handle_response(e.response)

lib/cryptomarket/websocket/wallet_client.rb

@@ -109,10 +109,18 @@ def get_wallet_balances(callback:)
       #
       # ==== Params
       # +String+ +currency+:: The currency code to query the balance
-      # +Proc+ +callback+:: A +Proc+ called with an user balance
+      # +Proc+ +callback+:: A +Proc+ called with a user balance
 
       def get_wallet_balance(currency:, callback:)
-        request('wallet_balance', callback, { currency: currency })
+        interceptor = lambda { |err, balance|
+          unless err.nil?
+            callback.call(err, nil)
+            return
+          end
+          balance['currency'] = currency
+          callback.call(err, balance)
+        }
+        request('wallet_balance', interceptor, { currency: currency })
       end
 
       # Get the transaction history of the account

tests/checker_generator.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+def red(msg)
+  "\e[31m#{msg}\e[0m"
+end
+
+def green(msg)
+  "\e[32m#{msg}\e[0m"
+end
+
+class VeredictChecker # rubocop:disable Style/Documentation
+  def initialize
+    @veredict = true
+    @err_msgs = []
+  end
+
+  def good_veredict?
+    print "\n"
+    @veredict
+  end
+
+  def err_msg
+    @err_msgs.to_s
+  end
+
+  def append(veredict, err_msg)
+    if veredict
+      print(green('.'))
+    else
+      print(red('.'))
+    end
+    @err_msgs.append(err_msg) unless veredict
+    @veredict &&= veredict
+  end
+end
+
+def check_error(err, veredict_checker)
+  return unless err
+
+  puts "err: #{err}"
+  veredict_checker.append(false, err)
+end
+
+def check_val(val, check_fn, veredict_checker)
+  return unless val
+
+  is_good_val = check_fn.call(val)
+  puts "bad value: #{val}" unless is_good_val
+  veredict_checker.append(is_good_val, val)
+end
+
+def check_list(val_list, check_fn, veredict_checker)
+  val_list.each { |val| check_val(val, check_fn, veredict_checker) }
+end
+
+def check_hash(hash, check_fn, veredict_checker)
+  hash.each_value { |val| check_val(val, check_fn, veredict_checker) }
+end
+
+def check_hash_list(hash, check_fn, veredict_checker)
+  hash.each_value { |val_list| check_list(val_list, check_fn, veredict_checker) }
+end
+
+def gen_result_callback(veredict_checker)
+  ->(err, _result) { check_error(err, veredict_checker) }
+end
+
+def gen_check_result_callback(check_fn, veredict_checker)
+  lambda { |err, result|
+    check_error(err, veredict_checker)
+    check_val(result, check_fn, veredict_checker)
+  }
+end
+
+def gen_check_result_list_callback(check_fn, veredict_checker)
+  lambda { |err, result|
+    check_error(err, veredict_checker)
+    check_list(result, check_fn, veredict_checker)
+  }
+end
+
+def gen_check_notification_w_n_type_callback(check_fn, veredict_checker)
+  ->(notification, _notification_type) { check_val(notification, check_fn, veredict_checker) }
+end
+
+def gen_check_notification_list_callback(check_fn, veredict_checker)
+  ->(notification) { check_list(notification, check_fn, veredict_checker) }
+end
+
+def |(check_fn, veredict_checker)
+  ->(notification, _notification_type) { check_list(notification, check_fn, veredict_checker) }
+end
+
+def gen_check_notification_hash_list_callback(check_fn, veredict_checker)
+  ->(notification, _notification_type) { check_hash_list(notification, check_fn, veredict_checker) }
+end
+
+def gen_check_notification_hash_callback(check_fn, veredict_checker)
+  ->(notification, _notification_type) { check_hash(notification, check_fn, veredict_checker) }
+end

tests/checks.rb

@@ -19,23 +19,7 @@ def defined(a_hash, key)
 def good_params(a_hash, fields)
   return false if a_hash.nil?
 
-  fields.each do |field|
-    return false unless defined(a_hash, field)
-  end
-  true
-end
-
-def good_list(check_fn, list)
-  list.each do |elem|
-    return false unless check_fn.call(elem)
-  end
-  true
-end
-
-def good_hash(_check_fn, hash)
-  hash.each_value do |elem|
-    return false unless check_fn(elem)
-  end
+  fields.each { |field| return false unless defined(a_hash, field) }
   true
 end
 
@@ -51,9 +35,7 @@ def good_currency(currency)
                        ])
     return false unless good
 
-    currency['networks'].each do |level|
-      return false unless good_network(level)
-    end
+    currency['networks'].each { |level| return false unless good_network(level) }
     true
   end
 
@@ -85,9 +67,7 @@ def good_price_history(price_history)
     good = good_params(price_history, %w[currency history])
     return false unless good
 
-    price_history['history'].each do |point|
-      return false unless good_history_point(point)
-    end
+    price_history['history'].each { |point| return false unless good_history_point(point) }
     true
   end
 
@@ -104,16 +84,11 @@ def self.good_public_trade
   end
 
   def good_orderbook(orderbook)
-    good_orderbook = good_params(orderbook,
-                                 %w[timestamp ask bid])
+    good_orderbook = good_params(orderbook, %w[timestamp ask bid])
     return false unless good_orderbook
 
-    orderbook['ask'].each do |level|
-      return false unless good_orderbook_level(level)
-    end
-    orderbook['bid'].each do |level|
-      return false unless good_orderbook_level(level)
-    end
+    orderbook['ask'].each { |level| return false unless good_orderbook_level(level) }
+    orderbook['bid'].each { |level| return false unless good_orderbook_level(level) }
     true
   end
 
@@ -131,23 +106,22 @@ def good_order(order)
                    quantity price quantity_cumulative created_at updated_at])
   end
 
-  def self.good_trade
+  def good_trade
     lambda { |trade|
       good_params(trade, %w[id orderId clientOrderId symbol side quantity
                             price fee timestamp])
     }
   end
 
-  def good_native_transaction(native_transaction)
+  def self.good_native_transaction(native_transaction)
     good_params(native_transaction, %w[tx_id index currency amount])
   end
 
-  def good_transaction(transaction)
-    good = good_params(transaction,
-                       %w[id status type subtype created_at updated_at])
+  def self.good_transaction(transaction)
+    good = good_params(transaction, %w[id status type subtype created_at updated_at])
     return false unless good
 
-    return false if transaction.key?('native') && !good_native_transaction(transaction['native'])
+    return false if transaction.key?('native') && !Checks.good_native_transaction(transaction['native'])
 
     true
   end
@@ -182,12 +156,8 @@ def self.good_orderbook
     lambda { |orderbook|
       return false unless good_params(orderbook, %w[t s a b])
 
-      orderbook['a'].each do |level|
-        return false unless good_orderbook_level(level)
-      end
-      orderbook['b'].each do |level|
-        return false unless good_orderbook_level(level)
-      end
+      orderbook['a'].each { |level| return false unless good_orderbook_level(level) }
+      orderbook['b'].each { |level| return false unless good_orderbook_level(level) }
       true
     }
   end
@@ -199,18 +169,30 @@ def self.good_orderbook_top
   def self.good_price_rate
     ->(price_rate) { good_params(price_rate, %w[t r]) }
   end
-end
 
-class VeredictChecker # rubocop:disable Style/Documentation
-  def initialize
-    @veredict = true
+  def self.good_report
+    lambda { |report|
+      good_params(report,
+                  %w[id client_order_id symbol side status type time_in_force
+                     quantity price quantity_cumulative created_at updated_at])
+    }
+  end
+
+  def self.good_balance
+    ->(balance) { good_params(balance, %w[currency available reserved]) }
+  end
+
+  def self.good_commission
+    ->(commission) { good_params(commission, %w[symbol take_rate make_rate]) }
   end
 
-  def good_veredict?
-    @veredict
+  def self.good_transaction
+    ->(transaction) { Checks.good_transaction(transaction) }
   end
 
-  def append(veredict)
-    @veredict &&= veredict
+  def self.print
+    lambda { |reports|
+      puts reports
+    }
   end
 end