shopify-money 0.14.6 → 1.0.0.pre

data/spec/money_parser_spec.rb

@@ -8,13 +8,15 @@ RSpec.describe MoneyParser do
 
   describe "parsing of amounts with period decimal separator" do
     it "parses an empty string to $0" do
-      expect(@parser.parse("")).to eq(Money.zero)
+      expect(@parser.parse("")).to eq(Money.new(0, Money::NULL_CURRENCY))
     end
 
     it "parses an invalid string when not strict" do
-      expect(Money).to receive(:deprecate).twice
-      expect(@parser.parse("no money")).to eq(Money.zero)
-      expect(@parser.parse("1..")).to eq(Money.new(1))
+      configure(legacy_deprecations: true) do
+        expect(Money).to receive(:deprecate).twice
+        expect(@parser.parse("no money", 'USD')).to eq(Money.new(0, 'USD'))
+        expect(@parser.parse("1..", 'USD')).to eq(Money.new(1, 'USD'))
+      end
     end
 
     it "parses raise with an invalid string and strict option" do
@@ -22,6 +24,12 @@ RSpec.describe MoneyParser do
       expect { @parser.parse("1..1", strict: true) }.to raise_error(MoneyParser::MoneyFormatError)
     end
 
+    it "parses raise with an invalid when a currency is missing" do
+      configure do
+        expect { @parser.parse("1") }.to raise_error(Money::Currency::UnknownCurrency)
+      end
+    end
+
     it "parses a single digit integer string" do
       expect(@parser.parse("1")).to eq(Money.new(1.00))
     end
@@ -144,8 +152,10 @@ RSpec.describe MoneyParser do
     end
 
     it "parses amount with multiple inconsistent thousands delimiters" do
-      expect(Money).to receive(:deprecate).once
-      expect(@parser.parse("1.1.11.111")).to eq(Money.new(1_111_111))
+      configure(legacy_deprecations: true) do
+        expect(Money).to receive(:deprecate).once
+        expect(@parser.parse("1.1.11.111", 'USD')).to eq(Money.new(1_111_111, 'USD'))
+      end
     end
 
     it "parses raises with multiple inconsistent thousands delimiters and strict option" do
@@ -216,8 +226,10 @@ RSpec.describe MoneyParser do
     end
 
     it "parses amount with multiple inconsistent thousands delimiters" do
-      expect(Money).to receive(:deprecate).once
-      expect(@parser.parse("1,1,11,111")).to eq(Money.new(1_111_111))
+      configure(legacy_deprecations: true) do
+        expect(Money).to receive(:deprecate).once
+        expect(@parser.parse("1,1,11,111", 'USD')).to eq(Money.new(1_111_111, 'USD'))
+      end
     end
 
     it "parses raises with multiple inconsistent thousands delimiters and strict option" do

data/spec/money_spec.rb

@@ -3,40 +3,25 @@ require 'spec_helper'
 require 'yaml'
 
 RSpec.describe "Money" do
-
   let (:money) { Money.new(1) }
   let (:amount_money) { Money.new(1.23, 'USD') }
   let (:non_fractional_money) { Money.new(1, 'JPY') }
   let (:zero_money) { Money.new(0) }
 
-  it "is contructable with empty class method" do
-    expect(Money.empty).to eq(Money.new)
-  end
-
   context "default currency not set" do
-    before(:each) do
-      @default_currency = Money.default_currency
-      Money.default_currency = nil
-    end
-    after(:each) do
-      Money.default_currency = @default_currency
-    end
-
     it "raises an error" do
-      expect { money }.to raise_error(ArgumentError)
+      configure(default_currency: nil) do
+        expect { money }.to raise_error(ArgumentError)
+      end
     end
   end
 
   it ".zero has no currency" do
-    expect(Money.zero.currency).to be_a(Money::NullCurrency)
+    expect(Money.new(0, Money::NULL_CURRENCY).currency).to be_a(Money::NullCurrency)
   end
 
   it ".zero is a 0$ value" do
-    expect(Money.zero).to eq(Money.new(0))
-  end
-
-  it ".zero accepts an optional currency" do
-    expect(Money.zero('USD')).to eq(Money.new(0, 'USD'))
+    expect(Money.new(0, Money::NULL_CURRENCY)).to eq(Money.new(0))
   end
 
   it "returns itself with to_money" do
@@ -47,9 +32,15 @@ RSpec.describe "Money" do
     expect(Money.new(1).to_money('CAD')).to eq(Money.new(1, 'CAD'))
   end
 
