amounts 0.0.8 → 0.1.0

data/test/amount/concerns/parsable_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "i18n"
+require_relative "../../test_helper"
+
+class AmountParsableTest < Minitest::Test
+  class GoldAmount < Amount
+    def purity = "24k"
+  end
+
+  def setup
+    AmountTestSupport.register_default_types!
+    @previous_locale = I18n.locale
+    @previous_backend = I18n.backend
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.available_locales = %i[en de fr]
+    I18n.backend.store_translations(:en, number: { format: { delimiter: ",", separator: "." } })
+    I18n.backend.store_translations(:de, number: { format: { delimiter: ".", separator: "," } })
+    I18n.backend.store_translations(:fr, number: { format: { delimiter: " ", separator: "," } })
+    Amount.localize = false
+  end
+
+  def teardown
+    Amount.localize = false
+    I18n.backend = @previous_backend
+    I18n.locale = @previous_locale
+    Amount.registry.clear!
+  end
+
+  def test_parse_reads_atomic_value
+    assert_equal 1_500_000, Amount.parse("USDC|1.5").atomic
+  end
+
+  def test_parse_roundtrips_to_s
+    assert_equal "USDC|1.50", Amount.parse("USDC|1.5").to_s
+  end
+
+  def test_wire_parse_unchanged
+    assert_equal 150_050, Amount.parse("USD|1500.50").atomic
+  end
+
+  def test_parse_dispatches_to_registered_subclass
+    use_gold_amount_registry!
+
+    assert_instance_of GoldAmount, Amount.parse("GOLD|1.0")
+  end
+
+  def test_parse_ui_returns_amount_for_registered_class
+    assert_instance_of Amount, Amount.parse_ui("1.50", :USD)
+  end
+
+  def test_parse_ui_unregistered_symbol_raises_unknown_type_from_new
+    assert_raises(Amount::Registry::UnknownType) { Amount.new("1", :NOPE) }
+  end
+
+  def test_parse_ui_unregistered_symbol_raises_unknown_type
+    assert_raises(Amount::Registry::UnknownType) { Amount.parse_ui("1", :NOPE) }
+  end
+
+  def test_parse_ui_unregistered_symbol_message_matches_new
+    new_error = error_from(Amount::Registry::UnknownType) { Amount.new("1", :NOPE) }
+    error = error_from(Amount::Registry::UnknownType) { Amount.parse_ui("1", :NOPE) }
+
+    assert_equal new_error.message, error.message
+  end
+
+  def test_parse_ui_returns_registered_subclass
+    use_gold_amount_registry!
+
+    assert_instance_of GoldAmount, Amount.parse_ui("1.500,5 oz", :GOLD, locale: :de)
+  end
+
+  def test_parse_ui_into_registered_subclass_reads_atomic_value
+    use_gold_amount_registry!
+
+    assert_equal 15_005_000, Amount.parse_ui("1.500,5 oz", :GOLD, locale: :de).atomic
+  end
+
+  def test_parse_ui_into_registered_subclass_has_subclass_behavior
+    use_gold_amount_registry!
+
+    assert_equal "24k", Amount.parse_ui("1.500,5 oz", :GOLD, locale: :de).purity
+  end
+
+  def test_parse_ui_into_registered_subclass_rejects_too_many_decimals
+    use_gold_amount_registry!
+
+    assert_raises(Amount::InvalidInput) { Amount.parse_ui("1,00001", :GOLD, locale: :de) }
+  end
+
+  private
+
+  # Replaces the default types with GOLD registered to {GoldAmount}.
+  def use_gold_amount_registry!
+    Amount.registry.clear!
+    Amount.register :GOLD, decimals: 4, display_symbol: "oz", class: GoldAmount
+  end
+end

