money-rails 1.0.0 → 1.1.0

data/spec/active_record/monetizable_spec.rb

@@ -16,35 +16,35 @@ if defined? ActiveRecord
       end
 
       it "should be inherited by subclasses" do
-        Sub.monetized_attributes.should == Product.monetized_attributes
+        expect(Sub.monetized_attributes).to eq(Product.monetized_attributes)
       end
 
       it "attaches a Money object to model field" do
-        product.price.should be_an_instance_of(Money)
-        product.discount_value.should be_an_instance_of(Money)
-        product.bonus.should be_an_instance_of(Money)
+        expect(product.price).to be_an_instance_of(Money)
+        expect(product.discount_value).to be_an_instance_of(Money)
+        expect(product.bonus).to be_an_instance_of(Money)
       end
 
       it "returns the expected money amount as a Money object" do
-        product.price.should == Money.new(3000, "USD")
+        expect(product.price).to eq(Money.new(3000, "USD"))
       end
 
       it "assigns the correct value from a Money object" do
         product.price = Money.new(3210, "USD")
-        product.save.should eq(true)
-        product.price_cents.should == 3210
+        expect(product.save).to be_truthy
+        expect(product.price_cents).to eq(3210)
       end
 
       it "assigns the correct value from a Money object using create" do
         product = Product.create(:price => Money.new(3210, "USD"), :discount => 150,
                                   :bonus_cents => 200, :optional_price => 100)
-        product.valid?.should eq(true)
-        product.price_cents.should == 3210
+        expect(product.valid?).to be_truthy
+        expect(product.price_cents).to eq(3210)
       end
 
       it "correctly updates from a Money object using update_attributes" do
-        product.update_attributes(:price => Money.new(215, "USD")).should eq(true)
-        product.price_cents.should == 215
+        expect(product.update_attributes(:price => Money.new(215, "USD"))).to be_truthy
+        expect(product.price_cents).to eq(215)
       end
 
       it "should raise error if can't change currency" do
@@ -54,28 +54,36 @@ if defined? ActiveRecord
         }.to raise_error("Can't change readonly currency 'USD' to 'RUB' for field 'price'")
       end
 
+      it "raises an error if trying to create two attributes with the same name" do
+        expect do
+          class Product
+            monetize :discount, as: :price
+          end
+        end.to raise_error
+      end
+
       it "respects :as argument" do
-        product.discount_value.should == Money.new(150, "USD")
+        expect(product.discount_value).to eq(Money.new(150, "USD"))
       end
 
       it "uses numericality validation" do
         product.price_cents = "foo"
-        product.save.should eq(false)
+        expect(product.save).to be_falsey
 
         product.price_cents = 2000
-        product.save.should eq(true)
+        expect(product.save).to be_truthy
       end
 
       it "skips numericality validation when disabled" do
         product.invalid_price_cents = 'not_valid'
-        product.save.should eq(true)
+        expect(product.save).to be_truthy
       end
 
       it "passes validation after updating fractional attribute which was previously invalid" do
         product.price_in_a_range = -5
-        product.should_not be_valid
+        expect(product).not_to be_valid
         product.price_in_a_range_cents = 500
-        product.should be_valid
+        expect(product).to be_valid
       end
 
       context "when MoneyRails.raise_error_on_money_parsing is true" do
@@ -94,175 +102,185 @@ if defined? ActiveRecord
       end
 
       it "respects numericality validation when using update_attributes" do
-        product.update_attributes(:price_cents => "some text").should eq(false)
-        product.update_attributes(:price_cents => 2000).should eq(true)
+        expect(product.update_attributes(:price_cents => "some text")).to be_falsey
+        expect(product.update_attributes(:price_cents => 2000)).to be_truthy
       end
 
       it "uses numericality validation on money attribute" do
         product.price = "some text"
-        product.save.should eq(false)
+        expect(product.save).to be_falsey
 
         product.price = Money.new(320, "USD")
-        product.save.should eq(true)
+        expect(product.save).to be_truthy
 
         product.sale_price = "12.34"
         product.sale_price_currency_code = 'EUR'
-        product.valid?.should eq(true)
+        expect(product.valid?).to be_truthy
       end
 
       it "fails validation with the proper error message if money value is invalid decimal" do
         product.price = "12.23.24"