-  it "#to_money doesn't overwrite the money object's currency" do
-    expect(Money).to receive(:deprecate).once
-    expect(Money.new(1, 'USD').to_money('CAD')).to eq(Money.new(1, 'USD'))
+  it "legacy_deprecations #to_money doesn't overwrite the money object's currency" do
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect(Money.new(1, 'USD').to_money('CAD')).to eq(Money.new(1, 'USD'))
+    end
+  end
+
+  it "#to_money raises when changing currency" do
+    expect{ Money.new(1, 'USD').to_money('CAD') }.to raise_error(Money::IncompatibleCurrencyError)
   end
 
   it "defaults to 0 when constructed with no arguments" do
@@ -60,9 +51,15 @@ RSpec.describe "Money" do
     expect(Money.new('')).to eq(Money.new(0))
   end
 
-  it "defaults to 0 when constructed with an invalid string" do
-    expect(Money).to receive(:deprecate).once
-    expect(Money.new('invalid')).to eq(Money.new(0.00))
+  it "legacy_deprecations defaults to 0 when constructed with an invalid string" do
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect(Money.new('invalid', 'USD')).to eq(Money.new(0.00, 'USD'))
+    end
+  end
+
+  it "raises when constructed with an invalid string" do
+    expect{ Money.new('invalid') }.to raise_error(ArgumentError)
   end
 
   it "to_s correctly displays the right number of decimal places" do
@@ -107,8 +104,19 @@ RSpec.describe "Money" do
     expect{ money.to_s(:some_weird_style) }.to raise_error(ArgumentError)
   end
 
-  it "as_json as a float with 2 decimal places" do
-    expect(money.as_json).to eq("1.00")
+  it "legacy_json_format makes as_json return the legacy format" do
+    configure(legacy_json_format: true) do
+      expect(Money.new(1, 'CAD').as_json).to eq("1.00")
+    end
+  end
+
+  it "legacy_format correctly sets the json format" do
+    expect(Money.new(1, 'CAD').as_json(legacy_format: true)).to eq("1.00")
+    expect(Money.new(1, 'CAD').to_json(legacy_format: true)).to eq("1.00")
+  end
+
+  it "as_json as a json containing the value and currency" do
+    expect(money.as_json).to eq(value: "1.00", currency: "CAD")
   end
 
   it "is constructable with a BigDecimal" do
@@ -147,9 +155,15 @@ RSpec.describe "Money" do
     expect((Money.new + Money.new)).to eq(Money.new)
   end
 
-  it "adds inconsistent currencies" do
-    expect(Money).to receive(:deprecate).once
-    expect(Money.new(5, 'USD') + Money.new(1, 'CAD')).to eq(Money.new(6, 'USD'))
+  it "legacy_deprecations adds inconsistent currencies" do
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect(Money.new(5, 'USD') + Money.new(1, 'CAD')).to eq(Money.new(6, 'USD'))
+    end
+  end
+
+  it "raises when adding inconsistent currencies" do
+    expect{ Money.new(5, 'USD') + Money.new(1, 'CAD') }.to raise_error(Money::IncompatibleCurrencyError)
   end
 
   it "is subtractable" do
@@ -165,8 +179,10 @@ RSpec.describe "Money" do
   end
 
   it "logs a deprecation warning when adding across currencies" do
-    expect(Money).to receive(:deprecate)
-    expect(Money.new(10, 'USD') - Money.new(1, 'JPY')).to eq(Money.new(9, 'USD'))
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate)
+      expect(Money.new(10, 'USD') - Money.new(1, 'JPY')).to eq(Money.new(9, 'USD'))
+    end
   end
 
   it "keeps currency when doing a computation with a null currency" do
@@ -247,11 +263,6 @@ RSpec.describe "Money" do
     expect((1.50 * Money.new(1.00))).to eq(Money.new(1.50))
   end
 
-  it "is multipliable by a cents amount" do
-    expect((Money.new(1.00) * 0.50)).to eq(Money.new(0.50))
-    expect((0.50 * Money.new(1.00))).to eq(Money.new(0.50))
-  end
-
   it "is multipliable by a rational" do
     expect((Money.new(3.3) * Rational(1, 12))).to eq(Money.new(0.28))
     expect((Rational(1, 12) * Money.new(3.3))).to eq(Money.new(0.28))
@@ -267,9 +278,15 @@ RSpec.describe "Money" do
     expect(((1.0 / 12) * Money.new(3.3))).to eq(Money.new(0.28))
   end
 
