money 6.1.1 → 6.2.0

data/spec/bank/variable_exchange_spec.rb

@@ -22,11 +22,11 @@ describe Money::Bank::VariableExchange do
         end
 
         it "exchanges one currency to another" do
-          bank.exchange_with(Money.new(100, 'USD'), 'EUR').should == Money.new(133, 'EUR')
+          expect(bank.exchange_with(Money.new(100, 'USD'), 'EUR')).to eq Money.new(133, 'EUR')
         end
 
         it "truncates extra digits" do
-          bank.exchange_with(Money.new(10, 'USD'), 'EUR').should == Money.new(13, 'EUR')
+          expect(bank.exchange_with(Money.new(10, 'USD'), 'EUR')).to eq Money.new(13, 'EUR')
         end
 
         it "raises an UnknownCurrency exception when an unknown currency is requested" do
@@ -40,13 +40,13 @@ describe Money::Bank::VariableExchange do
         #it "rounds the exchanged result down" do
         #  bank.add_rate("USD", "EUR", 0.788332676)
         #  bank.add_rate("EUR", "YEN", 122.631477)
-        #  bank.exchange_with(Money.new(10_00,  "USD"), "EUR").should == Money.new(788, "EUR")
-        #  bank.exchange_with(Money.new(500_00, "EUR"), "YEN").should == Money.new(6131573, "YEN")
+        #  expect(bank.exchange_with(Money.new(10_00,  "USD"), "EUR")).to eq Money.new(788, "EUR")
+        #  expect(bank.exchange_with(Money.new(500_00, "EUR"), "YEN")).to eq Money.new(6131573, "YEN")
         #end
 
         it "accepts a custom truncation method" do
           proc = Proc.new { |n| n.ceil }
-          bank.exchange_with(Money.new(10, 'USD'), 'EUR', &proc).should == Money.new(14, 'EUR')
+          expect(bank.exchange_with(Money.new(10, 'USD'), 'EUR', &proc)).to eq Money.new(14, 'EUR')
         end
       end
     end
@@ -61,12 +61,12 @@ describe Money::Bank::VariableExchange do
 
       describe "#exchange_with" do
         it "uses the stored truncation method" do
-          bank.exchange_with(Money.new(10, 'USD'), 'EUR').should == Money.new(14, 'EUR')
+          expect(bank.exchange_with(Money.new(10, 'USD'), 'EUR')).to eq Money.new(14, 'EUR')
         end
 
         it "accepts a custom truncation method" do
           proc = Proc.new { |n| n.ceil + 1 }
-          bank.exchange_with(Money.new(10, 'USD'), 'EUR', &proc).should == Money.new(15, 'EUR')
+          expect(bank.exchange_with(Money.new(10, 'USD'), 'EUR', &proc)).to eq Money.new(15, 'EUR')
         end
       end
     end
@@ -77,20 +77,20 @@ describe Money::Bank::VariableExchange do
       subject.add_rate("USD", "EUR", 0.788332676)
       subject.add_rate("EUR", "YEN", 122.631477)
 
-      subject.instance_variable_get(:@rates)['USD_TO_EUR'].should == 0.788332676
-      subject.instance_variable_get(:@rates)['EUR_TO_JPY'].should == 122.631477
+      expect(subject.instance_variable_get(:@rates)['USD_TO_EUR']).to eq 0.788332676
+      expect(subject.instance_variable_get(:@rates)['EUR_TO_JPY']).to eq 122.631477
     end
 
     it "treats currency names case-insensitively" do
       subject.add_rate("usd", "eur", 1)
-      subject.instance_variable_get(:@rates)['USD_TO_EUR'].should == 1
+      expect(subject.instance_variable_get(:@rates)['USD_TO_EUR']).to eq 1
     end
   end
 
   describe "#set_rate" do
     it "sets a rate" do
       subject.set_rate('USD', 'EUR', 1.25)
-      subject.instance_variable_get(:@rates)['USD_TO_EUR'].should == 1.25
+      expect(subject.instance_variable_get(:@rates)['USD_TO_EUR']).to eq 1.25
     end
 
     it "raises an UnknownCurrency exception when an unknown currency is passed" do
@@ -98,12 +98,12 @@ describe Money::Bank::VariableExchange do
     end
 
     it "uses a mutex by default" do
-      subject.instance_variable_get(:@mutex).should_receive(:synchronize)
+      expect(subject.instance_variable_get(:@mutex)).to receive(:synchronize)
       subject.set_rate('USD', 'EUR', 1.25)
     end
 
     it "doesn't use mutex if requested not to" do
