exchange 0.8.0 → 0.9.0

data/spec/exchange/{currency_spec.rb → money_spec.rb}

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe "Exchange::Currency" do
-  subject { Exchange::Currency.new(40, :usd) }
+describe "Exchange::Money" do
+  subject { Exchange::Money.new(40, :usd) }
   before(:all) do
     Exchange.configuration = Exchange::Configuration.new do |c|
       c.api = {
-        :subclass => :currency_bot
+        :subclass => :open_exchange_rates
       }
       c.cache = {
         :subclass => :no_cache
@@ -14,22 +14,30 @@ describe "Exchange::Currency" do
     end
   end
   after(:all) do
-    Exchange.configuration = Exchange::Configuration.new do |c|
-      c.api = {
-        :subclass => :memcached
-      }
-    end
+    Exchange.configuration.reset
   end
   it "should initialize with a number and a currency" do
     subject.value.should == 40
     subject.currency.should == :usd
   end
+  describe "initializing with a block" do
+    it "should be possible" do
+      currency = Exchange::Money.new(40) do |c|
+        c.currency = :usd
+        c.time     = Time.gm(2012,9,9)
+      end
+      
+      currency.value.should == 40
+      currency.currency.should == :usd
+      currency.time.should == Time.gm(2012,9,9)
+    end
+  end
   describe "convert_to" do
     it "should be able to convert itself to other currencies" do
       mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 3)
       subject.convert_to(:chf).value.round(2).should == 36.5
       subject.convert_to(:chf).currency.should == :chf
-      subject.convert_to(:chf).should be_kind_of Exchange::Currency
+      subject.convert_to(:chf).should be_kind_of Exchange::Money
     end
   end
   describe "operations" do
@@ -46,20 +54,20 @@ describe "Exchange::Currency" do
       end
       it "should be able to add another currency value" do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-        (subject + Exchange::Currency.new(30, :chf)).value.round(2).should == 72.87
-        (subject + Exchange::Currency.new(30, :sek)).currency.should == :usd
+        (subject + Exchange::Money.new(30, :chf)).value.round(2).should == 72.87
+        (subject + Exchange::Money.new(30, :sek)).currency.should == :usd
         subject.value.round(2).should == 40
         subject.currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
         Exchange.configuration.allow_mixed_operations = false