-        product.save.should eq(false)
-        product.errors[:price].first.should match(/Must be a valid/)
-        product.errors[:price].first.should match(/Got 12.23.24/)
+        expect(product.save).to be_falsey
+        expect(product.errors[:price].first).to match(/Must be a valid/)
+        expect(product.errors[:price].first).to match(/Got 12.23.24/)
       end
 
       it "fails validation with the proper error message if money value is nothing but periods" do
         product.price = "..."
-        product.save.should eq(false)
-        product.errors[:price].first.should match(/Must be a valid/)
-        product.errors[:price].first.should match(/Got .../)
+        expect(product.save).to be_falsey
+        expect(product.errors[:price].first).to match(/Must be a valid/)
+        expect(product.errors[:price].first).to match(/Got .../)
       end
 
       it "fails validation with the proper error message if money value has invalid thousands part" do
         product.price = "12,23.24"
-        product.save.should eq(false)
-        product.errors[:price].first.should match(/Must be a valid/)
-        product.errors[:price].first.should match(/Got 12,23.24/)
+        expect(product.save).to be_falsey
+        expect(product.errors[:price].first).to match(/Must be a valid/)
+        expect(product.errors[:price].first).to match(/Got 12,23.24/)
+      end
+
+      it "allows an empty string as the thousands separator" do
+        begin
+          I18n.locale = 'en-US'
+          product.price = '10.00'
+          expect(product).to be_valid
+        ensure
+          I18n.locale = I18n.default_locale
+        end
       end
 
       it "passes validation if money value is a Float and the currency decimal mark is not period" do
         # The corresponding String would be "12,34" euros
         service.discount = 12.34
-        service.save.should eq(true)
+        expect(service.save).to be_truthy
       end
 
        it "passes validation if money value is a Float" do
         product.price = 12.34
-        product.save.should eq(true)
+        expect(product.save).to be_truthy
       end
 
       it "passes validation if money value is an Integer" do
         product.price = 12
-        product.save.should eq(true)
+        expect(product.save).to be_truthy
       end
 
       it "fails validation with the proper error message using numericality validations" do
         product.price_in_a_range = "-12"
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range].first).to match(/Must be greater than zero and less than \$100/)
 
         product.price_in_a_range = Money.new(-1200, "USD")
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range].first).to match(/Must be greater than zero and less than \$100/)
 
         product.price_in_a_range = "0"
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range].first).to match(/Must be greater than zero and less than \$100/)
 
         product.price_in_a_range = "12"
-        product.valid?.should eq(true)
+        expect(product.valid?).to be_truthy
 
         product.price_in_a_range = Money.new(1200, "USD")
-        product.valid?.should eq(true)
+        expect(product.valid?).to be_truthy
 
         product.price_in_a_range = "101"
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range].first).to match(/Must be greater than zero and less than \$100/)
 
         product.price_in_a_range = Money.new(10100, "USD")
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range].first).to match(/Must be greater than zero and less than \$100/)
       end
 
       it "fails validation with the proper error message using validates :money" do
         product.validates_method_amount = "-12"
-        product.valid?.should eq(false)
-        product.errors[:validates_method_amount].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:validates_method_amount].first).to match(/Must be greater than zero and less than \$100/)
 
         product.validates_method_amount = Money.new(-1200, "USD")
-        product.valid?.should eq(false)
-        product.errors[:validates_method_amount].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:validates_method_amount].first).to match(/Must be greater than zero and less than \$100/)
 
         product.validates_method_amount = "0"
-        product.valid?.should eq(false)
-        product.errors[:validates_method_amount].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:validates_method_amount].first).to match(/Must be greater than zero and less than \$100/)
 
         product.validates_method_amount = "12"
-        product.valid?.should eq(true)
+        expect(product.valid?).to be_truthy
 
         product.validates_method_amount = Money.new(1200, "USD")
-        product.valid?.should eq(true)
+        expect(product.valid?).to be_truthy
 
         product.validates_method_amount = "101"
-        product.valid?.should eq(false)
-        product.errors[:validates_method_amount].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:validates_method_amount].first).to match(/Must be greater than zero and less than \$100/)
 
         product.validates_method_amount = Money.new(10100, "USD")
