honeymaker 0.12.4-aarch64-linux

data/test/honeymaker/utils_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::UtilsTest < Minitest::Test
+  def test_decimals_with_string
+    assert_equal 2, Honeymaker::Utils.decimals("0.01")
+    assert_equal 8, Honeymaker::Utils.decimals("0.00000001")
+    assert_equal 1, Honeymaker::Utils.decimals("0.10000000")
+  end
+
+  def test_decimals_with_integer
+    assert_equal 0, Honeymaker::Utils.decimals(1)
+    assert_equal 0, Honeymaker::Utils.decimals(100)
+  end
+
+  def test_decimals_with_float
+    assert_equal 2, Honeymaker::Utils.decimals(0.01)
+    assert_equal 1, Honeymaker::Utils.decimals(0.1)
+  end
+
+  def test_decimals_with_no_decimals
+    assert_equal 0, Honeymaker::Utils.decimals("1")
+    assert_equal 0, Honeymaker::Utils.decimals("10")
+  end
+
+  def test_decimals_with_nil
+    assert_equal 0, Honeymaker::Utils.decimals(nil)
+  end
+
+  def test_parse_filters
+    filters = [
+      { "filterType" => "PRICE_FILTER", "tickSize" => "0.01" },
+      { "filterType" => "LOT_SIZE", "stepSize" => "0.001" },
+      { "filterType" => "NOTIONAL", "minNotional" => "5" }
+    ]
+
+    result = Honeymaker::Utils.parse_filters(filters)
+
+    assert_equal "0.01", result[:price]["tickSize"]
+    assert_equal "0.001", result[:lot_size]["stepSize"]
+    assert_equal "5", result[:notional]["minNotional"]
+  end
+
+  def test_parse_filters_with_min_notional
+    filters = [
+      { "filterType" => "MIN_NOTIONAL", "minNotional" => "10" }
+    ]
+
+    result = Honeymaker::Utils.parse_filters(filters)
+
+    assert_nil result[:price]
+    assert_nil result[:lot_size]
+    assert_equal "10", result[:notional]["minNotional"]
+  end
+
+  def test_parse_filters_empty
+    result = Honeymaker::Utils.parse_filters([])
+
+    assert_nil result[:price]
+    assert_nil result[:lot_size]
+    assert_nil result[:notional]
+  end
+end

data/test/native/backend_switch_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "open3"
+
+class Honeymaker::Native::BackendSwitchTest < Minitest::Test
+  LIB = File.expand_path("../../lib", __dir__)
+
+  def ruby(env, code)
+    out, status = Open3.capture2e(env, RbConfig.ruby, "-I#{LIB}", "-rbundler/setup", "-e", code)
+    [out.strip, status]
+  end
+
+  def test_flag_off_uses_ruby_and_never_loads_the_extension
+    out, st = ruby({ "HONEYMAKER_NATIVE" => nil }, <<~RUBY)
+      require "honeymaker"
+      print [Honeymaker::CLIENTS["kraken"], Honeymaker::EXCHANGES["kraken"], Honeymaker.backend("kraken"),
+             $LOADED_FEATURES.grep(/honeymaker_native\\.(so|bundle|dll)\\z/).size].join(",")
+    RUBY
+    assert st.success?, out
+    assert_equal "Honeymaker::Clients::Kraken,Honeymaker::Exchanges::Kraken,ruby,0", out
+  end
+
+  def test_unsupported_flags_fail_at_require_time
+    ["binance", " kraken, ,binance ", " KRAKEN, bybit "].each do |flag|
+      out, st = ruby({ "HONEYMAKER_NATIVE" => flag }, 'require "honeymaker"')
+      refute st.success?, out
+      assert_match(/unsupported.*(?:binance|bybit)/i, out)
+      assert_match(/supported.*kraken/i, out)
+    end
+  end
+
+  def test_backend_only_reports_supported_enabled_names
+    out, st = ruby({ "HONEYMAKER_NATIVE" => " KRAKEN, ,kraken " }, <<~RUBY)
+      require "honeymaker"
+      print [Honeymaker.backend(" KRAKEN "), Honeymaker.backend(:binance), Honeymaker.backend("unknown")].join(",")
+    RUBY
+    assert st.success?, out
+    assert_equal "native,ruby,ruby", out
+  end
+
+  def test_flag_on_selects_native_for_kraken_only
+    skip "native extension not compiled" unless Dir[File.join(LIB, "honeymaker", "**", "honeymaker_native.{so,bundle,dll}")].any?
+
+    out, st = ruby({ "HONEYMAKER_NATIVE" => "kraken" }, <<~RUBY)
+      require "honeymaker"
+      print [Honeymaker.client("kraken").class, Honeymaker.exchange("kraken").class, Honeymaker.backend(:kraken),
+             Honeymaker.client("binance").class, $LOADED_FEATURES.grep(/honeymaker_native\\.(so|bundle|dll)\\z/).size].join(",")
+    RUBY
+    assert st.success?, out
+    assert_equal "Honeymaker::Native::KrakenClient,Honeymaker::Native::KrakenExchange,native,Honeymaker::Clients::Binance,1", out
+  end
+end

