money-rails 0.4.0 → 0.5.0

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
+## 0.5.0
+
+- Refactored instance currency implementation. Now, instance currency
+  is permitted to override the field currency, if they are both non-nil
+  values. (GH-23)
+- Replaced deprecated composed_of with a custom implementation for
+  activerecord. (GH-20)
+- Refactored testing structure to support multiple ORMs/ODMS.
+- Added Mongoid 2.x basic support. It uses serialization 
+  (a differrent approach than activerecord for now). (GH-19)
+
 ## 0.4.0
+
 - Provide ActionView helpers integration.
 - Map blank value assignments (for monetized fields) to nil.
 - Allow nil values for monetized fields. (GH-15)

data/README.md

@@ -1,6 +1,8 @@
 # RubyMoney - Money-Rails
 
 [![Build Status](https://secure.travis-ci.org/RubyMoney/money-rails.png?branch=master)](http://travis-ci.org/RubyMoney/money-rails)
+[![Dependency Status](https://gemnasium.com/RubyMoney/money-rails.png)](https://gemnasium.com/RubyMoney/money-rails)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/Robymoney/money-rails)
 
 ## Introduction
 
@@ -40,14 +42,16 @@ configuration parameters for the rails app.
 
 ## Usage
 
+### ActiveRecord
+
 For example, we create a Product model which has an integer price_cents column
 and we want to handle it by using a Money object instead:
 
 ```ruby
 class Product < ActiveRecord::Base
-  
+
   monetize :price_cents
-  
+
 end
 ```
 
@@ -55,7 +59,7 @@ Now each Product object will also have an attribute called ```price``` which
 is a Money object and can be used for money comparisons, conversions etc.
 
 In this case the name of the money attribute is created automagically by removing the
-```_cents``` suffix of the column name. 
+```_cents``` suffix of the column name.
 
 If you are using another db column name or you prefer another name for the
 money attribute, then you can provide ```as``` argument with a string
@@ -69,7 +73,7 @@ Now the model objects will have a ```discount``` attribute which
 is a Money object, wrapping the value of ```discount_subunit``` column to a
 Money instance.
 
-### Allow nil values
+#### Allow nil values
 
 If you want to allow the assignment of nil and/or blank values to a specific
 monetized field, you can use the `:allow_nil` parameter like this:
@@ -85,6 +89,45 @@ product.optional_price # => nil
 product.optional_price_cents # => nil
 ```
 
+### Mongoid 2.X
+
+`Money` is available as a field type to supply during a field definition:
+
+```ruby
+class Product
+  include Mongoid::Document
+
+  field :price, type: Money
+end
+
+obj = Product.new
+# => #<Product _id: 4fe865699671383656000001, _type: nil, price: nil>
+
+obj.price
+# => nil
+
+obj.price = Money.new(100, 'EUR')
+# => #<Money cents:100 currency:EUR>
+
+obj.price
+#=> #<Money cents:100 currency:EUR>
+
+obj.save
+# => true
+
+obj
+# => #<Product _id: 4fe865699671383656000001, _type: nil, price: {:cents=>100, :currency_iso=>"EUR"}>
+
+obj.price
+#=> #<Money cents:100 currency:EUR>
+
+## You can access the money hash too :
+obj[:price]
+# => {:cents=>100, :currency_iso=>"EUR"}
+```
+
+The usual options on `field` as `index`, `default`, ..., are available.
+
 ### Currencies
 
 Money-rails supports a set of options to handle currencies for your
@@ -107,11 +150,11 @@ satisfy your needs.
 
 #### Model Currency
 
-You can define a specific currency for an activerecord model. This currency is
-used for the creation and conversions of the Money objects referring to
-every monetized attributes of the specific model. This means it overrides
-the global default currency of Money library. To attach a currency to a
-model use the ```register_currency``` macro:
+You can define a specific currency for an activerecord model (not for mongoid).
+This currency is used for the creation and conversions of the Money objects
+referring to every monetized attributes of the specific model.
+This means it overrides the global default currency of Money library.
+To attach a currency to a model use the ```register_currency``` macro:
 
 ```ruby
 # app/models/product.rb
@@ -160,8 +203,8 @@ currency values. If you need to provide differrent currency per model
 instance, then you need to add a column with the name ```currency```
 in your db table. Money-rails will discover this automatically,
 and will use this knowledge to override the model level and global
-default values. Attribute currency cannot be combined with instance
-currency!
+default values. Non-nil instance currency values also override attribute
+currency values, so they have the highest precedence.
 
 ```ruby
 class Transaction < ActiveRecord::Base
@@ -177,17 +220,12 @@ class Transaction < ActiveRecord::Base
 
 end
 
-# Now instantiating with a specific currency overrides the
+# Now instantiating with a specific currency overrides
 # the model and global currencies
 t = Transaction.new(:amount_cents => 2500, :currency => "CAD")
 t.amount == Money.new(2500, "CAD") # true
 ```
 
-WARNING: In this case :with_currency is not permitted and the usage
-of this parameter will cause an ArgumentError exception.
-
-In general, the use of this strategy is discouraged unless there is a reason.
-
 ### Configuration parameters
 
 You can handle a bunch of configuration params through ```money.rb``` initializer:

data/Rakefile

@@ -16,9 +16,34 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new
 
-task :default => :spec
+task :default => "spec:all"
 task :test => :spec
 
+namespace :spec do
+  desc "Run Tests against mongoid"
+  task :mongoid2 do
+    sh "BUNDLE_GEMFILE='gemfiles/mongoid2.gemfile' bundle --quiet"
+    sh "BUNDLE_GEMFILE='gemfiles/mongoid2.gemfile' bundle exec rake -t spec"
+  end
+
+  desc "Run Tests against activerecord"
+  task :activerecord do
+    sh "bundle --quiet"
+    sh "bundle exec rake -t spec"
+  end
+
+  desc "Run Tests against all ORMs"
+  task :all do
+    # Mongoid 2
+    sh "BUNDLE_GEMFILE='gemfiles/mongoid2.gemfile' bundle --quiet"
+    sh "BUNDLE_GEMFILE='gemfiles/mongoid2.gemfile' bundle exec rake -t spec"
+
+    # ActiveRecord
+    sh "bundle --quiet"
+    sh "bundle exec rake -t spec"
+  end
+end
+
 desc "Update AUTHORS file"
 task :authors do
   sh "git shortlog -s | awk '{ print $2 \" \" $3 }' > AUTHORS"

data/lib/money-rails/active_record/monetizable.rb

@@ -21,11 +21,10 @@ module MoneyRails
               ":with_currency or :with_model_currency")
           end
 
-          # Optional table column which holds currency iso_codes
-          # It allows per row currency values
-          # Overrides default currency
-          model_currency_name = options[:with_model_currency] ||
+          # Optional accessor to be run on an instance to detect currency 
+          instance_currency_name = options[:with_model_currency] ||
             options[:model_currency] || "currency"
+          instance_currency_name = instance_currency_name.to_s
 
           # This attribute allows per column currency values
           # Overrides row and default currency
@@ -47,63 +46,45 @@ module MoneyRails
             name = subunit_name << "_money"
           end
 
-          has_currency_table_column = self.attribute_names.include? model_currency_name
+          # Include numericality validation if needed
+          validates_numericality_of subunit_name, :allow_nil => options[:allow_nil] if MoneyRails.include_validations
 
-          if has_currency_table_column
-            raise(ArgumentError, ":with_currency should not be used with tables" \
-                  " which contain a column for currency values") if field_currency_name
+          define_method name do
+            amount = send(subunit_name)
+            attr_currency = send("currency_for_#{name}")
 
-            mappings = [[subunit_name, "cents"], [model_currency_name, "currency_as_string"]]
-            constructor = Proc.new { |cents, currency|
-              Money.new(cents, currency || self.respond_to?(:currency) &&
-                        self.currency || Money.default_currency)
-            }
-            converter = Proc.new { |value|
-              raise(ArgumentError, "Only Money objects are allowed for assignment")
-            }
-          else
-            mappings = [[subunit_name, "cents"]]
-            constructor = Proc.new { |cents|
-              Money.new(cents, field_currency_name || self.respond_to?(:currency) &&
-                        self.currency || Money.default_currency)
-            }
-            converter = Proc.new { |value|
-              if options[:allow_nil] && value.blank?
-                nil
-              elsif value.respond_to?(:to_money)
-                value.to_money(field_currency_name || self.respond_to?(:currency) &&
-                              self.currency || Money.default_currency)
-              else
-                raise(ArgumentError, "Can't convert #{value.class} to Money")
-              end
-            }
-          end
+            # Dont create a new Money instance if the values haven't changed
+            memoized = instance_variable_get("@#{name}")
+            return memoized if memoized && memoized.cents == amount &&
+              memoized.currency == attr_currency
 
-          class_eval do
-            composed_of name.to_sym,
-              :class_name => "Money",
-              :mapping => mappings,
-              :constructor => constructor,
-              :converter => converter,
-              :allow_nil => options[:allow_nil]
+            amount = Money.new(amount, attr_currency) unless amount.blank?
+
+            instance_variable_set "@#{name}", amount
           end
 
-          if options[:allow_nil]
-            class_eval do
-              # Fixes issue with composed_of that breaks on blank params
-              # TODO: This should be removed when we will only support rails >=4.0
-              define_method "#{name}_with_blank_support=" do |value|
-                value = nil if value.blank?
-                send "#{name}_without_blank_support=", value
-              end
-              alias_method_chain "#{name}=", :blank_support
+          define_method "#{name}=" do |value|
+            if options[:allow_nil] && value.blank?
+              money = nil
+            else
+              money = value.is_a?(Money) ? value : value.to_money(send("currency_for_#{name}"))
             end
+
+            send("#{subunit_name}=", money.try(:cents))
+            send("#{instance_currency_name}=", money.try(:currency).try(:iso_code)) if self.respond_to?("#{instance_currency_name}=")
+
+            instance_variable_set "@#{name}", money
           end
 
-          # Include numericality validation if needed
-          if MoneyRails.include_validations
-            class_eval do
-              validates_numericality_of subunit_name, :allow_nil => options[:allow_nil]
+          define_method "currency_for_#{name}" do
+            if self.respond_to?(instance_currency_name) && send(instance_currency_name).present? 
+              Money::Currency.find(send(instance_currency_name))
+            elsif field_currency_name
+              Money::Currency.find(field_currency_name)
+            elsif self.class.respond_to?(:currency)
+              self.class.currency
+            else
+              Money.default_currency
             end
           end
         end

data/lib/money-rails/configuration.rb

@@ -1,3 +1,6 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors'
+
 module MoneyRails
 
   # MoneyRails configuration module.

data/lib/money-rails/hooks.rb

@@ -11,7 +11,7 @@ module MoneyRails
       begin; require 'mongoid'; rescue LoadError; end
       if defined? ::Mongoid
         if ::Mongoid::VERSION =~ /^2(.*)/
-          # Mongoid 2.x stuff here
+          require 'money-rails/mongoid/two' # Loading the file is enough
         end
 
         if ::Mongoid::VERSION =~ /^3(.*)/

data/lib/money-rails/mongoid/two.rb

@@ -0,0 +1,25 @@
+# Class name does not really matches the folder hierarchy, because
+# in order for (de)serialization to work, the class must be re-opened.
+# But this file brings mongoid 2.X compat., so...
+
+class Money
+  include ::Mongoid::Fields::Serializable
+
+  # Mongo friendly -> Money
+  def deserialize(object)
+    return nil if object.nil?
+
+    object = object.with_indifferent_access
+    ::Money.new object[:cents], object[:currency_iso]
+  end
+
+  # Money -> Mongo friendly
+  def serialize(object)
+    return nil unless object.is_a? Money
+
+    {
+      :cents        => object.cents,
+      :currency_iso => object.currency.iso_code
+    }
+  end
+end

data/lib/money-rails/version.rb

@@ -1,3 +1,3 @@
 module MoneyRails
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
 end

data/money-rails.gemspec

@@ -28,4 +28,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec",       "~> 2.10"
   s.add_development_dependency "rspec-rails", "~> 2.10"
   s.add_development_dependency "guard-rspec", "~> 1.1"
+  s.add_development_dependency 'database_cleaner', ['>= 0']
 end

data/spec/active_record/monetizable_spec.rb

@@ -1,217 +1,247 @@
 require 'spec_helper'
 
-describe MoneyRails::ActiveRecord::Monetizable do
+if defined? ActiveRecord
+  describe MoneyRails::ActiveRecord::Monetizable do
 
-  describe "monetize" do
-    before :each do
-      @product = Product.create(:price_cents => 3000, :discount => 150,
-                                :bonus_cents => 200, :optional_price => 100)
-      @service = Service.create(:charge_cents => 2000, :discount_cents => 120)
-    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)
-    end
-
-    it "returns the expected money amount as a Money object" do
-      @product.price.should == Money.new(3000, "USD")
-    end
-
-    it "assigns the correct value from a Money object" do
-      @product.price = Money.new(3210, "USD")
-      @product.save.should be_true
-      @product.price_cents.should == 3210
-    end
-
-    it "respects :as argument" do
-      @product.discount_value.should == Money.new(150, "USD")
-    end
-
-    it "uses numericality validation" do
-      @product.price_cents = "foo"
-      @product.save.should be_false
+    describe "monetize" do
+      before :each do
+        @product = Product.create(:price_cents => 3000, :discount => 150,
+                                  :bonus_cents => 200, :optional_price => 100)
+        @service = Service.create(:charge_cents => 2000, :discount_cents => 120)
+      end
 
-      @product.price_cents = 2000
-      @product.save.should be_true
-    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)
+      end
 
-    it "doesn't allow nil by default" do
-      @product.price_cents = nil
-      @product.save.should be_false
-    end
+      it "returns the expected money amount as a Money object" do
+        @product.price.should == Money.new(3000, "USD")
+      end
 
-    it "allows nil if optioned" do
-      @product.optional_price = nil
-      @product.save.should be_true
-      @product.optional_price.should be_nil
-    end
+      it "assigns the correct value from a Money object" do
+        @product.price = Money.new(3210, "USD")
+        @product.save.should be_true
+        @product.price_cents.should == 3210
+      end
 
-    it "uses Money default currency if :with_currency has not been used" do
-      @service.discount.currency.should == Money::Currency.find(:eur)
-    end
+      it "respects :as argument" do
+        @product.discount_value.should == Money.new(150, "USD")
+      end
 
-    it "overrides default currency with the currency registered for the model" do
-      @product.price.currency.should == Money::Currency.find(:usd)
-    end
+      it "uses numericality validation" do
+        @product.price_cents = "foo"
+        @product.save.should be_false
 
-    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)
-    end
+        @product.price_cents = 2000
+        @product.save.should be_true
+      end
 
