honeymaker 0.12.4-x86_64-linux

data/test/honeymaker/clients/kucoin_client_test.rb

@@ -0,0 +1,149 @@
+# 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, { "code" => "200000", "data" => { "orderId" => "123" } })
+    result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
+    assert result.success?
+    assert_equal "123", result.data[:order_id]
+  end
+
+  def test_get_order
+    stub_connection(:get, { "code" => "200000", "data" => {
+      "id" => "123", "symbol" => "BTC-USDT", "type" => "market", "side" => "buy",
+      "isActive" => false, "cancelExist" => false, "dealSize" => "0.001",
+      "dealFunds" => "50", "size" => "0.001", "price" => "50000"
+    } })
+    result = @client.get_order(order_id: "123")
+    assert result.success?
+    assert_equal :closed, result.data[:status]
+  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_get_historical_orders
+    stub_connection(:get, { "data" => { "items" => [{ "id" => "ho1", "symbol" => "BTC-USDT" }] } })
+    result = @client.get_historical_orders
+    assert result.success?
+  end
+
+  def test_get_fills
+    stub_connection(:get, { "data" => { "items" => [{ "tradeId" => "t1" }] } })
+    result = @client.get_fills(symbol: "BTC-USDT")
+    assert result.success?
+  end
+
+  def test_get_deposits
+    stub_connection(:get, { "data" => { "items" => [{ "currency" => "BTC" }] } })
+    result = @client.get_deposits
+    assert result.success?
+  end
+
+  def test_get_withdrawals
+    stub_connection(:get, { "data" => { "items" => [{ "currency" => "ETH" }] } })
+    result = @client.get_withdrawals
+    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
+
+  # KuCoin signals business errors in an HTTP-200 envelope. Callers classify on this text
+  # (insufficient funds, bad key, stale timestamp), so the code and msg must survive.
+  def test_place_order_keeps_api_code_and_message
+    stub_connection(:post, { "code" => "200004", "msg" => "Balance insufficient!" })
+    result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
+    assert result.failure?
+    assert_includes result.errors.first, "Balance insufficient!"
+    assert_includes result.errors.first, "200004"
+  end
+
+  def test_get_order_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "400002", "msg" => "Invalid KC-API-TIMESTAMP." })
+    result = @client.get_order(order_id: "123")
+    assert result.failure?
+    assert_includes result.errors.first, "Invalid KC-API-TIMESTAMP."
+  end
+
+  def test_get_balances_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "400003", "msg" => "KC-API-KEY not exists" })
+    result = @client.get_balances
+    assert result.failure?
+    assert_includes result.errors.first, "KC-API-KEY not exists"
+  end
+
+  def test_api_error_falls_back_when_body_carries_no_detail
+    stub_connection(:post, { "code" => nil })
+    result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
+    assert result.failure?
+    assert_equal "KuCoin API error", result.errors.first
+  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,98 @@
+# 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", "symbol" => "BTCUSDT", "status" => "FILLED", "type" => "MARKET",
+      "side" => "BUY", "origQty" => "0.001", "executedQty" => "0.001",
+      "cummulativeQuoteQty" => "50", "price" => "50000"
+    })
+    result = @client.query_order(symbol: "BTCUSDT", order_id: "123")
+    assert result.success?
+    assert_equal :closed, result.data[:status]
+  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_account_trade_list
+    stub_connection(:get, [{ "symbol" => "BTCUSDT", "id" => 1 }])
+    result = @client.account_trade_list(symbol: "BTCUSDT")
+    assert result.success?
+  end
+
+  def test_deposit_history
+    stub_connection(:get, [{ "coin" => "BTC" }])
+    result = @client.deposit_history
+    assert result.success?
+  end
+
+  def test_withdraw_history
+    stub_connection(:get, [{ "coin" => "ETH" }])
+    result = @client.withdraw_history
+    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/clients/validation_test.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ValidationTest < Minitest::Test
+  def test_validate_without_credentials
+    client = Honeymaker::Client.new
+    result = client.validate(:trading)
+    assert result.failure?
+    assert_includes result.errors, "No credentials provided"
+  end
+
+  def test_validate_unknown_type
+    client = Honeymaker::Client.new(api_key: "k", api_secret: "s")
+    assert_raises(Honeymaker::Error) { client.validate(:unknown) }
+  end
+
+  def test_validate_rescues_errors
+    client = Honeymaker::Client.new(api_key: "k", api_secret: "s")
+    client.define_singleton_method(:validate_trading_credentials) { raise "boom" }
+    result = client.validate(:trading)
+    assert result.failure?
+    assert_includes result.errors, "boom"
+  end
+
+  # Binance
+  def test_binance_validate_trading_success
+    client = Honeymaker::Clients::Binance.new(api_key: "k", api_secret: "s")
+    # cancel_order returns error code -2011 = valid key
+    stub_connection(client, :delete, { "code" => -2011, "msg" => "Unknown order" })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  def test_binance_validate_trading_failure
+    client = Honeymaker::Clients::Binance.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :delete, { "code" => -2015, "msg" => "Invalid API-key" })
+    result = client.validate(:trading)
+    assert result.failure?
+  end
+
+  def test_binance_validate_read
+    client = Honeymaker::Clients::Binance.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :get, { "ipRestrict" => true })
+    result = client.validate(:read)
+    assert result.success?
+  end
+
+  # Kraken
+  def test_kraken_validate_trading_success
+    client = Honeymaker::Clients::Kraken.new(api_key: "k", api_secret: Base64.strict_encode64("s" * 32))
+    stub_connection(client, :post, { "error" => [], "result" => { "XXBT" => "0.5" } })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  def test_kraken_validate_trading_failure
+    client = Honeymaker::Clients::Kraken.new(api_key: "k", api_secret: Base64.strict_encode64("s" * 32))
+    stub_connection(client, :post, { "error" => ["EAPI:Invalid key"], "result" => {} })
+    result = client.validate(:trading)
+    assert result.failure?
+  end
+
+  # Coinbase
+  def test_coinbase_validate_trading_success
+    key = OpenSSL::PKey::EC.generate("prime256v1")
+    client = Honeymaker::Clients::Coinbase.new(api_key: "k", api_secret: key.to_pem)
+    stub_connection(client, :get, { "accounts" => [] })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  # Bybit
+  def test_bybit_validate_trading_success
+    client = Honeymaker::Clients::Bybit.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :get, { "retCode" => 0, "result" => {} })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  def test_bybit_validate_trading_failure
+    client = Honeymaker::Clients::Bybit.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :get, { "retCode" => 10003, "retMsg" => "Invalid apikey" })
+    result = client.validate(:trading)
+    assert result.failure?
+  end
+
+  # MEXC
+  def test_mexc_validate_trading_success
+    client = Honeymaker::Clients::Mexc.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :get, { "balances" => [] })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  # Bitget
+  def test_bitget_validate_trading_success
+    client = Honeymaker::Clients::Bitget.new(api_key: "k", api_secret: "s", passphrase: "p")
+    stub_connection(client, :get, { "code" => "00000", "data" => [] })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  def test_bitget_validate_trading_failure
+    client = Honeymaker::Clients::Bitget.new(api_key: "k", api_secret: "s", passphrase: "p")
+    stub_connection(client, :get, { "code" => "40014", "msg" => "Invalid ApiKey" })
+    result = client.validate(:trading)
+    assert result.failure?
+  end
+
+  # KuCoin
+  def test_kucoin_validate_trading_success
+    client = Honeymaker::Clients::Kucoin.new(api_key: "k", api_secret: "s", passphrase: "p")
+    stub_connection(client, :get, { "code" => "200000", "data" => [] })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  # Bitvavo
+  def test_bitvavo_validate_trading_success
+    client = Honeymaker::Clients::Bitvavo.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :get, [{ "symbol" => "BTC", "available" => "0.5" }])
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  # Gemini
+  def test_gemini_validate_trading_success
+    client = Honeymaker::Clients::Gemini.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :post, [{ "currency" => "BTC", "amount" => "0.5" }])
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  # BingX
+  def test_bingx_validate_trading_success
+    client = Honeymaker::Clients::BingX.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :get, { "code" => 0, "data" => {} })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  # Bitrue
+  def test_bitrue_validate_trading_success
+    client = Honeymaker::Clients::Bitrue.new(api_key: "k", api_secret: "s")
+    stub_connection(client, :get, { "balances" => [] })
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  # Hyperliquid
+  def test_hyperliquid_validate_trading_success
+    client = Honeymaker::Clients::Hyperliquid.new(api_key: "0xabc", api_secret: "s")
+    stub_connection(client, :post, [])
+    result = client.validate(:trading)
+    assert result.success?
+  end
+
+  private
+
+  def stub_connection(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/error_chain_test.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "socket"
+
+# A transport failure — the request got no HTTP answer at all — carries the chain of exception
+# classes behind it, outermost first. The text of such a failure rarely says what happened
+# ("end of file reached"); the chain does, and it is what lets a caller tell a request that never
+# left (DNS, a refused connection, a proxy refusing CONNECT) from one that may have landed (EOF,
+# reset, read timeout). Honeymaker only reports it; deciding what it means is the caller's job.
+class Honeymaker::ErrorChainTest < Minitest::Test
+  def test_walks_wrapped_exceptions_and_causes_outermost_first
+    error = Faraday::ConnectionFailed.new(EOFError.new("end of file reached"))
+
+    assert_equal %w[Faraday::ConnectionFailed EOFError], Honeymaker::Utils.error_chain(error)
+  end
+
+  def test_follows_ruby_causes_and_names_each_class_once
+    error = begin
+      begin
+        raise Errno::ECONNREFUSED
+      rescue Errno::ECONNREFUSED
+        raise Faraday::ConnectionFailed, "connection refused"
+      end
+    rescue Faraday::ConnectionFailed => e
+      e
+    end
+
+    assert_equal %w[Faraday::ConnectionFailed Errno::ECONNREFUSED], Honeymaker::Utils.error_chain(error)
+  end
+
+  # Adapters re-wrap: a class seen once must not hide what sits beneath its second instance.
+  def test_a_repeated_class_does_not_cut_the_chain_short
+    inner = Faraday::ConnectionFailed.new(Errno::ECONNREFUSED.new)
+    error = Faraday::ConnectionFailed.new(inner)
+
+    assert_equal %w[Faraday::ConnectionFailed Errno::ECONNREFUSED], Honeymaker::Utils.error_chain(error)
+  end
+
+  def test_client_failure_carries_the_chain_and_keeps_its_text
+    result = Honeymaker::Client.new.send(:with_rescue) do
+      raise Faraday::ConnectionFailed, EOFError.new("end of file reached")
+    end
+
+    assert_equal ["end of file reached"], result.errors
+    assert_nil result.data[:status]
+    assert_equal %w[Faraday::ConnectionFailed EOFError], result.data[:error_chain]
+  end
+
+  def test_exchange_failure_carries_the_chain_and_keeps_its_text
+    result = Honeymaker::Exchange.new.send(:with_rescue) do
+      raise Faraday::ConnectionFailed, EOFError.new("end of file reached")
+    end
+
+    assert_equal ["end of file reached"], result.errors
+    assert_equal %w[Faraday::ConnectionFailed EOFError], result.data[:error_chain]
+  end
+
+  # An HTTP answer is not a transport failure: its status says what happened.
+  def test_a_failure_with_an_http_answer_has_no_chain
+    error = Faraday::ServerError.new("boom", { status: 503, body: "unavailable" })
+    [Honeymaker::Client.new, Honeymaker::Exchange.new].each do |receiver|
+      result = receiver.send(:with_rescue) { raise error }
+
+      assert_nil result.data[:error_chain], receiver.class.name
+    end
+  end
+
+  # --- The chains the real adapter produces, against local sockets -------------------------------
+
+  def setup
+    @servers = []
+  end
+
+  # Closing a server makes its blocked #accept raise, which ends the serving thread; joining it
+  # keeps that thread from outliving the test.
+  def teardown
+    @servers.each do |server, thread|
+      server.close
+      thread.join(1)
+    end
+  end
+
+  def test_real_chain_for_a_connection_closed_before_the_answer
+    port = local_server
+
+    assert_equal %w[Faraday::ConnectionFailed EOFError], chain_of("http://127.0.0.1:#{port}")
+  end
+
+  def test_real_chain_for_a_refused_connection
+    port = TCPServer.new("127.0.0.1", 0).then { |s| s.addr[1].tap { s.close } }
+
+    assert_includes chain_of("http://127.0.0.1:#{port}"), "Errno::ECONNREFUSED"
+  end
+
+  def test_real_chain_for_a_proxy_refusing_connect
+    port = local_server("HTTP/1.1 407 Proxy Authentication Required\r\nContent-Length: 0\r\n\r\n")
+    client = Honeymaker::Client.new(proxy: "http://127.0.0.1:#{port}")
+    result = client.send(:with_rescue) { client.send(:build_client_connection, "https://example.com").get("/") }
+
+    assert_equal %w[Faraday::ConnectionFailed Net::HTTPClientException], result.data[:error_chain]
+  end
+
+  private
+
+  # A local server that reads each request and answers with `reply`, or hangs up without an answer
+  # when there is none. Returns its port; teardown closes it.
+  def local_server(reply = nil)
+    server = TCPServer.new("127.0.0.1", 0)
+    thread = Thread.new do
+      loop do
+        client = server.accept
+        begin
+          client.readpartial(4096)
+          client.write(reply) if reply
+        rescue EOFError, SystemCallError
+          nil
+        ensure
+          client.close
+        end
+      end
+    rescue IOError, SystemCallError
+      nil # the server was closed in teardown
+    end
+    @servers << [server, thread]
+    server.addr[1]
+  end
+
+  def chain_of(url)
+    client = Honeymaker::Client.new
+    client.send(:with_rescue) { client.send(:build_client_connection, url).get("/") }.data[:error_chain]
+  end
+end

data/test/honeymaker/exchange_test.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::ExchangeTest < Minitest::Test
+  def test_get_tickers_info_raises_not_implemented
+    exchange = Honeymaker::Exchange.new
+    assert_raises(NotImplementedError) { exchange.get_tickers_info }
+  end
+
+  def test_with_rescue_wraps_faraday_errors
+    exchange = Honeymaker::Exchange.new
+    result = exchange.send(:with_rescue) { raise Faraday::TimeoutError, "timeout" }
+    assert result.failure?
+    assert_match(/timeout/, result.errors.first)
+  end
+
+  def test_with_rescue_wraps_standard_errors
+    exchange = Honeymaker::Exchange.new
+    result = exchange.send(:with_rescue) { raise StandardError, "boom" }
+    assert result.failure?
+    assert_equal ["boom"], result.errors
+  end
+
+  def test_with_rescue_returns_success_on_no_error
+    exchange = Honeymaker::Exchange.new
+    result = exchange.send(:with_rescue) { [1, 2, 3] }
+    assert result.success?
+    assert_equal [1, 2, 3], result.data
+  end
+
+  def test_get_bid_ask_raises_not_implemented
+    exchange = Honeymaker::Exchange.new
+    assert_raises(NotImplementedError) { exchange.get_bid_ask("BTCUSDT") }
+  end
+
+  def test_get_price_returns_midpoint
+    exchange = Honeymaker::Exchange.new
+    bid_ask = { bid: BigDecimal("100"), ask: BigDecimal("102") }
+    exchange.define_singleton_method(:get_bid_ask) { |_| Honeymaker::Result::Success.new(bid_ask) }
+
+    result = exchange.get_price("BTCUSDT")
+    assert result.success?
+    assert_equal BigDecimal("101"), result.data
+  end
+
+  def test_get_price_propagates_failure
+    exchange = Honeymaker::Exchange.new
+    exchange.define_singleton_method(:get_bid_ask) { |_| Honeymaker::Result::Failure.new("error") }
+
+    result = exchange.get_price("BTCUSDT")
+    assert result.failure?
+  end
+
+  def test_tickers_info_caches_result
+    exchange = Honeymaker::Exchange.new
+    tickers = [{ ticker: "BTCUSDT", base: "BTC", quote: "USDT" }]
+    call_count = 0
+    exchange.define_singleton_method(:get_tickers_info) do
+      call_count += 1
+      Honeymaker::Result::Success.new(tickers)
+    end
+
+    result1 = exchange.tickers_info
+    result2 = exchange.tickers_info
+    assert result1.success?
+    assert result2.success?
+    assert_equal 1, call_count
+  end
+
+  def test_tickers_info_does_not_cache_failure
+    exchange = Honeymaker::Exchange.new
+    call_count = 0
+    exchange.define_singleton_method(:get_tickers_info) do
+      call_count += 1
+      Honeymaker::Result::Failure.new("error")
+    end
+
+    exchange.tickers_info
+    exchange.tickers_info
+    assert_equal 2, call_count
+  end
+
+  def test_find_ticker_returns_matching_ticker
+    exchange = Honeymaker::Exchange.new
+    tickers = [
+      { ticker: "BTCUSDT", base: "BTC", quote: "USDT" },
+      { ticker: "ETHUSDT", base: "ETH", quote: "USDT" }
+    ]
+    exchange.define_singleton_method(:get_tickers_info) do
+      Honeymaker::Result::Success.new(tickers)
+    end
+
+    result = exchange.find_ticker("ETHUSDT")
+    assert result.success?
+    assert_equal "ETH", result.data[:base]
+  end
+
+  def test_find_ticker_returns_failure_for_unknown_symbol
+    exchange = Honeymaker::Exchange.new
+    exchange.define_singleton_method(:get_tickers_info) do
+      Honeymaker::Result::Success.new([{ ticker: "BTCUSDT" }])
+    end
+
+    result = exchange.find_ticker("NOPE")
+    assert result.failure?
+  end
+
+  def test_symbols_returns_base_quote_pairs
+    exchange = Honeymaker::Exchange.new
+    tickers = [
+      { ticker: "BTCUSDT", base: "BTC", quote: "USDT" },
+      { ticker: "ETHUSDT", base: "ETH", quote: "USDT" }
+    ]
+    exchange.define_singleton_method(:get_tickers_info) do
+      Honeymaker::Result::Success.new(tickers)
+    end
+
+    result = exchange.symbols
+    assert result.success?
+    assert_equal [{ base: "BTC", quote: "USDT" }, { base: "ETH", quote: "USDT" }], result.data
+  end
+
+  def test_cache_ttl_defaults_to_3600
+    exchange = Honeymaker::Exchange.new
+    assert_equal 3600, exchange.cache_ttl
+  end
+
+  def test_classify_error_returns_nil_when_no_patterns
+    exchange = Honeymaker::Exchange.new
+    assert_nil exchange.classify_error("anything")
+  end
+
+  def test_classify_error_returns_nil_for_nil_message
+    exchange = Honeymaker::Exchange.new
+    assert_nil exchange.classify_error(nil)
+  end
+end