data/test/native/convert_test.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "bigdecimal"
+
+class Honeymaker::Native::ConvertTest < Minitest::Test
+  def setup
+    Honeymaker::Native.load!
+  rescue LoadError
+    raise if ENV["HONEYMAKER_REQUIRE_NATIVE"]
+
+    skip "native extension not compiled"
+  end
+
+  def ext = Honeymaker::Native::Ext
+
+  def test_numeric_text_matches_ruby_to_s
+    [1.0e-09, -0.0, 0.0, 1.0e20, 1688888888.1234, Float::MIN, Float::MAX,
+     Float::INFINITY, -Float::INFINITY, Float::NAN, 12345678901234567890123].each do |value|
+      assert_equal value.to_s, ext.to_s_for_tests(value)
+    end
+  end
+
+  def test_decimal_json_and_to_s_follow_ruby
+    ["0.5", 12345678901234567890123, 1.0e-09, -0.0, Float::INFINITY,
+     -Float::INFINITY, Float::NAN, nil, true, false, [], { "k" => 1 }].each do |value|
+      [true, false].each do |stringify|
+        want = (BigDecimal(stringify ? value.to_s : value) rescue $!)
+        got = (ext.decimal_convert_for_tests(value, stringify) rescue $!)
+        assert_equal want.class, got.class, [value, stringify].inspect
+        if want.is_a?(Exception)
+          assert_equal want.message, got.message
+        else
+          assert_equal [want.to_s, want.sign], [got.to_s, got.sign]
+        end
+      end
+    end
+  end
+
+  def test_decimal_arithmetic_survives_gc_in_rust_container
+    [["1", "3"], ["-0.0", "2"], ["NaN", "Infinity"], ["1", "0"]].each do |a, b|
+      left, right = BigDecimal(a), BigDecimal(b)
+      want = [left + right, left - right, left / right]
+      GC.stress = true
+      got = ext.decimal_arithmetic_for_tests(a, b)
+      GC.stress = false
+      assert_equal want.map { |n| [n.to_s, n.sign] }, got.take(3).map { |n| [n.to_s, n.sign] }
+      assert_equal left.zero?, got[3]
+    end
+  ensure
+    GC.stress = false
+  end
+
+  def test_non_utf8_strings_roundtrip_with_bytes_and_encoding
+    ["O\xff", "O\xff".b, "é".b, "é".encode("ISO-8859-1")].each do |value|
+      got = ext.roundtrip_for_tests([value]).first
+      assert_equal value.bytes, got.bytes
+      assert_equal value.encoding, got.encoding
+    end
+  end
+
+  def test_invalid_string_hash_keys_roundtrip
+    ["O\xff", "O\xff".b, "é".b].each do |key|
+      got = ext.roundtrip_for_tests({ key => "value" }).keys.first
+      assert_equal key.bytes, got.bytes
+      assert_equal key.encoding, got.encoding
+    end
+  end
+
+  def test_internal_string_sentinel_names_are_ordinary_hash_keys
+    obj = { "\0ruby_string" => [[], "UTF-8"], "\0ruby_key:\"literal\"" => "value" }
+    assert_equal obj, ext.roundtrip_for_tests(obj)
+    assert_equal({ "\0ruby_string" => [[], "UTF-8"] }, ext.roundtrip_for_tests({ "\0ruby_string" => [[], "UTF-8"] }))
+  end
+
+  def test_invalid_decimal_strings_use_rubys_own_errors
+    ["1\xff", "1\xff".b].each do |value|
+      [true, false].each do |stringify|
+        want = (BigDecimal(value) rescue $!)
+        got = (ext.decimal_convert_for_tests(value, stringify) rescue $!)
+        assert_equal [want.class, want.message], [got.class, got.message]
+      end
+    end
+  end
+
+  def test_shape_errors
+    error = assert_raises(Honeymaker::Native::ShapeError) { ext.roundtrip_for_tests({ key: 1 }) }
+    assert_equal "non-string key", error.message
+    error = assert_raises(Honeymaker::Native::ShapeError) { ext.roundtrip_for_tests(:unsupported) }
+    assert_equal "unsupported value :unsupported", error.message
+  end
+
+  def test_false_negative_infinity_nan_and_negative_zero
+    got = ext.roundtrip_for_tests([false, -Float::INFINITY, Float::NAN, -0.0])
+    assert_equal false, got[0]
+    assert_equal(-Float::INFINITY, got[1])
+    assert_predicate got[2], :nan?
+    assert_equal(-Float::INFINITY, 1.0 / got[3])
+  end
+
+  def test_json_roundtrip_is_exact
+    obj = JSON.parse('{"i":12345678901234567890123,"f":1688888888.1234,"e":1e-09,"z":-0.0,"s":"\u00e9","n":null,' \
+                     '"b":true,"a":[1,2.5,"x"],"big":1e400,"o":{"k":{"k2":[]}}}')
+    got = ext.roundtrip_for_tests(obj)
+    assert_equal obj.keys, got.keys
+    obj.keys.each do |k|
+      v = obj[k]
+      assert_equal v.class, got[k].class, k
+      assert(v.is_a?(Float) ? v.eql?(got[k]) : v == got[k], k)
+    end
+    assert_equal Encoding::UTF_8, got["s"].encoding
+  end
+
+  def test_decimal_is_rubys_own
+    ["0.5", "-0.0000", "NaN", "Infinity", "1_000", "1e-9"].each do |s|
+      want = BigDecimal(s)
+      got = ext.decimal_for_tests(s)
+      assert_equal [want.to_s, want.sign], [got.to_s, got.sign], s
+    end
+    ["", "abc", "true", "[]", "{}"].each do |s|
+      want = (BigDecimal(s) rescue $!)
+      got = (ext.decimal_for_tests(s) rescue $!)
+      assert_equal [want.class, want.message], [got.class, got.message], s.inspect
+    end
+  end
+
+  def test_survives_gc_stress_and_compaction
+    obj = JSON.parse({ "rows" => (1..2_000).map { |i| { "id" => "O#{i}", "vol" => "0.#{i}", "t" => i + 0.5 } } }.to_json)
+    GC.stress = true
+    got = ext.roundtrip_for_tests(obj)
+    GC.stress = false
+    GC.compact if GC.respond_to?(:compact)
+    assert_equal obj, got
+  ensure
+    GC.stress = false
+  end
+end