-    it "assigns correctly Money objects to the attribute" do
-      @product.price = Money.new(2500, :USD)
-      @product.save.should be_true
-      @product.price.cents.should == 2500
-      @product.price.currency_as_string.should == "USD"
-    end
+      it "doesn't allow nil by default" do
+        @product.price_cents = nil
+        @product.save.should be_false
+      end
 
-    it "assigns correctly Fixnum objects to the attribute" do
-      @product.price = 25
-      @product.save.should be_true
-      @product.price.cents.should == 2500
-      @product.price.currency_as_string.should == "USD"
+      it "allows nil if optioned" do
+        @product.optional_price = nil
+        @product.save.should be_true
+        @product.optional_price.should be_nil
+      end
 
-      @service.discount = 2
-      @service.save.should be_true
-      @service.discount.cents.should == 200
-      @service.discount.currency_as_string.should == "EUR"
-    end
+      it "uses Money default currency if :with_currency has not been used" do
+        @service.discount.currency.should == Money::Currency.find(:eur)
+      end
 
-    it "assigns correctly String objects to the attribute" do
-      @product.price = "25"
-      @product.save.should be_true
-      @product.price.cents.should == 2500
-      @product.price.currency_as_string.should == "USD"
+      it "overrides default currency with the currency registered for the model" do
+        @product.price.currency.should == Money::Currency.find(:usd)
+      end
 