-      subject.instance_variable_get(:@mutex).should_not_receive(:synchronize)
+      expect(subject.instance_variable_get(:@mutex)).not_to receive(:synchronize)
       subject.set_rate('USD', 'EUR', 1.25, :without_mutex => true)
     end
   end
@@ -111,7 +111,7 @@ describe Money::Bank::VariableExchange do
   describe "#get_rate" do
     it "returns a rate" do
       subject.set_rate('USD', 'EUR', 1.25)
-      subject.get_rate('USD', 'EUR').should == 1.25
+      expect(subject.get_rate('USD', 'EUR')).to eq 1.25
     end
 
     it "raises an UnknownCurrency exception when an unknown currency is passed" do
@@ -119,12 +119,12 @@ describe Money::Bank::VariableExchange do
     end
 
     it "uses a mutex by default" do
-      subject.instance_variable_get(:@mutex).should_receive(:synchronize)
+      expect(subject.instance_variable_get(:@mutex)).to receive(:synchronize)
       subject.get_rate('USD', 'EUR')
     end
 
     it "doesn't use mutex if requested not to" do
-      subject.instance_variable_get(:@mutex).should_not_receive(:synchronize)
+      expect(subject.instance_variable_get(:@mutex)).not_to receive(:synchronize)
       subject.get_rate('USD', 'EUR', :without_mutex => true)
     end
   end
@@ -140,20 +140,20 @@ describe Money::Bank::VariableExchange do
     context "with format == :json" do
       it "should return rates formatted as json" do
         json = subject.export_rates(:json)
-        JSON.load(json).should == @rates
+        expect(JSON.load(json)).to eq @rates
       end
     end
 
     context "with format == :ruby" do
       it "should return rates formatted as ruby objects" do
-        Marshal.load(subject.export_rates(:ruby)).should == @rates
+        expect(Marshal.load(subject.export_rates(:ruby))).to eq @rates
       end
     end
 
     context "with format == :yaml" do
       it "should return rates formatted as yaml" do
         yaml = subject.export_rates(:yaml)
-        YAML.load(yaml).should == @rates
+        expect(YAML.load(yaml)).to eq @rates
       end
     end
 
@@ -166,20 +166,20 @@ describe Money::Bank::VariableExchange do
     context "with :file provided" do
       it "writes rates to file" do
         f = double('IO')
-        File.should_receive(:open).with('null', 'w').and_yield(f)
-        f.should_receive(:write).with(JSON.dump(@rates))
+        expect(File).to receive(:open).with('null', 'w').and_yield(f)
+        expect(f).to receive(:write).with(JSON.dump(@rates))
 
         subject.export_rates(:json, 'null')
       end
     end
 
     it "uses a mutex by default" do
-      subject.instance_variable_get(:@mutex).should_receive(:synchronize)
+      expect(subject.instance_variable_get(:@mutex)).to receive(:synchronize)
       subject.export_rates(:yaml)
     end
 
     it "doesn't use mutex if requested not to" do
-      subject.instance_variable_get(:@mutex).should_not_receive(:synchronize)
+      expect(subject.instance_variable_get(:@mutex)).not_to receive(:synchronize)
       subject.export_rates(:yaml, nil, :without_mutex => true)
     end
   end
@@ -189,8 +189,8 @@ describe Money::Bank::VariableExchange do
       it "loads the rates provided" do
         s = '{"USD_TO_EUR":1.25,"USD_TO_JPY":2.55}'
         subject.import_rates(:json, s)
-        subject.get_rate('USD', 'EUR').should == 1.25
-        subject.get_rate('USD', 'JPY').should == 2.55
+        expect(subject.get_rate('USD', 'EUR')).to eq 1.25
+        expect(subject.get_rate('USD', 'JPY')).to eq 2.55
       end
     end
 
@@ -198,8 +198,8 @@ describe Money::Bank::VariableExchange do
       it "loads the rates provided" do
         s = Marshal.dump({"USD_TO_EUR"=>1.25,"USD_TO_JPY"=>2.55})
         subject.import_rates(:ruby, s)
-        subject.get_rate('USD', 'EUR').should == 1.25
-        subject.get_rate('USD', 'JPY').should == 2.55
+        expect(subject.get_rate('USD', 'EUR')).to eq 1.25
+        expect(subject.get_rate('USD', 'JPY')).to eq 2.55
       end
     end
 
