amounts 0.0.8 → 0.1.0

data/test/amount/active_record/attribute_definition_test.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+require_relative "../../support/active_record_test_support"
+
+class AmountActiveRecordAttributeDefinitionTest < Minitest::Test
+  include ActiveRecordTestSetup
+
+  def test_reader_returns_amount
+    holding = Holding.create!(amount_atomic: 1_500_000, amount_symbol: "USDC")
+
+    assert_equal Amount.new("1.5", :USDC), holding.amount
+  end
+
+  def test_multi_symbol_reader_returns_nil_when_atomic_is_nil
+    assert_nil Holding.create!.amount
+  end
+
+  def test_fixed_symbol_reader_returns_nil_when_atomic_is_nil
+    assert_nil Holding.create!.fee
+  end
+
+  def test_multi_symbol_writer_stores_amount_atomic
+    assert_equal 1_500_000, amount_written_holding.amount_atomic
+  end
+
+  def test_multi_symbol_writer_stores_amount_symbol
+    assert_equal "USDC", amount_written_holding.amount_symbol
+  end
+
+  # Rails 8.1 cuts a String cast to an integer column to 16 bytes, so the
+  # writer must hand Rails the Integer, never its string form.
+  def test_writer_keeps_atomic_values_longer_than_sixteen_digits
+    holding = Holding.new(amount: Amount.new(10**30, :SOL, from: :atomic))
+
+    assert_equal 10**30, holding.amount_atomic
+  end
+
+  def test_fixed_symbol_writer_keeps_atomic_values_longer_than_sixteen_digits
+    holding = Holding.new(fee: Amount.new(10**30, :SOL, from: :atomic))
+
+    assert_equal 10**30, holding.fee_atomic
+  end
+
+  def test_fixed_symbol_writer_stores_amount_atomic
+    holding = Holding.new
+    holding.fee = Amount.new("2.5", :SOL)
+
+    assert_equal 2_500_000_000, holding.fee_atomic
+  end
+
+  def test_nil_assignment_clears_atomic_column
+    assert_nil nil_assigned_holding.amount_atomic
+  end
+
+  def test_nil_assignment_clears_symbol_column
+    assert_nil nil_assigned_holding.amount_symbol
+  end
+
+  def test_nil_assignment_reads_back_nil
+    assert_nil nil_assigned_holding.amount
+  end
+
+  def test_where_scope_matches_atomic_and_symbol
+    usdc = create_same_value_in_two_symbols
+
+    assert_equal [usdc.id], Holding.where_amount("USDC|1.5").pluck(:id)
+  end
+
+  def test_in_scope_matches_symbol
+    usdc = create_same_value_in_two_symbols
+
+    assert_equal [usdc.id], Holding.amount_in(:USDC).pluck(:id)
+  end
+
+  def test_gt_scope_filters_multi_symbol_amounts_by_symbol_and_atomic_value
+    _low, mid, high = create_usdc_ladder
+
+    assert_equal [mid.id, high.id], Holding.where_amount_gt("USDC|1.50").pluck(:id)
+  end
+
+  def test_gte_scope_filters_multi_symbol_amounts_by_symbol_and_atomic_value
+    _low, mid, high = create_usdc_ladder
+
+    assert_equal [mid.id, high.id], Holding.where_amount_gte("USDC|2.00").pluck(:id)
+  end
+
+  def test_lt_scope_filters_multi_symbol_amounts_by_symbol_and_atomic_value
+    low, mid, _high = create_usdc_ladder
+
+    assert_equal [low.id, mid.id], Holding.where_amount_lt("USDC|2.50").pluck(:id)
+  end
+
+  def test_lte_scope_filters_multi_symbol_amounts_by_symbol_and_atomic_value
+    low, mid, _high = create_usdc_ladder
+
+    assert_equal [low.id, mid.id], Holding.where_amount_lte("USDC|2.00").pluck(:id)
+  end
+
+  def test_between_scope_includes_both_bounds_for_multi_symbol_amounts
+    low, mid, high = create_usdc_ladder(other: "USD|2.00")
+
+    assert_equal [low.id, mid.id, high.id], Holding.where_amount_between("USDC|1.00", "USDC|3.00").pluck(:id)
+  end
+
+  def test_between_scope_filters_multi_symbol_amounts_inside_bounds
+    _low, mid, _high = create_usdc_ladder(other: "USD|2.00")
+
+    assert_equal [mid.id], Holding.where_amount_between("USDC|1.50", "USDC|2.50").pluck(:id)
+  end
+
+  def test_between_scope_requires_matching_symbols_for_multi_symbol_amounts
+    assert_raises(Amount::TypeMismatch) do
+      Holding.where_amount_between("USDC|1.00", "USD|2.00").load
+    end
+  end
+
+  def test_gt_scope_supports_fixed_symbol_numeric_values
+    _low, mid, high = create_fee_ladder
+
+    assert_equal [mid.id, high.id], Holding.where_fee_gt(0.25).pluck(:id)
+  end
+
+  def test_gte_scope_supports_fixed_symbol_numeric_values
+    _low, mid, high = create_fee_ladder
+
+    assert_equal [mid.id, high.id], Holding.where_fee_gte(0.50).pluck(:id)
+  end
+
+  def test_lt_scope_supports_fixed_symbol_numeric_values
+    low, mid, _high = create_fee_ladder
+
+    assert_equal [low.id, mid.id], Holding.where_fee_lt(0.75).pluck(:id)
+  end
+
+  def test_lte_scope_supports_fixed_symbol_numeric_values
+    low, mid, _high = create_fee_ladder
+
+    assert_equal [low.id, mid.id], Holding.where_fee_lte(0.50).pluck(:id)
+  end
+
+  def test_between_scope_supports_fixed_symbol_numeric_values
+    _low, mid, _high = create_fee_ladder
+
+    assert_equal [mid.id], Holding.where_fee_between(0.30, 0.60).pluck(:id)
+  end
+
+  def test_changed_predicate_uses_virtual_amount_attribute
+    assert changed_holding.amount_changed?
+  end
+
+  def test_change_uses_virtual_amount_attribute
+    assert_equal [Amount.new("1.0", :USDC), Amount.new("2.5", :USDC)], changed_holding.amount_change
+  end
+
+  def test_saved_change_predicate_uses_virtual_amount_attribute
+    assert saved_holding.saved_change_to_amount?
+  end
+
+  def test_before_last_save_uses_virtual_amount_attribute
+    assert_equal Amount.new("1.0", :USDC), saved_holding.amount_before_last_save
+  end
+
+  def test_saved_change_uses_virtual_amount_attribute
+    assert_equal [Amount.new("1.0", :USDC), Amount.new("2.5", :USDC)], saved_holding.saved_change_to_amount
+  end
+
+  def test_validation_rejects_atomic_without_symbol
+    refute Holding.new(amount_atomic: 100).valid?
+  end
+
+  def test_validation_requires_both_amount_columns_or_neither
+    holding = Holding.new(amount_atomic: 100)
+    holding.valid?
+
+    assert_includes holding.errors[:amount], "must set both atomic and symbol or neither"
+  end
+
+  def test_group_sum_totals_first_symbol_atomic_column
+    assert_equal 3_500_000, grouped_sums["USDC"]
+  end
+
+  def test_group_sum_totals_second_symbol_atomic_column
+    assert_equal 300, grouped_sums["USD"]
+  end
+
+  private
+
+  def amount_written_holding
+    Holding.new.tap { |holding| holding.amount = Amount.new("1.5", :USDC) }
+  end
+
+  def nil_assigned_holding
+    holding = Holding.create!(amount: Amount.new("1", :USDC))
+    holding.amount = nil
+    holding
+  end
+
+  # The USDC record; a USD record with the same value is created alongside.
+  def create_same_value_in_two_symbols
+    usdc = Holding.create!(amount: Amount.new("1.5", :USDC))
+    Holding.create!(amount: Amount.new("1.5", :USD))
+    usdc
+  end
+
+  # USDC 1.00, 2.00 and 3.00 (returned), plus one record in another symbol.
+  def create_usdc_ladder(other: "USD|2.50")
+    ladder = ["USDC|1.00", "USDC|2.00", "USDC|3.00"].map { |amount| Holding.create!(amount:) }
+    Holding.create!(amount: other)
+    ladder
+  end
+
+  def create_fee_ladder
+    [0.25, 0.50, 0.75].map { |fee| Holding.create!(fee:) }
+  end
+
+  def changed_holding
+    holding = Holding.create!(amount: Amount.new("1.0", :USDC))
+    holding.amount = "USDC|2.5"
+    holding
+  end
+
+  def saved_holding
+    changed_holding.tap(&:save!)
+  end
+
+  def grouped_sums
+    Holding.create!(amount: Amount.new("1.5", :USDC))
+    Holding.create!(amount: Amount.new("2.0", :USDC))
+    Holding.create!(amount: Amount.new("3.0", :USD))
+
+    Holding.group(:amount_symbol).sum(:amount_atomic)
+  end
+end

