honeymaker 0.12.4-aarch64-linux

data/test/honeymaker/clients/bitrue_client_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::BitrueTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Bitrue.new(api_key: "test_key", api_secret: "test_secret")
+  end
+
+  def test_url
+    assert_equal "https://openapi.bitrue.com", Honeymaker::Clients::Bitrue::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_account_trade_list
+    stub_connection(:get, [{ "symbol" => "BTCUSDT", "id" => 1 }])
+    result = @client.account_trade_list(symbol: "BTCUSDT")
+    assert result.success?
+  end
+
+  def test_headers_include_api_key
+    headers = @client.send(:auth_headers)
+    assert_equal "test_key", headers[:"X-MBX-APIKEY"]
+  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/bitvavo_client_test.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::BitvavoTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Bitvavo.new(api_key: "test_key", api_secret: "test_secret")
+  end
+
+  def test_url
+    assert_equal "https://api.bitvavo.com", Honeymaker::Clients::Bitvavo::URL
+  end
+
+  def test_get_markets
+    stub_connection(:get, [{ "market" => "BTC-EUR" }])
+    result = @client.get_markets
+    assert result.success?
+  end
+
+  def test_get_ticker_price
+    stub_connection(:get, [{ "market" => "BTC-EUR", "price" => "50000" }])
+    result = @client.get_ticker_price
+    assert result.success?
+  end
+
+  def test_get_raw_balance
+    stub_connection(:get, [{ "symbol" => "BTC", "available" => "0.5" }])
+    result = @client.get_raw_balance
+    assert result.success?
+  end
+
+  def test_place_order
+    stub_connection(:post, { "orderId" => "123" })
+    result = @client.place_order(market: "BTC-EUR", side: "buy", order_type: "market", amount_quote: "100")
+    assert result.success?
+  end
+
+  def test_get_order
+    stub_connection(:get, { "orderId" => "123", "status" => "filled" })
+    result = @client.get_order(market: "BTC-EUR", order_id: "123")
+    assert result.success?
+  end
+
+  def test_cancel_order
+    stub_connection(:delete, { "orderId" => "123" })
+    result = @client.cancel_order(market: "BTC-EUR", order_id: "123")
+    assert result.success?
+  end
+
+  # Bitvavo requires a mandatory integer operatorId on every order create/cancel
+  # (errorCode 203). These tests yield the real Faraday request block so we assert
+  # what the client actually sends, not just the stubbed response.
+
+  def test_place_order_sends_default_operator_id
+    req = capture_request(:post, { "orderId" => "123" })
+    @client.place_order(market: "BTC-EUR", side: "buy", order_type: "market", amount_quote: "100")
+    assert_equal @client.class::DEFAULT_OPERATOR_ID, req.body[:operatorId]
+    assert_kind_of Integer, req.body[:operatorId]
+  end
+
+  def test_place_order_operator_id_override
+    req = capture_request(:post, { "orderId" => "123" })
+    @client.place_order(market: "BTC-EUR", side: "buy", order_type: "market", amount_quote: "100", operator_id: 42)
+    assert_equal 42, req.body[:operatorId]
+  end
+
+  def test_cancel_order_sends_default_operator_id
+    req = capture_request(:delete, { "orderId" => "123" })
+    @client.cancel_order(market: "BTC-EUR", order_id: "123")
+    assert_equal @client.class::DEFAULT_OPERATOR_ID, req.params[:operatorId]
+    assert_kind_of Integer, req.params[:operatorId]
+  end
+
+  def test_cancel_order_operator_id_override
+    req = capture_request(:delete, { "orderId" => "123" })
+    @client.cancel_order(market: "BTC-EUR", order_id: "123", operator_id: 42)
+    assert_equal 42, req.params[:operatorId]
+  end
+
+  def test_withdraw
+    stub_connection(:post, { "success" => true })
+    result = @client.withdraw(symbol: "BTC", amount: "0.1", address: "addr")
+    assert result.success?
+  end
+
+  def test_get_assets
+    stub_connection(:get, [{ "symbol" => "BTC" }])
+    result = @client.get_assets
+    assert result.success?
+  end
+
+  def test_get_trades
+    stub_connection(:get, [{ "id" => "t1", "side" => "buy" }])
+    result = @client.get_trades(market: "BTC-EUR")
+    assert result.success?
+  end
+
+  def test_get_deposit_history
+    stub_connection(:get, [{ "symbol" => "BTC", "amount" => "1.0" }])
+    result = @client.get_deposit_history
+    assert result.success?
+  end
+
+  def test_get_withdrawal_history
+    stub_connection(:get, [{ "symbol" => "ETH", "amount" => "2.0" }])
+    result = @client.get_withdrawal_history
+    assert result.success?
+  end
+
+  def test_signed_headers_include_access_window
+    ts = "1234567890"
+    headers = @client.send(:signed_headers, ts, "payload")
+    assert_equal "test_key", headers[:"BITVAVO-ACCESS-KEY"]
+    assert_equal "10000", headers[:"BITVAVO-ACCESS-WINDOW"]
+    assert headers.key?(:"BITVAVO-ACCESS-SIGNATURE")
+  end
+
+  def test_signing_payload_format
+    # Verify the signing payload matches Bitvavo's expected format
+    sig1 = @client.send(:hmac_sha256, "test_secret", "1234567890GET/v2/balance")
+    sig2 = @client.send(:hmac_sha256, "test_secret", "1234567890POST/v2/order{\"market\":\"BTC-EUR\"}")
+    assert sig1.is_a?(String)
+    assert sig2.is_a?(String)
+    refute_equal sig1, sig2
+  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
+
+  # Records what the client sets on the Faraday request. Unlike stub_connection,
+  # this yields the request block (connection.post { |req| ... }) so the real
+  # body/params-building code in post_signed/delete_signed actually executes.
+  class RequestRecorder
+    attr_accessor :headers, :body, :params
+    attr_reader :requested_url
+
+    def url(path)
+      @requested_url = path
+    end
+  end
+
+  def capture_request(method, body)
+    response = stub(body: body)
+    recorder = RequestRecorder.new
+    connection = stub
+    connection.stubs(method).yields(recorder).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+    recorder
+  end
+end