-      @service.discount = "2"
-      @service.save.should be_true
-      @service.discount.cents.should == 200
-      @service.discount.currency_as_string.should == "EUR"
-    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)
+      end
 
-    it "overrides default, model currency with the value of :with_currency in fixnum assignments" do
-      @product.bonus = 25
-      @product.save.should be_true
-      @product.bonus.cents.should == 2500
-      @product.bonus.currency_as_string.should == "GBP"
+      it "assigns correctly Money objects to the attribute" do
+        @product.price = Money.new(2500, :USD)
+        @product.save.should be_true
+        @product.price.cents.should == 2500
+        @product.price.currency_as_string.should == "USD"
+      end
 
-      @service.charge = 2
-      @service.save.should be_true
-      @service.charge.cents.should == 200
-      @service.charge.currency_as_string.should == "USD"
-    end
+      it "assigns correctly Fixnum objects to the attribute" do
+        @product.price = 25
+        @product.save.should be_true
+        @product.price.cents.should == 2500
+        @product.price.currency_as_string.should == "USD"
 
-    it "overrides default, model currency with the value of :with_currency in string assignments" do
-      @product.bonus = "25"
-      @product.save.should be_true
-      @product.bonus.cents.should == 2500
-      @product.bonus.currency_as_string.should == "GBP"
+        @service.discount = 2
+        @service.save.should be_true
+        @service.discount.cents.should == 200
+        @service.discount.currency_as_string.should == "EUR"
+      end
 
