money 6.7.0 → 6.13.0

data/spec/locale_backend/i18n_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+describe Money::LocaleBackend::I18n do
+  describe '#initialize' do
+    it 'raises an error when I18n is not defined' do
+      hide_const('I18n')
+
+      expect { described_class.new }.to raise_error(Money::LocaleBackend::NotSupported)
+    end
+  end
+
+  describe '#lookup' do
+    after do
+      reset_i18n
+      I18n.locale = :en
+    end
+
+    subject { described_class.new }
+
+    context 'with number.currency.format defined' do
+      before do
+        I18n.locale = :de
+        I18n.backend.store_translations(:de, number: {
+          currency: { format: { delimiter: '.', separator: ',' } }
+        })
+      end
+
+      it 'returns thousands_separator based on the current locale' do
+        expect(subject.lookup(:thousands_separator, nil)).to eq('.')
+      end
+
+      it 'returns decimal_mark based on the current locale' do
+        expect(subject.lookup(:decimal_mark, nil)).to eq(',')
+      end
+    end
+
+    context 'with number.format defined' do
+      before do
+        I18n.locale = :de
+        I18n.backend.store_translations(:de, number: { format: { delimiter: '.', separator: ',' } })
+      end
+
+      it 'returns thousands_separator based on the current locale' do
+        expect(subject.lookup(:thousands_separator, nil)).to eq('.')
+      end
+
+      it 'returns decimal_mark based on the current locale' do
+        expect(subject.lookup(:decimal_mark, nil)).to eq(',')
+      end
+    end
+
+    context 'with no translation defined' do
+      it 'returns thousands_separator based on the current locale' do
+        expect(subject.lookup(:thousands_separator, nil)).to eq(nil)
+      end
+
+      it 'returns decimal_mark based on the current locale' do
+        expect(subject.lookup(:decimal_mark, nil)).to eq(nil)
+      end
+    end
+  end
+end

data/spec/locale_backend/legacy_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+describe Money::LocaleBackend::Legacy do
+  after { Money.use_i18n = true }
+
+  describe '#initialize' do
+    it 'raises an error when use_i18n is true and I18n is not defined' do
+      Money.use_i18n = true
+      hide_const('I18n')
+
+      expect { described_class.new }.to raise_error(Money::LocaleBackend::NotSupported)
+    end
+
+    it 'does not raise error when use_i18n is false and I18n is not defined' do
+      Money.use_i18n = false
+      hide_const('I18n')
+
+      expect { described_class.new }.not_to raise_error
+    end
+  end
+
+  describe '#lookup' do
+    subject { described_class.new }
+    let(:currency) { Money::Currency.new('USD') }
+
+    context 'use_i18n is true and i18n lookup is successful' do
+      before do
+        allow(subject.send(:i18n_backend))
+          .to receive(:lookup)
+          .with(:thousands_separator, nil)
+          .and_return('.')
+
+        allow(subject.send(:i18n_backend))
+          .to receive(:lookup)
+          .with(:decimal_mark, nil)
+          .and_return(',')
+      end
+
+      it 'returns thousands_separator from I18n' do
+        expect(subject.lookup(:thousands_separator, currency)).to eq('.')
+      end
+
+      it 'returns decimal_mark based from I18n' do
+        expect(subject.lookup(:decimal_mark, currency)).to eq(',')
+      end
+    end
+
+    context 'use_i18n is true but i18n lookup is unsuccessful' do
+      before do
+        allow(subject.send(:i18n_backend)).to receive(:lookup).and_return(nil)
+      end
+
+      it 'returns thousands_separator as defined in currency' do
+        expect(subject.lookup(:thousands_separator, currency)).to eq(',')
+      end
+
+      it 'returns decimal_mark based as defined in currency' do
+        expect(subject.lookup(:decimal_mark, currency)).to eq('.')
+      end
+    end
+
+    context 'use_i18n is false' do
+      before { Money.use_i18n = false }
+
+      it 'returns thousands_separator as defined in currency' do
+        expect(subject.lookup(:thousands_separator, currency)).to eq(',')
+      end
+
+      it 'returns decimal_mark based as defined in currency' do
+        expect(subject.lookup(:decimal_mark, currency)).to eq('.')
+      end
+    end
+  end
+end