-        product.valid?.should eq(false)
-        product.errors[:validates_method_amount].first.should match(/Must be greater than zero and less than \$100/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:validates_method_amount].first).to match(/Must be greater than zero and less than \$100/)
       end
 
       it "fails validation with the proper error message on the cents field " do
         product.price_in_a_range = "-12"
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range_cents].first.should match(/greater than 0/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range_cents].first).to match(/greater than 0/)
 
         product.price_in_a_range = "0"
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range_cents].first.should match(/greater than 0/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range_cents].first).to match(/greater than 0/)
 
         product.price_in_a_range = "12"
-        product.valid?.should eq(true)
+        expect(product.valid?).to be_truthy
 
         product.price_in_a_range = "101"
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range_cents].first.should match(/less than or equal to 10000/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range_cents].first).to match(/less than or equal to 10000/)
       end
 
       it "fails validation when a non number string is given" do
         product = Product.create(:price_in_a_range => "asd")
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range].first.should match(/greater than zero/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range].first).to match(/greater than zero/)
 
         product = Product.create(:price_in_a_range => "asd23")
-        product.valid?.should eq(false)
-        product.errors[:price_in_a_range].first.should match(/greater than zero/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price_in_a_range].first).to match(/greater than zero/)
 
         product = Product.create(:price => "asd")
-        product.valid?.should eq(false)
-        product.errors[:price].first.should match(/is not a number/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price].first).to match(/is not a number/)
 
         product = Product.create(:price => "asd23")
-        product.valid?.should eq(false)
-        product.errors[:price].first.should match(/is not a number/)
+        expect(product.valid?).to be_falsey
+        expect(product.errors[:price].first).to match(/is not a number/)
       end
 
       it "passes validation when amount contains spaces (99 999 999.99)" do
         product.price = "99 999 999.99"
-        product.should be_valid
-        product.price_cents.should == 9999999999
+        expect(product).to be_valid
+        expect(product.price_cents).to eq(9999999999)
       end
 
       it "passes validation when amount contains underscores (99_999_999.99)" do
         product.price = "99_999_999.99"
-        product.should be_valid
-        product.price_cents.should == 9999999999
+        expect(product).to be_valid
+        expect(product.price_cents).to eq(9999999999)
       end
 
       it "passes validation if money value has correct format" do
         product.price = "12,230.24"
-        product.save.should eq(true)
+        expect(product.save).to be_truthy
       end
 
       it "passes validation if there is a whitespace between the currency symbol and amount" do
         product.price = "$ 123,456.78"
-        product.save.should eq(true)
+        expect(product.save).to be_truthy
       end
 
       it "respects numericality validation when using update_attributes on money attribute" do
-        product.update_attributes(:price => "some text").should eq(false)
-        product.update_attributes(:price => Money.new(320, 'USD')).should eq(true)
+        expect(product.update_attributes(:price => "some text")).to be_falsey
+        expect(product.update_attributes(:price => Money.new(320, 'USD'))).to be_truthy
       end
 
       it "uses i18n currency format when validating" do
@@ -270,10 +288,10 @@ if defined? ActiveRecord
 
         I18n.locale = "en-GB"
         Money.default_currency = Money::Currency.find('EUR')
-        "12.00".to_money.should == Money.new(1200, :eur)
+        expect("12.00".to_money).to eq(Money.new(1200, :eur))
         transaction = Transaction.new(amount: "12.00", tax: "13.00")
-        transaction.amount_cents.should == 1200
-        transaction.valid?.should eq(true)
+        expect(transaction.amount_cents).to eq(1200)
+        expect(transaction.valid?).to be_truthy
 
         # reset locale setting
         I18n.locale = old_locale
@@ -284,10 +302,10 @@ if defined? ActiveRecord
 
         I18n.locale = "zxsw"
         Money.default_currency = Money::Currency.find('EUR')
-        "12,00".to_money.should == Money.new(1200, :eur)
+        expect("12,00".to_money).to eq(Money.new(1200, :eur))
         transaction = Transaction.new(amount: "12,00", tax: "13,00")
-        transaction.amount_cents.should == 1200
-        transaction.valid?.should eq(true)
+        expect(transaction.amount_cents).to eq(1200)
+        expect(transaction.valid?).to be_truthy
 
         # reset locale setting
         I18n.locale = old_locale