-      @service.charge = "2"
-      @service.save.should be_true
-      @service.charge.cents.should == 200
-      @service.charge.currency_as_string.should == "USD"
-    end
+      it "assigns correctly String objects to the attribute" do
+        @product.price = "25"
+        @product.save.should be_true
+        @product.price.cents.should == 2500
+        @product.price.currency_as_string.should == "USD"
 
-    it "overrides default currency with model currency, in fixnum assignments" do
-      @product.discount_value = 5
-      @product.save.should be_true
-      @product.discount_value.cents.should == 500
-      @product.discount_value.currency_as_string.should == "USD"
-    end
+        @service.discount = "2"
+        @service.save.should be_true
+        @service.discount.cents.should == 200
+        @service.discount.currency_as_string.should == "EUR"
+      end
 
-    it "overrides default currency with model currency, in string assignments" do
-      @product.discount_value = "5"
-      @product.save.should be_true
-      @product.discount_value.cents.should == 500
-      @product.discount_value.currency_as_string.should == "USD"
-    end
+      it "overrides default, model currency with the value of :with_currency in fixnum assignments" do
+        @product.bonus = 25
+        @product.save.should be_true
+        @product.bonus.cents.should == 2500
+        @product.bonus.currency_as_string.should == "GBP"
 
-    it "falls back to default currency, in fixnum assignments" do
-      @service.discount = 5
-      @service.save.should be_true
-      @service.discount.cents.should == 500
-      @service.discount.currency_as_string.should == "EUR"
-    end
+        @service.charge = 2
+        @service.save.should be_true
+        @service.charge.cents.should == 200
+        @service.charge.currency_as_string.should == "USD"
+      end
 