-        lambda { subject + Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+        lambda { subject + Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
         Exchange.configuration.allow_mixed_operations = true
       end
       it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
         Exchange.configuration.allow_mixed_operations = false
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-        lambda { subject + Exchange::Currency.new(30, :usd) }.should_not raise_error
+        lambda { subject + Exchange::Money.new(30, :usd) }.should_not raise_error
         Exchange.configuration.allow_mixed_operations = true
       end
       context "modifying the base value" do
@@ -79,7 +87,7 @@ describe "Exchange::Currency" do
         end
         it "should be able to add another currency value" do
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-          added = (@instantiated += Exchange::Currency.new(30, :chf))
+          added = (@instantiated += Exchange::Money.new(30, :chf))
           added.value.round(2).should == 72.87
           added.currency.should == :usd
           @instantiated.value.round(2).should == 72.87
@@ -87,13 +95,13 @@ describe "Exchange::Currency" do
         end
         it "should raise when currencies get mixed and the configuration does not allow it" do
           Exchange.configuration.allow_mixed_operations = false
-          lambda { @instantiated += Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+          lambda { @instantiated += Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
           Exchange.configuration.allow_mixed_operations = true
         end
         it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
           Exchange.configuration.allow_mixed_operations = false
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-          lambda { @instantiated += Exchange::Currency.new(30, :usd) }.should_not raise_error
+          lambda { @instantiated += Exchange::Money.new(30, :usd) }.should_not raise_error
           Exchange.configuration.allow_mixed_operations = true
         end
       end
@@ -112,18 +120,18 @@ describe "Exchange::Currency" do
       it "should be able to subtract another currency value" do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
         Exchange.configuration.allow_mixed_operations = true
-        (subject - Exchange::Currency.new(10, :chf)).value.round(2).should == 29.04
-        (subject - Exchange::Currency.new(23.3, :eur)).currency.should == :usd
+        (subject - Exchange::Money.new(10, :chf)).value.round(2).should == 29.04
+        (subject - Exchange::Money.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
         Exchange.configuration.allow_mixed_operations = false
-        lambda { subject - Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+        lambda { subject - Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
         Exchange.configuration.allow_mixed_operations = true
       end
       it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
         Exchange.configuration.allow_mixed_operations = false
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-        lambda { subject - Exchange::Currency.new(30, :usd) }.should_not raise_error
+        lambda { subject - Exchange::Money.new(30, :usd) }.should_not raise_error
         Exchange.configuration.allow_mixed_operations = true
       end
       context "modifying the base value" do
@@ -144,7 +152,7 @@ describe "Exchange::Currency" do
         it "should be able to subtract another currency value" do
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
           Exchange.configuration.allow_mixed_operations = true
-          added = (@instantiated -= Exchange::Currency.new(10, :chf))
+          added = (@instantiated -= Exchange::Money.new(10, :chf))
           added.value.round(2).should == 29.04
           added.currency.should == :usd
           @instantiated.value.round(2).should == 29.04
@@ -152,13 +160,13 @@ describe "Exchange::Currency" do
         end
         it "should raise when currencies get mixed and the configuration does not allow it" do
           Exchange.configuration.allow_mixed_operations = false
-          lambda { @instantiated -= Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+          lambda { @instantiated -= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
           Exchange.configuration.allow_mixed_operations = true
         end
         it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
           Exchange.configuration.allow_mixed_operations = false
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-          lambda { @instantiated -= Exchange::Currency.new(30, :usd) }.should_not raise_error
+          lambda { @instantiated -= Exchange::Money.new(30, :usd) }.should_not raise_error
           Exchange.configuration.allow_mixed_operations = true
         end
       end
@@ -167,28 +175,33 @@ describe "Exchange::Currency" do
       it "should be able to multiply by an integer" do
         (subject * 40).value.should == 1600
       end
-      it "should be able to multiply a float" do
-        (subject * 40.5).value.should == 1620
+      context "with a float" do
+        subject { Exchange::Money.new(50, :usd) }
+        it "should be able to multiply a float" do
+          (subject * 40.5).value.should == 2025
+        end
+        it "should not fall for rounding errors" do
+          (subject * 0.29).round(0).value.should == 15
+        end
       end
-      it "should not modify the base value" do
-        (subject * 40).value.should == 1600
-        subject.value.should == 40.0
+      it "should not fall for float rounding errors" do
+        (subject * 40.5)
       end
       it "should be able to multiply by another currency value" do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
         Exchange.configuration.allow_mixed_operations = true
-        (subject * Exchange::Currency.new(10, :chf)).value.round(1).should == 438.3
-        (subject * Exchange::Currency.new(23.3, :eur)).currency.should == :usd
+        (subject * Exchange::Money.new(10, :chf)).value.round(1).should == 438.3
+        (subject * Exchange::Money.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
         Exchange.configuration.allow_mixed_operations = false
-        lambda { subject * Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+        lambda { subject * Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
         Exchange.configuration.allow_mixed_operations = true
       end
       it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
         Exchange.configuration.allow_mixed_operations = false
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-        lambda { subject * Exchange::Currency.new(30, :usd) }.should_not raise_error
+        lambda { subject * Exchange::Money.new(30, :usd) }.should_not raise_error
         Exchange.configuration.allow_mixed_operations = true
       end
       context "modifying the base value" do
@@ -209,7 +222,7 @@ describe "Exchange::Currency" do
         it "should be able to multiply by another currency value" do
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
           Exchange.configuration.allow_mixed_operations = true
-          added = (@instantiated *= Exchange::Currency.new(9, :chf))
+          added = (@instantiated *= Exchange::Money.new(9, :chf))
           added.value.round(1).should == 394.50
           added.currency.should == :usd
           @instantiated.value.round(1).should == 394.50
@@ -217,13 +230,13 @@ describe "Exchange::Currency" do
         end
         it "should raise when currencies get mixed and the configuration does not allow it" do
           Exchange.configuration.allow_mixed_operations = false
-          lambda { @instantiated *= Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+          lambda { @instantiated *= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
           Exchange.configuration.allow_mixed_operations = true
         end
         it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
           Exchange.configuration.allow_mixed_operations = false
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-          lambda { @instantiated *= Exchange::Currency.new(30, :usd) }.should_not raise_error
+          lambda { @instantiated *= Exchange::Money.new(30, :usd) }.should_not raise_error
           Exchange.configuration.allow_mixed_operations = true
         end
       end
@@ -232,9 +245,16 @@ describe "Exchange::Currency" do
       it "should be able to divide by an integer" do
         (subject / 40).value.should == 1
       end
-      it "should be able to divide by a float" do
-        BigDecimal.new((subject / 40.5).value.to_s).round(4).should == 0.9877
+      context "with a float" do
+        subject { Exchange::Money.new(1829.82, :omr) }
+        it "should be able to divide by a float" do
+          (subject / 40.5).value.round(4).should == 45.1807
+        end
+        it "should not fall for floating point errors" do
+          (subject / 12.0).round(2).value.should == 152.49
+        end
       end
+
       it "should not modify the base value" do
         (subject / 40).value.should == 1
         subject.value.should == 40.0
@@ -247,18 +267,18 @@ describe "Exchange::Currency" do
       it "should be able to divide by another currency value" do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
         Exchange.configuration.allow_mixed_operations = true
-        (subject / Exchange::Currency.new(10, :chf)).value.round(2).should == BigDecimal.new("3.65")
-        (subject / Exchange::Currency.new(23.3, :eur)).currency.should == :usd
+        (subject / Exchange::Money.new(10, :chf)).value.round(2).should == BigDecimal.new("3.65")
+        (subject / Exchange::Money.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
         Exchange.configuration.allow_mixed_operations = false
-        lambda { subject / Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+        lambda { subject / Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
         Exchange.configuration.allow_mixed_operations = true
       end
       it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
         Exchange.configuration.allow_mixed_operations = false
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-        lambda { subject / Exchange::Currency.new(30, :usd) }.should_not raise_error
+        lambda { subject / Exchange::Money.new(30, :usd) }.should_not raise_error
         Exchange.configuration.allow_mixed_operations = true
       end
       context "modifying the base value" do
@@ -279,7 +299,7 @@ describe "Exchange::Currency" do
         it "should be able to divide by another currency value" do
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
           Exchange.configuration.allow_mixed_operations = true
-          added = (@instantiated /= Exchange::Currency.new(10, :chf))
+          added = (@instantiated /= Exchange::Money.new(10, :chf))
           added.value.round(2).should == 3.65
           added.currency.should == :usd
           @instantiated.value.round(2).should == 3.65
@@ -287,25 +307,25 @@ describe "Exchange::Currency" do
         end
         it "should raise when currencies get mixed and the configuration does not allow it" do
           Exchange.configuration.allow_mixed_operations = false
-          lambda { @instantiated /= Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+          lambda { @instantiated /= Exchange::Money.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
           Exchange.configuration.allow_mixed_operations = true
         end
         it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
           Exchange.configuration.allow_mixed_operations = false
           mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
-          lambda { @instantiated /= Exchange::Currency.new(30, :usd) }.should_not raise_error
+          lambda { @instantiated /= Exchange::Money.new(30, :usd) }.should_not raise_error
           Exchange.configuration.allow_mixed_operations = true
         end
       end
     end
     describe "comparison" do
-      subject { Exchange::Currency.new(40.123, :usd) }
-      let(:comp1) { Exchange::Currency.new(40.123, :usd) }
-      let(:comp2) { Exchange::Currency.new(40, :usd) }
-      let(:comp3) { Exchange::Currency.new(50, :eur) }
-      let(:comp4) { Exchange::Currency.new(45, :eur) }
-      let(:comp5) { Exchange::Currency.new(50, :eur).to_usd }
-      let(:comp6) { Exchange::Currency.new(66.1, :usd, :at => Time.gm(2011,1,1)) }
+      subject { Exchange::Money.new(40.123, :usd) }
+      let(:comp1) { Exchange::Money.new(40.123, :usd) }
+      let(:comp2) { Exchange::Money.new(40, :usd) }
+      let(:comp3) { Exchange::Money.new(50, :eur) }
+      let(:comp4) { Exchange::Money.new(45, :eur) }
+      let(:comp5) { Exchange::Money.new(50, :eur).to_usd }
+      let(:comp6) { Exchange::Money.new(66.1, :usd, :at => Time.gm(2011,1,1)) }
       before(:each) do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 2)
       end
@@ -331,11 +351,11 @@ describe "Exchange::Currency" do
       end
     end
     describe "sorting" do
-      subject { Exchange::Currency.new(40.123, :usd) }
-      let(:comp1) { Exchange::Currency.new(40.123, :usd) }
-      let(:comp2) { Exchange::Currency.new(40, :usd) }
-      let(:comp3) { Exchange::Currency.new(50, :eur) }
-      let(:comp4) { Exchange::Currency.new(45, :eur) }
+      subject { Exchange::Money.new(40.123, :usd) }
+      let(:comp1) { Exchange::Money.new(40.123, :usd) }
+      let(:comp2) { Exchange::Money.new(40, :usd) }
+      let(:comp3) { Exchange::Money.new(50, :eur) }
+      let(:comp4) { Exchange::Money.new(45, :eur) }
       before(:each) do
         mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 6)
       end
@@ -344,12 +364,12 @@ describe "Exchange::Currency" do
       end
     end
     describe "round" do
-      subject { Exchange::Currency.new(40.123, :usd) }
+      subject { Exchange::Money.new(40.123, :usd) }
       context "without arguments" do
         it "should apply it to its number in the iso certified format" do
           subject.round.value.should == 40.12
           subject.round.currency.should == :usd
-          subject.round.should be_kind_of Exchange::Currency
+          subject.round.should be_kind_of Exchange::Money
         end
         it "should not modify the base value" do
           subject.round.value.should == 40.12
@@ -360,22 +380,22 @@ describe "Exchange::Currency" do
         it "should apply it to its number" do
           subject.round(0).value.should == 40
           subject.round(0).currency.should == :usd
-          subject.round(0).should be_kind_of Exchange::Currency
+          subject.round(0).should be_kind_of Exchange::Money
         end
         it "should allow to round to whatever number of decimals" do
           subject.round(2).value.should == 40.12
           subject.round(2).currency.should == :usd
-          subject.round(2).should be_kind_of Exchange::Currency
+          subject.round(2).should be_kind_of Exchange::Money
         end
       end
     end
     describe "ceil" do
-      subject { Exchange::Currency.new(40.1236, :omr) }
+      subject { Exchange::Money.new(40.1236, :omr) }
       context "without arguments" do
         it "should apply it to its number in the iso certified format" do
           subject.ceil.value.should == 40.124
           subject.ceil.currency.should == :omr
-          subject.ceil.should be_kind_of Exchange::Currency
+          subject.ceil.should be_kind_of Exchange::Money
         end
         it "should not modify the base value" do
           subject.ceil.value.should == 40.124
@@ -386,22 +406,22 @@ describe "Exchange::Currency" do
         it "should apply it to its number" do
           subject.ceil(0).value.should == 41
           subject.ceil(0).currency.should == :omr
-          subject.ceil(0).should be_kind_of Exchange::Currency
+          subject.ceil(0).should be_kind_of Exchange::Money
         end
         it "should allow to round to whatever number of decimals" do
           subject.ceil(2).value.should == 40.13
           subject.ceil(2).currency.should == :omr
-          subject.ceil(2).should be_kind_of Exchange::Currency
+          subject.ceil(2).should be_kind_of Exchange::Money
         end
       end
     end
     describe "floor" do
-      subject { Exchange::Currency.new(40.723, :jpy) }
+      subject { Exchange::Money.new(40.723, :jpy) }
       context "without arguments" do
         it "should apply it to its number in the iso certified format" do
           subject.floor.value.should == 40
           subject.floor.currency.should == :jpy
-          subject.floor.should be_kind_of Exchange::Currency
+          subject.floor.should be_kind_of Exchange::Money
         end
         it "should not modify the base value" do
           subject.floor.value.should == 40
@@ -412,38 +432,38 @@ describe "Exchange::Currency" do
         it "should apply it to its number" do
           subject.floor(1).value.should == 40.7
           subject.floor(1).currency.should == :jpy
-          subject.floor(1).should be_kind_of Exchange::Currency
+          subject.floor(1).should be_kind_of Exchange::Money
         end
         it "should allow to round to whatever number of decimals" do
           subject.floor(2).value.should == 40.72
           subject.floor(2).currency.should == :jpy
-          subject.floor(2).should be_kind_of Exchange::Currency
+          subject.floor(2).should be_kind_of Exchange::Money
         end
       end
     end
   end
   describe "to_s" do
     it "should render the currency according to ISO 4217 Definitions" do
-      Exchange::Currency.new(23.232524, 'TND').to_s.should == "TND 23.233"
-      Exchange::Currency.new(23.23252423, 'SAR').to_s.should == "SAR 23.23"
-      Exchange::Currency.new(23.23252423, 'CLP').to_s.should == "CLP 23"
-      Exchange::Currency.new(23.2, 'TND').to_s.should == "TND 23.200"
-      Exchange::Currency.new(23.4, 'SAR').to_s.should == "SAR 23.40"
-      Exchange::Currency.new(23.0, 'CLP').to_s.should == "CLP 23"
+      Exchange::Money.new(23.232524, :tnd).to_s.should == "TND 23.233"
+      Exchange::Money.new(23.23252423, :sar).to_s.should == "SAR 23.23"
+      Exchange::Money.new(23.23252423, :clp).to_s.should == "CLP 23"
+      Exchange::Money.new(23.2, :tnd).to_s.should == "TND 23.200"
+      Exchange::Money.new(23.4, :sar).to_s.should == "SAR 23.40"
+      Exchange::Money.new(23.0, :clp).to_s.should == "CLP 23"
     end
     it "should render only the currency amount if the argument amount is passed" do
-      Exchange::Currency.new(23.232524, 'TND').to_s(:amount).should == "23.233"
-      Exchange::Currency.new(23.23252423, 'SAR').to_s(:amount).should == "23.23"
-      Exchange::Currency.new(23.23252423, 'CLP').to_s(:amount).should == "23"
-      Exchange::Currency.new(23.2, 'TND').to_s(:amount).should == "23.200"
-      Exchange::Currency.new(23.4, 'SAR').to_s(:amount).should == "23.40"
-      Exchange::Currency.new(23.0, 'CLP').to_s(:amount).should == "23"
+      Exchange::Money.new(23.232524, :tnd).to_s(:amount).should == "23.233"
+      Exchange::Money.new(23.23252423, :sar).to_s(:amount).should == "23.23"
+      Exchange::Money.new(23.23252423, :clp).to_s(:amount).should == "23"
+      Exchange::Money.new(23.2, :tnd).to_s(:amount).should == "23.200"
+      Exchange::Money.new(23.4, :sar).to_s(:amount).should == "23.40"
+      Exchange::Money.new(23.0, :clp).to_s(:amount).should == "23"
     end
   end
   describe "methods via method missing" do
     it "should be able to convert via to_currency to other currencies" do
       mock_api("http://openexchangerates.org/api/latest.json?app_id=", fixture('api_responses/example_json_api.json'), 6)
-      {'chf' => 36.5, 'usd' => 40.0, 'dkk' => 225.12, 'sek' => 269.85, 'nok' => 232.06, 'rub' => 1205.24}.each do |currency, value|
+      {:chf => 36.5, :usd => 40.0, :dkk => 225.12, :sek => 269.85, :nok => 232.06, :rub => 1205.24}.each do |currency, value|
         c = subject.send(:"to_#{currency}")
         c.value.round(2).should == value
         c.currency.should == currency
@@ -451,7 +471,7 @@ describe "Exchange::Currency" do
     end
     it "should be able to convert via to_currency to other currencies and use historic data" do
       mock_api("http://openexchangerates.org/api/historical/2011-10-09.json?app_id=", fixture('api_responses/example_json_api.json'), 6)
-      {'chf' => 36.5, 'usd' => 40.0, 'dkk' => 225.12, 'sek' => 269.85, 'nok' => 232.06, 'rub' => 1205.24}.each do |currency, value|
+      {:chf => 36.5, :usd => 40.0, :dkk => 225.12, :sek => 269.85, :nok => 232.06, :rub => 1205.24}.each do |currency, value|
         c = subject.send(:"to_#{currency}", :at => Time.gm(2011,10,9))
         c.value.round(2).should == value
         c.currency.should == currency

data/spec/exchange/typecasting_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe "Exchange::Typecasting" do
+  
+  class Manager
+    
+    attr_accessor :currency
+    
+    def initialize *args
+      self.currency = :eur
+      
+      super
+    end
+    
+  end
+  
+  class MyClass
+    extend Exchange::Typecasting
+    
+    attr_accessor :price, :manager
+    
+    def initialize *args
+      self.manager = Manager.new
+      
+      super
+    end
+    
+    def created_at
+      Time.gm(2012,8,8)
+    end
+    
+    money :price, :at => :created_at, :currency => lambda { |s| s.manager.currency }
+    
+  end
+  
+  describe "get" do
+    subject { MyClass.new }
+    before(:each) do
+      subject.price = 0.77
+    end
+    it "should instantiate the attribute as a currency" do
+      subject.price.should be_instance_of(Exchange::Money)
+    end
+    it "should instantiate the currency with the right currency" do
+      subject.price.currency.should == :eur
+    end
+    it "should instantiate with the right value" do
+      subject.price.value.should == 0.77
+    end
+    it "should instantiate the currency with the right time" do
+      subject.price.time.should == Time.gm(2012,8,8)
+    end
+    context "when changing the currency value" do
+      before(:each) do
+        subject.manager.currency = :usd
+      end
+      it "should instantiate with the new currency" do
+        subject.price.currency.should == :usd
+      end
+      it "should leave the value unchanged" do
+        subject.price.value.should == 0.77
+      end
+    end
+  end
+  
+  describe "set" do
+    subject { MyClass.new }
+    before(:each) do
+      subject.price = 0.77
+    end
+    it "should set the value if the given value is numeric" do
+      subject.price = 0.83
+      subject.price.should == 0.83.eur
+    end
+    it "should not convert the value if the given value is in the same currency" do
+      subject.price = 0.83.eur
+      subject.price.should == 0.83.eur
+    end
+    it "should convert the value if the given value is in another currency" do
+      mock_api("http://api.finance.xaviermedia.com/api/#{Time.now.strftime("%Y/%m/%d")}.xml", fixture('api_responses/example_xml_api.xml'))
+      subject.price = 0.83.usd
+      subject.price.should == 0.62.eur
+    end
+  end
+  
+end