money 6.1.1 → 6.2.0

data/spec/money_spec.rb

@@ -7,7 +7,9 @@ describe Money do
     let(:initializing_value) { 1 }
     subject(:money) { Money.new(initializing_value) }
 
-    its(:bank) { should be Money::Bank::VariableExchange.instance }
+    it "should be an instance of `Money::Bank::VariableExchange`" do
+      expect(money.bank).to be Money::Bank::VariableExchange.instance
+    end
 
     context 'given the initializing value is an integer' do
       let(:initializing_value) { Integer(1) }
@@ -19,38 +21,41 @@ describe Money do
     context 'given the initializing value is a float' do
       context 'and the value is 1.00' do
         let(:initializing_value) { 1.00 }
-        it { should eq Money.new(1) }
+        it { is_expected.to eq Money.new(1) }
       end
 
       context 'and the value is 1.01' do
         let(:initializing_value) { 1.01 }
-        it { should eq Money.new(1) }
+        it { is_expected.to eq Money.new(1) }
       end
 
       context 'and the value is 1.50' do
         let(:initializing_value) { 1.50 }
-        it { should eq Money.new(2) }
+        it { is_expected.to eq Money.new(2) }
       end
     end
 
     context 'given the initializing value is a rational' do
       let(:initializing_value) { Rational(1) }
-      it { should eq Money.new(1) }
+      it { is_expected.to eq Money.new(1) }
     end
 
     context 'given the initializing value is money' do
       let(:initializing_value) { Money.new(1_00, Money::Currency.new('NZD')) }
-      it { should eq initializing_value }
+      it { is_expected.to eq initializing_value }
     end
 
     context "given the initializing value doesn't respond to .to_d" do
       let(:initializing_value) { :"1" }
-      it { should eq Money.new(1) }
+      it { is_expected.to eq Money.new(1) }
     end
 
     context 'given a currency is not provided' do
       subject(:money) { Money.new(initializing_value) }
-      its(:currency) { should eq Money.default_currency }
+
+      it "should have the default currency" do
+        expect(money.currency).to eq Money.default_currency
+      end
     end
 
     context 'given a currency is provided' do
@@ -58,53 +63,71 @@ describe Money do
 
       context 'and the currency is NZD' do
         let(:currency) { Money::Currency.new('NZD') }
-        its(:currency) { should eq Money::Currency.new('NZD') }
+
+        it "should have NZD currency" do
+          expect(money.currency).to eq Money::Currency.new('NZD')
+        end
+      end
+
+      context 'and the currency is nil' do
+        let(:currency) { nil }
+
+        it "should have the default currency" do
+          expect(money.currency).to eq Money.default_currency
+        end
       end
     end
 
     context "infinite_precision = true" do
-      before { Money.stub(:infinite_precision => true) }
+      before { expect(Money).to receive(:infinite_precision).and_return(true) }
       context 'given the initializing value is 1.50' do
         let(:initializing_value) { 1.50 }
-        its(:cents) { should eq BigDecimal('1.50') }
+
+        it "should have the correct cents" do
+          expect(money.cents).to eq BigDecimal('1.50')
+        end
       end
     end
   end
 
   describe ".empty" do
     it "creates a new Money object of 0 cents" do
-      Money.empty.should == Money.new(0)
+      expect(Money.empty).to eq Money.new(0)
     end
 
     it "memoizes the result" do
-      Money.empty.object_id.should == Money.empty.object_id
+      expect(Money.empty.object_id).to eq Money.empty.object_id
     end
 
     it "memoizes a result for each currency" do
-      Money.empty(:cad).object_id.should == Money.empty(:cad).object_id
+      expect(Money.empty(:cad).object_id).to eq Money.empty(:cad).object_id
+    end
+
+    it "doesn't allow money to be modified for a currency" do
+      expect(Money.empty).to be_frozen
     end
   end
 
   describe ".zero" do
     subject { Money.zero }