data/spec/money/allocation_spec.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+describe Money::Allocation do
+  describe 'given number as argument' do
+    it 'raises an error when invalid argument is given' do
+      expect { described_class.generate(100, 0) }.to raise_error(ArgumentError)
+      expect { described_class.generate(100, -1) }.to raise_error(ArgumentError)
+    end
+
+    context 'whole amounts' do
+      it 'returns the amount when 1 is given' do
+        expect(described_class.generate(100, 1)).to eq([100])
+      end
+
+      it 'splits the amount into equal parts' do
+        expect(described_class.generate(100, 2)).to eq([50, 50])
+        expect(described_class.generate(100, 4)).to eq([25, 25, 25, 25])
+        expect(described_class.generate(100, 5)).to eq([20, 20, 20, 20, 20])
+      end
+
+      it 'does not loose pennies' do
+        expect(described_class.generate(5, 2)).to eq([3, 2])
+        expect(described_class.generate(2, 3)).to eq([1, 1, 0])
+        expect(described_class.generate(100, 3)).to eq([34, 33, 33])
+        expect(described_class.generate(100, 6)).to eq([17, 17, 17, 17, 16, 16])
+      end
+    end
+
+    context 'fractional amounts' do
+      it 'returns the amount when 1 is given' do
+        expect(described_class.generate(BigDecimal(100), 1, false)).to eq([BigDecimal(100)])
+      end
+
+      it 'splits the amount into equal parts' do
+        expect(described_class.generate(BigDecimal(100), 2, false)).to eq([50, 50])
+        expect(described_class.generate(BigDecimal(100), 4, false)).to eq([25, 25, 25, 25])
+        expect(described_class.generate(BigDecimal(100), 5, false)).to eq([20, 20, 20, 20, 20])
+      end
+
+      it 'splits the amount into equal fractions' do
+        expect(described_class.generate(BigDecimal(5), 2, false)).to eq([2.5, 2.5])
+        expect(described_class.generate(BigDecimal(5), 4, false)).to eq([1.25, 1.25, 1.25, 1.25])
+      end
+
+      it 'handles splits into repeating decimals' do
+        amount = BigDecimal(100)
+        parts = described_class.generate(amount, 3, false)
+
+        # Rounding due to inconsistent BigDecimal size in ruby compared to jruby. In reality the
+        # first 2 elements will look like the last one with a '5' at the end, compensating for a
+        # missing fraction
+        expect(parts.map { |x| x.round(10) }).to eq([
+          BigDecimal('33.3333333333'),
+          BigDecimal('33.3333333333'),
+          BigDecimal('33.3333333333')
+        ])
+        expect(parts.inject(0, :+)).to eq(amount)
+      end
+    end
+  end
+
+  describe 'given array as argument' do
+    it 'raises an error when invalid argument is given' do
+      expect { described_class.generate(100, []) }.to raise_error(ArgumentError)
+    end
+
+    context 'whole amounts' do
+      it 'returns the amount when array contains only one element' do
+        expect(described_class.generate(100, [1])).to eq([100])
+        expect(described_class.generate(100, [5])).to eq([100])
+      end
+
+      it 'splits the amount into whole parts respecting the order' do
+        expect(described_class.generate(100, [1, 1])).to eq([50, 50])
+        expect(described_class.generate(100, [1, 1, 2])).to eq([25, 25, 50])
+        expect(described_class.generate(100, [7, 3])).to eq([70, 30])
+      end
+
+      it 'accepts floats as arguments' do
+        expect(described_class.generate(100, [1.0, 1.0])).to eq([50, 50])
+        expect(described_class.generate(100, [0.1, 0.1, 0.2])).to eq([25, 25, 50])
+        expect(described_class.generate(100, [0.07, 0.03])).to eq([70, 30])
+        expect(described_class.generate(10, [0.1, 0.2, 0.1])).to eq([3, 5, 2])
+      end
+
+      it 'does not loose pennies' do
+        expect(described_class.generate(10, [1, 1, 2])).to eq([3, 2, 5])
+        expect(described_class.generate(100, [1, 1, 1])).to eq([34, 33, 33])
+      end
+    end
+
+    context 'fractional amounts' do
+      it 'returns the amount when array contains only one element' do
+        expect(described_class.generate(BigDecimal(100), [1], false)).to eq([100])
+        expect(described_class.generate(BigDecimal(100), [5], false)).to eq([100])
+      end
+
+      it 'splits the amount into whole parts respecting the order' do
+        expect(described_class.generate(BigDecimal(100), [1, 1], false)).to eq([50, 50])
+        expect(described_class.generate(BigDecimal(100), [1, 1, 2], false)).to eq([25, 25, 50])
+        expect(described_class.generate(BigDecimal(100), [7, 3], false)).to eq([70, 30])
+      end
+
+      it 'splits the amount proportionally to the given parts' do
+        expect(described_class.generate(BigDecimal(10), [1, 1, 2], false)).to eq([2.5, 2.5, 5])
+        expect(described_class.generate(BigDecimal(7), [1, 1], false)).to eq([3.5, 3.5])
+      end
+
+      it 'keeps the class of the splits the same as given amount' do
+        # Note that whole_amount is false but result is whole values
+        expect(described_class.generate(10, [1, 1, 2], false)).to eq([3, 2, 5])
+      end
+
+      it 'handles splits into repeating decimals' do
+        amount = BigDecimal(100)
+        parts = described_class.generate(amount, [1, 1, 1], false)
+
+        # Rounding due to inconsistent BigDecimal size in ruby compared to jruby. In reality the
+        # first 2 elements will look like the last one with a '5' at the end, compensating for a
+        # missing fraction
+        expect(parts.map { |x| x.round(10) }).to eq([
+          BigDecimal('33.3333333333'),
+          BigDecimal('33.3333333333'),
+          BigDecimal('33.3333333333')
+        ])
+        expect(parts.inject(0, :+)).to eq(amount)
+      end
+    end
+  end
+end