data/test/amount/active_record/migration_methods_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+require_relative "../../support/active_record_test_support"
+
+class AmountActiveRecordMigrationMethodsTest < Minitest::Test
+  include ActiveRecordTestSetup
+
+  def test_creates_atomic_column_for_multi_symbol_amount
+    assert columns.key?("amount_atomic")
+  end
+
+  def test_creates_symbol_column_for_multi_symbol_amount
+    assert columns.key?("amount_symbol")
+  end
+
+  def test_creates_atomic_column_for_fixed_symbol_amount
+    assert columns.key?("fee_atomic")
+  end
+
+  def test_creates_no_symbol_column_for_fixed_symbol_amount
+    refute columns.key?("fee_symbol")
+  end
+
+  def test_atomic_column_precision_defaults_to_seventy_eight
+    assert_equal 78, columns.fetch("amount_atomic").precision
+  end
+
+  def test_symbol_column_limit_is_ten_characters
+    assert_equal 10, columns.fetch("amount_symbol").limit
+  end
+
+  def test_atomic_column_uses_given_precision
+    assert_equal 40, columns.fetch("reserve_atomic").precision
+  end
+
+  def test_default_sets_symbol_column_default
+    assert_equal "USDC", columns.fetch("reserve_symbol").default
+  end
+
+  def test_schema_declares_default_atomic_column_as_scale_zero_decimal
+    assert_includes schema_sql, "\"amount_atomic\" decimal(78,0)"
+  end
+
+  def test_schema_declares_atomic_column_with_given_precision_as_scale_zero_decimal
+    assert_includes schema_sql, "\"reserve_atomic\" decimal(40,0)"
+  end
+
+  private
+
+  def columns
+    Holding.columns_hash
+  end
+
+  def schema_sql
+    ::ActiveRecord::Base.connection.select_value(<<~SQL)
+      SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'holdings'
+    SQL
+  end
+end