-    it { should == Money.empty }
+    it { is_expected.to eq Money.empty }
   end
 
   describe ".ca_dollar" do
     it "creates a new Money object of the given value in CAD" do
-      Money.ca_dollar(50).should == Money.new(50, "CAD")
+      expect(Money.ca_dollar(50)).to eq Money.new(50, "CAD")
     end
   end
 
   describe ".us_dollar" do
     it "creates a new Money object of the given value in USD" do
-      Money.us_dollar(50).should == Money.new(50, "USD")
+      expect(Money.us_dollar(50)).to eq Money.new(50, "USD")
     end
   end
 
   describe ".euro" do
     it "creates a new Money object of the given value in EUR" do
-      Money.euro(50).should == Money.new(50, "EUR")
+      expect(Money.euro(50)).to eq Money.new(50, "EUR")
     end
   end
 
@@ -120,7 +143,7 @@ describe Money do
 
     it "saves rate into current bank" do
       Money.add_rate("EUR", "USD", 10)
-      Money.new(10_00, "EUR").exchange_to("USD").should == Money.new(100_00, "USD")
+      expect(Money.new(10_00, "EUR").exchange_to("USD")).to eq Money.new(100_00, "USD")
     end
   end
 
@@ -145,19 +168,19 @@ describe Money do
       def expectation.fractional
         "expectation"
       end
-      expectation.cents.should == "expectation"
+      expect(expectation.cents).to eq "expectation"
     end
   end
 
   describe "#fractional" do
     it "returns the amount in fractional unit" do
-      Money.new(1_00).fractional.should == 1_00
+      expect(Money.new(1_00).fractional).to eq 1_00
     end
 
     it "stores fractional as an integer regardless of what is passed into the constructor" do
       m = Money.new(100)
-      m.fractional.should == 100
-      m.fractional.should be_a(Fixnum)
+      expect(m.fractional).to eq 100
+      expect(m.fractional).to be_a(Fixnum)
     end
 
     context "loading a serialized Money via YAML" do
@@ -186,10 +209,10 @@ YAML
 
       it "uses BigDecimal when rounding" do
         m = YAML::load serialized
-        m.should be_a(Money)
-        m.class.infinite_precision.should == false
-        m.fractional.should == 250 # 249.5 rounded up
-        m.fractional.should be_a(Integer)
+        expect(m).to be_a(Money)
+        expect(m.class.infinite_precision).to be false
+        expect(m.fractional).to eq 250 # 249.5 rounded up
+        expect(m.fractional).to be_a(Integer)
       end
 
       context "with infinite_precision" do
@@ -203,7 +226,7 @@ YAML
 
         it "is a BigDecimal" do
           money = YAML::load serialized
-          money.fractional.should be_a BigDecimal
+          expect(money.fractional).to be_a BigDecimal
         end
       end
     end
@@ -216,36 +239,36 @@ YAML
       context "with the setter" do
         it "respects the rounding_mode" do
           Money.rounding_mode = BigDecimal::ROUND_DOWN
-          Money.new(1.9).fractional.should == 1
+          expect(Money.new(1.9).fractional).to eq 1
 
           Money.rounding_mode = BigDecimal::ROUND_UP
-          Money.new(1.1).fractional.should == 2
+          expect(Money.new(1.1).fractional).to eq 2
         end
       end
 
       context "with a block" do
         it "respects the rounding_mode" do
-          Money.rounding_mode(BigDecimal::ROUND_DOWN) do
+          expect(Money.rounding_mode(BigDecimal::ROUND_DOWN) do
             Money.new(1.9).fractional
-          end.should == 1
+          end).to eq 1
 
-          Money.rounding_mode(BigDecimal::ROUND_UP) do
+          expect(Money.rounding_mode(BigDecimal::ROUND_UP) do
             Money.new(1.1).fractional
-          end.should == 2
+          end).to eq 2
 