@@ -295,13 +313,13 @@ if defined? ActiveRecord
 
       it "doesn't allow nil by default" do
         product.price_cents = nil
-        product.save.should eq(false)
+        expect(product.save).to be_falsey
       end
 
       it "allows nil if optioned" do
         product.optional_price = nil
-        product.save.should eq(true)
-        product.optional_price.should be_nil
+        expect(product.save).to be_truthy
+        expect(product.optional_price).to be_nil
       end
 
       it "doesn't raise exception if validation is used and nil is not allowed" do
@@ -311,142 +329,151 @@ if defined? ActiveRecord
       it "doesn't save nil values if validation is used and nil is not allowed" do
         product.price = nil
         product.save
-        product.price_cents.should_not be_nil
+        expect(product.price_cents).not_to be_nil
       end
 
       it "resets money_before_type_cast attr every time a save operation occurs" do
         v = Money.new(100, :usd)
         product.price = v
-        product.price_money_before_type_cast.should == v
+        expect(product.price_money_before_type_cast).to eq(v)
         product.save
-        product.price_money_before_type_cast.should be_nil
+        expect(product.price_money_before_type_cast).to be_nil
         product.price = 10
-        product.price_money_before_type_cast.should == 10
+        expect(product.price_money_before_type_cast).to eq(10)
         product.save
-        product.price_money_before_type_cast.should be_nil
+        expect(product.price_money_before_type_cast).to be_nil
       end
 
       it "does not reset money_before_type_cast attr if save operation fails" do
         product.bonus = ""
-        product.bonus_money_before_type_cast.should == ""
-        product.save.should eq(false)
-        product.bonus_money_before_type_cast.should == ""
+        expect(product.bonus_money_before_type_cast).to eq("")
+        expect(product.save).to be_falsey
+        expect(product.bonus_money_before_type_cast).to eq("")
       end
 
       it "uses Money default currency if :with_currency has not been used" do
-        service.discount.currency.should == Money::Currency.find(:eur)
+        expect(service.discount.currency).to eq(Money::Currency.find(:eur))
       end
 
       it "overrides default currency with the currency registered for the model" do
-        product.price.currency.should == Money::Currency.find(:usd)
+        expect(product.price.currency).to eq(Money::Currency.find(:usd))
       end
 
       it "overrides default currency with the value of :with_currency argument" do
-        service.charge.currency.should == Money::Currency.find(:usd)
-        product.bonus.currency.should == Money::Currency.find(:gbp)
+        expect(service.charge.currency).to eq(Money::Currency.find(:usd))
+        expect(product.bonus.currency).to eq(Money::Currency.find(:gbp))
       end
 
       it "correctly assigns Money objects to the attribute" do
         product.price = Money.new(2500, :USD)
-        product.save.should eq(true)
-        product.price.cents.should == 2500
-        product.price.currency_as_string.should == "USD"
+        expect(product.save).to be_truthy
+        expect(product.price.cents).to eq(2500)
+        expect(product.price.currency_as_string).to eq("USD")
       end
 
       it "correctly assigns Fixnum objects to the attribute" do
         product.price = 25
-        product.save.should eq(true)
-        product.price.cents.should == 2500
-        product.price.currency_as_string.should == "USD"
+        expect(product.save).to be_truthy
+        expect(product.price.cents).to eq(2500)
+        expect(product.price.currency_as_string).to eq("USD")
 
         service.discount = 2
-        service.save.should eq(true)
-        service.discount.cents.should == 200
-        service.discount.currency_as_string.should == "EUR"
+        expect(service.save).to be_truthy
+        expect(service.discount.cents).to eq(200)
+        expect(service.discount.currency_as_string).to eq("EUR")
       end
 
       it "correctly assigns String objects to the attribute" do
         product.price = "25"
-        product.save.should eq(true)
-        product.price.cents.should == 2500
-        product.price.currency_as_string.should == "USD"
+        expect(product.save).to be_truthy
+        expect(product.price.cents).to eq(2500)
+        expect(product.price.currency_as_string).to eq("USD")
 
         service.discount = "2"
