honeymaker 0.1.0 → 0.2.0

data/test/honeymaker/clients/kraken_client_test.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::KrakenTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Kraken.new(
+      api_key: "test_key",
+      api_secret: Base64.strict_encode64("test_secret_key_1234567890123456")
+    )
+  end
+
+  def test_url
+    assert_equal "https://api.kraken.com", Honeymaker::Clients::Kraken::URL
+  end
+
+  def test_get_tradable_asset_pairs
+    stub_connection(:get, { "error" => [], "result" => { "XBTUSDT" => { "altname" => "XBTUSDT" } } })
+    result = @client.get_tradable_asset_pairs
+    assert result.success?
+    assert result.data["result"].key?("XBTUSDT")
+  end
+
+  def test_get_ticker_information
+    stub_connection(:get, { "error" => [], "result" => { "XBTUSDT" => { "a" => ["50000"] } } })
+    result = @client.get_ticker_information(pair: "XBTUSDT")
+    assert result.success?
+  end
+
+  def test_add_order
+    stub_connection(:post, { "error" => [], "result" => { "txid" => ["ORDER-123"] } })
+    result = @client.add_order(ordertype: "market", type: "buy", volume: "0.001", pair: "XBTUSDT")
+    assert result.success?
+    assert_equal ["ORDER-123"], result.data["result"]["txid"]
+  end
+
+  def test_cancel_order
+    stub_connection(:post, { "error" => [], "result" => { "count" => 1 } })
+    result = @client.cancel_order(txid: "ORDER-123")
+    assert result.success?
+  end
+
+  def test_get_extended_balance
+    stub_connection(:post, { "error" => [], "result" => { "XXBT" => { "balance" => "0.5" } } })
+    result = @client.get_extended_balance
+    assert result.success?
+  end
+
+  def test_private_headers_produce_signature
+    headers = @client.send(:private_headers, "/0/private/Balance", "nonce=12345")
+    assert headers.key?(:"API-Key")
+    assert headers.key?(:"API-Sign")
+    assert_equal "test_key", headers[:"API-Key"]
+  end
+
+  def test_public_headers_no_auth
+    client = Honeymaker::Clients::Kraken.new
+    headers = client.send(:public_headers)
+    refute headers.key?(:"API-Key")
+  end
+
+  private
+
+  def stub_connection(method, body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(method).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/clients/kucoin_client_test.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::KucoinTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Kucoin.new(
+      api_key: "test_key", api_secret: "test_secret", passphrase: "test_pass"
+    )
+  end
+
+  def test_url
+    assert_equal "https://api.kucoin.com", Honeymaker::Clients::Kucoin::URL
+  end
+
+  def test_accepts_passphrase
+    assert_equal "test_pass", @client.passphrase
+  end
+
+  def test_get_symbols
+    stub_connection(:get, { "data" => [{ "symbol" => "BTC-USDT" }] })
+    result = @client.get_symbols
+    assert result.success?
+  end
+
+  def test_get_all_tickers
+    stub_connection(:get, { "data" => { "ticker" => [] } })
+    result = @client.get_all_tickers
+    assert result.success?
+  end
+
+  def test_get_accounts
+    stub_connection(:get, { "data" => [{ "currency" => "BTC" }] })
+    result = @client.get_accounts
+    assert result.success?
+  end
+
+  def test_place_order
+    stub_connection(:post, { "data" => { "orderId" => "123" } })
+    result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
+    assert result.success?
+  end
+
+  def test_get_order
+    stub_connection(:get, { "data" => { "id" => "123", "isActive" => false } })
+    result = @client.get_order(order_id: "123")
+    assert result.success?
+  end
+
+  def test_cancel_order
+    stub_connection(:delete, { "data" => { "cancelledOrderIds" => ["123"] } })
+    result = @client.cancel_order(order_id: "123")
+    assert result.success?
+  end
+
+  def test_withdraw
+    stub_connection(:post, { "data" => { "withdrawalId" => "w1" } })
+    result = @client.withdraw(currency: "BTC", address: "addr", amount: "0.1")
+    assert result.success?
+  end
+
+  def test_signed_headers_include_passphrase_and_version
+    ts = "1234567890"
+    headers = @client.send(:signed_headers, ts, "payload")
+    assert_equal "test_key", headers[:"KC-API-KEY"]
+    assert_equal "2", headers[:"KC-API-KEY-VERSION"]
+    assert headers.key?(:"KC-API-SIGN")
+    assert headers.key?(:"KC-API-PASSPHRASE")
+  end
+
+  def test_passphrase_is_signed
+    ts = "1234567890"
+    headers = @client.send(:signed_headers, ts, "payload")
+    # KuCoin v2 signs the passphrase with the secret
+    raw_passphrase = "test_pass"
+    expected = Base64.strict_encode64(OpenSSL::HMAC.digest("sha256", "test_secret", raw_passphrase))
+    assert_equal expected, headers[:"KC-API-PASSPHRASE"]
+  end
+
+  private
+
+  def stub_connection(method, body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(method).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/clients/mexc_client_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::MexcTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Mexc.new(api_key: "test_key", api_secret: "test_secret")
+  end
+
+  def test_url
+    assert_equal "https://api.mexc.com", Honeymaker::Clients::Mexc::URL
+  end
+
+  def test_exchange_information
+    stub_connection(:get, { "symbols" => [{ "symbol" => "BTCUSDT" }] })
+    result = @client.exchange_information
+    assert result.success?
+  end
+
+  def test_symbol_price_ticker
+    stub_connection(:get, { "symbol" => "BTCUSDT", "price" => "50000" })
+    result = @client.symbol_price_ticker(symbol: "BTCUSDT")
+    assert result.success?
+  end
+
+  def test_account_information
+    stub_connection(:get, { "balances" => [{ "asset" => "BTC" }] })
+    result = @client.account_information
+    assert result.success?
+  end
+
+  def test_new_order
+    stub_connection(:post, { "orderId" => "123" })
+    result = @client.new_order(symbol: "BTCUSDT", side: "BUY", type: "MARKET", quantity: "0.001")
+    assert result.success?
+  end
+
+  def test_query_order
+    stub_connection(:get, { "orderId" => "123", "status" => "FILLED" })
+    result = @client.query_order(symbol: "BTCUSDT", order_id: "123")
+    assert result.success?
+  end
+
+  def test_cancel_order
+    stub_connection(:delete, { "orderId" => "123" })
+    result = @client.cancel_order(symbol: "BTCUSDT", order_id: "123")
+    assert result.success?
+  end
+
+  def test_withdraw
+    stub_connection(:post, { "id" => "w1" })
+    result = @client.withdraw(coin: "BTC", address: "addr", amount: "0.1")
+    assert result.success?
+  end
+
+  def test_headers_include_api_key
+    headers = @client.send(:headers)
+    assert_equal "test_key", headers[:"X-MEXC-APIKEY"]
+  end
+
+  def test_sign_params
+    sig = @client.send(:sign_params, { symbol: "BTCUSDT", timestamp: 1234567890 })
+    assert sig.is_a?(String)
+    assert_equal 64, sig.length
+  end
+
+  private
+
+  def stub_connection(method, body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(method).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+  end
+end

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