-          Money.rounding_mode.should == BigDecimal::ROUND_HALF_EVEN
+          expect(Money.rounding_mode).to eq BigDecimal::ROUND_HALF_EVEN
         end
 
         it "works for multiplication within a block" do
           Money.rounding_mode(BigDecimal::ROUND_DOWN) do
-            (Money.new(1_00) * "0.019".to_d).fractional.should == 1
+            expect((Money.new(1_00) * "0.019".to_d).fractional).to eq 1
           end
 
           Money.rounding_mode(BigDecimal::ROUND_UP) do
-            (Money.new(1_00) * "0.011".to_d).fractional.should == 2
+            expect((Money.new(1_00) * "0.011".to_d).fractional).to eq 2
           end
 
-          Money.rounding_mode.should == BigDecimal::ROUND_HALF_EVEN
+          expect(Money.rounding_mode).to eq BigDecimal::ROUND_HALF_EVEN
         end
       end
     end
@@ -260,34 +283,34 @@ YAML
       end
 
       it "returns the amount in fractional unit" do
-        Money.new(1_00).fractional.should == BigDecimal("100")
+        expect(Money.new(1_00).fractional).to eq BigDecimal("100")
       end
 
       it "stores in fractional unit as an integer regardless of what is passed into the constructor" do
         m = Money.new(100)
-        m.fractional.should == BigDecimal("100")
-        m.fractional.should be_a(BigDecimal)
+        expect(m.fractional).to eq BigDecimal("100")
+        expect(m.fractional).to be_a(BigDecimal)
       end
     end
   end
 
   describe "#amount" do
     it "returns the amount of cents as dollars" do
-      Money.new(1_00).amount.should == 1
+      expect(Money.new(1_00).amount).to eq 1
     end
 
     it "respects :subunit_to_unit currency property" do
-      Money.new(1_00,  "USD").amount.should == 1
-      Money.new(1_000, "TND").amount.should == 1
-      Money.new(1,     "CLP").amount.should == 1
+      expect(Money.new(1_00,  "USD").amount).to eq 1
+      expect(Money.new(1_000, "TND").amount).to eq 1
+      expect(Money.new(1,     "CLP").amount).to eq 1
     end
 
     it "does not loose precision" do
-      Money.new(100_37).amount.should == 100.37
+      expect(Money.new(100_37).amount).to eq 100.37
     end
 
     it 'produces a BigDecimal' do
-      Money.new(1_00).amount.should be_a BigDecimal
+      expect(Money.new(1_00).amount).to be_a BigDecimal
     end
   end
 
@@ -300,20 +323,20 @@ YAML
         5
       end
 
-      m.dollars.should == 5
+      expect(m.dollars).to eq 5
     end
   end
 
   describe "#currency" do
     it "returns the currency object" do
-      Money.new(1_00, "USD").currency.should == Money::Currency.new("USD")
+      expect(Money.new(1_00, "USD").currency).to eq Money::Currency.new("USD")
     end
   end
 
   describe "#currency_as_string" do
     it "returns the iso_code of the currency object" do
-      Money.new(1_00, "USD").currency_as_string.should == "USD"
-      Money.new(1_00, "EUR").currency_as_string.should == "EUR"
+      expect(Money.new(1_00, "USD").currency_as_string).to eq "USD"
+      expect(Money.new(1_00, "EUR").currency_as_string).to eq "EUR"
     end
   end
 
@@ -321,61 +344,61 @@ YAML
     it "sets the currency object using the provided string" do
       money = Money.new(100_00, "USD")
       money.currency_as_string = "EUR"
-      money.currency.should == Money::Currency.new("EUR")
+      expect(money.currency).to eq Money::Currency.new("EUR")
       money.currency_as_string = "YEN"
-      money.currency.should == Money::Currency.new("YEN")
+      expect(money.currency).to eq Money::Currency.new("YEN")
     end
   end
 
   describe "#hash=" do
     it "returns the same value for equal objects" do