@@ -207,8 +207,8 @@ describe Money::Bank::VariableExchange do
       it "loads the rates provided" do
         s = "--- \nUSD_TO_EUR: 1.25\nUSD_TO_JPY: 2.55\n"
         subject.import_rates(:yaml, s)
-        subject.get_rate('USD', 'EUR').should == 1.25
-        subject.get_rate('USD', 'JPY').should == 2.55
+        expect(subject.get_rate('USD', 'EUR')).to eq 1.25
+        expect(subject.get_rate('USD', 'JPY')).to eq 2.55
       end
     end
 
@@ -219,13 +219,13 @@ describe Money::Bank::VariableExchange do
     end
 
     it "uses a mutex by default" do
-      subject.instance_variable_get(:@mutex).should_receive(:synchronize)
+      expect(subject.instance_variable_get(:@mutex)).to receive(:synchronize)
       s = "--- \nUSD_TO_EUR: 1.25\nUSD_TO_JPY: 2.55\n"
       subject.import_rates(:yaml, s)
     end
 
     it "doesn't use mutex if requested not to" do
-      subject.instance_variable_get(:@mutex).should_not_receive(:synchronize)
+      expect(subject.instance_variable_get(:@mutex)).not_to receive(:synchronize)
       s = "--- \nUSD_TO_EUR: 1.25\nUSD_TO_JPY: 2.55\n"
       subject.import_rates(:yaml, s, :without_mutex => true)
     end
@@ -249,10 +249,10 @@ describe Money::Bank::VariableExchange do
     end
 
     it "returns a hashkey based on the passed arguments" do
-      subject.send(:rate_key_for, 'USD', 'EUR').should == 'USD_TO_EUR'
-      subject.send(:rate_key_for, Money::Currency.wrap('USD'), 'EUR').should == 'USD_TO_EUR'
-      subject.send(:rate_key_for, 'USD', Money::Currency.wrap('EUR')).should == 'USD_TO_EUR'
-      subject.send(:rate_key_for, Money::Currency.wrap('USD'), Money::Currency.wrap('EUR')).should == 'USD_TO_EUR'
+      expect(subject.send(:rate_key_for, 'USD', 'EUR')).to eq 'USD_TO_EUR'
+      expect(subject.send(:rate_key_for, Money::Currency.wrap('USD'), 'EUR')).to eq 'USD_TO_EUR'
+      expect(subject.send(:rate_key_for, 'USD', Money::Currency.wrap('EUR'))).to eq 'USD_TO_EUR'
+      expect(subject.send(:rate_key_for, Money::Currency.wrap('USD'), Money::Currency.wrap('EUR'))).to eq 'USD_TO_EUR'
     end
 
     it "raises a Money::Currency::UnknownCurrency exception when an unknown currency is passed" do
@@ -268,8 +268,8 @@ describe Money::Bank::VariableExchange do
     it "works with Marshal.load" do
       bank = Marshal.load(Marshal.dump(subject))
 
-      bank.rates.should           == subject.rates
-      bank.rounding_method.should == subject.rounding_method
+      expect(bank.rates).to           eq subject.rates
+      expect(bank.rounding_method).to eq subject.rounding_method
     end
   end
 end

data/spec/currency/heuristics_spec.rb

@@ -6,79 +6,79 @@ describe Money::Currency::Heuristics do
     let(:it) { Money::Currency }
 
     it "is not affected by blank characters and numbers" do
-      it.analyze('123').should == []
-      it.analyze('\n123 \t').should == []
+      expect(it.analyze('123')).to eq []
+      expect(it.analyze('\n123 \t')).to eq []
     end
 
     it "returns nothing when given nothing" do
-      it.analyze('').should == []
-      it.analyze(nil).should == []
+      expect(it.analyze('')).to eq []
+      expect(it.analyze(nil)).to eq []
     end
 
     it "finds a currency by use of its symbol" do
-      it.analyze('zł').should == ['PLN']
+      expect(it.analyze('zł')).to eq ['PLN']
     end
 
     it "is not affected by trailing dot" do
-      it.analyze('zł.').should == ['PLN']
+      expect(it.analyze('zł.')).to eq ['PLN']
     end
 
     it "finds match even if has numbers after" do
-      it.analyze('zł 123').should == ['PLN']
+      expect(it.analyze('zł 123')).to eq ['PLN']
     end
 
     it "finds match even if has numbers before" do
-      it.analyze('123 zł').should == ['PLN']
+      expect(it.analyze('123 zł')).to eq ['PLN']
     end
 
     it "find match even if symbol is next to number" do
