honeymaker 0.12.4-x86_64-linux

data/test/honeymaker/exchanges/binance_test.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::BinanceTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Binance.new
+  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]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00000100", ticker[:minimum_base_size]
+    assert_equal "5.00000000", ticker[:minimum_quote_size]
+    assert_equal 6, ticker[:base_decimals]
+    assert_equal 8, ticker[:quote_decimals]
+    assert_equal 2, ticker[:price_decimals]
+    assert ticker[:available]
+    assert ticker[:trading_enabled]
+  end
+
+  def test_get_tickers_info_marks_non_trading_pairs_disabled
+    body = load_fixture("binance_exchange_info.json")
+    body["symbols"].first["status"] = "BREAK"
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    ticker = result.data.first
+    assert ticker[:available]        # still listed
+    refute ticker[:trading_enabled]  # but not trading
+  end
+
+  def test_get_tickers_info_handles_api_error
+    connection = stub
+    connection.stubs(:get).raises(Faraday::ServerError.new("500", { status: 500, body: "Internal Server Error" }))
+    @exchange.instance_variable_set(:@connection, connection)
+
+    result = @exchange.get_tickers_info
+
+    assert result.failure?
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("binance_book_ticker.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTCUSDT")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  end
+
+  def test_get_bid_ask_handles_api_error
+    connection = stub
+    connection.stubs(:get).raises(Faraday::ServerError.new("500", { status: 500, body: "Internal Server Error" }))
+    @exchange.instance_variable_set(:@connection, connection)
+
+    result = @exchange.get_bid_ask("BTCUSDT")
+
+    assert result.failure?
+  end
+
+  private
+
+  def stub_connection(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).with { |path, &block| block&.call(OpenStruct.new(params: {})); true }.returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/binance_us_test.rb