-        service.save.should eq(true)
-        service.discount.cents.should == 200
-        service.discount.currency_as_string.should == "EUR"
+        expect(service.save).to be_truthy
+        expect(service.discount.cents).to eq(200)
+        expect(service.discount.currency_as_string).to eq("EUR")
       end
 
       it "overrides default, model currency with the value of :with_currency in fixnum assignments" do
         product.bonus = 25
-        product.save.should eq(true)
-        product.bonus.cents.should == 2500
-        product.bonus.currency_as_string.should == "GBP"
+        expect(product.save).to be_truthy
+        expect(product.bonus.cents).to eq(2500)
+        expect(product.bonus.currency_as_string).to eq("GBP")
 
         service.charge = 2
-        service.save.should eq(true)
-        service.charge.cents.should == 200
-        service.charge.currency_as_string.should == "USD"
+        expect(service.save).to be_truthy
+        expect(service.charge.cents).to eq(200)
+        expect(service.charge.currency_as_string).to eq("USD")
       end
 
       it "overrides default, model currency with the value of :with_currency in string assignments" do
         product.bonus = "25"
-        product.save.should eq(true)
-        product.bonus.cents.should == 2500
-        product.bonus.currency_as_string.should == "GBP"
+        expect(product.save).to be_truthy
+        expect(product.bonus.cents).to eq(2500)
+        expect(product.bonus.currency_as_string).to eq("GBP")
 
         service.charge = "2"
-        service.save.should eq(true)
-        service.charge.cents.should == 200
-        service.charge.currency_as_string.should == "USD"
+        expect(service.save).to be_truthy
+        expect(service.charge.cents).to eq(200)
+        expect(service.charge.currency_as_string).to eq("USD")
       end
 
       it "overrides default currency with model currency, in fixnum assignments" do
         product.discount_value = 5
-        product.save.should eq(true)
-        product.discount_value.cents.should == 500
-        product.discount_value.currency_as_string.should == "USD"
+        expect(product.save).to be_truthy
+        expect(product.discount_value.cents).to eq(500)
+        expect(product.discount_value.currency_as_string).to eq("USD")
       end
 
       it "overrides default currency with model currency, in string assignments" do
         product.discount_value = "5"
-        product.save.should eq(true)
-        product.discount_value.cents.should == 500
-        product.discount_value.currency_as_string.should == "USD"
+        expect(product.save).to be_truthy
+        expect(product.discount_value.cents).to eq(500)
+        expect(product.discount_value.currency_as_string).to eq("USD")
       end
 
       it "falls back to default currency, in fixnum assignments" do
         service.discount = 5
-        service.save.should eq(true)
-        service.discount.cents.should == 500
-        service.discount.currency_as_string.should == "EUR"
+        expect(service.save).to be_truthy
+        expect(service.discount.cents).to eq(500)
+        expect(service.discount.currency_as_string).to eq("EUR")
       end
 
       it "falls back to default currency, in string assignments" do
         service.discount = "5"
-        service.save.should eq(true)
-        service.discount.cents.should == 500
-        service.discount.currency_as_string.should == "EUR"
+        expect(service.save).to be_truthy
+        expect(service.discount.cents).to eq(500)
+        expect(service.discount.currency_as_string).to eq("EUR")
       end
 
       it "sets field to nil, in nil assignments if allow_nil is set" do
         product.optional_price = nil
-        product.save.should eq(true)
-        product.optional_price.should be_nil
+        expect(product.save).to be_truthy
+        expect(product.optional_price).to be_nil
       end
 
       it "sets field to nil, in instantiation if allow_nil is set" do
         pr = Product.new(:optional_price => nil, :price_cents => 5320,
           :discount => 350, :bonus_cents => 320)
-        pr.optional_price.should be_nil
-        pr.save.should eq(true)
-        pr.optional_price.should be_nil
+        expect(pr.optional_price).to be_nil
+        expect(pr.save).to be_truthy
+        expect(pr.optional_price).to be_nil
       end
 
       it "sets field to nil, in blank assignments if allow_nil is set" do
         product.optional_price = ""
-        product.save.should eq(true)
-        product.optional_price.should be_nil
+        expect(product.save).to be_truthy
+        expect(product.optional_price).to be_nil
+      end
+
+
+      context "when the monetized field is an aliased attribute" do
+        it "writes the subunits to the original (unaliased) column" do
+          pending if Rails::VERSION::MAJOR < 4
+          product.renamed = "$10.00"
+          expect(product.aliased_cents).to eq 10_00
+        end
       end
 
       context "for column with model currency:" do