data/spec/money/arithmetic_spec.rb

@@ -12,6 +12,8 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(- special_money_class.new(10_00)).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :-@
   end
 
   describe "#==" do
@@ -45,6 +47,19 @@ describe Money do
       expect(Money.new(2_50, "USD")).not_to eq klass.new(3_00, "USD")
       expect(Money.new(1_00, "GBP")).not_to eq klass.new(1_00, "USD")
     end
+
+    it 'allows comparison with zero' do
+      expect(Money.new(0, :usd)).to eq 0
+      expect(Money.new(0, :usd)).to eq 0.0
+      expect(Money.new(0, :usd)).to eq BigDecimal(0)
+      expect(Money.new(1, :usd)).to_not eq 0
+    end
+
+    it 'raises error for non-zero numerics' do
+      expect { Money.new(1_00, :usd) == 1 }.to raise_error ArgumentError
+      expect { Money.new(1_00, :usd) == -2.0 }.to raise_error ArgumentError
+      expect { Money.new(1_00, :usd) == Float::INFINITY }.to raise_error ArgumentError
+    end
   end
 
   describe "#eql?" do
@@ -55,6 +70,12 @@ describe Money do
       expect(Money.new(1_00, "USD").eql?(Money.new(99_00, "EUR"))).to be false
     end
 
+    it "returns true when their amounts are zero and currencies differ" do
+      expect(Money.new(0, "USD").eql?(Money.new(0, "EUR"))).to be true
+      expect(Money.new(0, "USD").eql?(Money.new(0, "USD"))).to be true
+      expect(Money.new(0, "AUD").eql?(Money.new(0, "EUR"))).to be true
+    end
+
     it "returns false if used to compare with an object that doesn't inherit from Money" do
       expect(Money.new(1_00, "USD").eql?(Object.new)).to  be false
       expect(Money.new(1_00, "USD").eql?(Class)).to       be false
@@ -108,17 +129,45 @@ describe Money do
       expect(Money.new(1_00) <=> klass.new(2_00)).to be < 0
     end
 
-    it "raises TypeError when used to compare with an object that doesn't inherit from Money" do
+    it "returns nill when comparing with an object that doesn't inherit from Money" do
       expect(Money.new(1_00) <=> 100).to be_nil
-
       expect(Money.new(1_00) <=> Object.new).to be_nil
-
       expect(Money.new(1_00) <=> Class).to be_nil
-
       expect(Money.new(1_00) <=> Kernel).to be_nil
-
       expect(Money.new(1_00) <=> /foo/).to be_nil
     end
+
+    context 'when conversions disallowed' do
+      around do |example|
+        begin
+          old_default_bank = Money.default_bank
+          Money.disallow_currency_conversion!
+          example.run
+        ensure
+          Money.default_bank = old_default_bank
+        end
+      end
+
+      context 'when currencies differ' do
+        context 'when both values are 1_00' do
+          it 'raises currency error' do
+            expect { Money.usd(1_00) <=> Money.gbp(1_00) }.to raise_error Money::Bank::DifferentCurrencyError
+          end
+        end
+
+        context 'when both values are 0' do
+          it 'considers them equal' do
+            expect(Money.usd(0) <=> Money.gbp(0)).to eq(0)
+          end
+        end
+      end
+    end
+
+    it 'compares with numeric 0' do
+      expect(Money.usd(1) < 0).to eq false
+      expect(Money.usd(1) > 0.0).to eq true
+      expect(Money.usd(0) >= 0.0).to eq true
+    end
   end
 
   describe "#positive?" do