-    it "falls back to default currency, in string assignments" do
-      @service.discount = "5"
-      @service.save.should be_true
-      @service.discount.cents.should == 500
-      @service.discount.currency_as_string.should == "EUR"
-    end
+      it "overrides default, model currency with the value of :with_currency in string assignments" do
+        @product.bonus = "25"
+        @product.save.should be_true
+        @product.bonus.cents.should == 2500
+        @product.bonus.currency_as_string.should == "GBP"
 
-    it "sets field to nil, in nil assignments if allow_nil is set" do
-      @product.optional_price = nil 
-      @product.save.should be_true
-      @product.optional_price.should be_nil
-    end
+        @service.charge = "2"
+        @service.save.should be_true
+        @service.charge.cents.should == 200
+        @service.charge.currency_as_string.should == "USD"
+      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 be_true
-      pr.optional_price.should be_nil
-    end
+      it "overrides default currency with model currency, in fixnum assignments" do
+        @product.discount_value = 5
+        @product.save.should be_true
+        @product.discount_value.cents.should == 500
+        @product.discount_value.currency_as_string.should == "USD"
+      end
 
-    it "sets field to nil, in blank assignments if allow_nil is set" do
-      @product.optional_price = ""
-      @product.save.should be_true
-      @product.optional_price.should be_nil
-    end
-    
-    context "for model with currency column:" do
-      before :each do
-        @transaction = Transaction.create(:amount_cents => 2400, :tax_cents => 600,
-                                          :currency => :usd)
-        @dummy_product1 = DummyProduct.create(:price_cents => 2400, :currency => :usd)
-        @dummy_product2 = DummyProduct.create(:price_cents => 2600) # nil currency
+      it "overrides default currency with model currency, in string assignments" do
+        @product.discount_value = "5"
+        @product.save.should be_true
+        @product.discount_value.cents.should == 500
+        @product.discount_value.currency_as_string.should == "USD"
       end
 
