honeymaker 0.1.0 → 0.3.0

data/test/honeymaker/exchanges/binance_us_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BinanceUsTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::BinanceUs.new
+  end
+
+  def test_inherits_from_binance
+    assert_kind_of Honeymaker::Exchanges::Binance, @exchange
+  end
+
+  def test_uses_binance_us_url
+    assert_equal "https://api.binance.us", Honeymaker::Exchanges::BinanceUs::BASE_URL
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("binance_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    ticker = result.data.first
+    assert_equal "BTCUSDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).with { |_, &block| block&.call(OpenStruct.new(params: {})); true }.returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/bingx_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BingXTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::BingX.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("bingx_symbols.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    # "INVALID" has no dash so it's skipped
+    assert_equal 1, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTC-USDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "1", ticker[:minimum_quote_size]
+    assert_equal "500", ticker[:maximum_base_size]
+    assert_equal 5, ticker[:base_decimals]
+    assert_equal 2, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_skips_symbols_without_dash
+    body = load_fixture("bingx_symbols.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    tickers = result.data.map { |t| t[:ticker] }
+    refute_includes tickers, "INVALID"
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/bitget_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BitgetTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Bitget.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("bitget_symbols.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTCUSDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "5", ticker[:minimum_quote_size]
+    assert_equal "9000", ticker[:maximum_base_size]
+    assert_equal 6, ticker[:base_decimals]
+    assert_equal 8, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_offline_symbol_not_available
+    body = load_fixture("bitget_symbols.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    eth = result.data.find { |t| t[:ticker] == "ETHUSDT" }
+    refute eth[:available]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/bitmart_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BitMartTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::BitMart.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("bitmart_symbols.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTC_USDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "5", ticker[:minimum_quote_size]
+    assert_nil ticker[:maximum_base_size]
+    assert_equal 5, ticker[:base_decimals]
+    assert_equal 2, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_pre_trade_not_available
+    body = load_fixture("bitmart_symbols.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    eth = result.data.find { |t| t[:ticker] == "ETH_USDT" }
+    refute eth[:available]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/bitrue_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BitrueTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Bitrue.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("bitrue_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTCUSDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "5", ticker[:minimum_quote_size]
+    assert_equal "9000", ticker[:maximum_base_size]
+    assert_equal 5, ticker[:base_decimals]
+    assert_equal 2, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_falls_back_to_precision_fields_when_no_filters
+    body = load_fixture("bitrue_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    eth = result.data.find { |t| t[:ticker] == "ETHUSDT" }
+    assert_equal 6, eth[:base_decimals]
+    assert_equal 2, eth[:price_decimals]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/bitvavo_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BitvavoTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Bitvavo.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("bitvavo_markets.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTC-EUR", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "EUR", ticker[:quote]
+    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "5", ticker[:minimum_quote_size]
+    assert_nil ticker[:maximum_base_size]
+    assert_equal 5, ticker[:base_decimals]
+    assert_equal 5, ticker[:quote_decimals]
+    assert_equal 5, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_halted_market_not_available
+    body = load_fixture("bitvavo_markets.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    eth = result.data.find { |t| t[:ticker] == "ETH-EUR" }
+    refute eth[:available]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/bybit_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BybitTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Bybit.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("bybit_instruments.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 1, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTCUSDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.000048", ticker[:minimum_base_size]
+    assert_equal "1", ticker[:minimum_quote_size]
+    assert_equal "71.73956243", ticker[:maximum_base_size]
+    assert_equal "4000000", ticker[:maximum_quote_size]
+    assert_equal 6, ticker[:base_decimals]
+    assert_equal 8, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).with { |_, &block| block&.call(OpenStruct.new(params: {})); true }.returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/coinbase_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::CoinbaseTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Coinbase.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("coinbase_products.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    # RENDER is blacklisted, so only BTC-USD should remain
+    assert_equal 1, result.data.size
+    ticker = result.data.first
+    assert_equal "BTC-USD", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USD", ticker[:quote]
+    assert_equal "0.00000001", ticker[:minimum_base_size]
+    assert_equal "1", ticker[:minimum_quote_size]
+    assert_equal "3400", ticker[:maximum_base_size]
+    assert_equal 8, ticker[:base_decimals]
+    assert_equal 2, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_filters_blacklisted_assets
+    body = load_fixture("coinbase_products.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    bases = result.data.map { |t| t[:base] }
+    refute_includes bases, "RENDER"
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/gemini_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::GeminiTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Gemini.new
+  end
+
+  def test_get_tickers_info_parses_response
+    symbols_body = load_fixture("gemini_symbols.json")
+    detail_body = load_fixture("gemini_symbol_detail.json")
+
+    symbols_response = stub(body: symbols_body)
+    detail_response = stub(body: detail_body)
+    connection = stub
+    connection.stubs(:get).with("/v1/symbols").returns(symbols_response)
+    connection.stubs(:get).with { |path| path.start_with?("/v1/symbols/details/") }.returns(detail_response)
+    @exchange.instance_variable_set(:@connection, connection)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTCUSD", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USD", ticker[:quote]
+    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "0", ticker[:minimum_quote_size]
+    assert_equal 8, ticker[:base_decimals]
+    assert_equal 2, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/hyperliquid_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::HyperliquidTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Hyperliquid.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("hyperliquid_spot_meta.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 1, result.data.size
+
+    ticker = result.data.first
+    assert_equal "PURR/USDC", ticker[:ticker]
+    assert_equal "PURR", ticker[:base]
+    assert_equal "USDC", ticker[:quote]
+    assert_nil ticker[:minimum_base_size]
+    assert_nil ticker[:minimum_quote_size]
+    assert_equal 2, ticker[:base_decimals]
+    assert_equal 2, ticker[:quote_decimals]
+    assert_equal 5, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_skips_pairs_with_missing_tokens
+    body = load_fixture("hyperliquid_spot_meta.json")
+    body["universe"] << { "name" => "MISSING/PAIR", "tokens" => [99, 100] }
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 1, result.data.size
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:post).with { |_, &block| block&.call(OpenStruct.new(body: nil)); true }.returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/kucoin_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::KucoinTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Kucoin.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("kucoin_symbols.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 1, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTC-USDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "0.1", ticker[:minimum_quote_size]
+    assert_equal "10000000000", ticker[:maximum_base_size]
+    assert_equal "99999999", ticker[:maximum_quote_size]
+    assert_equal 8, ticker[:base_decimals]
+    assert_equal 6, ticker[:quote_decimals]
+    assert_equal 1, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/mexc_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::MexcTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Mexc.new
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("mexc_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+
+    ticker = result.data.first
+    assert_equal "BTCUSDT", ticker[:ticker]
+    assert_equal "BTC", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00001", ticker[:minimum_base_size]
+    assert_equal "5", ticker[:minimum_quote_size]
+    assert_equal "9000", ticker[:maximum_base_size]
+    assert_equal 5, ticker[:base_decimals]
+    assert_equal 8, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+  end
+
+  def test_halted_symbol_not_available
+    body = load_fixture("mexc_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    halted = result.data.find { |t| t[:ticker] == "ETHUSDT" }
+    refute halted[:available]
+  end
+
+  def test_falls_back_to_precision_fields_when_no_filters
+    body = load_fixture("mexc_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    # ETHUSDT has empty filters, should use baseAssetPrecision/quotePrecision
+    eth = result.data.find { |t| t[:ticker] == "ETHUSDT" }
+    assert_equal 6, eth[:base_decimals]
+    assert_equal 2, eth[:price_decimals]
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/utils_test.rb

@@ -23,4 +23,42 @@ class Honeymaker::UtilsTest < Minitest::Test
     assert_equal 0, Honeymaker::Utils.decimals("1")
     assert_equal 0, Honeymaker::Utils.decimals("10")
   end
+
+  def test_decimals_with_nil
+    assert_equal 0, Honeymaker::Utils.decimals(nil)
+  end
+
+  def test_parse_filters
+    filters = [
+      { "filterType" => "PRICE_FILTER", "tickSize" => "0.01" },
+      { "filterType" => "LOT_SIZE", "stepSize" => "0.001" },
+      { "filterType" => "NOTIONAL", "minNotional" => "5" }
+    ]
+
+    result = Honeymaker::Utils.parse_filters(filters)
+
+    assert_equal "0.01", result[:price]["tickSize"]
+    assert_equal "0.001", result[:lot_size]["stepSize"]
+    assert_equal "5", result[:notional]["minNotional"]
+  end
+
+  def test_parse_filters_with_min_notional
+    filters = [
+      { "filterType" => "MIN_NOTIONAL", "minNotional" => "10" }
+    ]
+
+    result = Honeymaker::Utils.parse_filters(filters)
+
+    assert_nil result[:price]
+    assert_nil result[:lot_size]
+    assert_equal "10", result[:notional]["minNotional"]
+  end
+
+  def test_parse_filters_empty
+    result = Honeymaker::Utils.parse_filters([])
+
+    assert_nil result[:price]
+    assert_nil result[:lot_size]
+    assert_nil result[:notional]
+  end
 end

data/test/test_helper.rb

@@ -2,6 +2,7 @@
 
 require "minitest/autorun"
 require "mocha/minitest"
+require "ostruct"
 require "honeymaker"
 
 # Load fixture helpers