data/test/amount/active_record/model_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+require_relative "../../support/active_record_test_support"
+
+class AmountActiveRecordModelTest < Minitest::Test
+  include ActiveRecordTestSetup
+
+  def test_fixed_symbol_writer_with_wrong_symbol_makes_record_invalid
+    refute wrong_symbol_fee_holding.valid?
+  end
+
+  def test_fixed_symbol_writer_with_wrong_symbol_reports_error_on_validation
+    holding = wrong_symbol_fee_holding
+    holding.valid?
+
+    assert_includes holding.errors[:fee], "expected SOL, got USDC"
+  end
+
+  def test_multi_symbol_writer_with_raw_numeric_makes_record_invalid
+    refute raw_numeric_amount_holding.valid?
+  end
+
+  def test_multi_symbol_writer_with_raw_numeric_reports_error_on_validation
+    holding = raw_numeric_amount_holding
+    holding.valid?
+
+    assert_includes holding.errors[:amount], "raw numeric assignment requires a fixed symbol"
+  end
+
+  private
+
+  def wrong_symbol_fee_holding
+    Holding.new.tap { |holding| holding.fee = Amount.new("1", :USDC) }
+  end
+
+  def raw_numeric_amount_holding
+    Holding.new.tap { |holding| holding.amount = 5 }
+  end
+end

data/test/amount/active_record/type_test.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "../../test_helper"
+require_relative "../../support/active_record_test_support"
+
+class AmountActiveRecordTypeTest < Minitest::Test
+  include ActiveRecordTestSetup
+
+  def test_multi_symbol_writer_parses_string_into_atomic_column
+    assert_equal 250, holding_with(amount: "USD|2.50").amount_atomic
+  end
+
+  def test_multi_symbol_writer_parses_string_into_symbol_column
+    assert_equal "USD", holding_with(amount: "USD|2.50").amount_symbol
+  end
+
+  def test_multi_symbol_writer_loads_atomic_hash
+    holding = holding_with(amount: { "atomic" => 42, "symbol" => "USDC" })
+
+    assert_equal Amount.new(42, :USDC, from: :atomic), holding.amount
+  end
+
+  def test_fixed_symbol_writer_converts_raw_float_into_atomic_column
+    assert_equal 1_250_000_000, holding_with(fee: 1.25).fee_atomic
+  end
+
+  def test_fixed_symbol_writer_reads_back_raw_float_as_amount
+    assert_equal Amount.new("1.25", :SOL), holding_with(fee: 1.25).fee
+  end
+
+  def test_large_atomic_value_round_trips_through_sqlite
+    skip "SQLite stores DECIMAL(78,0) values above 64-bit range imprecisely under ActiveRecord"
+
+    huge_atomic = 10**30
+    holding = Holding.create!(amount: Amount.new(huge_atomic, :SOL, from: :atomic))
+
+    assert_equal huge_atomic, holding.reload.amount.atomic
+  end
+
+  def test_custom_class_symbol_reads_back_as_registered_class
+    assert_instance_of metal_class, metal_record.weight
+  end
+
+  def test_custom_class_symbol_reads_back_atomic_value
+    assert_equal 25_000, metal_record.weight.atomic
+  end
+
+  private
+
+  def holding_with(**attributes)
+    holding = Holding.new
+    attributes.each { |name, value| holding.public_send("#{name}=", value) }
+    holding
+  end
+
+  def metal_class
+    @metal_class ||= Class.new(Amount) do
+      def self.name
+        "MetalAmount"
+      end
+    end
+  end
+
+  def metal_record
+    Amount.register :METAL, decimals: 4, class: metal_class
+
+    ::ActiveRecord::Schema.define do
+      create_table :metal_holdings, force: true do |t|
+        t.amount :weight, symbol: :METAL, null: false
+      end
+    end
+
+    klass = Class.new(::ActiveRecord::Base) do
+      self.table_name = "metal_holdings"
+      has_amount :weight, symbol: :METAL
+    end
+
+    klass.create!(weight: metal_class.new("2.5", :METAL)).reload
+  end
+end

data/test/amount/active_record_test.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+require_relative "../../lib/amount/active_record"
+
+class AmountActiveRecordTest < Minitest::Test
+  def test_locale_file_is_loaded_once
+    Amount::ActiveRecord.install_locale!
+
+    assert_equal 1, I18n.load_path.count(Amount::ActiveRecord::LOCALE_PATH)
+  end
+end