shopify-money 0.10.0

data/spec/core_extensions_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.shared_examples_for "an object supporting to_money" do
+  it "supports to_money" do
+    expect(@value.to_money).to eq(@money)
+    expect(@value.to_money('CAD').currency).to eq(Money::Currency.find!('CAD'))
+  end
+end
+
+RSpec.describe Integer do
+  before(:each) do
+    @value = 1
+    @money = Money.new("1.00")
+  end
+
+  it_should_behave_like "an object supporting to_money"
+end
+
+RSpec.describe Float do
+  before(:each) do
+    @value = 1.23
+    @money = Money.new("1.23")
+  end
+
+  it_should_behave_like "an object supporting to_money"
+end
+
+RSpec.describe String do
+  before(:each) do
+    @value = "1.23"
+    @money = Money.new(@value)
+  end
+
+  it_should_behave_like "an object supporting to_money"
+end
+
+RSpec.describe BigDecimal do
+  before(:each) do
+    @value = BigDecimal.new("1.23")
+    @money = Money.new("1.23")
+  end
+
+  it_should_behave_like "an object supporting to_money"
+end

data/spec/currency/loader_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe Money::Currency::Loader do
+
+  describe 'load_currencies' do
+    it 'loads the iso currency file' do
+      expect(subject.load_currencies['usd']['iso_code']).to eq('USD')
+      expect(subject.load_currencies['usd']['symbol']).to eq('$')
+      expect(subject.load_currencies['usd']['subunit_to_unit']).to eq(100)
+      expect(subject.load_currencies['usd']['smallest_denomination']).to eq(1)
+    end
+
+    it 'loads the non iso currency file' do
+      expect(subject.load_currencies['jep']['iso_code']).to eq('JEP')
+    end
+
+    it 'loads the historic iso currency file' do
+      expect(subject.load_currencies['eek']['iso_code']).to eq('EEK')
+    end
+  end
+end