data/test/amount/concerns/registrable_test.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+
+class AmountRegistrableTest < Minitest::Test
+  def setup
+    AmountTestSupport.register_default_types!
+  end
+
+  def teardown
+    Amount.registry.clear!
+  end
+
+  def test_registry_returns_the_same_object_on_repeated_calls
+    assert_same Amount.registry, Amount.registry
+  end
+
+  def test_subclass_shares_amount_registry
+    assert_same Amount.registry, Class.new(Amount).registry
+  end
+
+  def test_register_adds_a_type
+    Amount.register :PTS, decimals: 0
+
+    assert_equal :PTS, Amount.registry.lookup(:PTS).symbol
+  end
+
+  def test_register_default_rate_stores_the_rate
+    Amount.register_default_rate :USD, :USDC, "1"
+
+    assert_equal BigDecimal("1"), Amount.registry.default_rate(:USD, :USDC)
+  end
+
+  def test_with_registry_activates_the_given_registry_inside_the_block
+    temporary = Amount::Registry.new
+
+    assert_same temporary, Amount.with_registry(temporary) { Amount.registry }
+  end
+
+  def test_with_registry_restores_the_original_registry_afterwards
+    original = Amount.registry
+    Amount.with_registry(Amount::Registry.new) { nil }
+
+    assert_same original, Amount.registry
+  end
+
+  def test_with_registry_restores_the_original_registry_when_the_block_raises
+    original = Amount.registry
+    error_from(RuntimeError) { Amount.with_registry(Amount::Registry.new) { raise "boom" } }
+
+    assert_same original, Amount.registry
+  end
+
+  def test_with_registry_returns_the_block_value
+    assert_equal :result, Amount.with_registry(Amount::Registry.new) { :result }
+  end
+
+  def test_with_registry_removes_outgoing_generated_constructors_inside_the_block
+    refute Amount.with_registry(Amount::Registry.new) { Amount.respond_to?(:of_usdc) }
+  end
+
+  def test_with_registry_restores_outgoing_generated_constructors_afterwards
+    Amount.with_registry(Amount::Registry.new) { nil }
+
+    assert Amount.respond_to?(:of_usdc)
+  end
+end

data/test/amount/concerns/serializable_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../test_helper"
+
+class AmountSerializableTest < Minitest::Test
+  class GoldAmount < Amount
+    def purity_estimate
+      "24k"
+    end
+  end
+
+  def setup
+    AmountTestSupport.register_default_types!
+  end
+
+  def teardown
+    Amount.registry.clear!
+  end
+
+  def test_to_h_and_load_round_trip_for_large_negative_amount
+    amount = Amount.new(-(10**30), :USDC, from: :atomic)
+
+    assert_equal amount, Amount.load(amount.to_h)
+  end
+
+  def test_to_h_returns_versioned_string_safe_payload
+    assert_equal(
+      { v: 1, atomic: "1500000", symbol: "USDC" },
+      Amount.new("1.5", :USDC).to_h
+    )
+  end
+
+  def test_load_accepts_legacy_unversioned_payload
+    amount = Amount.load(atomic: 1_500_000, symbol: :USDC)
+
+    assert_equal Amount.new("1.5", :USDC), amount
+  end
+
+  def test_load_without_atomic_raises_invalid_input
+    assert_raises(Amount::InvalidInput) { Amount.load(v: 1, symbol: "USDC") }
+  end
+
+  def test_load_without_atomic_names_the_missing_key
+    assert_match(/missing key: atomic/, error_from(Amount::InvalidInput) { Amount.load(v: 1, symbol: "USDC") }.message)
+  end
+
+  def test_load_empty_payload_raises_invalid_input
+    assert_raises(Amount::InvalidInput) { Amount.load({}) }
+  end
+
+  def test_load_empty_payload_reports_missing_key
+    assert_match(/missing key/, error_from(Amount::InvalidInput) { Amount.load({}) }.message)
+  end
+
+  def test_as_json_returns_compact_string
+    assert_equal "USDC|1.50", Amount.new("1.5", :USDC).as_json
+  end
+
+  def test_to_json_returns_quoted_compact_string
+    assert_equal '"USDC|1.50"', Amount.new("1.5", :USDC).to_json
+  end
+
+  def test_as_json_works_when_nested_in_hash
+    hash = { amount: Amount.new("1.5", :USDC) }
+
+    assert_equal({ "amount" => "USDC|1.50" }, JSON.parse(hash.to_json))
+  end
+
+  def test_load_rejects_unknown_serialization_version
+    assert_raises(Amount::InvalidInput) do
+      Amount.load(v: 2, atomic: "1500000", symbol: "USDC")
+    end
+  end
+
+  def test_load_dispatches_to_registered_subclass
+    assert_instance_of GoldAmount, restored_gold
+  end
+
+  def test_load_restores_subclass_behavior
+    assert_equal "24k", restored_gold.purity_estimate
+  end
+
+  private
+
+  def restored_gold
+    register_gold_subclass!
+    Amount.load(GoldAmount.new("1", :GOLD).to_h)
+  end
+
+  # Replaces the default registry with GOLD bound to GoldAmount.
+  def register_gold_subclass!
+    Amount.registry.clear!
+    Amount.register :GOLD, decimals: 8, display_symbol: "oz t",
+                           display_position: :suffix, ui_decimals: 4,
+                           class: GoldAmount
+  end
+end