-      Money.new(1_00, "EUR").hash.should == Money.new(1_00, "EUR").hash
-      Money.new(2_00, "USD").hash.should == Money.new(2_00, "USD").hash
-      Money.new(1_00, "EUR").hash.should_not == Money.new(2_00, "EUR").hash
-      Money.new(1_00, "EUR").hash.should_not == Money.new(1_00, "USD").hash
-      Money.new(1_00, "EUR").hash.should_not == Money.new(2_00, "USD").hash
+      expect(Money.new(1_00, "EUR").hash).to eq Money.new(1_00, "EUR").hash
+      expect(Money.new(2_00, "USD").hash).to eq Money.new(2_00, "USD").hash
+      expect(Money.new(1_00, "EUR").hash).not_to eq Money.new(2_00, "EUR").hash
+      expect(Money.new(1_00, "EUR").hash).not_to eq Money.new(1_00, "USD").hash
+      expect(Money.new(1_00, "EUR").hash).not_to eq Money.new(2_00, "USD").hash
     end
 
     it "can be used to return the intersection of Money object arrays" do
       intersection = [Money.new(1_00, "EUR"), Money.new(1_00, "USD")] & [Money.new(1_00, "EUR")]
-      intersection.should == [Money.new(1_00, "EUR")]
+      expect(intersection).to eq [Money.new(1_00, "EUR")]
     end
   end
 
   describe "#symbol" do
     it "works as documented" do
       currency = Money::Currency.new("EUR")
-      currency.should_receive(:symbol).and_return("€")
-      Money.new(0, currency).symbol.should == "€"
+      expect(currency).to receive(:symbol).and_return("€")
+      expect(Money.new(0, currency).symbol).to eq "€"
 
       currency = Money::Currency.new("EUR")
-      currency.should_receive(:symbol).and_return(nil)
-      Money.new(0, currency).symbol.should == "¤"
+      expect(currency).to receive(:symbol).and_return(nil)
+      expect(Money.new(0, currency).symbol).to eq "¤"
     end
   end
 
   describe "#to_s" do
     it "works as documented" do
-      Money.new(10_00).to_s.should == "10.00"
-      Money.new(400_08).to_s.should == "400.08"
-      Money.new(-237_43).to_s.should == "-237.43"
+      expect(Money.new(10_00).to_s).to eq "10.00"
+      expect(Money.new(400_08).to_s).to eq "400.08"
+      expect(Money.new(-237_43).to_s).to eq "-237.43"
     end
 
     it "respects :subunit_to_unit currency property" do
-      Money.new(10_00, "BHD").to_s.should == "1.000"
-      Money.new(10_00, "CNY").to_s.should == "10.00"
+      expect(Money.new(10_00, "BHD").to_s).to eq "1.000"
+      expect(Money.new(10_00, "CNY").to_s).to eq "10.00"
     end
 
     it "does not have decimal when :subunit_to_unit == 1" do
-      Money.new(10_00, "CLP").to_s.should == "1000"
+      expect(Money.new(10_00, "CLP").to_s).to eq "1000"
     end
 
     it "does not work when :subunit_to_unit == 5" do
-      Money.new(10_00, "MGA").to_s.should == "200.0"
+      expect(Money.new(10_00, "MGA").to_s).to eq "200.0"
     end
 
     it "respects :decimal_mark" do
-      Money.new(10_00, "BRL").to_s.should == "10,00"
+      expect(Money.new(10_00, "BRL").to_s).to eq "10,00"
     end
 
     context "infinite_precision = true" do
@@ -388,15 +411,15 @@ YAML
       end
 
       it "shows fractional cents" do
-        Money.new(1.05, "USD").to_s.should == "0.0105"
+        expect(Money.new(1.05, "USD").to_s).to eq "0.0105"
       end
 
       it "suppresses fractional cents when there is none" do
-        Money.new(1.0, "USD").to_s.should == "0.01"
+        expect(Money.new(1.0, "USD").to_s).to eq "0.01"
       end
 
       it "shows fractional if needed when :subunut_to_unit == 1" do