data/spec/currency_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+RSpec.describe "Currency" do
+  CURRENCY_DATA = {
+    "iso_code": "USD",
+    "name": "United States Dollar",
+    "subunit_to_unit": 100,
+    "iso_numeric": "840",
+    "smallest_denomination": 1,
+    "minor_units": 2,
+    "symbol": '$',
+    "disambiguate_symbol": "US$",
+    "subunit_symbol": "¢",
+    "decimal_mark": ".",
+  }
+
+  let(:currency) { Money::Currency.new('usd') }
+
+  describe ".new" do
+    it "is constructable with a uppercase string" do
+      expect(Money::Currency.new('USD').iso_code).to eq('USD')
+    end
+
+    it "is constructable with a symbol" do
+      expect(Money::Currency.new(:usd).iso_code).to eq('USD')
+    end
+
+    it "is constructable with a lowercase string" do
+      expect(Money::Currency.new('usd').iso_code).to eq('USD')
+    end
+
+    it "raises when the currency is invalid" do
+      expect { Money::Currency.new('yyy') }.to raise_error(Money::Currency::UnknownCurrency)
+    end
+
+    it "raises when the currency is nil" do
+      expect { Money::Currency.new(nil) }.to raise_error(Money::Currency::UnknownCurrency)
+    end
+  end
+
+  describe ".find" do
+    it "returns nil when the currency is invalid" do
+      expect(Money::Currency.find('yyy')).to eq(nil)
+    end
+
+    it "returns a valid currency" do
+      expect(Money::Currency.find('usd')).to eq(Money::Currency.new('usd'))
+    end
+  end
+
+  describe ".find!" do
+    it "raises when the currency is invalid" do
+      expect { Money::Currency.find!('yyy') }.to raise_error(Money::Currency::UnknownCurrency)
+    end
+
+    it "returns a valid currency" do
+      expect(Money::Currency.find!('CAD')).to eq(Money::Currency.new('CAD'))
+    end
+  end
+
+  CURRENCY_DATA.each do |attribute, value|
+    describe "##{attribute}" do
+      it 'returns the correct value' do
+        expect(currency.public_send(attribute)).to eq(value)
+      end
+    end
+  end
+
+  describe "#eql?" do
+    it "returns true when both objects represent the same currency" do
+      expect(currency.eql?(Money.new(1, 'USD').currency)).to eq(true)
+    end
+
+    it "returns false when the currency iso is different" do
+      expect(currency.eql?(Money.new(1, 'CAD').currency)).to eq(false)
+    end
+  end
+
+  describe "==" do
+    it "returns true when both objects have the same currency" do
+      expect(currency == Money.new(1, 'USD').currency).to eq(true)
+    end
+
+    it "returns false when the currency iso is different" do
+      expect(currency == Money.new(1, 'CAD').currency).to eq(false)
+    end
+  end
+
+  describe "#to_s" do
+    it "to return the iso code string" do
+      expect(currency.to_s).to eq('USD')
+    end
+  end
+
+  describe "#compatible" do
+
+    it "returns true for the same currency" do
+      expect(currency.compatible?(Money::Currency.new('USD'))).to eq(true)
+    end
+
+    it "returns true for null_currency" do
+      expect(currency.compatible?(Money::NULL_CURRENCY)).to eq(true)
+    end
+
+    it "returns false for nil" do
+      expect(currency.compatible?(nil)).to eq(false)
+    end
+
+    it "returns false for a different currency" do
+      expect(currency.compatible?(Money::Currency.new('JPY'))).to eq(false)
+    end
+  end
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+RSpec.describe Money::Helpers do
+
+  describe 'value_to_decimal' do
+    let (:amount) { BigDecimal.new('1.23') }
+    let (:money) { Money.new(amount) }
+
+    it 'returns the value of a money object' do
+      expect(subject.value_to_decimal(money)).to eq(amount)
+    end
+
+    it 'returns itself if it is already a big decimal' do
+      expect(subject.value_to_decimal(BigDecimal.new('1.23'))).to eq(amount)
+    end
+
+    it 'returns zero when nil' do
+      expect(subject.value_to_decimal(nil)).to eq(0)
+    end
+
+    it 'returns zero when empty' do
+      expect(subject.value_to_decimal('')).to eq(0)
+    end
+
+    it 'returns the bigdecimal version of a integer' do
+      expect(subject.value_to_decimal(1)).to eq(BigDecimal.new('1'))
+    end
+
+    it 'returns the bigdecimal version of a float' do
+      expect(subject.value_to_decimal(1.23)).to eq(amount)
+    end
+
+    it 'returns the bigdecimal version of a rational' do
+      expect(subject.value_to_decimal(amount.to_r)).to eq(amount)
+    end
+
+    it 'returns the bigdecimal version of a ruby number string' do
+      expect(subject.value_to_decimal('1.23')).to eq(amount)
+    end
+
+    it 'returns the bigdecimal version of a ruby number string with whitespace padding' do
+      expect(subject.value_to_decimal(' 1.23 ')).to eq(amount)
+      expect(subject.value_to_decimal("1.23\n")).to eq(amount)
+      expect(subject.value_to_decimal(' -1.23 ')).to eq(-amount)
+    end
+
+    it 'invalid string returns zero' do
+      expect(Money).to receive(:deprecate).once
+      expect(subject.value_to_decimal('invalid')).to eq(0)
+    end
+
+    it 'returns the bigdecimal representation of numbers while they are deprecated' do
+      expect(Money).to receive(:deprecate).exactly(2).times
+      expect(subject.value_to_decimal('1.23abc')).to eq(amount)
+      expect(subject.value_to_decimal("1.23\n23")).to eq(amount)
+    end
+
+    it 'raises on invalid object' do
+      expect { subject.value_to_decimal(OpenStruct.new(amount: 1)) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns regular zero for a negative zero value' do
+      expect(subject.value_to_decimal(-BigDecimal.new(0))).to eq(BigDecimal.new(0))
+    end
+  end
+
+  describe 'subject.value_to_currency' do
+    it 'returns itself if it is already a currency' do
+      expect(subject.value_to_currency(Money::Currency.new('usd'))).to eq(Money::Currency.find!('usd'))
+      expect(subject.value_to_currency(Money::NULL_CURRENCY)).to be_a(Money::NullCurrency)
+    end
+
+    it 'returns the default currency when value is nil' do
+      expect(subject.value_to_currency(nil)).to eq(Money.default_currency)
+    end
+
+    it 'returns the default currency when value is empty' do
+      expect(subject.value_to_currency('')).to eq(Money.default_currency)
+    end
+
+    it 'returns the default currency when value is xxx' do
+      expect(subject.value_to_currency('xxx')).to eq(Money::NULL_CURRENCY)
+    end
+
+    it 'returns the current currency when value is set' do
+      expect(Money.with_currency('USD') { subject.value_to_currency(nil) }).to eq(Money::Currency.find!('usd'))
+    end
+
+    it 'returns the matching currency' do
+      expect(subject.value_to_currency('usd')).to eq(Money::Currency.new('USD'))
+    end
+
+    it 'returns the null currency when invalid iso is passed' do
+      expect(Money).to receive(:deprecate).once
+      expect(subject.value_to_currency('invalid')).to eq(Money::NULL_CURRENCY)
+    end
+
+    it 'raises on invalid object' do
+      expect { subject.value_to_currency(OpenStruct.new(amount: 1)) }.to raise_error(ArgumentError)
+      expect { subject.value_to_currency(1) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/money_accessor_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+class NormalObject
+  include MoneyAccessor
+
+  money_accessor :price
+
+  def initialize(price)
+    @price = price
+  end
+end
+
+class StructObject < Struct.new(:price)
+  include MoneyAccessor
+
+  money_accessor :price
+end
+
+RSpec.shared_examples_for "an object with a money accessor" do
+  it "generates an attribute reader that returns a money object" do
+    object = described_class.new(100)
+
+    expect(object.price).to eq(Money.new(100))
+  end
+
+  it "generates an attribute reader that returns a nil object if the value was nil" do
+    object = described_class.new(nil)
+
+    expect(object.price).to eq(nil)
+  end
+
+  it "generates an attribute reader that returns a nil object if the value was blank" do
+    object = described_class.new('')
+
+    expect(object.price).to eq(nil)
+  end
+
+  it "generates an attribute writer that allow setting a money object" do
+    object = described_class.new(0)
+    object.price = Money.new(10)
+
+    expect(object.price).to eq(Money.new(10))
+  end
+
+  it "generates an attribute writer that allow setting a integer value" do
+    object = described_class.new(0)
+    object.price = 10
+
+    expect(object.price).to eq(Money.new(10))
+  end
+
+  it "generates an attribute writer that allow setting a float value" do
+    object = described_class.new(0)
+    object.price = 10.12
+
+    expect(object.price).to eq(Money.new(10.12))
+  end
+
+  it "generates an attribute writer that allow setting a nil value" do
+    object = described_class.new(0)
+    object.price = nil
+
+    expect(object.price).to eq(nil)
+  end
+
+  it "generates an attribute writer that allow setting a blank value" do
+    object = described_class.new(0)
+    object.price = ''
+
+    expect(object.price).to eq(nil)
+  end
+end
+
+RSpec.describe NormalObject do
+  it_behaves_like "an object with a money accessor"
+end
+
+RSpec.describe StructObject do
+  it_behaves_like "an object with a money accessor"
+
+  it 'does not generate an ivar to store the price value' do
+    object = described_class.new(10.00)
+
+    expect(object.instance_variable_get(:@price)).to eq(nil)
+  end
+end

data/spec/money_column_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+
+class MoneyRecord < ActiveRecord::Base
+  RATE = 1.17
+  before_validation do
+    self.price_usd = Money.new(self["price"] * RATE, 'USD') if self["price"]
+  end
+  money_column :price, currency_column: 'currency'
+  money_column :prix, currency_column: :devise
+  money_column :price_usd, currency: 'USD'
+end
+
+class MoneyWithValidation < ActiveRecord::Base
+  self.table_name = 'money_records'
+  validates :price, :currency, presence: true
+  money_column :price, currency_column: 'currency'
+end
+
+class MoneyWithReadOnlyCurrency < ActiveRecord::Base
+  self.table_name = 'money_records'
+  money_column :price, currency_column: 'currency', currency_read_only: true
+end
+
+class MoneyRecordCoerceNull < ActiveRecord::Base
+  self.table_name = 'money_records'
+  money_column :price, currency_column: 'currency', coerce_null: true
+  money_column :price_usd, currency: 'USD', coerce_null: true
+end
+
+class MoneyWithDelegatedCurrency < ActiveRecord::Base
+  self.table_name = 'money_records'
+  attr_accessor :delegated_record
+  delegate :currency, to: :delegated_record
+  money_column :price, currency_column: 'currency', currency_read_only: true
+  money_column :prix, currency_column: 'currency2', currency_read_only: true
+  def currency2
+    delegated_record.currency
+  end
+end
+
+RSpec.describe 'MoneyColumn' do
+  let(:amount) { 1.23 }
+  let(:currency) { 'EUR' }
+  let(:money) { Money.new(amount, currency) }
+  let(:toonie) { Money.new(2.00, 'CAD') }
+  let(:subject) { MoneyRecord.new(price: money, prix: toonie) }
+  let(:record) do
+    subject.devise = 'CAD'
+    subject.save
+    subject.reload
+  end
+
+  it 'returns money with currency from the default column' do
+    expect(record.price).to eq(Money.new(1.23, 'EUR'))
+  end
+
+  it 'writes the currency to the db' do
+    record.update(currency: nil)
+    record.update(price: Money.new(4, 'JPY'))
+    record.reload
+    expect(record.price.value).to eq(4)
+    expect(record.price.currency.to_s).to eq('JPY')
+  end
+
+  it 'duplicating the record keeps the money values' do
+    expect(MoneyRecord.new(price: money).clone.price).to eq(money)
+    expect(MoneyRecord.new(price: money).dup.price).to eq(money)
+  end
+
+  it 'returns money with currency from the specified column' do
+    expect(record.prix).to eq(Money.new(2.00, 'CAD'))
+  end
+
+  it 'returns money with the hardcoded currency' do
+    expect(record.price_usd).to eq(Money.new(1.44, 'USD'))
+  end
+
+  it 'returns money with null currency when the currency in the DB is invalid' do
+    expect(Money).to receive(:deprecate).once
+    record.update_columns(currency: 'invalid')
+    record.reload
+    expect(record.price.currency).to be_a(Money::NullCurrency)
+    expect(record.price.value).to eq(1.23)
+  end
+
+  it 'handles legacy support for saving floats' do
+    record.update(price: 3.21, prix: 3.21)
+    expect(record.price.value).to eq(3.21)
+    expect(record.price.currency.to_s).to eq(currency)
+    expect(record.price_usd.value).to eq(3.76)
+    expect(record.price_usd.currency.to_s).to eq('USD')
+    expect(record.prix.value).to eq(3.21)
+    expect(record.prix.currency.to_s).to eq('CAD')
+  end
+
+  it 'handles legacy support for saving floats with correct currency rounding' do
+    record.update(price: 3.2112, prix: 3.2156)
+    expect(record.attributes['price']).to eq(3.21)
+    expect(record.price.value).to eq(3.21)
+    expect(record.price.currency.to_s).to eq(currency)
+    expect(record.attributes['prix']).to eq(3.22)
+    expect(record.prix.value).to eq(3.22)
+    expect(record.prix.currency.to_s).to eq('CAD')
+  end
+
+  it 'handles legacy support for saving string' do
+    record.update(price: '3.21', prix: '3.21')
+    expect(record.price.value).to eq(3.21)
+    expect(record.price.currency.to_s).to eq(currency)
+    expect(record.price_usd.value).to eq(3.76)
+    expect(record.price_usd.currency.to_s).to eq('USD')
+    expect(record.prix.value).to eq(3.21)
+    expect(record.prix.currency.to_s).to eq('CAD')
+  end
+
+  it 'does not overwrite a currency column with a default currency when saving zero' do
+    expect(record.currency.to_s).to eq('EUR')
+    record.update(price: Money.zero)
+    expect(record.currency.to_s).to eq('EUR')
+  end
+
+  it 'does overwrite a currency if changed but will show a deprecation notice' do
+    expect(record.currency.to_s).to eq('EUR')
+    expect(Money).to receive(:deprecate).once
+    record.update(price: Money.new(4, 'JPY'))
+    expect(record.currency.to_s).to eq('JPY')
+  end
+
+  describe 'non-fractional-currencies' do
+    let(:money) { Money.new(1, 'JPY') }
+
+    it 'returns money with currency from the default column' do
+      expect(record.price).to eq(Money.new(1, 'JPY'))
+    end
+  end
+
+  describe 'three-decimal currencies' do
+    let(:money) { Money.new(1.234, 'JOD') }
+
+    it 'returns money with currency from the default column' do
+      expect(record.price).to eq(Money.new(1.234, 'JOD'))
+    end
+  end
+
+  describe 'garbage amount' do
+    let(:amount) { 'foo' }
+
+    it 'raises a deprecation warning' do
+      expect { subject }.to raise_error(ActiveSupport::DeprecationException)
+    end
+  end
+
+  describe 'garbage currency' do
+    let(:currency) { 'foo' }
+
+    it 'raises an UnknownCurrency error' do
+      expect { subject }.to raise_error(ActiveSupport::DeprecationException)
+    end
+  end
+
+  describe 'wrong money_column currency arguments' do
+    let(:subject) do
+      class MoneyWithWrongCurrencyArguments < ActiveRecord::Base
+        self.table_name = 'money_records'
+        money_column :price, currency_column: :currency, currency: 'USD'
+      end
+    end
+
+    it 'raises an ArgumentError' do
+      expect { subject }.to raise_error(ArgumentError, 'cannot set both currency_column and a fixed currency')
+    end
+  end
+
+  describe 'missing money_column currency arguments' do
+    let(:subject) do
+      class MoneyWithWrongCurrencyArguments < ActiveRecord::Base
+        self.table_name = 'money_records'
+        money_column :price
+      end
+    end
+
+    it 'raises an ArgumentError' do
+      expect { subject }.to raise_error(ArgumentError, 'must set one of :currency_column or :currency options')
+    end
+  end
+
+  describe 'null currency and validations' do
+    let(:currency) { Money::NULL_CURRENCY }
+    let(:subject) { MoneyWithValidation.new(price: money) }
+
+    it 'is not allowed to be saved because `to_s` returns a blank string' do
+      subject.valid?
+      expect(subject.errors[:currency]).to include("can't be blank")
+    end
+  end
+
+  describe 'read_only_currency true' do
+    it 'does not write the currency to the db' do
+      record = MoneyWithReadOnlyCurrency.create
+      record.update_columns(price: 1, currency: 'USD')
+      expect(Money).to receive(:deprecate).once
+      record.update(price: Money.new(4, 'CAD'))
+      expect(record.price.value).to eq(4)
+      expect(record.price.currency.to_s).to eq('USD')
+    end
+
+    it 'reads the currency that is already in the db' do
+      record = MoneyWithReadOnlyCurrency.create
+      record.update_columns(currency: 'USD', price: 1)
+      record.reload
+      expect(record.price.value).to eq(1)
+      expect(record.price.currency.to_s).to eq('USD')
+    end
+
+    it 'reads an invalid currency from the db and generates a no currency object' do
+      expect(Money).to receive(:deprecate).once
+      record = MoneyWithReadOnlyCurrency.create
+      record.update_columns(currency: 'invalid', price: 1)
+      record.reload
+      expect(record.price.value).to eq(1)
+      expect(record.price.currency.to_s).to eq('')
+    end
+
+    it 'sets the currency correctly when the currency is changed' do
+      record = MoneyWithReadOnlyCurrency.create(currency: 'CAD', price: 1)
+      record.currency = 'USD'
+      expect(record.price.currency.to_s).to eq('USD')
+    end
+
+    it 'handle cases where the delegate allow_nil is false' do
+      record = MoneyWithDelegatedCurrency.new(price: Money.new(10, 'USD'), delegated_record: MoneyRecord.new(currency: 'USD'))
+      expect(record.price.currency.to_s).to eq('USD')
+    end
+
+    it 'handle cases where a manual delegate does not allow nil' do
+      record = MoneyWithDelegatedCurrency.new(prix: Money.new(10, 'USD'), delegated_record: MoneyRecord.new(currency: 'USD'))
+      expect(record.price.currency.to_s).to eq('USD')
+    end
+  end
+
+  describe 'coerce_null' do
+    it 'returns nil when money value have not been set and coerce_null is false' do
+      record = MoneyRecord.new(price: nil)
+      expect(record.price).to eq(nil)
+      expect(record.price_usd).to eq(nil)
+    end
+
+    it 'returns 0$ when money value have not been set and coerce_null is true' do
+      record = MoneyRecordCoerceNull.new(price: nil)
+      expect(record.price.value).to eq(0)
+       expect(record.price_usd.value).to eq(0)
+    end
+  end
+
+  describe 'memoization' do
+    it 'correctly memoizes the read value' do
+      expect(record.instance_variable_get(:@money_column_cache)["price"]).to eq(nil)
+      price = Money.new(1, 'USD')
+      record = MoneyRecord.new(price: price)
+      expect(record.price).to eq(price)
+      expect(record.instance_variable_get(:@money_column_cache)["price"]).to eq(price)
+    end
+
+    it 'memoizes values get reset when writing a new value' do
+      price = Money.new(1, 'USD')
+      record = MoneyRecord.new(price: price)
+      expect(record.price).to eq(price)
+      price = Money.new(2, 'USD')
+      record.update!(price: price)
+      expect(record.price).to eq(price)
+      expect(record.instance_variable_get(:@money_column_cache)["price"]).to eq(price)
+    end
+
+    it 'reload will clear memoizes money values' do
+      price = Money.new(1, 'USD')
+      record = MoneyRecord.create(price: price)
+      expect(record.price).to eq(price)
+      expect(record.instance_variable_get(:@money_column_cache)["price"]).to eq(price)
+      record.reload
+      expect(record.instance_variable_get(:@money_column_cache)["price"]).to eq(nil)
+      record.price
+      expect(record.instance_variable_get(:@money_column_cache)["price"]).to eq(price)
+    end
+  end
+
+  describe 'ActiveRecord querying' do
+    it 'can be serialized for querying on the value' do
+      price = Money.new(1, 'USD')
+      record = MoneyRecord.create!(price: price)
+      expect(MoneyRecord.find_by(price: price)).to eq(record)
+    end
+
+    it 'nil value persist in the DB' do
+      record = MoneyRecord.create!(price: nil)
+      expect(MoneyRecord.find_by(price: nil)).to eq(record)
+    end
+  end
+end