@@ -160,7 +209,7 @@ describe Money do
       expect(Money.new(10_00, "USD") + other).to eq Money.new(19_00, "USD")
     end
 
-    it "adds Fixnum 0 to money and returns the same ammount" do
+    it "adds Integer 0 to money and returns the same ammount" do
       expect(Money.new(10_00) + 0).to eq Money.new(10_00)
     end
 
@@ -168,6 +217,8 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(10_00, "USD") + Money.new(90, "USD")).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :+, Money.new(1)
   end
 
   describe "#-" do
@@ -181,7 +232,7 @@ describe Money do
       expect(Money.new(10_00, "USD") - other).to eq Money.new(1_00, "USD")
     end
 
-    it "subtract Fixnum 0 to money and returns the same ammount" do
+    it "subtract Integer 0 to money and returns the same ammount" do
       expect(Money.new(10_00) - 0).to eq Money.new(10_00)
     end
 
@@ -189,15 +240,17 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(10_00, "USD") - Money.new(90, "USD")).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :-, Money.new(1)
   end
 
   describe "#*" do
-    it "multiplies Money by Fixnum and returns Money" do
+    it "multiplies Money by Integer and returns Money" do
       ts = [
-        {:a => Money.new( 10, :USD), :b =>  4, :c => Money.new( 40, :USD)},
-        {:a => Money.new( 10, :USD), :b => -4, :c => Money.new(-40, :USD)},
-        {:a => Money.new(-10, :USD), :b =>  4, :c => Money.new(-40, :USD)},
-        {:a => Money.new(-10, :USD), :b => -4, :c => Money.new( 40, :USD)},
+        {a: Money.new( 10, :USD), b: 4, c: Money.new( 40, :USD)},
+        {a: Money.new( 10, :USD), b: -4, c: Money.new(-40, :USD)},
+        {a: Money.new(-10, :USD), b: 4, c: Money.new(-40, :USD)},
+        {a: Money.new(-10, :USD), b: -4, c: Money.new( 40, :USD)},
       ]
       ts.each do |t|
         expect(t[:a] * t[:b]).to eq t[:c]
@@ -205,30 +258,32 @@ describe Money do
     end
 
     it "does not multiply Money by Money (same currency)" do
-      expect { Money.new( 10, :USD) * Money.new( 4, :USD) }.to raise_error(ArgumentError)
+      expect { Money.new(10, :USD) * Money.new(4, :USD) }.to raise_error(TypeError)
     end
 
     it "does not multiply Money by Money (different currency)" do
-      expect { Money.new( 10, :USD) * Money.new( 4, :EUR) }.to raise_error(ArgumentError)
+      expect { Money.new(10, :USD) * Money.new(4, :EUR) }.to raise_error(TypeError)
     end
 
     it "does not multiply Money by an object which is NOT a number" do
-      expect { Money.new( 10, :USD) *  'abc' }.to raise_error(ArgumentError)
+      expect { Money.new(10, :USD) *  'abc' }.to raise_error(TypeError)
     end
 
     it "preserves the class in the result when using a subclass of Money" do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(10_00, "USD") * 2).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :*, 1
   end
 
   describe "#/" do
-    it "divides Money by Fixnum and returns Money" do
+    it "divides Money by Integer and returns Money" do
       ts = [
-        {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
-        {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3, :USD)},
-        {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-3, :USD)},
-        {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3, :USD)},
+        {a: Money.new( 13, :USD), b: 4, c: Money.new( 3, :USD)},
+        {a: Money.new( 13, :USD), b: -4, c: Money.new(-3, :USD)},
+        {a: Money.new(-13, :USD), b: 4, c: Money.new(-3, :USD)},
+        {a: Money.new(-13, :USD), b: -4, c: Money.new( 3, :USD)},
       ]
       ts.each do |t|
         expect(t[:a] / t[:b]).to eq t[:c]
@@ -280,10 +335,10 @@ describe Money do
 
     it "divides Money by Money (same currency) and returns Float" do
       ts = [
-        {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c =>  3.25},
-        {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => -3.25},
-        {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => -3.25},
-        {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c =>  3.25},
+        {a: Money.new( 13, :USD), b: Money.new( 4, :USD), c: 3.25},
+        {a: Money.new( 13, :USD), b: Money.new(-4, :USD), c: -3.25},
+        {a: Money.new(-13, :USD), b: Money.new( 4, :USD), c: -3.25},
+        {a: Money.new(-13, :USD), b: Money.new(-4, :USD), c: 3.25},
       ]
       ts.each do |t|
         expect(t[:a] / t[:b]).to eq t[:c]