-        Money.new(10_00.1, "CLP").to_s.should == "1000,1"
+        expect(Money.new(10_00.1, "CLP").to_s).to eq "1000,1"
       end
     end
   end
@@ -404,92 +427,102 @@ YAML
   describe "#to_d" do
     it "works as documented" do
       decimal = Money.new(10_00).to_d
-      decimal.should be_a(BigDecimal)
-      decimal.should == 10.0
+      expect(decimal).to be_a(BigDecimal)
+      expect(decimal).to eq 10.0
     end
 
     it "respects :subunit_to_unit currency property" do
       decimal = Money.new(10_00, "BHD").to_d
-      decimal.should be_a(BigDecimal)
-      decimal.should == 1.0
+      expect(decimal).to be_a(BigDecimal)
+      expect(decimal).to eq 1.0
     end
 
     it "works with float :subunit_to_unit currency property" do
       money = Money.new(10_00, "BHD")
-      money.currency.stub(:subunit_to_unit).and_return(1000.0)
+      allow(money.currency).to receive(:subunit_to_unit).and_return(1000.0)
 
       decimal = money.to_d
-      decimal.should be_a(BigDecimal)
-      decimal.should == 1.0
+      expect(decimal).to be_a(BigDecimal)
+      expect(decimal).to eq 1.0
     end
   end
 
   describe "#to_f" do
     it "works as documented" do
-      Money.new(10_00).to_f.should == 10.0
+      expect(Money.new(10_00).to_f).to eq 10.0
     end
 
     it "respects :subunit_to_unit currency property" do
-      Money.new(10_00, "BHD").to_f.should == 1.0
+      expect(Money.new(10_00, "BHD").to_f).to eq 1.0
+    end
+  end
+
+  describe "#to_i" do
+    it "works as documented" do
+      expect(Money.new(10_00).to_i).to eq 10
+    end
+
+    it "respects :subunit_to_unit currency property" do
+      expect(Money.new(10_00, "BHD").to_i).to eq 1
     end
   end
 
   describe "#to_money" do
     it "works as documented" do
       money = Money.new(10_00, "DKK")
-      money.should == money.to_money
-      money.should == money.to_money("DKK")
-      money.bank.should_receive(:exchange_with).with(Money.new(10_00, Money::Currency.new("DKK")), Money::Currency.new("EUR")).and_return(Money.new(200_00, Money::Currency.new('EUR')))
-      money.to_money("EUR").should == Money.new(200_00, "EUR")
+      expect(money).to eq money.to_money
+      expect(money).to eq money.to_money("DKK")
+      expect(money.bank).to receive(:exchange_with).with(Money.new(10_00, Money::Currency.new("DKK")), Money::Currency.new("EUR")).and_return(Money.new(200_00, Money::Currency.new('EUR')))
+      expect(money.to_money("EUR")).to eq Money.new(200_00, "EUR")
     end
   end
 
   describe "#exchange_to" do
     it "exchanges the amount via its exchange bank" do
       money = Money.new(100_00, "USD")
-      money.bank.should_receive(:exchange_with).with(Money.new(100_00, Money::Currency.new("USD")), Money::Currency.new("EUR")).and_return(Money.new(200_00, Money::Currency.new('EUR')))
+      expect(money.bank).to receive(:exchange_with).with(Money.new(100_00, Money::Currency.new("USD")), Money::Currency.new("EUR")).and_return(Money.new(200_00, Money::Currency.new('EUR')))
       money.exchange_to("EUR")
     end
 
     it "exchanges the amount properly" do
       money = Money.new(100_00, "USD")
-      money.bank.should_receive(:exchange_with).with(Money.new(100_00, Money::Currency.new("USD")), Money::Currency.new("EUR")).and_return(Money.new(200_00, Money::Currency.new('EUR')))
-      money.exchange_to("EUR").should == Money.new(200_00, "EUR")
+      expect(money.bank).to receive(:exchange_with).with(Money.new(100_00, Money::Currency.new("USD")), Money::Currency.new("EUR")).and_return(Money.new(200_00, Money::Currency.new('EUR')))
+      expect(money.exchange_to("EUR")).to eq Money.new(200_00, "EUR")
     end
 
     it 'uses the block given as rounding method' do
       money = Money.new(100_00, 'USD')