-  it "is multipliable by a money object" do
-    expect(Money).to receive(:deprecate).once
-    expect((Money.new(3.3) * Money.new(1))).to eq(Money.new(3.3))
+  it "legacy_deprecations is multipliable by a money object" do
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect((Money.new(3.3, 'USD') * Money.new(1, 'USD'))).to eq(Money.new(3.3, 'USD'))
+    end
+  end
+
+  it "raises when multiplied by a money object" do
+    expect{ (Money.new(3.3) * Money.new(1)) }.to raise_error(ArgumentError)
   end
 
   it "rounds multiplication result with fractional penny of 5 or higher up" do
@@ -306,12 +323,14 @@ RSpec.describe "Money" do
     expect { Money.new(55.00) / 55 }.to raise_error(RuntimeError)
   end
 
-  it "returns cents in to_liquid" do
-    expect(Money.new(1.00).to_liquid).to eq(100)
+  it "returns cents in to_json" do
+    configure(legacy_json_format: true) do
+      expect(Money.new('1.23', 'USD').to_json).to eq('1.23')
+    end
   end
 
-  it "returns cents in to_json" do
-    expect(Money.new(1.00).to_json).to eq("1.00")
+  it "returns value and currency in to_json" do
+    expect(Money.new(1.00).to_json).to eq('{"value":"1.00","currency":"CAD"}')
   end
 
   it "supports absolute value" do
@@ -330,24 +349,28 @@ RSpec.describe "Money" do
     expect(Money.new(1.50).to_f.to_s).to eq("1.5")
   end
 
-  it "is creatable from an integer value in cents" do
-    expect(Money.from_cents(1950)).to eq(Money.new(19.50))
-  end
+  describe '#from_subunits' do
+    it "creates Money object from an integer value in cents and currency" do
+      expect(Money.from_subunits(1950, 'CAD')).to eq(Money.new(19.50))
+    end
 
-  it "is creatable from an integer value of 0 in cents" do
-    expect(Money.from_cents(0)).to eq(Money.new)
-  end
+    it "creates Money object from an integer value in dollars and currency with no cents" do
+      expect(Money.from_subunits(1950, 'JPY')).to eq(Money.new(1950, 'JPY'))
+    end
 
-  it "is creatable from a float cents amount" do
-    expect(Money.from_cents(1950.5)).to eq(Money.new(19.51))
-  end
+    describe 'with format specified' do
+      it 'overrides the subunit_to_unit amount' do
+        expect(Money.from_subunits(100, 'ISK', format: :stripe)).to eq(Money.new(1, 'ISK'))
+      end
 
-  it "is creatable from an integer value in cents and currency" do
-    expect(Money.from_subunits(1950, 'CAD')).to eq(Money.new(19.50))
-  end
+      it 'fallbacks to the default subunit_to_unit amount if no override is specified' do
+        expect(Money.from_subunits(100, 'USD', format: :stripe)).to eq(Money.new(1, 'USD'))
+      end
 
-  it "is creatable from an integer value in dollars and currency with no cents" do
-    expect(Money.from_subunits(1950, 'JPY')).to eq(Money.new(1950, 'JPY'))
+      it 'raises if the format is not found' do
+        expect { Money.from_subunits(100, 'ISK', format: :unknown) }.to(raise_error(ArgumentError))
+      end
+    end
   end
 
   it "raises when constructed with a NaN value" do
@@ -365,9 +388,12 @@ RSpec.describe "Money" do
   end
 
   it "generates a true rational" do
-    expect(Money.rational(Money.new(10.0), Money.new(15.0))).to eq(Rational(2,3))
-    expect(Money).to receive(:deprecate).once
-    expect(Money.rational(Money.new(10.0, 'USD'), Money.new(15.0, 'JPY'))).to eq(Rational(2,3))
+    expect(Money.rational(Money.new(10.0, 'USD'), Money.new(15.0, 'USD'))).to eq(Rational(2,3))
+
+    configure(legacy_deprecations: true) do
+      expect(Money).to receive(:deprecate).once
+      expect(Money.rational(Money.new(10.0, 'USD'), Money.new(15.0, 'JPY'))).to eq(Rational(2,3))
+    end
   end
 
   describe "frozen with amount of $1" do
@@ -426,9 +452,11 @@ RSpec.describe "Money" do
     end
 
     it "<=> issues deprecation warning when comparing incompatible currency" do
-      expect(Money).to receive(:deprecate).twice
-      expect(Money.new(1000, 'USD') <=> Money.new(2000, 'JPY')).to eq(-1)
-      expect(Money.new(2000, 'JPY') <=> Money.new(1000, 'USD')).to eq(1)
+      configure(legacy_deprecations: true) do
+        expect(Money).to receive(:deprecate).twice
+        expect(Money.new(1000, 'USD') <=> Money.new(2000, 'JPY')).to eq(-1)
+        expect(Money.new(2000, 'JPY') <=> Money.new(1000, 'USD')).to eq(1)
+      end
     end
 
     describe('same values') do