@@ -292,10 +347,10 @@ describe Money do
 
     it "divides Money by Money (different currency) and returns Float" do
       ts = [
-        {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c =>  1.625},
-        {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => -1.625},
-        {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => -1.625},
-        {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c =>  1.625},
+        {a: Money.new( 13, :USD), b: Money.new( 4, :EUR), c: 1.625},
+        {a: Money.new( 13, :USD), b: Money.new(-4, :EUR), c: -1.625},
+        {a: Money.new(-13, :USD), b: Money.new( 4, :EUR), c: -1.625},
+        {a: Money.new(-13, :USD), b: Money.new(-4, :EUR), c: 1.625},
       ]
       ts.each do |t|
         expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
@@ -306,25 +361,27 @@ describe Money do
     context "with infinite_precision", :infinite_precision do
       it "uses BigDecimal division" do
         ts = [
-          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3.25, :USD)},
-          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3.25, :USD)},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-3.25, :USD)},
-          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3.25, :USD)},
+          {a: Money.new( 13, :USD), b: 4, c: Money.new( 3.25, :USD)},
+          {a: Money.new( 13, :USD), b: -4, c: Money.new(-3.25, :USD)},
+          {a: Money.new(-13, :USD), b: 4, c: Money.new(-3.25, :USD)},
+          {a: Money.new(-13, :USD), b: -4, c: Money.new( 3.25, :USD)},
         ]
         ts.each do |t|
           expect(t[:a] / t[:b]).to eq t[:c]
         end
       end
     end
+
+    it_behaves_like 'instance with custom bank', :/, 1
   end
 
   describe "#div" do
-    it "divides Money by Fixnum and returns Money" do
+    it "divides Money by Integer and returns Money" do
       ts = [
-          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
-          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3, :USD)},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-3, :USD)},
-          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3, :USD)},
+          {a: Money.new( 13, :USD), b: 4, c: Money.new( 3, :USD)},
+          {a: Money.new( 13, :USD), b: -4, c: Money.new(-3, :USD)},
+          {a: Money.new(-13, :USD), b: 4, c: Money.new(-3, :USD)},
+          {a: Money.new(-13, :USD), b: -4, c: Money.new( 3, :USD)},
       ]
       ts.each do |t|
         expect(t[:a].div(t[:b])).to eq t[:c]
@@ -333,10 +390,10 @@ describe Money do
 
     it "divides Money by Money (same currency) and returns Float" do
       ts = [
-          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c =>  3.25},
-          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => -3.25},
-          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => -3.25},
-          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c =>  3.25},
+          {a: Money.new( 13, :USD), b: Money.new( 4, :USD), c: 3.25},
+          {a: Money.new( 13, :USD), b: Money.new(-4, :USD), c: -3.25},
+          {a: Money.new(-13, :USD), b: Money.new( 4, :USD), c: -3.25},
+          {a: Money.new(-13, :USD), b: Money.new(-4, :USD), c: 3.25},
       ]
       ts.each do |t|
         expect(t[:a].div(t[:b])).to eq t[:c]
@@ -345,10 +402,10 @@ describe Money do
 
     it "divides Money by Money (different currency) and returns Float" do
       ts = [
-          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c =>  1.625},
-          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => -1.625},
-          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => -1.625},
-          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c =>  1.625},
+          {a: Money.new( 13, :USD), b: Money.new( 4, :EUR), c: 1.625},
+          {a: Money.new( 13, :USD), b: Money.new(-4, :EUR), c: -1.625},
+          {a: Money.new(-13, :USD), b: Money.new( 4, :EUR), c: -1.625},
+          {a: Money.new(-13, :USD), b: Money.new(-4, :EUR), c: 1.625},
       ]
       ts.each do |t|
         expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
@@ -359,10 +416,10 @@ describe Money do
     context "with infinite_precision", :infinite_precision do
       it "uses BigDecimal division" do
         ts = [
-          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3.25, :USD)},
-          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3.25, :USD)},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-3.25, :USD)},
-          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3.25, :USD)},
+          {a: Money.new( 13, :USD), b: 4, c: Money.new( 3.25, :USD)},
+          {a: Money.new( 13, :USD), b: -4, c: Money.new(-3.25, :USD)},
+          {a: Money.new(-13, :USD), b: 4, c: Money.new(-3.25, :USD)},
+          {a: Money.new(-13, :USD), b: -4, c: Money.new( 3.25, :USD)},
         ]
         ts.each do |t|
           expect(t[:a].div(t[:b])).to eq t[:c]