-      money.bank.should_receive(:exchange_with).and_yield(300_00)
+      expect(money.bank).to receive(:exchange_with).and_yield(300_00)
       expect { |block| money.exchange_to(Money::Currency.new('EUR'), &block) }.to yield_successive_args(300_00)
     end
 
     it "does no exchange when the currencies are the same" do
       money = Money.new(100_00, "USD")
-      money.bank.should_not_receive(:exchange_with)
-      money.exchange_to("USD").should == money
+      expect(money.bank).to_not receive(:exchange_with)
+      expect(money.exchange_to("USD")).to eq money
     end
   end
 
   describe "#allocate" do
     it "takes no action when one gets all" do
-      Money.us_dollar(005).allocate([1.0]).should == [Money.us_dollar(5)]
+      expect(Money.us_dollar(005).allocate([1.0])).to eq [Money.us_dollar(5)]
     end
 
     it "keeps currencies intact" do
-      Money.ca_dollar(005).allocate([1]).should == [Money.ca_dollar(5)]
+      expect(Money.ca_dollar(005).allocate([1])).to eq [Money.ca_dollar(5)]
     end
 
     it "does not loose pennies" do
       moneys = Money.us_dollar(5).allocate([0.3, 0.7])
-      moneys[0].should == Money.us_dollar(2)
-      moneys[1].should == Money.us_dollar(3)
+      expect(moneys[0]).to eq Money.us_dollar(2)
+      expect(moneys[1]).to eq Money.us_dollar(3)
     end
 
     it "does not loose pennies" do
       moneys = Money.us_dollar(100).allocate([0.333, 0.333, 0.333])
-      moneys[0].cents.should == 34
-      moneys[1].cents.should == 33
-      moneys[2].cents.should == 33
+      expect(moneys[0].cents).to eq 34
+      expect(moneys[1].cents).to eq 33
+      expect(moneys[2].cents).to eq 33
     end
 
     it "requires total to be less then 1" do
@@ -509,9 +542,9 @@ YAML
         one_third = BigDecimal("1") / BigDecimal("3")
 
         moneys = Money.new(100).allocate([one_third, one_third, one_third])
-        moneys[0].cents.should == one_third * BigDecimal("100")
-        moneys[1].cents.should == one_third * BigDecimal("100")
-        moneys[2].cents.should == one_third * BigDecimal("100")
+        expect(moneys[0].cents).to eq one_third * BigDecimal("100")
+        expect(moneys[1].cents).to eq one_third * BigDecimal("100")
+        expect(moneys[2].cents).to eq one_third * BigDecimal("100")
       end
     end
   end
@@ -523,22 +556,22 @@ YAML
     end
 
     it "gives 1 cent to both people if we start with 2" do
-      Money.us_dollar(2).split(2).should == [Money.us_dollar(1), Money.us_dollar(1)]
+      expect(Money.us_dollar(2).split(2)).to eq [Money.us_dollar(1), Money.us_dollar(1)]
     end
 
     it "may distribute no money to some parties if there isnt enough to go around" do
-      Money.us_dollar(2).split(3).should == [Money.us_dollar(1), Money.us_dollar(1), Money.us_dollar(0)]
+      expect(Money.us_dollar(2).split(3)).to eq [Money.us_dollar(1), Money.us_dollar(1), Money.us_dollar(0)]
     end
 
     it "does not lose pennies" do
-      Money.us_dollar(5).split(2).should == [Money.us_dollar(3), Money.us_dollar(2)]
+      expect(Money.us_dollar(5).split(2)).to eq [Money.us_dollar(3), Money.us_dollar(2)]
     end
 
     it "splits a dollar" do
       moneys = Money.us_dollar(100).split(3)