-      it.analyze('300zł').should == ['PLN']
+      expect(it.analyze('300zł')).to eq ['PLN']
     end
 
     it "finds match even if has numbers with delimiters" do
-      it.analyze('zł 123,000.50').should == ['PLN']
-      it.analyze('zł123,000.50').should == ['PLN']
+      expect(it.analyze('zł 123,000.50')).to eq ['PLN']
+      expect(it.analyze('zł123,000.50')).to eq ['PLN']
     end
 
     it "finds currencies with dots in symbols" do
-      it.analyze('L.E.').should == ['EGP']
+      expect(it.analyze('L.E.')).to eq ['EGP']
     end
 
     it "finds by name" do
-      it.analyze('1900 bulgarian lev').should == ['BGN']
-      it.analyze('Swedish Krona').should == ['SEK']
+      expect(it.analyze('1900 bulgarian lev')).to eq ['BGN']
+      expect(it.analyze('Swedish Krona')).to eq ['SEK']
     end
 
     it "Finds several currencies when several match" do
       r = it.analyze('$400')
-      r.should include("ARS")
-      r.should include("USD")
-      r.should include("NZD")
+      expect(r).to include("ARS")
+      expect(r).to include("USD")
+      expect(r).to include("NZD")
 
       r = it.analyze('9000 £')
-      r.should include("GBP")
-      r.should include("SHP")
-      r.should include("SYP")
+      expect(r).to include("GBP")
+      expect(r).to include("SHP")
+      expect(r).to include("SYP")
     end
 
     it "should use alternate symbols" do
-      it.analyze('US$').should == ['USD']
+      expect(it.analyze('US$')).to eq ['USD']
     end
 
     it "finds a currency by use of its iso code" do
-      it.analyze('USD 200').should == ['USD']
+      expect(it.analyze('USD 200')).to eq ['USD']
     end
 
     it "finds currencies in the middle of a sentence!" do
-      it.analyze('It would be nice to have 10000 Albanian lek by tomorrow!').should == ['ALL']
+      expect(it.analyze('It would be nice to have 10000 Albanian lek by tomorrow!')).to eq ['ALL']
     end
 
     it "finds several currencies in the same text!" do
-      it.analyze("10EUR is less than 100:- but really, I want US$1").should == ['EUR', 'SEK', 'USD']
+      expect(it.analyze("10EUR is less than 100:- but really, I want US$1")).to eq ['EUR', 'SEK', 'USD']
     end
 
     it "should function with unicode characters" do
-      it.analyze("10 դր.").should == ["AMD"]
+      expect(it.analyze("10 դր.")).to eq ["AMD"]
     end
   end
 end

data/spec/currency_spec.rb

@@ -18,72 +18,72 @@ describe Money::Currency do
     it "returns currency matching given id" do
 
       expected = Money::Currency.new(:foo)
-      Money::Currency.find(:foo).should  == expected
-      Money::Currency.find(:FOO).should  == expected
-      Money::Currency.find("foo").should == expected
-      Money::Currency.find("FOO").should == expected
+      expect(Money::Currency.find(:foo)).to eq  expected
+      expect(Money::Currency.find(:FOO)).to eq  expected
+      expect(Money::Currency.find("foo")).to eq expected
+      expect(Money::Currency.find("FOO")).to eq expected
     end
 
     it "returns nil unless currency matching given id" do
-      Money::Currency.find("ZZZ").should be_nil
+      expect(Money::Currency.find("ZZZ")).to be_nil
     end
   end
 
   describe ".find_by_iso_numeric" do
     it "returns currency matching given numeric code" do
-      Money::Currency.find_by_iso_numeric(978).should          == Money::Currency.new(:eur)
-      Money::Currency.find_by_iso_numeric(208).should_not      == Money::Currency.new(:eur)
-      Money::Currency.find_by_iso_numeric('840').should        == Money::Currency.new(:usd)
+      expect(Money::Currency.find_by_iso_numeric(978)).to eq          Money::Currency.new(:eur)
+      expect(Money::Currency.find_by_iso_numeric(208)).not_to eq      Money::Currency.new(:eur)
+      expect(Money::Currency.find_by_iso_numeric('840')).to eq        Money::Currency.new(:usd)
 
       class Mock
         def to_s
           '208'
         end
       end
