honeymaker 0.12.4-x86_64-linux

data/test/honeymaker/exchanges/gemini_test.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::GeminiTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Gemini.new
+    # Recorded, not slept: the pacing and the backoff are asserted as a sequence.
+    sleeps = @sleeps = []
+    @exchange.define_singleton_method(:sleep) { |seconds| sleeps << seconds }
+  end
+
+  def test_get_tickers_info_parses_response
+    stub_catalogue(load_fixture("gemini_symbols.json"))
+
+    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]
+    assert ticker[:trading_enabled]
+  end
+
+  def test_get_tickers_info_paces_every_request
+    stub_catalogue(%w[btcusd ethusd])
+
+    assert @exchange.get_tickers_info.success?
+    assert_equal [0.5, 0.5, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_retries_a_dropped_detail_request
+    connection = stub_catalogue(%w[btcusd ethusd])
+    connection.stubs(:get).with("/v1/symbols/details/ethusd")
+              .raises(Faraday::ConnectionFailed, "end of file reached")
+              .then.returns(stub(body: detail_for("ethusd")))
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+    assert_equal [0.5, 0.5, 0.5, 2, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_retries_the_symbols_request
+    connection = stub_catalogue(%w[btcusd])
+    connection.stubs(:get).with("/v1/symbols")
+              .raises(Faraday::TooManyRequestsError, "429")
+              .then.returns(stub(body: %w[btcusd]))
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 1, result.data.size
+  end
+
+  def test_get_tickers_info_retries_every_transient_error_class
+    Honeymaker::Exchanges::Gemini::TRANSIENT_ERRORS.each do |error_class|
+      setup
+      connection = stub_catalogue(%w[btcusd])
+      connection.stubs(:get).with("/v1/symbols/details/btcusd")
+                .raises(error_class, "transient").then.returns(detail_response)
+
+      assert @exchange.get_tickers_info.success?, "#{error_class} should be retried"
+    end
+  end
+
+  # Set aside, not fatal: a symbol that keeps failing is left out and named, and the run goes on.
+  def test_get_tickers_info_sets_aside_a_symbol_that_keeps_failing
+    connection = stub_catalogue(%w[btcusd ethusd solusd])
+    connection.expects(:get).with("/v1/symbols/details/ethusd").times(3)
+              .raises(Faraday::ConnectionFailed, "end of file reached")
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal %w[BTCUSD SOLUSD], result.data.map { |t| t[:ticker] }
+    assert_equal({ "ETHUSD" => "Faraday::ConnectionFailed: end of file reached" }, @exchange.unreadable_symbols)
+    assert_equal [0.5, 0.5, 0.5, 2, 0.5, 4, 0.5, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_does_not_retry_a_non_transient_error
+    connection = stub_catalogue(%w[btcusd ethusd])
+    connection.expects(:get).with("/v1/symbols/details/btcusd").once
+              .raises(Faraday::ResourceNotFound, "404")
+
+    assert_equal %w[ETHUSD], @exchange.get_tickers_info.data.map { |t| t[:ticker] }
+    assert_equal %w[BTCUSD], @exchange.unreadable_symbols.keys
+  end
+
+  # Gemini lists perpetual swaps in /v1/symbols with the same base and quote as the spot pair
+  # (BTCGUSDPERP is BTC/GUSD). They are not spot instruments, and would take the spot pair's place.
+  def test_get_tickers_info_keeps_only_spot_instruments
+    connection = stub_catalogue(%w[btcusd btcusdperp])
+    connection.stubs(:get).with("/v1/symbols/details/btcusdperp")
+              .returns(stub(body: detail_body.merge("symbol" => "BTCUSDPERP", "product_type" => "swap")))
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal %w[BTCUSD], result.data.map { |t| t[:ticker] }
+  end
+
+  # An unclassified instrument is not assumed to be spot: it is set aside, and callers keep what
+  # they have for it.
+  def test_get_tickers_info_sets_aside_a_symbol_with_no_product_type
+    connection = stub_catalogue(%w[btcusd ethusd])
+    connection.stubs(:get).with("/v1/symbols/details/ethusd")
+              .returns(stub(body: detail_body.except("product_type").merge("symbol" => "ETHUSD")))
+
+    result = @exchange.get_tickers_info
+
+    assert_equal %w[BTCUSD], result.data.map { |t| t[:ticker] }
+    assert_match(/ethusd: no product_type/, @exchange.unreadable_symbols["ETHUSD"])
+  end
+
+  def test_get_tickers_info_sets_aside_both_instruments_claiming_one_pair
+    connection = stub_catalogue(%w[btcusd btcusd2 ethusd])
+    connection.stubs(:get).with("/v1/symbols/details/btcusd2")
+              .returns(stub(body: detail_body.merge("symbol" => "BTCUSD2")))
+
+    result = @exchange.get_tickers_info
+
+    assert_equal %w[ETHUSD], result.data.map { |t| t[:ticker] }
+    assert_equal %w[BTCUSD BTCUSD2], @exchange.unreadable_symbols.keys.sort
+    assert_match(%r{BTC/USD}, @exchange.unreadable_symbols["BTCUSD"])
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("gemini_pubticker.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTCUSD")
+
+    assert result.success?
+    assert_equal BigDecimal("67123.45"), result.data[:bid]
+    assert_equal BigDecimal("67125.67"), result.data[:ask]
+  end
+
+  private
+
+  def detail_body
+    load_fixture("gemini_symbol_detail.json")
+  end
+
+  def detail_response
+    stub(body: detail_body)
+  end
+
+  # Every symbol resolves to the one detail fixture; a test overrides a path to make it fail.
+  # Each symbol answers with the fixture's details for its own pair ("ethusd" is ETH/USD), since a
+  # catalogue may not hold two instruments for one pair.
+  def stub_catalogue(symbols)
+    connection = stub
+    connection.stubs(:get).with("/v1/symbols").returns(stub(body: symbols))
+    symbols.each do |symbol|
+      connection.stubs(:get).with("/v1/symbols/details/#{symbol}").returns(stub(body: detail_for(symbol)))
+    end
+    @exchange.instance_variable_set(:@connection, connection)
+    connection
+  end
+
+  def detail_for(symbol)
+    detail_body.merge("symbol" => symbol.upcase, "base_currency" => symbol[0, 3], "quote_currency" => symbol[3..])
+  end
+
+  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,64 @@
+# 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] # no per-token base floor in spotMeta
+    assert_equal 10, ticker[:minimum_quote_size] # Hyperliquid's hard 10-USDC spot order floor
+    assert_equal 2, ticker[:base_decimals]
+    assert_equal 2, ticker[:quote_decimals]
+    assert_equal 5, ticker[:price_decimals]
+    assert ticker[:available]
+    assert ticker[:trading_enabled] # no native status -> always true
+  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
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("hyperliquid_all_mids.json")
+    stub_connection(body)
+
+    result = @exchange.get_bid_ask("BTC/USDC")
+
+    assert result.success?
+    assert_equal BigDecimal("67124.56"), result.data[:bid]
+    assert_equal BigDecimal("67124.56"), result.data[:ask]
+  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/kraken_test.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Exchanges::KrakenTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Kraken.new
+  end
+
+  # Tokenized equities (xStocks) live behind aclass_base and are invisible to a bare AssetPairs call.
+  # aclass_base=all returns currency + tokenized in one request; the two sets are disjoint.
+  def test_get_tickers_info_requests_every_asset_class
+    response = stub(body: load_fixture("kraken_asset_pairs.json"))
+    connection = stub
+    connection.expects(:get).with("/0/public/AssetPairs", { aclass_base: "all" }).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+
+    assert @exchange.get_tickers_info.success?
+  end
+
+  # Kraken returns every tokenized pair TWICE - once under an SPV key, once under the x key - with
+  # one shared wsname and altname. Only tokenized pairs are double-keyed; currency pairs never are.
+  # Mapping the raw response would ingest each of them twice.
+  def test_get_tickers_info_deduplicates_the_spv_alias
+    body = load_fixture("kraken_asset_pairs.json")
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    nvda = result.data.select { |t| t[:base] == "NVDAx" }
+    assert_equal 1, nvda.size, "NVDAxUSD and NVDASPVUSD are one pair"
+    assert_equal "NVDAxUSD", nvda.first[:ticker]
+  end
+
+  # Listed, so a holding can be resolved and valued; not tradable, because AddOrder needs an
+  # asset_class parameter this client does not send, and Kraken closes the tokenized order books to
+  # EEA clients over the API regardless.
+  def test_tokenized_pairs_are_listed_but_not_trading_enabled
+    body = load_fixture("kraken_asset_pairs.json")
+    stub_request(body)
+
+    nvda = @exchange.get_tickers_info.data.find { |t| t[:base] == "NVDAx" }
+
+    assert_equal "online", body["result"]["NVDAxUSD"]["status"]
+    assert nvda[:available], "listed, so balances resolve"
+    refute nvda[:trading_enabled], "we cannot place these orders"
+  end
+
+  def test_get_tickers_info_parses_response
+    body = load_fixture("kraken_asset_pairs.json")
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    ticker = result.data.first
+    assert_equal "XBTUSDT", ticker[:ticker]
+    assert_equal "XBT", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert_equal "0.00010000", ticker[:minimum_base_size]
+    assert_equal "5", ticker[:minimum_quote_size]
+    assert_equal 8, ticker[:base_decimals]
+    assert_equal 5, ticker[:quote_decimals]
+    assert_equal 1, ticker[:price_decimals]
+    assert ticker[:available]
+    assert ticker[:trading_enabled] # fixture has no status -> defaults to true
+  end
+
+  def test_get_tickers_info_disables_non_online_status
+    body = load_fixture("kraken_asset_pairs.json")
+    body["result"]["XBTUSDT"]["status"] = "cancel_only"
+    stub_request(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_enables_online_status
+    body = load_fixture("kraken_asset_pairs.json")
+    body["result"]["XBTUSDT"]["status"] = "online"
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.data.first[:trading_enabled]
+  end
+
+  def test_get_tickers_info_defaults_trading_enabled_when_status_absent
+    body = load_fixture("kraken_asset_pairs.json") # no status key
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.data.first[:trading_enabled]
+  end
+
+  def test_get_tickers_info_skips_pairs_without_wsname
+    body = load_fixture("kraken_asset_pairs.json")
+    body["result"]["XBTUSDT"]["wsname"] = nil
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    # Asserts the wsname-less pair is dropped, not that the whole response is - the fixture now
+    # carries a tokenized pair too.
+    refute result.data.any? { |t| t[:ticker] == "XBTUSDT" }
+  end
+
+  def test_get_tickers_info_uses_real_costmin
+    body = load_fixture("kraken_asset_pairs.json")
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    ticker = result.data.first
+    # USDT is in REAL_COSTMIN with value 5
+    assert_equal "5", ticker[:minimum_quote_size]
+  end
+
+  def test_get_tickers_info_handles_api_error
+    body = { "error" => ["EGeneral:Internal error"], "result" => {} }
+    stub_request(body)
+
+    result = @exchange.get_tickers_info
+
+    assert result.failure?
+    assert_includes result.errors, "EGeneral:Internal error"
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("kraken_ticker.json")
+    stub_request(body)
+
+    result = @exchange.get_bid_ask("XBTUSDT")
+
+    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
+    body = { "error" => ["EGeneral:Internal error"], "result" => {} }
+    stub_request(body)
+
+    result = @exchange.get_bid_ask("XBTUSDT")
+
+    assert result.failure?
+  end
+
+  def test_classify_error_regional_restriction
+    result = @exchange.classify_error("EAccount:Invalid permissions:XAUT trading restricted for DK.")
+    assert_equal({ code: :regional_restriction, asset: "XAUT", country: "DK" }, result)
+  end
+
+  def test_classify_error_invalid_nonce
+    assert_equal({ code: :transient_nonce }, @exchange.classify_error("EAPI:Invalid nonce"))
+  end
+
+  def test_classify_error_internal_error_is_transient_unavailable
+    assert_equal({ code: :transient_unavailable }, @exchange.classify_error("EGeneral:Internal error"))
+  end
+
+  def test_classify_error_service_codes_are_transient_unavailable
+    assert_equal({ code: :transient_unavailable }, @exchange.classify_error("EService:Unavailable"))
+    assert_equal({ code: :transient_unavailable }, @exchange.classify_error("EService:Busy"))
+    assert_equal({ code: :transient_unavailable }, @exchange.classify_error("EService:Deadline elapsed"))
+  end
+
+  def test_classify_error_returns_nil_for_unknown_message
+    assert_nil @exchange.classify_error("EOrder:Unknown order")
+  end
+
+  def test_classify_error_returns_nil_for_nil_message
+    assert_nil @exchange.classify_error(nil)
+  end
+
+  private
+
+  def stub_request(body)
+    response = stub(body: body)
+    connection = stub
+    connection.stubs(:get).returns(response)
+    @exchange.instance_variable_set(:@connection, connection)
+  end
+end

data/test/honeymaker/exchanges/kucoin_test.rb

@@ -0,0 +1,55 @@
+# 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]
+    assert ticker[:trading_enabled]
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("kucoin_orderbook_level1.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/mexc_test.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "digest"
+
+class Honeymaker::Exchanges::MexcTest < Minitest::Test
+  include FixtureHelper
+
+  def setup
+    @exchange = Honeymaker::Exchanges::Mexc.new
+  end
+
+  # H1. MEXC's exchangeInfo has never carried Binance's status encoding. The fixture this file
+  # drives was a hand-edited clone of the Binance one ("TRADING"/"HALT", LOT_SIZE/PRICE_FILTER/
+  # MIN_NOTIONAL filters) written from the same wrong assumption as the parser it tested, so both
+  # agreed and both were wrong. Asserting the raw bytes is the only guard that survives an author
+  # who believes the wrong thing twice; the digest also binds this file to deltabadger's copy, which
+  # drives the same capture through the other implementation of this contract.
+  def test_fixture_carries_mexcs_own_status_encoding
+    body = load_fixture("mexc_exchange_info.json")
+
+    assert_equal "1", body["symbols"].first["status"]
+    refute body["symbols"].any? { |s| s["status"] == "TRADING" }
+    refute body["symbols"].any? { |s| s["filters"].any? { |f| f["filterType"] == "LOT_SIZE" } }
+
+    assert_equal "13a65c0c8ebde52fac4cdca9a5be9d9a18ba7b5438c496b1b30606cf52fd60d3",
+                 Digest::SHA256.hexdigest(File.read(fixture_path("mexc_exchange_info.json")))
+  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 "METALUSDT", ticker[:ticker]
+    assert_equal "METAL", ticker[:base]
+    assert_equal "USDT", ticker[:quote]
+    assert ticker[:available]
+    assert ticker[:trading_enabled]
+  end
+
+  # H2. status is "1" for every MEXC symbol, including the 103 the venue will not accept a spot
+  # order for. The status check alone re-enables all of them; isSpotTradingAllowed is what keeps
+  # them out of the picker.
+  def test_a_symbol_mexc_does_not_allow_for_spot_is_not_trading_enabled
+    body = load_fixture("mexc_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    disallowed = result.data.find { |t| t[:ticker] == "PALMAIUSDT" }
+    assert_equal "1", body["symbols"].last["status"]
+    assert disallowed[:available]        # still listed
+    refute disallowed[:trading_enabled]  # but not spot-tradable
+  end
+
+  # H5. Real MEXC sends only PERCENT_PRICE_BY_SIDE, so the precision fallback is the ONLY path —
+  # there is no filter-bearing symbol to contrast it against.
+  def test_falls_back_to_precision_fields_when_no_size_filters
+    body = load_fixture("mexc_exchange_info.json")
+    stub_connection(body)
+
+    result = @exchange.get_tickers_info
+
+    metal = result.data.find { |t| t[:ticker] == "METALUSDT" }
+    assert_equal 2, metal[:base_decimals]   # baseAssetPrecision
+    assert_equal 5, metal[:quote_decimals]  # quoteAssetPrecision
+    assert_equal 5, metal[:price_decimals]  # quotePrecision
+    assert_nil metal[:minimum_base_size]
+    assert_nil metal[:minimum_quote_size]
+  end
+
+  def test_get_bid_ask_parses_response
+    body = load_fixture("mexc_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/honeymaker_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HoneymakerTest < Minitest::Test
+  def test_version
+    refute_nil Honeymaker::VERSION
+  end
+
+  def test_exchange_returns_correct_class
+    exchange = Honeymaker.exchange("binance")
+    assert_instance_of Honeymaker::Exchanges::Binance, exchange
+  end
+
+  def test_exchange_with_symbol
+    exchange = Honeymaker.exchange(:kraken)
+    assert_instance_of Honeymaker::Exchanges::Kraken, exchange
+  end
+
+  def test_exchange_raises_for_unknown
+    assert_raises(Honeymaker::Error) { Honeymaker.exchange("unknown") }
+  end
+
+  def test_all_exchanges_registered
+    assert_equal 13, Honeymaker::EXCHANGES.size
+  end
+end

data/test/honeymaker/result_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::ResultTest < Minitest::Test
+  def test_success_is_successful
+    result = Honeymaker::Result::Success.new("data")
+    assert result.success?
+    refute result.failure?
+    assert_equal "data", result.data
+    assert_empty result.errors
+  end
+
+  def test_success_with_nil_data
+    result = Honeymaker::Result::Success.new
+    assert result.success?
+    assert_nil result.data
+  end
+
+  def test_failure_is_not_successful
+    result = Honeymaker::Result::Failure.new("something went wrong")
+    refute result.success?
+    assert result.failure?
+    assert_equal ["something went wrong"], result.errors
+  end
+
+  def test_failure_with_multiple_errors
+    result = Honeymaker::Result::Failure.new("error1", "error2")
+    assert_equal ["error1", "error2"], result.errors
+  end
+
+  def test_failure_with_default_error
+    result = Honeymaker::Result::Failure.new
+    assert_equal ["Error"], result.errors
+  end
+
+  def test_failure_with_data
+    result = Honeymaker::Result::Failure.new("err", data: { partial: true })
+    assert_equal({ partial: true }, result.data)
+    assert_equal ["err"], result.errors
+  end
+end