data/test/native/gem_isolation_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "open3"
+
+# Spec §2.2: the platform gems cross-compile with nothing but pure-Rust crypto. The async client
+# lives in the same Cargo workspace, so this proves the extension never pulls it in.
+class Honeymaker::Native::GemIsolationTest < Minitest::Test
+  FORBIDDEN = /\A(tokio|tokio-rustls|hyper|hyper-util|rustls|ring|aws-lc-rs|aws-lc-sys|webpki-roots|honeymaker-client) /
+
+  def test_the_extension_does_not_depend_on_the_async_client_stack
+    out, status = Open3.capture2("cargo", "tree", "--locked", "-p", "honeymaker_native", "-e", "normal,build",
+                                 "--prefix", "none", chdir: File.expand_path("../..", __dir__))
+    assert status.success?, "cargo tree failed"
+    assert_empty out.lines.grep(FORBIDDEN).uniq
+  end
+end

data/test/native/loader_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Native::LoaderTest < Minitest::Test
+  def setup
+    Honeymaker::Native.load!
+  rescue LoadError => e
+    raise if ENV["HONEYMAKER_REQUIRE_NATIVE"]
+
+    skip "native extension not compiled (#{e.message})"
+  end
+
+  def test_extension_reports_the_gem_version
+    assert_equal Honeymaker::VERSION, Honeymaker::Native::Ext.version
+  end
+
+  def test_flag_parsing
+    Honeymaker::Native.instance_variable_set(:@enabled, nil)
+    ENV["HONEYMAKER_NATIVE"] = " KRAKEN, ,kraken "
+    assert_equal %w[kraken], Honeymaker::Native.enabled
+    assert Honeymaker::Native.enabled?(:kraken)
+    assert Honeymaker::Native.enabled?(" KRAKEN ")
+    refute Honeymaker::Native.enabled?("bybit")
+  ensure
+    ENV.delete("HONEYMAKER_NATIVE")
+    Honeymaker::Native.instance_variable_set(:@enabled, nil)
+  end
+end