@@ -372,12 +429,12 @@ describe Money do
   end
 
   describe "#divmod" do
-    it "calculates division and modulo with Fixnum" do
+    it "calculates division and modulo with Integer" do
       ts = [
-          {:a => Money.new( 13, :USD), :b =>  4, :c => [Money.new( 3, :USD), Money.new( 1, :USD)]},
-          {:a => Money.new( 13, :USD), :b => -4, :c => [Money.new(-3, :USD), Money.new(-3, :USD)]},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => [Money.new(-3, :USD), Money.new( 3, :USD)]},
-          {:a => Money.new(-13, :USD), :b => -4, :c => [Money.new( 3, :USD), Money.new(-1, :USD)]},
+          {a: Money.new( 13, :USD), b: 4, c: [Money.new( 3, :USD), Money.new( 1, :USD)]},
+          {a: Money.new( 13, :USD), b: -4, c: [Money.new(-4, :USD), Money.new(-3, :USD)]},
+          {a: Money.new(-13, :USD), b: 4, c: [Money.new(-4, :USD), Money.new( 3, :USD)]},
+          {a: Money.new(-13, :USD), b: -4, c: [Money.new( 3, :USD), Money.new(-1, :USD)]},
       ]
       ts.each do |t|
         expect(t[:a].divmod(t[:b])).to eq t[:c]
@@ -386,10 +443,10 @@ describe Money do
 
     it "calculates division and modulo with Money (same currency)" do
       ts = [
-          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => [ 3, Money.new( 1, :USD)]},
-          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => [-4, Money.new(-3, :USD)]},
-          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => [-4, Money.new( 3, :USD)]},
-          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => [ 3, Money.new(-1, :USD)]},
+          {a: Money.new( 13, :USD), b: Money.new( 4, :USD), c: [ 3, Money.new( 1, :USD)]},
+          {a: Money.new( 13, :USD), b: Money.new(-4, :USD), c: [-4, Money.new(-3, :USD)]},
+          {a: Money.new(-13, :USD), b: Money.new( 4, :USD), c: [-4, Money.new( 3, :USD)]},
+          {a: Money.new(-13, :USD), b: Money.new(-4, :USD), c: [ 3, Money.new(-1, :USD)]},
       ]
       ts.each do |t|
         expect(t[:a].divmod(t[:b])).to eq t[:c]
@@ -398,10 +455,10 @@ describe Money do
 
     it "calculates division and modulo with Money (different currency)" do
       ts = [
-          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => [ 1, Money.new( 5, :USD)]},
-          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => [-2, Money.new(-3, :USD)]},
-          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => [-2, Money.new( 3, :USD)]},
-          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => [ 1, Money.new(-5, :USD)]},
+          {a: Money.new( 13, :USD), b: Money.new( 4, :EUR), c: [ 1, Money.new( 5, :USD)]},
+          {a: Money.new( 13, :USD), b: Money.new(-4, :EUR), c: [-2, Money.new(-3, :USD)]},
+          {a: Money.new(-13, :USD), b: Money.new( 4, :EUR), c: [-2, Money.new( 3, :USD)]},
+          {a: Money.new(-13, :USD), b: Money.new(-4, :EUR), c: [ 1, Money.new(-5, :USD)]},
       ]
       ts.each do |t|
         expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
@@ -412,10 +469,10 @@ describe Money do
     context "with infinite_precision", :infinite_precision do
       it "uses BigDecimal division" do
         ts = [
-            {:a => Money.new( 13, :USD), :b =>  4, :c => [Money.new( 3, :USD), Money.new( 1, :USD)]},
-            {:a => Money.new( 13, :USD), :b => -4, :c => [Money.new(-4, :USD), Money.new(-3, :USD)]},
-            {:a => Money.new(-13, :USD), :b =>  4, :c => [Money.new(-4, :USD), Money.new( 3, :USD)]},
-            {:a => Money.new(-13, :USD), :b => -4, :c => [Money.new( 3, :USD), Money.new(-1, :USD)]},
+            {a: Money.new( 13, :USD), b: 4, c: [Money.new( 3, :USD), Money.new( 1, :USD)]},
+            {a: Money.new( 13, :USD), b: -4, c: [Money.new(-4, :USD), Money.new(-3, :USD)]},
+            {a: Money.new(-13, :USD), b: 4, c: [Money.new(-4, :USD), Money.new( 3, :USD)]},
+            {a: Money.new(-13, :USD), b: -4, c: [Money.new( 3, :USD), Money.new(-1, :USD)]},
         ]
         ts.each do |t|
           expect(t[:a].divmod(t[:b])).to eq t[:c]