@@ -450,15 +478,22 @@ RSpec.describe "Money" do
         it { expect(cad_10 <  nil_10).to(eq(false)) }
       end
 
-      describe('different currencies') do
+      describe('legacy different currencies') do
+        around(:each) do |test|
+          configure(legacy_deprecations: true) { test.run }
+        end
+
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <=> usd_10).to(eq(0)) }
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 >  usd_10).to(eq(false)) }
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 >= usd_10).to(eq(true)) }
-        it { expect(cad_10 == usd_10).to(eq(false)) }
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <= usd_10).to(eq(true)) }
         it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <  usd_10).to(eq(false)) }
       end
 
+      describe('different currencies') do
+        it { expect(cad_10 == usd_10).to(eq(false)) }
+      end
+
       describe('to_money types') do
         it { expect(cad_10 <=> 10.00).to(eq(0)) }
         it { expect(cad_10 >   10.00).to(eq(false)) }
@@ -544,6 +579,20 @@ RSpec.describe "Money" do
       expect(Money.new(1, 'IQD').subunits).to eq(1000)
       expect(Money.new(1).subunits).to eq(100)
     end
+
+    describe 'with format specified' do
+      it 'overrides the subunit_to_unit amount' do
+        expect(Money.new(1, 'ISK').subunits(format: :stripe)).to eq(100)
+      end
+
+      it 'fallbacks to the default subunit_to_unit amount if no override is specified' do
+        expect(Money.new(1, 'USD').subunits(format: :stripe)).to eq(100)
+      end
+
+      it 'raises if the format is not found' do
+        expect { Money.new(1, 'ISK').subunits(format: :unknown) }.to(raise_error(ArgumentError))
+      end
+    end
   end
 
   describe "value" do
@@ -589,10 +638,6 @@ RSpec.describe "Money" do
       expect(money.value).to eq(BigDecimal("1.00"))
     end
 
-    it "returns cents as 100 cents" do
-      expect(money.cents).to eq(100)
-    end
-
     it "returns cents as 100 cents" do
       expect(money.subunits).to eq(100)
     end
@@ -713,8 +758,7 @@ RSpec.describe "Money" do
   end
 
   describe "parser dependency injection" do
-    before(:each) { Money.parser = AccountingMoneyParser }
-    after(:each) { Money.parser = MoneyParser }
+    around(:each) { |test| configure(parser: AccountingMoneyParser, default_currency: 'CAD') { test.run }}
 
     it "keeps AccountingMoneyParser class on new money objects" do
       expect(Money.new.class.parser).to eq(AccountingMoneyParser)
@@ -753,20 +797,6 @@ RSpec.describe "Money" do
   end
 
   describe "from_amount quacks like RubyMoney" do
-    it "accepts numeric values" do
-      expect(Money.from_amount(1)).to eq Money.from_cents(1_00)
-      expect(Money.from_amount(1.0)).to eq Money.from_cents(1_00)
-      expect(Money.from_amount(BigDecimal("1"))).to eq Money.from_cents(1_00)
-    end
-
-    it "accepts string values" do
-      expect(Money.from_amount("1")).to eq Money.from_cents(1_00)
-    end
-
-    it "accepts nil values" do
-      expect(Money.from_amount(nil)).to eq Money.from_cents(0)
-    end
-
     it "accepts an optional currency parameter" do
       expect { Money.from_amount(1, "CAD") }.to_not raise_error
     end
@@ -786,10 +816,14 @@ RSpec.describe "Money" do
       money = YAML.dump(Money.new(750, 'usd'))
       expect(money).to eq("--- !ruby/object:Money\nvalue: '750.0'\ncurrency: USD\n")
     end
+
+    it "does not change BigDecimal value to Integer while rounding for currencies without subunits" do
+      money = Money.new(100, 'JPY').to_yaml
+      expect(money).to eq("--- !ruby/object:Money\nvalue: '100.0'\ncurrency: JPY\n")
+    end
   end
 
   describe "YAML deserialization" do
-
     it "accepts values with currencies" do
       money = YAML.load("--- !ruby/object:Money\nvalue: '750.0'\ncurrency: USD\n")
       expect(money).to eq(Money.new(750, 'usd'))
@@ -888,8 +922,7 @@ RSpec.describe "Money" do
     end
 
     context "with .default_currency set" do