-      moneys[0].cents.should == 34
-      moneys[1].cents.should == 33
-      moneys[2].cents.should == 33
+      expect(moneys[0].cents).to eq 34
+      expect(moneys[1].cents).to eq 33
+      expect(moneys[2].cents).to eq 33
     end
 
     context "infinite_precision = true" do
@@ -554,9 +587,9 @@ YAML
         thirty_three_and_one_third = BigDecimal("100") / BigDecimal("3")
 
         moneys = Money.new(100).split(3)
-        moneys[0].cents.should == thirty_three_and_one_third
-        moneys[1].cents.should == thirty_three_and_one_third
-        moneys[2].cents.should == thirty_three_and_one_third
+        expect(moneys[0].cents).to eq thirty_three_and_one_third
+        expect(moneys[1].cents).to eq thirty_three_and_one_third
+        expect(moneys[2].cents).to eq thirty_three_and_one_third
       end
     end
   end
@@ -573,8 +606,8 @@ YAML
 
       it "returns self (as it is already rounded)" do
         rounded = money.round
-        rounded.should be money
-        rounded.cents.should eq 16
+        expect(rounded).to be money
+        expect(rounded.cents).to eq 16
       end
     end
 
@@ -588,20 +621,20 @@ YAML
       end
 
       it "returns a different money" do
-        rounded.should_not be money
+        expect(rounded).not_to be money
       end
 
       it "rounds the cents" do
-        rounded.cents.should eq 16
+        expect(rounded.cents).to eq 16
       end
 
       it "maintains the currency" do
-        rounded.currency.should eq Money::Currency.new('NZD')
+        expect(rounded.currency).to eq Money::Currency.new('NZD')
       end
 
       it "uses a provided rounding strategy" do
         rounded = money.round(BigDecimal::ROUND_DOWN)
-        rounded.cents.should eq 15
+        expect(rounded.cents).to eq 15
       end
     end
   end
@@ -614,7 +647,7 @@ YAML
       # ./lib/money/money.rb:63:in `fractional'
       # ./lib/money/money/arithmetic.rb:115:in `-'
       MoneyChild = Class.new(Money)
-      (MoneyChild.new(1000) - Money.new(500)).should eq Money.new(500)
+      expect(MoneyChild.new(1000) - Money.new(500)).to eq Money.new(500)
     end
   end
 
@@ -632,17 +665,17 @@ YAML
 
     specify "as_us_dollar converts Money object to USD" do
       obj = Money.new(1, "EUR")
-      obj.as_us_dollar.should == Money.new(1, "USD")
+      expect(obj.as_us_dollar).to eq Money.new(1, "USD")
     end
 
     specify "as_ca_dollar converts Money object to CAD" do
       obj = Money.new(1, "EUR")
-      obj.as_ca_dollar.should == Money.new(1, "CAD")
+      expect(obj.as_ca_dollar).to eq Money.new(1, "CAD")
     end
 
     specify "as_euro converts Money object to EUR" do
       obj = Money.new(1, "USD")
-      obj.as_euro.should == Money.new(1, "EUR")
+      expect(obj.as_euro).to eq Money.new(1, "EUR")
     end
   end
 
@@ -651,18 +684,18 @@ YAML
       @default_currency = Money.default_currency
     end
 
+    after do
+      Money.default_currency = @default_currency
+    end
+
     it "accepts a lambda" do
       Money.default_currency = lambda { :eur }
-      Money.default_currency.should == Money::Currency.new(:eur)
+      expect(Money.default_currency).to eq Money::Currency.new(:eur)
     end
 
     it "accepts a symbol" do
       Money.default_currency = :eur
-      Money.default_currency.should == Money::Currency.new(:eur)
-    end
-
-    after do
-      Money.default_currency = @default_currency
+      expect(Money.default_currency).to eq Money::Currency.new(:eur)
     end
   end
 end