@@ -432,15 +489,18 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(10_00, "USD").divmod(special_money_class.new(4_00)).last).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :divmod, Money.new(1)
+    it_behaves_like 'instance with custom bank', :divmod, 1
   end
 
   describe "#modulo" do
-    it "calculates modulo with Fixnum" do
+    it "calculates modulo with Integer" do
       ts = [
-          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :USD)},
-          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3, :USD)},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
-          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new(-1, :USD)},
+          {a: Money.new( 13, :USD), b: 4, c: Money.new( 1, :USD)},
+          {a: Money.new( 13, :USD), b: -4, c: Money.new(-3, :USD)},
+          {a: Money.new(-13, :USD), b: 4, c: Money.new( 3, :USD)},
+          {a: Money.new(-13, :USD), b: -4, c: Money.new(-1, :USD)},
       ]
       ts.each do |t|
         expect(t[:a].modulo(t[:b])).to eq t[:c]
@@ -449,10 +509,10 @@ describe Money do
 
     it "calculates modulo with Money (same currency)" do
       ts = [
-          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 1, :USD)},
-          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-3, :USD)},
-          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 3, :USD)},
-          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-1, :USD)},
+          {a: Money.new( 13, :USD), b: Money.new( 4, :USD), c: Money.new( 1, :USD)},
+          {a: Money.new( 13, :USD), b: Money.new(-4, :USD), c: Money.new(-3, :USD)},
+          {a: Money.new(-13, :USD), b: Money.new( 4, :USD), c: Money.new( 3, :USD)},
+          {a: Money.new(-13, :USD), b: Money.new(-4, :USD), c: Money.new(-1, :USD)},
       ]
       ts.each do |t|
         expect(t[:a].modulo(t[:b])).to eq t[:c]
@@ -461,10 +521,10 @@ describe Money do
 
     it "calculates modulo with Money (different currency)" do
       ts = [
-          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 5, :USD)},
-          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-3, :USD)},
-          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 3, :USD)},
-          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-5, :USD)},
+          {a: Money.new( 13, :USD), b: Money.new( 4, :EUR), c: Money.new( 5, :USD)},
+          {a: Money.new( 13, :USD), b: Money.new(-4, :EUR), c: Money.new(-3, :USD)},
+          {a: Money.new(-13, :USD), b: Money.new( 4, :EUR), c: Money.new( 3, :USD)},
+          {a: Money.new(-13, :USD), b: Money.new(-4, :EUR), c: Money.new(-5, :USD)},
       ]
       ts.each do |t|
         expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
@@ -474,12 +534,12 @@ describe Money do
   end
 
   describe "#%" do
-    it "calculates modulo with Fixnum" do
+    it "calculates modulo with Integer" do
       ts = [
-          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :USD)},
-          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3, :USD)},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
-          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new(-1, :USD)},
+          {a: Money.new( 13, :USD), b: 4, c: Money.new( 1, :USD)},
+          {a: Money.new( 13, :USD), b: -4, c: Money.new(-3, :USD)},
+          {a: Money.new(-13, :USD), b: 4, c: Money.new( 3, :USD)},
+          {a: Money.new(-13, :USD), b: -4, c: Money.new(-1, :USD)},
       ]
       ts.each do |t|
         expect(t[:a] % t[:b]).to eq t[:c]
@@ -488,10 +548,10 @@ describe Money do
 
     it "calculates modulo with Money (same currency)" do
       ts = [
-          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 1, :USD)},
-          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-3, :USD)},
-          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 3, :USD)},
-          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-1, :USD)},
+          {a: Money.new( 13, :USD), b: Money.new( 4, :USD), c: Money.new( 1, :USD)},
+          {a: Money.new( 13, :USD), b: Money.new(-4, :USD), c: Money.new(-3, :USD)},
+          {a: Money.new(-13, :USD), b: Money.new( 4, :USD), c: Money.new( 3, :USD)},
+          {a: Money.new(-13, :USD), b: Money.new(-4, :USD), c: Money.new(-1, :USD)},
       ]
       ts.each do |t|
         expect(t[:a] % t[:b]).to eq t[:c]