-      before(:each) { Money.default_currency = Money::Currency.new('EUR') }
-      after(:each) { Money.default_currency = Money::NULL_CURRENCY }
+      around(:each) { |test| configure(default_currency: Money::Currency.new('EUR')) { test.run }}
 
       it "can be nested and falls back to default_currency outside of the blocks" do
         money2, money3 = nil

data/spec/rubocop/cop/money/missing_currency_spec.rb

@@ -8,12 +8,16 @@ RSpec.describe RuboCop::Cop::Money::MissingCurrency do
 
   let(:config) { RuboCop::Config.new }
 
-  describe '#on_send' do
-    it 'registers an offense for Money.new without a currency argument' do
+  context 'with default configuration' do
+    it 'registers an offense and corrects for Money.new without a currency argument' do
       expect_offense(<<~RUBY)
         Money.new(1)
         ^^^^^^^^^^^^ Money is missing currency argument
       RUBY
+
+      expect_correction(<<~RUBY)
+        Money.new(1, Money::NULL_CURRENCY)
+      RUBY
     end
 
     it 'does not register an offense for Money.new with currency argument' do
@@ -22,18 +26,26 @@ RSpec.describe RuboCop::Cop::Money::MissingCurrency do
       RUBY
     end
 
-    it 'registers an offense for Money.new without a currency argument' do
+    it 'registers an offense and corrects for Money.new without a currency argument' do
       expect_offense(<<~RUBY)
         Money.new
         ^^^^^^^^^ Money is missing currency argument
       RUBY
+
+      expect_correction(<<~RUBY)
+        Money.new(0, Money::NULL_CURRENCY)
+      RUBY
     end
 
-    it 'registers an offense for Money.from_amount without a currency argument' do
+    it 'registers an offense and corrects for Money.from_amount without a currency argument' do
       expect_offense(<<~RUBY)
         Money.from_amount(1)
         ^^^^^^^^^^^^^^^^^^^^ Money is missing currency argument
       RUBY
+
+      expect_correction(<<~RUBY)
+        Money.from_amount(1, Money::NULL_CURRENCY)
+      RUBY
     end
 
     it 'does not register an offense for Money.from_amount with currency argument' do
@@ -42,11 +54,15 @@ RSpec.describe RuboCop::Cop::Money::MissingCurrency do
       RUBY
     end
 
-    it 'registers an offense for Money.from_cents without a currency argument' do
+    it 'registers an offense and corrects for Money.from_cents without a currency argument' do
       expect_offense(<<~RUBY)
         Money.from_cents(1)
         ^^^^^^^^^^^^^^^^^^^ Money is missing currency argument
       RUBY
+
+      expect_correction(<<~RUBY)
+        Money.from_cents(1, Money::NULL_CURRENCY)
+      RUBY
     end
 
     it 'does not register an offense for Money.from_cents with currency argument' do
@@ -55,11 +71,26 @@ RSpec.describe RuboCop::Cop::Money::MissingCurrency do
       RUBY
     end
 
-    it 'registers an offense for to_money without a currency argument' do
+    it 'registers an offense and corrects for to_money without a currency argument' do
       expect_offense(<<~RUBY)
         '1'.to_money
         ^^^^^^^^^^^^ to_money is missing currency argument
       RUBY
+
+      expect_correction(<<~RUBY)
+        '1'.to_money(Money::NULL_CURRENCY)
+      RUBY
+    end
+
+    it 'registers an offense and corrects for safe navigation to_money without a currency argument' do
+      expect_offense(<<~RUBY)
+        item&.to_money
+        ^^^^^^^^^^^^^^ to_money is missing currency argument
+      RUBY
+
+      expect_correction(<<~RUBY)
+        item&.to_money(Money::NULL_CURRENCY)
+      RUBY
     end
 
     it 'does not register an offense for to_money with currency argument' do
@@ -68,15 +99,19 @@ RSpec.describe RuboCop::Cop::Money::MissingCurrency do
       RUBY
     end
 
-    it 'registers an offense for to_money block pass form' do
+    it 'registers an offense and corrects for to_money block pass form' do
       expect_offense(<<~RUBY)
         ['1'].map(&:to_money)
         ^^^^^^^^^^^^^^^^^^^^^ to_money is missing currency argument
       RUBY
+
+      expect_correction(<<~RUBY)
+        ['1'].map { |x| x.to_money(Money::NULL_CURRENCY) }
+      RUBY
     end
   end
 
-  describe '#autocorrect' do
+  context 'with ReplacementCurrency configuration' do
     let(:config) do
       RuboCop::Config.new(
         'Money/MissingCurrency' => {