-      Money::Currency.find_by_iso_numeric(Mock.new).should     == Money::Currency.new(:dkk)
-      Money::Currency.find_by_iso_numeric(Mock.new).should_not == Money::Currency.new(:usd)
+      expect(Money::Currency.find_by_iso_numeric(Mock.new)).to eq     Money::Currency.new(:dkk)
+      expect(Money::Currency.find_by_iso_numeric(Mock.new)).not_to eq Money::Currency.new(:usd)
     end
 
     it "returns nil if no currency has the given numeric code" do
-      Money::Currency.find_by_iso_numeric('non iso 4217 numeric code').should == nil
-      Money::Currency.find_by_iso_numeric(0).should                           == nil
+      expect(Money::Currency.find_by_iso_numeric('non iso 4217 numeric code')).to be_nil
+      expect(Money::Currency.find_by_iso_numeric(0)).to be_nil
     end
   end
 
   describe ".wrap" do
     it "returns nil if object is nil" do
-      Money::Currency.wrap(nil).should == nil
-      Money::Currency.wrap(Money::Currency.new(:usd)).should == Money::Currency.new(:usd)
-      Money::Currency.wrap(:usd).should == Money::Currency.new(:usd)
+      expect(Money::Currency.wrap(nil)).to be_nil
+      expect(Money::Currency.wrap(Money::Currency.new(:usd))).to eq Money::Currency.new(:usd)
+      expect(Money::Currency.wrap(:usd)).to eq Money::Currency.new(:usd)
     end
   end
 
   describe ".all" do
     it "returns an array of currencies" do
-      Money::Currency.all.should include Money::Currency.new(:usd)
+      expect(Money::Currency.all).to include Money::Currency.new(:usd)
     end
     it "includes registered currencies" do
       Money::Currency.register(JSON.parse(FOO, :symbolize_names => true))
-      Money::Currency.all.should include Money::Currency.new(:foo)
+      expect(Money::Currency.all).to include Money::Currency.new(:foo)
       Money::Currency.unregister(JSON.parse(FOO, :symbolize_names => true))
     end
     it 'is sorted by priority' do
-      Money::Currency.all.first.priority.should == 1
+      expect(Money::Currency.all.first.priority).to eq 1
     end
   end
 
   describe "#initialize" do
     it "lookups data from loaded config" do
       currency = Money::Currency.new("USD")
-      currency.id.should                  == :usd
-      currency.priority.should            == 1
-      currency.iso_code.should            == "USD"
-      currency.iso_numeric.should         == "840"
-      currency.name.should                == "United States Dollar"
-      currency.decimal_mark.should        == "."
-      currency.separator.should           == "."
-      currency.thousands_separator.should == ","
-      currency.delimiter.should           == ","
+      expect(currency.id).to                  eq :usd
+      expect(currency.priority).to            eq 1
+      expect(currency.iso_code).to            eq "USD"
+      expect(currency.iso_numeric).to         eq "840"
+      expect(currency.name).to                eq "United States Dollar"
+      expect(currency.decimal_mark).to        eq "."
+      expect(currency.separator).to           eq "."
+      expect(currency.thousands_separator).to eq ","
+      expect(currency.delimiter).to           eq ","
     end
 
     it "raises UnknownMoney::Currency with unknown currency" do
@@ -93,99 +93,98 @@ describe Money::Currency do
 
   describe "#<=>" do
     it "compares objects by priority" do
-      Money::Currency.new(:cad).should > Money::Currency.new(:usd)
-      Money::Currency.new(:usd).should < Money::Currency.new(:eur)
+      expect(Money::Currency.new(:cad)).to be > Money::Currency.new(:usd)
+      expect(Money::Currency.new(:usd)).to be < Money::Currency.new(:eur)
     end
   end
 
   describe "#==" do
     it "returns true if self === other" do
       currency = Money::Currency.new(:eur)
-      currency.should == currency
+      expect(currency).to eq currency
     end
 
     it "returns true if the id is equal ignorning case" do
-      Money::Currency.new(:eur).should     == Money::Currency.new(:eur)
-      Money::Currency.new(:eur).should     == Money::Currency.new(:EUR)
-      Money::Currency.new(:eur).should_not == Money::Currency.new(:usd)
+      expect(Money::Currency.new(:eur)).to     eq Money::Currency.new(:eur)
+      expect(Money::Currency.new(:eur)).to     eq Money::Currency.new(:EUR)
+      expect(Money::Currency.new(:eur)).not_to eq Money::Currency.new(:usd)
     end
-    
+
     it "allows direct comparison of currencies and symbols/strings" do