data/test/honeymaker/clients/bybit_client_test.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::BybitTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Bybit.new(api_key: "test_key", api_secret: "test_secret")
+  end
+
+  def test_url
+    assert_equal "https://api.bybit.com", Honeymaker::Clients::Bybit::URL
+  end
+
+  def test_instruments_info
+    stub_connection(:get, { "result" => { "list" => [{ "symbol" => "BTCUSDT" }] } })
+    result = @client.instruments_info(category: "spot")
+    assert result.success?
+  end
+
+  def test_tickers
+    stub_connection(:get, { "result" => { "list" => [{ "lastPrice" => "50000" }] } })
+    result = @client.tickers(category: "spot", symbol: "BTCUSDT")
+    assert result.success?
+  end
+
+  def test_wallet_balance
+    stub_connection(:get, { "result" => { "list" => [{ "coin" => [{ "coin" => "BTC" }] }] } })
+    result = @client.wallet_balance(account_type: "UNIFIED")
+    assert result.success?
+  end
+
+  def test_create_order
+    stub_connection(:post, { "retCode" => 0, "retMsg" => "OK", "result" => { "orderId" => "123" } })
+    result = @client.create_order(category: "spot", symbol: "BTCUSDT", side: "Buy", order_type: "Market", qty: "0.001")
+    assert result.success?
+    assert_equal "123", result.data[:order_id]
+  end
+
+  def test_get_order
+    stub_connection(:get, { "retCode" => 0, "retMsg" => "OK", "result" => { "list" => [{
+      "orderId" => "123", "orderType" => "Market", "side" => "Buy", "orderStatus" => "Filled",
+      "avgPrice" => "50000", "qty" => "0.001", "cumExecQty" => "0.001", "cumExecValue" => "50"
+    }] } })
+    result = @client.get_order(category: "spot", order_id: "123")
+    assert result.success?
+    assert_equal :closed, result.data[:status]
+  end
+
+  def test_get_order_partially_filled_canceled_is_cancelled
+    stub_connection(:get, { "retCode" => 0, "retMsg" => "OK", "result" => { "list" => [{
+      "orderId" => "123", "orderType" => "Limit", "side" => "Buy", "orderStatus" => "PartiallyFilledCanceled",
+      "avgPrice" => "50000", "qty" => "0.002", "cumExecQty" => "0.001", "cumExecValue" => "50"
+    }] } })
+    result = @client.get_order(category: "spot", order_id: "123")
+    assert_equal :cancelled, result.data[:status]
+    assert_equal BigDecimal("0.001"), result.data[:amount_exec]
+  end
+
+  def test_order_history
+    @client.expects(:get_authenticated).with("/v5/order/history", {
+      category: "spot", symbol: nil, orderId: "123", orderLinkId: nil, orderStatus: nil,
+      startTime: 1, endTime: 2, limit: 50, cursor: "c"
+    }).returns(Honeymaker::Result::Success.new({ "retCode" => 0 }))
+    assert @client.order_history(category: "spot", order_id: "123", start_time: 1, end_time: 2, limit: 50, cursor: "c").success?
+  end
+
+  def test_internal_deposit_records
+    @client.expects(:get_authenticated).with("/v5/asset/deposit/query-internal-record", {
+      txID: nil, coin: "USDT", startTime: 1, endTime: 2, limit: 50, cursor: "c"
+    }).returns(Honeymaker::Result::Success.new({ "retCode" => 0 }))
+    assert @client.internal_deposit_records(coin: "USDT", start_time: 1, end_time: 2, limit: 50, cursor: "c").success?
+  end
+
+  def test_cancel_order
+    stub_connection(:post, { "result" => { "orderId" => "123" } })
+    result = @client.cancel_order(category: "spot", symbol: "BTCUSDT", order_id: "123")
+    assert result.success?
+  end
+
+  def test_kline
+    stub_connection(:get, { "result" => { "list" => [] } })
+    result = @client.kline(category: "spot", symbol: "BTCUSDT", interval: "60")
+    assert result.success?
+  end
+
+  def test_withdraw
+    stub_connection(:post, { "result" => { "id" => "w1" } })
+    result = @client.withdraw(coin: "BTC", chain: "BTC", address: "addr", amount: "0.1")
+    assert result.success?
+  end
+
+  def test_transaction_log
+    stub_connection(:get, { "result" => { "list" => [{ "transactionTime" => "1710936000000" }] } })
+    result = @client.transaction_log
+    assert result.success?
+  end
+
+  def test_execution_list
+    stub_connection(:get, { "result" => { "list" => [{ "execId" => "e1" }] } })
+    result = @client.execution_list(category: "spot")
+    assert result.success?
+  end
+
+  def test_deposit_records
+    stub_connection(:get, { "result" => { "rows" => [{ "coin" => "BTC" }] } })
+    result = @client.deposit_records
+    assert result.success?
+  end
+
+  def test_withdraw_records
+    stub_connection(:get, { "result" => { "rows" => [{ "coin" => "ETH" }] } })
+    result = @client.withdraw_records
+    assert result.success?
+  end
+
+  def test_signed_headers_include_api_key
+    headers = @client.send(:signed_headers, "GET", { foo: "bar" })
+    assert_equal "test_key", headers[:"X-BAPI-API-KEY"]
+    assert headers.key?(:"X-BAPI-SIGN")
+    assert headers.key?(:"X-BAPI-TIMESTAMP")
+  end
+
+  def test_unauthenticated_client
+    client = Honeymaker::Clients::Bybit.new
+    headers = client.send(:signed_headers, "GET", {})
+    refute headers.key?(:"X-BAPI-SIGN")
+  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/coinbase_client_test.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::CoinbaseTest < Minitest::Test
+  def setup
+    # Use ECDSA key for testing
+    @key = OpenSSL::PKey::EC.generate("prime256v1")
+    @client = Honeymaker::Clients::Coinbase.new(
+      api_key: "test_key",
+      api_secret: @key.to_pem
+    )
+  end
+
+  def test_url
+    assert_equal "https://api.coinbase.com", Honeymaker::Clients::Coinbase::URL
+  end
+
+  def test_get_order
+    stub_connection(:get, { "order" => {
+      "order_id" => "abc", "status" => "FILLED", "order_type" => "MARKET", "side" => "BUY",
+      "average_filled_price" => "50000", "filled_size" => "0.001",
+      "total_value_after_fees" => "50", "outstanding_hold_amount" => "0",
+      "order_configuration" => { "market_market_ioc" => { "quote_size" => "50" } }
+    } })
+    result = @client.get_order(order_id: "abc")
+    assert result.success?
+    assert_equal "abc", result.data[:order_id]
+    assert_equal :closed, result.data[:status]
+  end
+
+  def test_create_order
+    stub_connection(:post, { "success" => true, "success_response" => { "order_id" => "xyz" } })
+    result = @client.create_order(
+      client_order_id: "c1", product_id: "BTC-USD",
+      side: "BUY", order_configuration: { market_market_ioc: { quote_size: "100" } }
+    )
+    assert result.success?
+    assert_equal "xyz", result.data[:order_id]
+  end
+
+  def test_cancel_orders
+    stub_connection(:post, { "results" => [{ "success" => true }] })
+    result = @client.cancel_orders(order_ids: ["abc"])
+    assert result.success?
+  end
+
+  def test_list_public_products
+    stub_connection(:get, { "products" => [{ "product_id" => "BTC-USD" }] })
+    result = @client.list_public_products
+    assert result.success?
+  end
+
+  def test_get_public_product
+    stub_connection(:get, { "product_id" => "BTC-USD" })
+    result = @client.get_public_product(product_id: "BTC-USD")
+    assert result.success?
+  end
+
+  def test_get_api_key_permissions
+    stub_connection(:get, { "can_trade" => true })
+    result = @client.get_api_key_permissions
+    assert result.success?
+  end
+
+  def test_list_accounts
+    stub_connection(:get, { "accounts" => [] })
+    result = @client.list_accounts
+    assert result.success?
+  end
+
+  def test_list_accounts_passes_cursor_and_limit
+    response = stub(body: { "accounts" => [], "has_next" => false, "cursor" => "" })
+    request = stub(url: nil)
+    request.stubs(:headers=)
+    request.stubs(:http_method).returns(:get)
+    request.stubs(:path).returns("/api/v3/brokerage/accounts")
+    request.expects(:params=).with({ limit: 250, cursor: "c2" })
+    connection = stub
+    connection.stubs(:get).yields(request).returns(response)
+    @client.instance_variable_set(:@connection, connection)
+
+    assert @client.list_accounts(limit: 250, cursor: "c2").success?
+  end
+
+  def test_send_money
+    stub_connection(:post, { "data" => { "id" => "tx1" } })
+    result = @client.send_money(account_id: "acc1", to: "addr", amount: "0.1", currency: "BTC")
+    assert result.success?
+  end
+
+  def test_list_fills
+    stub_connection(:get, { "fills" => [{ "trade_id" => "f1", "product_id" => "BTC-USD" }] })
+    result = @client.list_fills(product_id: "BTC-USD")
+    assert result.success?
+    assert_equal "f1", result.data["fills"].first["trade_id"]
+  end
+
+  def test_list_transactions
+    stub_connection(:get, { "data" => [{ "id" => "tx1", "type" => "send" }] })
+    result = @client.list_transactions(account_id: "acc1")
+    assert result.success?
+    assert_equal "tx1", result.data["data"].first["id"]
+  end
+
+  def test_handles_api_error
+    connection = stub
+    connection.stubs(:get).raises(Faraday::ClientError.new("401", { status: 401, body: "Unauthorized" }))
+    @client.instance_variable_set(:@connection, connection)
+    result = @client.list_accounts
+    assert result.failure?
+  end
+
+  def test_ecdsa_key_detected
+    assert @client.send(:ecdsa_key?)
+  end
+
+  def test_non_ecdsa_key_not_detected
+    client = Honeymaker::Clients::Coinbase.new(api_key: "k", api_secret: "not-a-pem-key")
+    refute client.send(:ecdsa_key?)
+  end
+
+  def test_ed25519_returns_nil_without_rbnacl
+    client = Honeymaker::Clients::Coinbase.new(api_key: "k", api_secret: Base64.encode64("short"))
+    # rbnacl may or may not be installed; either way should not raise
+    result = client.send(:ed25519_signing_key)
+    # Returns nil if rbnacl not installed or key is invalid
+    assert_nil result
+  end
+
+  def test_unauthenticated_headers
+    client = Honeymaker::Clients::Coinbase.new
+    stub_connection_on(client, :get, { "products" => [] })
+    result = client.list_public_products
+    assert result.success?
+  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
+
+  def stub_connection_on(client, 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/gemini_client_test.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::GeminiTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::Gemini.new(api_key: "test_key", api_secret: "test_secret")
+  end
+
+  def test_url
+    assert_equal "https://api.gemini.com", Honeymaker::Clients::Gemini::URL
+  end
+
+  def test_get_symbols
+    stub_connection(:get, ["btcusd", "ethusd"])
+    result = @client.get_symbols
+    assert result.success?
+    assert_includes result.data, "btcusd"
+  end
+
+  def test_get_symbol_details
+    stub_connection(:get, { "symbol" => "BTCUSD", "base_currency" => "BTC" })
+    result = @client.get_symbol_details(symbol: "btcusd")
+    assert result.success?
+  end
+
+  def test_get_ticker
+    stub_connection(:get, { "last" => "50000" })
+    result = @client.get_ticker(symbol: "btcusd")
+    assert result.success?
+  end
+
+  def test_get_balances
+    stub_connection(:post, [{ "currency" => "BTC", "amount" => "0.5" }])
+    result = @client.get_balances
+    assert result.success?
+  end
+
+  def test_new_order
+    stub_connection(:post, { "order_id" => "123" })
+    result = @client.new_order(symbol: "btcusd", amount: "0.001", price: "50000", side: "buy", type: "exchange limit")
+    assert result.success?
+  end
+
+  def test_order_status
+    stub_connection(:post, { "order_id" => "123", "is_live" => false })
+    result = @client.order_status(order_id: "123")
+    assert result.success?
+  end
+
+  def test_cancel_order
+    stub_connection(:post, { "order_id" => "123", "is_cancelled" => true })
+    result = @client.cancel_order(order_id: "123")
+    assert result.success?
+  end
+
+  def test_withdraw
+    stub_connection(:post, { "destination" => "addr", "amount" => "0.1" })
+    result = @client.withdraw(currency: "btc", address: "addr", amount: "0.1")
+    assert result.success?
+  end
+
+  def test_get_my_trades
+    stub_connection(:post, [{ "tid" => 123, "price" => "50000" }])
+    result = @client.get_my_trades(symbol: "btcusd")
+    assert result.success?
+  end
+
+  def test_get_transfers
+    stub_connection(:post, [{ "type" => "Deposit", "currency" => "BTC" }])
+    result = @client.get_transfers
+    assert result.success?
+  end
+
+  # Gemini signs with HMAC-SHA384 of the base64 payload
+  # (https://developer.gemini.com/authentication/api-key); any other digest is rejected.
+  def test_private_requests_are_signed_with_hmac_sha384
+    request = Struct.new(:headers) { def url(_path) = nil }.new
+    connection = Object.new
+    connection.define_singleton_method(:post) do |&block|
+      block.call(request)
+      Struct.new(:body).new({})
+    end
+    @client.instance_variable_set(:@connection, connection)
+
+    @client.get_balances
+
+    payload = request.headers[:"X-GEMINI-PAYLOAD"]
+    assert_equal OpenSSL::HMAC.hexdigest("sha384", "test_secret", payload), request.headers[:"X-GEMINI-SIGNATURE"]
+  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/honeymaker_client_registry_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HoneymakerClientRegistryTest < Minitest::Test
+  def test_client_returns_correct_class
+    client = Honeymaker.client("binance", api_key: "k", api_secret: "s")
+    assert_instance_of Honeymaker::Clients::Binance, client
+  end
+
+  def test_client_with_symbol
+    client = Honeymaker.client(:kraken, api_key: "k", api_secret: "s")
+    assert_instance_of Honeymaker::Clients::Kraken, client
+  end
+
+  def test_client_raises_for_unknown
+    assert_raises(Honeymaker::Error) { Honeymaker.client("unknown") }
+  end
+
+  def test_all_clients_registered
+    assert_equal 14, Honeymaker::CLIENTS.size
+  end
+
+  def test_client_passes_credentials
+    client = Honeymaker.client("binance", api_key: "my_key", api_secret: "my_secret")
+    assert_equal "my_key", client.api_key
+    assert_equal "my_secret", client.api_secret
+  end
+
+  def test_bitget_accepts_passphrase
+    client = Honeymaker.client("bitget", api_key: "k", api_secret: "s", passphrase: "p")
+    assert_equal "p", client.passphrase
+  end
+
+  def test_kucoin_accepts_passphrase
+    client = Honeymaker.client("kucoin", api_key: "k", api_secret: "s", passphrase: "p")
+    assert_equal "p", client.passphrase
+  end
+end