@@ -0,0 +1,53 @@
+# 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]
+    assert ticker[:available]
+    assert ticker[:trading_enabled]
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("binance_book_ticker.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTCUSDT")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  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,65 @@
+# 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]
+    assert ticker[:trading_enabled]
+  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
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("bingx_ticker.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTC-USDT")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  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,65 @@
+# 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]
+    assert ticker[:trading_enabled]
+  end
+
+  def test_offline_symbol_listed_but_not_trading_enabled
+    body = load_fixture("bitget_symbols.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    eth = result.data.find { |t| t[:ticker] == "ETHUSDT" }
+    assert eth[:available]          # still listed
+    refute eth[:trading_enabled]    # but not trading
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("bitget_tickers.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTCUSDT")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  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,65 @@
+# 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]
+    assert ticker[:trading_enabled]
+  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
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("bitrue_book_ticker.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTCUSDT")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  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,65 @@
+# 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 8, ticker[:base_decimals]
+    assert_equal 2, ticker[:quote_decimals]
+    assert_equal 0, ticker[:price_decimals] # tickSize "1.00" -> whole-number prices
+    assert ticker[:available]
+    assert ticker[:trading_enabled]
+  end
+
+  def test_halted_market_listed_but_not_trading_enabled
+    body = load_fixture("bitvavo_markets.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    eth = result.data.find { |t| t[:ticker] == "ETH-EUR" }
+    assert eth[:available]          # still listed
+    refute eth[:trading_enabled]    # but not trading
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("bitvavo_book_ticker.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTC-EUR")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  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,55 @@
+# 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]
+    assert ticker[:trading_enabled]
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("bybit_tickers.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTCUSDT")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  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,106 @@
+# 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?
+    # RNDR 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]
+    assert ticker[:trading_enabled] # no disabled signal -> defaults to true
+  end
+
+  def test_get_tickers_info_disables_when_trading_disabled
+    body = load_fixture("coinbase_products.json")
+    body["products"].first["trading_disabled"] = true
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    ticker = result.data.first
+    assert ticker[:available]        # still listed
+    refute ticker[:trading_enabled]  # but not trading
+  end
+
+  def test_get_tickers_info_disables_when_status_not_online
+    body = load_fixture("coinbase_products.json")
+    body["products"].first["status"] = "delisted"
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    refute result.data.first[:trading_enabled]
+  end
+
+  def test_get_tickers_info_disables_restricted_modes
+    %w[limit_only cancel_only is_disabled].each do |flag|
+      body = load_fixture("coinbase_products.json")
+      body["products"].first[flag] = true
+      stub_connection(body)
+
+      ticker = @exchange.get_tickers_info.data.first
+      assert ticker[:available], flag
+      refute ticker[:trading_enabled], flag
+    end
+  end
+
+  def test_keeps_render
+    body = load_fixture("coinbase_products.json")
+    body["products"] << body["products"].last.merge("product_id" => "RENDER-USD")
+    stub_connection(body)
+
+    assert_includes @exchange.get_tickers_info.data.map { |t| t[:base] }, "RENDER"
+  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, "RNDR"
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("coinbase_product.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTC-USD")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  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_catalogue_test.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# The set-aside rule, driven through honeymaker's real middleware stack: one symbol Gemini lists but
+# cannot describe is left out and named, and never fails the whole catalogue.
+class Honeymaker::Exchanges::GeminiCatalogueTest < Minitest::Test
+  JSON_CT = { "Content-Type" => "application/json" }.freeze
+
+  def detail(sym, base, quote, **over)
+    { "symbol" => sym.upcase, "base_currency" => base, "quote_currency" => quote, "tick_size" => "0.00000001",
+      "quote_increment" => "0.01", "min_order_size" => "0.00001", "status" => "open", "product_type" => "spot" }.merge(over.transform_keys(&:to_s))
+  end
+
+  def exchange_with(symbols, &details)
+    stubs = Faraday::Adapter::Test::Stubs.new do |s|
+      s.get("/v1/symbols") { [200, JSON_CT, JSON.dump(symbols)] }
+      symbols.each { |sym| s.get("/v1/symbols/details/#{sym}") { details.call(sym) } }
+    end
+    ex = Honeymaker::Exchanges::Gemini.new
+    @sleeps = sleeps = []
+    ex.define_singleton_method(:sleep) { |s| sleeps << s }
+    conn = Faraday.new(url: "https://api.gemini.com") do |c|
+      c.request :json; c.response :json; c.response :raise_error; c.adapter :test, stubs
+    end
+    ex.instance_variable_set(:@connection, conn)
+    ex
+  end
+
+  def ok(sym)
+    base = sym[0..-4].upcase
+    [200, JSON_CT, JSON.dump(detail(sym, base, "USD"))]
+  end
+
+  def test_incident_replay_sets_gramsgd_aside_and_reads_the_rest
+    body = '{"result":"error","reason":"InvalidSymbol","message":"Received unsupported symbol \'gramsgd\'"}'
+    ex = exchange_with(%w[btcusd gramsgd ethusd]) { |s| s == "gramsgd" ? [400, JSON_CT, body] : ok(s) }
+    r = ex.get_tickers_info
+    assert r.success?
+    assert_equal %w[BTCUSD ETHUSD], r.data.map { |t| t[:ticker] }
+    assert_equal({ "GRAMSGD" => "HTTP 400 #{body}" }, ex.unreadable_symbols)
+    assert_equal [0.5] * 4, @sleeps, "a 400 is not retried"
+  end
+
+  def test_text_plain_details_are_set_aside_not_read_as_non_spot
+    ex = exchange_with(%w[btcusd ethusd]) do |s|
+      s == "ethusd" ? [200, { "Content-Type" => "text/plain" }, JSON.dump(detail("ethusd", "ETH", "USD"))] : ok(s)
+    end
+    r = ex.get_tickers_info
+    assert r.success?
+    assert_equal %w[BTCUSD], r.data.map { |t| t[:ticker] }
+    assert_match(/not an object/, ex.unreadable_symbols["ETHUSD"])
+  end
+
+  def test_garbage_shapes_are_each_set_aside
+    shapes = {
+      "aaausd" => [200, JSON_CT, JSON.dump(detail("aaausd", "AAA", "USD").except("product_type"))],
+      "bbbusd" => [200, { "Content-Type" => "text/html" }, "<html>oops</html>"],
+      "cccusd" => [200, JSON_CT, "{not json"],
+      "dddusd" => [200, JSON_CT, JSON.dump([1, 2])],
+      "eeeusd" => [200, JSON_CT, JSON.dump(detail("eeeusd", nil, "USD"))],
+      "fffusd" => [403, { "Content-Type" => "text/html" }, "<html>blocked</html>"],
+      "gggusd" => [404, JSON_CT, "{}"],
+      "hhhusd" => [200, JSON_CT, JSON.dump(detail("hhhusd", "HHH", "USD", product_type: ""))],
+      "iiiusd" => [200, JSON_CT, JSON.dump(detail("iiiusd", "III", "USD").except("status"))]
+    }
+    ex = exchange_with(%w[btcusd] + shapes.keys) { |s| shapes[s] || ok(s) }
+    r = ex.get_tickers_info
+    assert r.success?, r.errors.inspect
+    assert_equal %w[BTCUSD], r.data.map { |t| t[:ticker] }
+    assert_equal shapes.keys.map(&:upcase).sort, ex.unreadable_symbols.keys.sort
+  end
+
+  def test_one_symbol_without_answer_is_set_aside_after_its_retries
+    ex = exchange_with(%w[btcusd ethusd solusd]) { |s| s == "ethusd" ? [503, JSON_CT, "{}"] : ok(s) }
+    r = ex.get_tickers_info
+    assert r.success?
+    assert_equal %w[BTCUSD SOLUSD], r.data.map { |t| t[:ticker] }
+    assert_equal [0.5, 0.5, 0.5, 2, 0.5, 4, 0.5, 0.5], @sleeps
+  end
+
+  def test_the_no_answer_budget_fails_the_whole_catalogue
+    syms = (1..12).map { |i| format("x%02dusd", i) }
+    requested = []
+    ex = exchange_with(syms) { |s| requested << s; [503, JSON_CT, "{}"] }
+    r = ex.get_tickers_info
+    assert r.failure?
+    assert_equal({ status: 503 }, r.data)
+    assert_equal 10, requested.uniq.size, "stops at the budget"
+  end
+
+  def test_nine_no_answers_among_readable_symbols_still_succeed
+    syms = (1..9).flat_map { |i| [format("x%02dusd", i), format("y%02dusd", i)] }
+    ex = exchange_with(syms) { |s| s.start_with?("x") ? [503, JSON_CT, "{}"] : ok(s) }
+    r = ex.get_tickers_info
+    assert r.success?, r.errors.inspect
+    assert_equal 9, r.data.size
+    assert_equal 9, ex.unreadable_symbols.size
+  end
+
+  def test_every_pair_claimed_twice_is_set_aside_and_the_rest_kept
+    twins = { "btcusd2" => %w[BTC USD], "ethusd2" => %w[ETH USD] }
+    ex = exchange_with(%w[btcusd btcusd2 ethusd ethusd2 solusd]) do |s|
+      twins[s] ? [200, JSON_CT, JSON.dump(detail(s, *twins[s]))] : ok(s)
+    end
+    r = ex.get_tickers_info
+    assert r.success?
+    assert_equal %w[SOLUSD], r.data.map { |t| t[:ticker] }
+    assert_equal %w[BTCUSD BTCUSD2 ETHUSD ETHUSD2], ex.unreadable_symbols.keys.sort
+  end
+
+  def test_nothing_readable_is_a_failure_and_state_resets_between_runs
+    ex = exchange_with(%w[btcusd]) { |_| [400, JSON_CT, "{}"] }
+    assert ex.get_tickers_info.failure?
+    assert_equal %w[BTCUSD], ex.unreadable_symbols.keys
+    assert_equal({}, Honeymaker::Exchanges::Binance.new.unreadable_symbols)
+  end
+end