test: fix rest market data tests

Author: Insmael

tests/checks.rb

@@ -27,8 +27,8 @@ def good_orderbook_level(level)
   level.length == 2
 end
 
-module Checks # rubocop:disable Style/Documentation
-  def good_currency(currency)
+module Check # rubocop:disable Style/Documentation
+  def self.good_currency(currency)
     good = good_params(currency, %w[
                          full_name payin_enabled payout_enabled transfer_enabled
                          precision_transfer networks
@@ -39,51 +39,51 @@ def good_currency(currency)
     true
   end
 
-  def good_network(network)
+  def self.good_network(network)
     good_params(network,
                 %w[
                   network default payin_enabled payout_enabled precision_payout
                   payout_fee payout_is_payment_id payin_payment_id payin_confirmations
                 ])
   end
 
-  def good_symbol(symbol)
+  def self.good_symbol(symbol)
     good_params(symbol,
                 %w[
                   type base_currency quote_currency status quantity_increment
                   tick_size take_rate make_rate fee_currency
                 ])
   end
 
-  def good_ticker(ticker)
+  def self.good_ticker(ticker)
     good_params(ticker, %w[low high volume volume_quote timestamp])
   end
 
-  def good_price(price)
+  def self.good_price(price)
     good_params(price, %w[currency price timestamp])
   end
 
-  def good_price_history(price_history)
+  def self.good_price_history(price_history)
     good = good_params(price_history, %w[currency history])
     return false unless good
 
     price_history['history'].each { |point| return false unless good_history_point(point) }
     true
   end
 
-  def good_history_point(point)
+  def self.good_history_point(point)
     good_params(point, %w[open close min max timestamp])
   end
 
-  def good_ticker_price(price)
+  def self.good_ticker_price(price)
     good_params(price, %w[price timestamp])
   end
 
-  def self.good_public_trade
-    ->(trade) { good_params(trade, %w[id price qty side timestamp]) }
+  def self.good_public_trade(trade)
+    good_params(trade, %w[id price qty side timestamp])
   end
 
-  def good_orderbook(orderbook)
+  def self.good_orderbook(orderbook)
     good_orderbook = good_params(orderbook, %w[timestamp ask bid])
     return false unless good_orderbook
 
@@ -92,21 +92,21 @@ def good_orderbook(orderbook)
     true
   end
 
-  def good_candle(candle)
+  def self.good_candle(candle)
     good_params(candle, %w[timestamp open close min max volume volume_quote])
   end
 
-  def good_balance(balance)
+  def self.good_balance(balance)
     good_params(balance, %w[currency available reserved])
   end
 
-  def good_order(order)
+  def self.good_order(order)
     good_params(order,
                 %w[id client_order_id symbol side status type time_in_force
                    quantity price quantity_cumulative created_at updated_at])
   end
 
-  def good_trade
+  def self.good_trade
     lambda { |trade|
       good_params(trade, %w[id orderId clientOrderId symbol side quantity
                             price fee timestamp])
@@ -121,21 +121,21 @@ 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') && !Checks.good_native_transaction(transaction['native'])
+    return false if transaction.key?('native') && !Check.good_native_transaction(transaction['native'])
 
     true
   end
 
-  def good_address(address)
+  def self.good_address(address)
     good_params(address, %w[currency address])
   end
 
-  def good_trading_commission(commission)
+  def self.good_trading_commission(commission)
     good_params(commission, %w[symbol make_rate take_rate])
   end
 end
 
-module WSChecks # rubocop:disable Style/Documentation
+module WSCheck # rubocop:disable Style/Documentation
   def self.good_ws_public_trade
     ->(trade) { good_params(trade, %w[t i p q s]) }
   end
@@ -145,7 +145,7 @@ def self.good_ws_public_candle
   end
 
   def self.good_ws_mini_ticker
-    WSChecks.good_ws_public_candle
+    WSCheck.good_ws_public_candle
   end
 
   def self.good_ticker
@@ -187,7 +187,7 @@ def self.good_commission
   end
 
   def self.good_transaction
-    ->(transaction) { Checks.good_transaction(transaction) }
+    ->(transaction) { Check.good_transaction(transaction) }
   end
 
   def self.print

tests/rest/market_data.rb

@@ -11,120 +11,120 @@ def setup
 
   def test_get_currencies
     result = @client.get_currencies currencies: nil
-    result.each_value { |val| assert(good_currency(val)) }
+    result.each_value { |val| assert(Check.good_currency(val)) }
   end
 
   def test_get_2_currencies
     result = @client.get_currencies currencies: %w[EOS CRO]
-    result.each_value { |val| assert(good_currency(val)) }
+    result.each_value { |val| assert(Check.good_currency(val)) }
   end
 
   def test_get_currency
     result = @client.get_currency currency: 'USDT'
-    assert(good_currency(result))
+    assert(Check.good_currency(result))
   end
 
   def test_get_symbols
     result = @client.get_symbols
-    result.each_value { |val| assert(good_symbol(val)) }
+    result.each_value { |val| assert(Check.good_symbol(val)) }
   end
 
   def test_get_2_symbols
     result = @client.get_symbols symbols: %w[XLMETH PAXGUSD]
-    result.each_value { |val| assert(good_symbol(val)) }
+    result.each_value { |val| assert(Check.good_symbol(val)) }
   end
 
   def test_get_symbol
     result = @client.get_symbol symbol: 'CROETH'
-    assert(good_symbol(result))
+    assert(Check.good_symbol(result))
   end
 
   def test_get_tickers
     result = @client.get_tickers
 
     result.each_value do |val|
-      assert(good_ticker(val))
+      assert(Check.good_ticker(val))
     end
   end
 
   def test_get_2_tickers
     result = @client.get_tickers symbols: %w[XLMETH PAXGUSD]
-    result.each_value { |val| assert(good_ticker(val)) }
+    result.each_value { |val| assert(Check.good_ticker(val)) }
   end
 
   def test_get_ticker
     result = @client.get_ticker symbol: 'XLMETH'
-    assert(good_ticker(result))
+    assert(Check.good_ticker(result))
   end
 
   def test_get_all_prices
     result = @client.get_prices to: 'ETH'
     assert(false, 'wrong number of ticker prices') if result.length < 2
-    result.each_value { |val| assert(good_price(val)) }
+    result.each_value { |val| assert(Check.good_price(val)) }
   end
 
   def test_get_a_price
     result = @client.get_prices(to: 'XLM', from: 'ETH')
     assert(false, 'wrong number of ticker prices') if result.length != 1
-    result.each_value { |val| assert(good_price(val)) }
+    result.each_value { |val| assert(Check.good_price(val)) }
   end
 
   def test_get_price_history
     result = @client.get_price_history to: 'XLM'
-    result.each_value { |val| assert(good_price_history(val)) }
+    result.each_value { |val| assert(Check.good_price_history(val)) }
   end
 
   def test_get_ticker_prices
     result = @client.get_ticker_prices symbols: %w[PAXGUSDT ETHBTC]
     assert(false, 'wrong number of ticker prices') if result.length != 2
-    result.each_value { |val| assert(good_ticker_price(val)) }
+    result.each_value { |val| assert(Check.good_ticker_price(val)) }
   end
 
   def test_get_ticker_price
     result = @client.get_ticker_price symbol: 'PAXGUSDT'
-    assert(good_ticker_price(result))
+    assert(Check.good_ticker_price(result))
   end
 
   def test_get_trades
     result = @client.get_trades(symbols: %w[XLMETH EOSETH], limit: 5)
     result.each_value do |trades|
-      trades.each { |val| assert(good_public_trade(val)) }
+      trades.each { |val| assert(Check.good_public_trade(val)) }
     end
   end
 
   def test_get_trades_by_symbol
     result = @client.get_trades_by_symbol(symbol: 'USDTDAI', limit: 5, offset: 10)
-    result.each { |val| assert(good_public_trade(val)) }
+    result.each { |val| assert(Check.good_public_trade(val)) }
   end
 
   def test_get_orderbooks
     result = @client.get_orderbooks(symbols: %w[EOSETH XLMETH])
     result.each_value do |val|
-      assert(good_orderbook(val))
+      assert(Check.good_orderbook(val))
     end
   end
 
   def test_get_orderbook
     result = @client.get_orderbook(symbol: 'EOSETH')
-    assert(good_orderbook(result))
+    assert(Check.good_orderbook(result))
   end
 
   def test_get_orderbook_volume
     result = @client.get_orderbook_volume(symbol: 'EOSETH', volume: '100')
-    assert(good_orderbook(result))
+    assert(Check.good_orderbook(result))
   end
 
   def test_get_candles
     result = @client.get_candles(symbols: ['EOSETH'], limit: 2)
     result.each_value do |candles|
-      candles.each { |val| assert(good_candle(val)) }
+      candles.each { |val| assert(Check.good_candle(val)) }
     end
   end
 
   def test_get_candles_by_symbol
     result = @client.get_candles_by_symbol(symbol: 'EOSETH', limit: 2)
     result.each do |candle|
-      assert(good_candle(candle))
+      assert(Check.good_candle(candle))
     end
   end
 end