data/test/native/lockstep_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "tmpdir"
+
+class Honeymaker::Native::LockstepTest < Minitest::Test
+  def test_cargo_workspace_version_equals_gem_version
+    cargo = File.read(File.expand_path("../../Cargo.toml", __dir__))
+    assert_equal Honeymaker::VERSION, cargo[/^\[workspace\.package\].*?^version = "([^"]+)"/m, 1]
+  end
+
+  def test_bump_updates_cargo_too
+    rakefile = File.expand_path("../../Rakefile", __dir__)
+    Dir.mktmpdir do |dir|
+      FileUtils.mkdir_p(File.join(dir, "lib/honeymaker"))
+      File.write(File.join(dir, "lib/honeymaker/version.rb"), %(module Honeymaker\n  VERSION = "1.2.3"\nend\n))
+      File.write(File.join(dir, "Cargo.toml"), %([workspace]\nmembers = []\n\n[workspace.package]\nversion = "1.2.3" # c\n))
+      out = Dir.chdir(dir) { `HONEYMAKER_RAKEFILE_LIB_ONLY=1 #{RbConfig.ruby} -rrake -e 'load "#{rakefile}"; bump_version(:minor)' 2>&1` }
+      assert_includes out, "1.3.0"
+      assert_includes File.read(File.join(dir, "Cargo.toml")), %(version = "1.3.0" # c)
+    end
+  end
+end

data/test/native/signing_smoke_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class KrakenSigningSmokeTest < Minitest::Test
+  def setup
+    Honeymaker::Native.load!
+    require_relative "../support/kraken_signing_smoke"
+  rescue LoadError => e
+    raise if ENV["HONEYMAKER_REQUIRE_NATIVE"]
+
+    skip e.message
+  end
+
+  def test_real_signing_vector
+    assert KrakenSigningSmoke.verify!
+  end
+
+  def test_rejects_incorrect_key_or_signature
+    vector = JSON.parse(File.read(KrakenSigningSmoke::VECTORS)).find { |v| !v.fetch("api_key").empty? && !v.fetch("api_secret").empty? }
+    %w[API-Key API-Sign].each do |field|
+      signer = stub(sign: vector.fetch("headers").merge(field => "wrong"))
+      Honeymaker::Native::Ext::Kraken.stubs(:new).with(vector.fetch("api_key"), vector.fetch("api_secret")).returns(signer)
+      _, stderr = capture_io { assert_raises(SystemExit) { KrakenSigningSmoke.verify! } }
+      assert_match(/#{field}/, stderr)
+    end
+  end
+end