@@ -458,7 +485,7 @@ if defined? ActiveRecord
         it "is overridden by instance currency column" do
           product = Product.create(:sale_price_amount => 1234,
                                    :sale_price_currency_code => 'CAD')
-          product.sale_price.currency_as_string.should == 'CAD'
+          expect(product.sale_price.currency_as_string).to eq('CAD')
         end
 
         it 'can change currency of custom column' do
@@ -469,14 +496,14 @@ if defined? ActiveRecord
             :sale_price_amount => 1234,
             :sale_price_currency_code => 'USD')
 
-          product.sale_price.currency_as_string.should == 'USD'
+          expect(product.sale_price.currency_as_string).to eq('USD')
 
           product.sale_price = Money.new 456, 'CAD'
           product.save
           product.reload
 
-          product.sale_price.currency_as_string.should == 'CAD'
-          product.discount_value.currency_as_string.should == 'USD'
+          expect(product.sale_price.currency_as_string).to eq('CAD')
+          expect(product.discount_value.currency_as_string).to eq('USD')
         end
       end
 
@@ -504,50 +531,52 @@ if defined? ActiveRecord
           d.price = Money.new(10, "EUR")
           d.save!
           d.reload
-          d.currency.should == "EUR"
+          expect(d.currency).to eq("EUR")
         end
 
         it "overrides default currency with the value of row currency" do
-          transaction.amount.currency.should == Money::Currency.find(:usd)
+          expect(transaction.amount.currency).to eq(Money::Currency.find(:usd))
         end
 
         it "overrides default currency with the currency registered for the model" do
-          dummy_product_with_nil_currency.price.currency.should ==
+          expect(dummy_product_with_nil_currency.price.currency).to eq(
             Money::Currency.find(:gbp)
+          )
         end
 
         it "overrides default currency with the currency registered for the model if currency is invalid" do
-          dummy_product_with_invalid_currency.price.currency.should ==
+          expect(dummy_product_with_invalid_currency.price.currency).to eq(
             Money::Currency.find(:gbp)
+          )
         end
 
         it "overrides default and model currency with the row currency" do
-          dummy_product.price.currency.should == Money::Currency.find(:usd)
+          expect(dummy_product.price.currency).to eq(Money::Currency.find(:usd))
         end
 
         it "constructs the money attribute from the stored mapped attribute values" do
-          transaction.amount.should == Money.new(2400, :usd)
+          expect(transaction.amount).to eq(Money.new(2400, :usd))
         end
 
         it "correctly instantiates Money objects from the mapped attributes" do
           t = Transaction.new(:amount_cents => 2500, :currency => "CAD")
-          t.amount.should == Money.new(2500, "CAD")
+          expect(t.amount).to eq(Money.new(2500, "CAD"))
         end
 
         it "correctly assigns Money objects to the attribute" do
           transaction.amount = Money.new(2500, :eur)
-          transaction.save.should eq(true)
-          transaction.amount.cents.should == Money.new(2500, :eur).cents
-          transaction.amount.currency_as_string.should == "EUR"
+          expect(transaction.save).to be_truthy
+          expect(transaction.amount.cents).to eq(Money.new(2500, :eur).cents)
+          expect(transaction.amount.currency_as_string).to eq("EUR")
         end
 
         it "uses default currency if a non Money object is assigned to the attribute" do
           transaction.amount = 234
-          transaction.amount.currency_as_string.should == "USD"
+          expect(transaction.amount.currency_as_string).to eq("USD")
         end
 
         it "constructs the money object from the mapped method value" do
-          transaction.total.should == Money.new(3000, :usd)
+          expect(transaction.total).to eq(Money.new(3000, :usd))
         end
 
       end
@@ -555,8 +584,8 @@ if defined? ActiveRecord
 
     describe "register_currency" do
       it "attaches currency at model level" do
-        Product.currency.should == Money::Currency.find(:usd)
-        DummyProduct.currency.should == Money::Currency.find(:gbp)
+        expect(Product.currency).to eq(Money::Currency.find(:usd))
+        expect(DummyProduct.currency).to eq(Money::Currency.find(:gbp))
       end
     end
   end