-      it "overrides default currency with the value of row currency" do
-        @transaction.amount.currency.should == Money::Currency.find(:usd)
+      it "falls back to default currency, in fixnum assignments" do
+        @service.discount = 5
+        @service.save.should be_true
+        @service.discount.cents.should == 500
+        @service.discount.currency_as_string.should == "EUR"
       end
 
-      it "overrides default currency with the currency registered for the model" do
-        @dummy_product2.price.currency.should == Money::Currency.find(:gbp)
+      it "falls back to default currency, in string assignments" do
+        @service.discount = "5"
+        @service.save.should be_true
+        @service.discount.cents.should == 500
+        @service.discount.currency_as_string.should == "EUR"
       end
 
-      it "overrides default and model currency with the row currency" do
-        @dummy_product1.price.currency.should == Money::Currency.find(:usd)
+      it "sets field to nil, in nil assignments if allow_nil is set" do
+        @product.optional_price = nil 
+        @product.save.should be_true
+        @product.optional_price.should be_nil
       end
 
-      it "constructs the money attribute from the stored mapped attribute values" do
-        @transaction.amount.should == Money.new(2400, :usd)
+      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 be_true
+        pr.optional_price.should be_nil
       end
 
-      it "instantiates correctly Money objects from the mapped attributes" do
-        t = Transaction.new(:amount_cents => 2500, :currency => "CAD")
-        t.amount.should == Money.new(2500, "CAD")
+      it "sets field to nil, in blank assignments if allow_nil is set" do
+        @product.optional_price = ""
+        @product.save.should be_true
+        @product.optional_price.should be_nil
       end
 
-      it "assigns correctly Money objects to the attribute" do
-        @transaction.amount = Money.new(2500, :eur)
-        @transaction.save.should be_true
-        @transaction.amount.cents.should == Money.new(2500, :eur).cents
-        @transaction.amount.currency_as_string.should == "EUR"
+      context "for column with currency:" do
+        it "is overridden by instance currency" do
+          product = Product.create(:price_cents => 5320, :discount => 350, :bonus_cents => 320)
+          product.stub(:currency) { "EUR" }
+          product.bonus.currency_as_string.should == "EUR"
+        end
       end
 
-      it "raises exception if a non Money object is assigned to the attribute" do
-        expect { @transaction.amount = "not a Money object" }.to raise_error(ArgumentError)
-        expect { @transaction.amount = 234 }.to raise_error(ArgumentError)
+      context "for column with model currency:" do
+        it "has default currency if not specified" do
+          product = Product.create(:sale_price_amount => 1234)
+          product.sale_price.currency_as_string == 'USD'
+        end
+        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'
+        end
       end
 
+      context "for model with currency column:" do
+        before :each do
+          @transaction = Transaction.create(:amount_cents => 2400, :tax_cents => 600,
+                                            :currency => :usd)
+          @dummy_product1 = DummyProduct.create(:price_cents => 2400, :currency => :usd)
+          @dummy_product2 = DummyProduct.create(:price_cents => 2600) # nil currency
+        end
+
+        it "serializes correctly the currency to a new instance of model" do
+          d = DummyProduct.new
+          d.price = Money.new(10, "EUR")
+          d.save!
+          d.reload
+          d.currency.should == "EUR"
+        end
+
+        it "overrides default currency with the value of row currency" do
+          @transaction.amount.currency.should == Money::Currency.find(:usd)
+        end
+
+        it "overrides default currency with the currency registered for the model" do
+          @dummy_product2.price.currency.should == Money::Currency.find(:gbp)
+        end
+
+        it "overrides default and model currency with the row currency" do
+          @dummy_product1.price.currency.should == Money::Currency.find(:usd)
+        end
+
+        it "constructs the money attribute from the stored mapped attribute values" do
+          @transaction.amount.should == Money.new(2400, :usd)
+        end
+
+        it "instantiates correctly Money objects from the mapped attributes" do
+          t = Transaction.new(:amount_cents => 2500, :currency => "CAD")
+          t.amount.should == Money.new(2500, "CAD")
+        end
+
+        it "assigns correctly Money objects to the attribute" do
+          @transaction.amount = Money.new(2500, :eur)
+          @transaction.save.should be_true
+          @transaction.amount.cents.should == Money.new(2500, :eur).cents
+          @transaction.amount.currency_as_string.should == "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"
+        end
+
+      end
     end
-  end
 
-  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)
+    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)
+      end
     end
   end
 end