-      Money::Currency.new(:eur).should     == 'eur'
-      Money::Currency.new(:eur).should     == 'EUR'
-      Money::Currency.new(:eur).should     == :eur
-      Money::Currency.new(:eur).should     == :EUR
-      Money::Currency.new(:eur).should_not == 'usd'
+      expect(Money::Currency.new(:eur)).to     eq 'eur'
+      expect(Money::Currency.new(:eur)).to     eq 'EUR'
+      expect(Money::Currency.new(:eur)).to     eq :eur
+      expect(Money::Currency.new(:eur)).to     eq :EUR
+      expect(Money::Currency.new(:eur)).not_to eq 'usd'
     end
 
     it "allows comparison with nil and returns false" do
-      Money::Currency.new(:eur).should_not == nil
+      expect(Money::Currency.new(:eur)).not_to be_nil
     end
   end
 
   describe "#eql?" do
     it "returns true if #== returns true" do
-      Money::Currency.new(:eur).eql?(Money::Currency.new(:eur)).should be true
-      Money::Currency.new(:eur).eql?(Money::Currency.new(:usd)).should be false
+      expect(Money::Currency.new(:eur).eql?(Money::Currency.new(:eur))).to be true
+      expect(Money::Currency.new(:eur).eql?(Money::Currency.new(:usd))).to be false
     end
   end
 
   describe "#hash" do
     it "returns the same value for equal objects" do
-      Money::Currency.new(:eur).hash.should == Money::Currency.new(:eur).hash
-      Money::Currency.new(:eur).hash.should_not == Money::Currency.new(:usd).hash
+      expect(Money::Currency.new(:eur).hash).to eq Money::Currency.new(:eur).hash
+      expect(Money::Currency.new(:eur).hash).not_to eq Money::Currency.new(:usd).hash
     end
 
     it "can be used to return the intersection of Currency object arrays" do
       intersection = [Money::Currency.new(:eur), Money::Currency.new(:usd)] & [Money::Currency.new(:eur)]
-      intersection.should == [Money::Currency.new(:eur)]
+      expect(intersection).to eq [Money::Currency.new(:eur)]
     end
   end
 
   describe "#inspect" do
     it "works as documented" do
-      Money::Currency.new(:usd).inspect.should ==
-          %Q{#<Money::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, exponent: 2.0, iso_code: USD, iso_numeric: 840, subunit: Cent>}
+      expect(Money::Currency.new(:usd).inspect).to eq %Q{#<Money::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, exponent: 2.0, iso_code: USD, iso_numeric: 840, subunit: Cent>}
     end
   end
 
   describe "#to_s" do
     it "works as documented" do
-      Money::Currency.new(:usd).to_s.should == "USD"
-      Money::Currency.new(:eur).to_s.should == "EUR"
+      expect(Money::Currency.new(:usd).to_s).to eq("USD")
+      expect(Money::Currency.new(:eur).to_s).to eq("EUR")
     end
   end
 
   describe "#to_str" do
     it "works as documented" do
-      Money::Currency.new(:usd).to_str.should == "USD"
-      Money::Currency.new(:eur).to_str.should == "EUR"
+      expect(Money::Currency.new(:usd).to_str).to eq("USD")
+      expect(Money::Currency.new(:eur).to_str).to eq("EUR")
     end
   end
 
   describe "#to_sym" do
     it "works as documented" do
-      Money::Currency.new(:usd).to_sym.should == :USD
-      Money::Currency.new(:eur).to_sym.should == :EUR
+      expect(Money::Currency.new(:usd).to_sym).to eq(:USD)
+      expect(Money::Currency.new(:eur).to_sym).to eq(:EUR)
     end
   end
 
   describe "#to_currency" do
     it "works as documented" do
       usd = Money::Currency.new(:usd)
-      usd.to_currency.should == usd
+      expect(usd.to_currency).to eq usd
     end
 
     it "doesn't create new symbols indefinitely" do
       expect { Money::Currency.new("bogus") }.to raise_exception(Money::Currency::UnknownCurrency)
-      Symbol.all_symbols.map{|s| s.to_s}.should_not include("bogus")
+      expect(Symbol.all_symbols.map{|s| s.to_s}).not_to include("bogus")
     end
   end
 
   describe "#code" do
     it "works as documented" do
-      Money::Currency.new(:usd).code.should == "$"
-      Money::Currency.new(:azn).code.should == "AZN"
+      expect(Money::Currency.new(:usd).code).to eq "$"
+      expect(Money::Currency.new(:azn).code).to eq "\u20BC"
     end
   end