data/test/amount/display_test.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require_relative "../test_helper"
+
+class AmountDisplayTest < Minitest::Test
+  def setup
+    AmountTestSupport.register_default_types!
+  end
+
+  def teardown
+    Amount.registry.clear!
+  end
+
+  # name => [expected, value, symbol]
+  {
+    "usdc" => ["1.500000", "1.5", :USDC],
+    "sol" => ["1.500000000", "1.5", :SOL],
+    "logs" => ["1", 1, :LOGS]
+  }.each do |name, (expected, value, symbol)|
+    define_method("test_formatted_respects_storage_decimals_for_#{name}") do
+      assert_equal expected, Amount.new(value, symbol).formatted
+    end
+  end
+
+  # name => [expected, value, symbol]
+  {
+    "usdc" => ["$1.50", "1.5", :USDC],
+    "usdc_rounded_down" => ["$1.56", "1.567", :USDC],
+    "sol" => ["1.5000 SOL", "1.5", :SOL],
+    "logs" => ["1 logs", 1, :LOGS]
+  }.each do |name, (expected, value, symbol)|
+    define_method("test_ui_respects_ui_decimals_and_position_for_#{name}") do
+      assert_equal expected, Amount.new(value, symbol).ui
+    end
+  end
+
+  def test_ui_ceil_direction
+    assert_equal "$1.57", Amount.new("1.561", :USDC).ui(direction: :ceil)
+  end
+
+  # name => [expected, value, symbol]
+  {
+    "usdc" => ["1.50", "1.5", :USDC],
+    "sol" => ["1.5000", "1.5", :SOL],
+    "logs" => ["1", 1, :LOGS]
+  }.each do |name, (expected, value, symbol)|
+    define_method("test_ui_decorated_false_omits_the_display_symbol_for_#{name}") do
+      assert_equal expected, Amount.new(value, symbol).ui(decorated: false)
+    end
+  end
+
+  def test_ui_decorated_false_with_ceil_direction
+    assert_equal "1.57", Amount.new("1.561", :USDC).ui(direction: :ceil, decorated: false)
+  end
+
+  # name => [expected, ui options]
+  {
+    "default_unit" => ["1.5000 oz t", {}],
+    "gram" => ["46.65 g", { unit: :gram }],
+    "kg" => ["0.04665 kg", { unit: :kg }]
+  }.each do |name, (expected, options)|
+    define_method("test_display_units_scale_output_in_#{name}") do
+      assert_equal expected, Amount.new("1.5", :GOLD).ui(**options)
+    end
+  end
+
+  # name => [expected, ui options]
+  {
+    "default_unit" => ["1.5000", { decorated: false }],
+    "gram" => ["46.65", { unit: :gram, decorated: false }],
+    "kg" => ["0.04665", { unit: :kg, decorated: false }]
+  }.each do |name, (expected, options)|
+    define_method("test_display_units_with_decorated_false_in_#{name}") do
+      assert_equal expected, Amount.new("1.5", :GOLD).ui(**options)
+    end
+  end
+
+  def test_in_unit_returns_raw_bigdecimal
+    gold = Amount.new("1.0", :GOLD)
+
+    assert_in_delta 31.1035, gold.in_unit(:gram).to_f, 0.0001
+  end
+
+  def test_unknown_display_unit_raises
+    assert_raises(Amount::Registry::InvalidDisplayUnit) do
+      Amount.new("1", :GOLD).ui(unit: :pound)
+    end
+  end
+
+  # name => [expected, value, from]
+  {
+    "fraction" => ["2.5 TZ", "2.5", nil],
+    "whole" => ["1 TZ", "1.0", nil],
+    "zero" => ["0 TZ", "0.0", nil],
+    "no_trailing_zeros" => ["1.123 TZ", "1.123", nil],
+    "small_atomic" => ["0.00005 TZ", 50_000, :atomic]
+  }.each do |name, (expected, value, from)|
+    define_method("test_trim_zeros_strips_trailing_zeros_for_#{name}") do
+      register_trim_zeros_type!
+      amount = from ? Amount.new(value, :TZ, from:) : Amount.new(value, :TZ)
+
+      assert_equal expected, amount.ui
+    end
+  end
+
+  # name => [expected, value]
+  {
+    "fraction" => ["$1.50", "1.5"],
+    "whole" => ["$1.00", "1.0"]
+  }.each do |name, (expected, value)|
+    define_method("test_trim_zeros_false_preserves_trailing_zeros_for_#{name}") do
+      assert_equal expected, Amount.new(value, :USDC).ui
+    end
+  end
+
+  # name => [expected, value]
+  {
+    "fraction" => ["2.5", "2.5"],
+    "whole" => ["1", "1.0"]
+  }.each do |name, (expected, value)|
+    define_method("test_trim_zeros_with_decorated_false_for_#{name}") do
+      register_trim_zeros_type!
+
+      assert_equal expected, Amount.new(value, :TZ).ui(decorated: false)
+    end
+  end
+
+  def test_trim_zeros_with_display_units
+    Amount.register :TZG, decimals: 8, display_symbol: "oz t", display_position: :suffix,
+                          trim_zeros: true,
+                          display_units: { gram: { scale: "31.1035", symbol: "g", ui_decimals: 4 } }
+
+    assert_equal "31.1035 g", Amount.new("1.0", :TZG).ui(unit: :gram)
+  end
+
+  def test_trim_zeros_display_unit_override
+    Amount.register :TZO, decimals: 6, display_symbol: "T", display_position: :suffix,
+                          trim_zeros: true,
+                          display_units: { fixed: { scale: 1, symbol: "F", ui_decimals: 2, trim_zeros: false } }
+
+    assert_equal "1.50 F", Amount.new("1.5", :TZO).ui(unit: :fixed)
+  end
+
+  def test_trim_zeros_call_site_true_strips_zeros
+    assert_equal "1.5 SOL", Amount.new("1.5", :SOL).ui(trim_zeros: true)
+  end
+
+  def test_trim_zeros_call_site_false_keeps_zeros
+    assert_equal "1.0000 SOL", Amount.new("1.0", :SOL).ui(trim_zeros: false)
+  end
+
+  def test_trim_zeros_call_site_overrides_registry
+    Amount.register :TZR, decimals: 6, display_symbol: "T", display_position: :suffix, trim_zeros: true
+
+    assert_equal "1.500000 T", Amount.new("1.5", :TZR).ui(trim_zeros: false)
+  end
+
+  def test_in_unit_with_rational_scale
+    assert_equal BigDecimal("0.5"), rational_scale_metal.in_unit(:half)
+  end
+
+  def test_ui_with_rational_scale
+    assert_match(/\A0\.50/, rational_scale_metal.ui(unit: :half))
+  end
+
+  private
+
+  def register_trim_zeros_type!
+    Amount.register :TZ, decimals: 9, display_symbol: "TZ", display_position: :suffix, trim_zeros: true
+  end
+
+  def rational_scale_metal
+    Amount.registry.clear!
+    Amount.register :METAL, decimals: 4, display_symbol: "x", display_position: :suffix,
+                            ui_decimals: 2,
+                            display_units: { half: { scale: Rational(1, 2), symbol: "h", ui_decimals: 2 } },
+                            default_display: :half
+    Amount.new("1", :METAL)
+  end
+end