@@ -500,10 +560,10 @@ describe Money do
 
     it "calculates modulo with Money (different currency)" do
       ts = [
-          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 5, :USD)},
-          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-3, :USD)},
-          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 3, :USD)},
-          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-5, :USD)},
+          {a: Money.new( 13, :USD), b: Money.new( 4, :EUR), c: Money.new( 5, :USD)},
+          {a: Money.new( 13, :USD), b: Money.new(-4, :EUR), c: Money.new(-3, :USD)},
+          {a: Money.new(-13, :USD), b: Money.new( 4, :EUR), c: Money.new( 3, :USD)},
+          {a: Money.new(-13, :USD), b: Money.new(-4, :EUR), c: Money.new(-5, :USD)},
       ]
       ts.each do |t|
         expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
@@ -513,17 +573,19 @@ describe Money do
   end
 
   describe "#remainder" do
-    it "calculates remainder with Fixnum" do
+    it "calculates remainder with Integer" do
       ts = [
-          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :USD)},
-          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new( 1, :USD)},
-          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-1, :USD)},
-          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new(-1, :USD)},
+          {a: Money.new( 13, :USD), b: 4, c: Money.new( 1, :USD)},
+          {a: Money.new( 13, :USD), b: -4, c: Money.new( 1, :USD)},
+          {a: Money.new(-13, :USD), b: 4, c: Money.new(-1, :USD)},
+          {a: Money.new(-13, :USD), b: -4, c: Money.new(-1, :USD)},
       ]
       ts.each do |t|
         expect(t[:a].remainder(t[:b])).to eq t[:c]
       end
     end
+
+    it_behaves_like 'instance with custom bank', :remainder, -1
   end
 
   describe "#abs" do
@@ -537,6 +599,8 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(-1).abs).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :abs
   end
 
   describe "#zero?" do
@@ -567,6 +631,11 @@ describe Money do
   end
 
   describe "#coerce" do
+    it 'allows non-default currency money objects to be summed' do
+      result = 0 + Money.new(4, 'EUR') + Money.new(5, 'EUR')
+      expect(result).to eq Money.new(9, 'EUR')
+    end
+
     it "allows mathematical operations by coercing arguments" do
       result = 2 * Money.new(4, 'USD')
       expect(result).to eq Money.new(8, 'USD')
@@ -590,6 +659,16 @@ describe Money do
       }.to raise_exception(TypeError)
     end
 
+    it "allows subtraction from numeric zero" do
+      result = 0 - Money.new(4, 'USD')
+      expect(result).to eq Money.new(-4, 'USD')
+    end
+
+    it "allows addition from numeric zero" do
+      result = 0 + Money.new(4, 'USD')
+      expect(result).to eq Money.new(4, 'USD')
+    end
+
     it "treats multiplication as commutative" do
       expect {
         2 * Money.new(2, 'USD')
@@ -607,23 +686,27 @@ describe Money do
     it "correctly handles <=>" do
       expect {
         2 < Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
+      }.to raise_exception(ArgumentError)
 
       expect {
         2 > Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
+      }.to raise_exception(ArgumentError)
 
       expect {
         2 <= Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
+      }.to raise_exception(ArgumentError)
 
       expect {
         2 >= Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
+      }.to raise_exception(ArgumentError)
 
-      expect {
-        2 <=> Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
+      expect(2 <=> Money.new(2, 'USD')).to be_nil
+    end
+
+    it 'compares with numeric 0' do
+      expect(0 < Money.usd(1)).to eq true
+      expect(0.0 > Money.usd(1)).to eq false
+      expect(0.0 >= Money.usd(0)).to eq true
     end
 
     it "raises exceptions for all numeric types, not just Integer" do
@@ -640,4 +723,34 @@ describe Money do
       }.to raise_exception(TypeError)
     end
   end
+
+  %w(+ - / divmod remainder).each do |op|
+    describe "##{op}" do
+      subject { ->(other = self.other) { instance.send(op, other) } }
+      let(:instance) { Money.usd(1) }
+
+      context 'when conversions disallowed' do
+        around do |ex|
+          begin
+            old = Money.default_bank
+            Money.disallow_currency_conversion!
+            ex.run
+          ensure
+            Money.default_bank = old
+          end
+        end
+
+        context 'and other is money with different currency' do
+          let(:other) { Money.gbp(1) }
+          it { should raise_error Money::Bank::DifferentCurrencyError }
+
+          context 'even for zero' do
+            let(:instance) { Money.usd(0) }
+            let(:other) { Money.gbp(0) }
+            it { should raise_error Money::Bank::DifferentCurrencyError }
+          end
+        end
+      end
+    end
+  end
 end