cleanconscience-currency 0.7.0.11

data/spec/historical_writer_spec.rb

@@ -0,0 +1,121 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+require File.dirname(__FILE__) + '/ar_spec_helper'
+
+require File.dirname(__FILE__) + '/../lib/currency/exchange/rate/source/historical'
+require File.dirname(__FILE__) + '/../lib/currency/exchange/rate/source/historical/writer'
+require File.dirname(__FILE__) + '/../lib/currency/exchange/rate/source/xe'
+require File.dirname(__FILE__) + '/../lib/currency/exchange/rate/source/new_york_fed'
+
+include Currency
+RATE_CLASS = Exchange::Rate::Source::Historical::Rate
+TABLE_NAME = RATE_CLASS.table_name
+
+class HistoricalRateMigration < ActiveRecord::Migration
+  def self.up
+    RATE_CLASS.__create_table(self)
+  end
+
+  def self.down
+    drop_table TABLE_NAME.to_sym
+  end
+end
+
+describe "HistoricalWriter" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(database_spec)
+    @currency_test_migration ||= HistoricalRateMigration
+    schema_down
+    schema_up
+    @xe_src  = Exchange::Rate::Source::Xe.new
+    @fed_src = Exchange::Rate::Source::NewYorkFed.new
+  end
+  
+  after(:all) do
+    schema_down
+  end
+  
+  def setup_writer(source)
+    writer = Exchange::Rate::Source::Historical::Writer.new
+    writer.time_quantitizer = :current
+    writer.required_currencies = [ :USD, :GBP, :EUR, :CAD ]
+    writer.base_currencies = [ :USD ]
+    writer.preferred_currencies = writer.required_currencies
+    writer.reciprocal_rates = true
+    writer.all_rates = true
+    writer.identity_rates = false
+    writer.source = source
+    writer
+  end
+  
+  it "can read, parse and write XE data" do
+    writer = setup_writer(@xe_src)
+    rates = writer.write_rates
+    rates.size.should == 12
+    assert_h_rates(rates, writer)
+  end
+  
+  it "can read, parse and write NewYorkFed data (will fail on weekends)" do
+    if @fed_src.available?
+      writer = setup_writer(@fed_src)
+      rates = writer.write_rates
+      rates.size.should == 12
+      assert_h_rates(rates, writer)
+    end
+  end
+  
+  def assert_h_rates(rates, writer = nil)
+    hr0 = rates[0]
+    hr0.should_not be_nil
+    rates.each do | hr |
+      found_hr = nil
+      begin
+        found_hr = hr.find_matching_this(:first)
+        found_hr.should_not be_nil
+      rescue Object => err
+        raise "#{hr.inspect}: #{err}:\n#{err.backtrace.inspect}"
+      end
+      assert_equal_rate(hr, found_hr)
+      assert_rate_defaults(hr, writer)
+
+      hr.instance_eval do
+        date.should    ==  hr0.date
+        date_0.should  ==  hr0.date_0
+        date_1.should  ==  hr0.date_1
+        source.should  ==  hr0.source
+      end
+    end
+  end
+
+  def assert_equal_rate(hr0, hr)
+    tollerance = 0.00001
+    hr.c1.to_s.should == hr0.c1.to_s
+    hr.c2.to_s.should == hr0.c2.to_s
+    hr.source.should == hr0.source
+    
+    hr0.rate.should be_close(hr.rate, tollerance)
+    hr0.rate_avg.should be_close(hr.rate_avg, tollerance)
+    hr0.rate_samples.should == hr.rate_samples.should
+    
+    hr0.rate_lo.should be_close(hr.rate_lo, tollerance)
+    hr0.rate_hi.should be_close(hr.rate_hi, tollerance)
+    hr0.rate_date_0.should be_close(hr.rate_date_0, tollerance)
+    hr0.rate_date_1.should be_close(hr.rate_date_1, tollerance)
+    
+    hr0.date.should == hr.date
+    hr0.date_0.should == hr.date_0
+    hr0.date_1.should == hr.date_1
+    hr0.derived.should == hr.derived
+  end
+
+  def assert_rate_defaults(hr, writer)
+    hr.source.should        ==  writer.source.name
+    hr.rate_avg.should      ==  hr.rate
+    hr.rate_samples.should  ==  1
+    hr.rate_lo.should       ==  hr.rate
+    hr.rate_hi.should       ==  hr.rate
+    hr.rate_date_0.should   ==  hr.rate
+    hr.rate_date_1.should   ==  hr.rate
+  end
+
+end

data/spec/macro_spec.rb

@@ -0,0 +1,109 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+require 'test/test_base'
+require 'currency'
+require 'currency/macro'
+
+module Currency
+
+class MacroTest < TestBase
+  class Record
+    include ::Currency::Macro
+
+    attr_accessor :date
+    attr_accessor :gross
+    attr_accessor :tax
+    attr_accessor :net
+    attr_accessor :currency
+
+    attr_money :gross_money, :value => :gross, :time => :date, :currency => :currency
+    attr_money :tax_money,   :value => :tax,   :time => :date, :currency => :currency
+    attr_money :net_money,   :value => :net,   :time => :date, :currency => :currency
+
+    def initialize
+      self.date = Time.now
+      self.currency = :USD
+    end
+
+    def compute_net
+      self.net = self.gross - self.tax
+    end
+
+    def compute_net_money
+      self.net_money = self.gross_money - self.tax_money
+    end
+
+  end
+
+  before do
+    super
+  end
+
+  ############################################
+  # Tests
+  #
+
+  it "read money" do
+    assert_kind_of  Record, r = Record.new
+    r.gross = 10.00.should_not == nil
+    r.gross.should == r.gross_money.to_f
+    r.currency.should == r.gross_money.currency.code
+    r.date.should == r.gross_money.time
+
+    r
+  end
+
+
+  it "write money rep" do
+    assert_kind_of  Record, r = Record.new
+    r.gross_money = 10.00.should_not == nil
+    r.gross.should == r.gross_money.to_f
+    r.currency.should == r.gross_money.currency.code
+    r.date.should == r.gross_money.time
+
+    r
+  end
+
+
+  it "money cache" do
+    r = test_read_money
+
+    r_gross = r.gross.should_not == nil
+    r_gross.object_id.should == r.gross.object_id
+
+    # Cache flush
+    r.gross = 12.00.should_not == nil
+    r.gross.should == r.gross_money.to_f
+    r_gross.object_id != r.gross.object_id.should_not == nil
+  end
+
+
+  it "currency" do
+    r = test_read_money
+
+    r.gross_money.currency.should_not == nil
+    r.currency.should == r.gross_money.currency.code
+    
+  end
+
+
+  it "compute" do
+    assert_kind_of  Record, r = Record.new
+    r.gross = 10.00.should_not == nil
+    r.tax = 1.50.should_not == nil
+    r.compute_net
+
+    r.net.should == 8.50
+    r.net_money.to_f.should == r.net
+
+    r.compute_net_money
+
+    r.net.should == 8.50
+    r.net_money.to_f.should == r.net
+  end
+
+end # class
+
+end # module
+

data/spec/money_spec.rb

@@ -0,0 +1,367 @@
+require File.dirname(__FILE__) + '/spec_helper'
+# require File.dirname(__FILE__) + '/../lib/currency/formatter'
+
+describe Currency::Money do
+
+  before :all do
+    Currency::Config.configure do |config|
+      config.scale_exp = 6
+    end
+    
+  end
+
+  def zero_money
+    @zero_money ||= Currency::Money.new(0)
+  end
+  
+  def negative_money
+    @negative_money ||= Currency::Money.new(-1.00, :USD)
+  end
+  
+  def positive_money
+    @positive_money ||= Currency::Money.new(2.99, :USD)
+  end
+
+  it "creates Monies" do
+    m = Currency::Money.new(1.99)
+    m.should be_kind_of(Currency::Money) 
+    Currency::Currency.default.should == m.currency
+    :USD.should == m.currency.code
+  end
+
+  describe "Converts different objects to Money with the 'money' method" do
+    it "works with a float" do
+      m = 1.99.money(:USD)
+      m.should be_kind_of(Currency::Money)
+      :USD.should == m.currency.code
+      m.rep.should == 1990000
+    end
+
+    it "works with a FixNum" do
+      m = 199.money(:CAD)
+      m.should be_kind_of(Currency::Money)
+      :CAD.should == m.currency.code
+      m.rep.should == 199000000
+    end
+
+    it "works with a string" do
+      m = "13.98".money(:CAD)
+      m.should be_kind_of(Currency::Money)
+      :CAD.should == m.currency.code
+      m.rep.should == 13980000
+    end
+
+    it "works with a string again" do
+      m = "45.99".money(:EUR)
+      m.should be_kind_of(Currency::Money)
+      :EUR.should == m.currency.code
+      m.rep.should == 45990000
+    end
+    
+    describe "deals with voids" do
+      it "does not raise with an empty string" do
+        lambda{
+          Currency::Money.new('')
+        }.should_not raise_error
+      end
+      
+      it "considers the empty string to be nil " do
+        Currency::Money.new('').should be_nil
+      end
+    end
+  end
+
+  it "deals with zero in the least surprising way" do
+    zero_money.negative?.should_not == true
+    zero_money.zero?.should_not == nil
+    zero_money.positive?.should_not == true
+  end
+  
+  it "deals with negatives in the least surprising way" do
+    negative_money.negative?.should_not == nil
+    negative_money.zero?.should_not == true
+    negative_money.positive?.should_not == true
+  end
+
+  it "deals with positive numbers in the least surprising way" do
+    positive_money.negative?.should_not == true
+    positive_money.zero?.should_not == true
+    positive_money.positive?.should_not == nil
+  end
+
+  it "can do comparisons between monies" do
+    n = negative_money
+    z = zero_money
+    p = positive_money
+
+    negative_money.should < positive_money
+    (negative_money > positive_money).should_not be_true
+    (positive_money < negative_money).should_not be_true
+    (p.should > n)
+    (p != n).should_not == nil
+
+    (z.should <= z)
+    (z.should >= z)
+
+    (z.should <= p)
+    (n.should <= z)
+    (z.should >= n)
+
+    n.should == n
+    p.should == p
+
+    z.should == zero_money
+  end
+
+  it "compare" do
+    n = negative_money
+    z = zero_money
+    p = positive_money
+
+    (n <=> p).should == -1
+    (p <=> n).should == 1
+    (p <=> z).should == 1
+
+    (n <=> n).should == 0
+    (z <=> z).should == 0
+    (p <=> p).should == 0    
+  end
+
+  it "rep" do
+    m = Currency::Money.new(123, :USD)
+    m.should_not == nil
+    m.rep.should == 123000000
+    
+    m = Currency::Money.new(123.45, :USD)
+    m.should_not == nil
+    m.rep.should == 123450000
+
+    m = Currency::Money.new("123.456", :USD)
+    m.should_not == nil
+    m.rep.should == 123456000
+  end
+
+  it "convert" do
+    m = Currency::Money.new("123.456", :USD)
+    m.should_not == nil
+    m.rep.should == 123456000
+
+    m.to_i.should == 123
+    m.to_f.should == 123.456
+    m.to_s.should == "$123.456000"
+  end
+
+  it "eql" do
+    usd1 = Currency::Money.new(123, :USD)
+    usd1.should_not == nil
+    usd2 = Currency::Money.new("123", :USD)
+    usd2.should_not == nil
+
+    usd1.currency.code.should == :USD
+    usd2.currency.code.should == :USD
+    
+    usd2.rep.should == usd1.rep
+
+    usd1.should == usd2
+
+  end
+
+  it "not eql" do  
+ 
+    usd1 = Currency::Money.new(123, :USD)
+    usd1.should_not == nil
+    usd2 = Currency::Money.new("123.01", :USD)
+    usd2.should_not == nil
+
+    usd1.currency.code.should == :USD
+    usd2.currency.code.should == :USD
+    
+    usd2.rep.should_not == usd1.rep
+
+    (usd1 != usd2).should_not == nil
+
+    ################
+    # currency !=
+    # rep ==
+
+    usd = Currency::Money.new(123, :USD)
+    usd.should_not == nil
+    cad = Currency::Money.new(123, :CAD)
+    cad.should_not == nil
+
+    usd.currency.code.should == :USD
+    cad.currency.code.should == :CAD
+
+    cad.rep.should == usd.rep
+    (usd.currency != cad.currency).should_not == nil
+
+    (usd != cad).should_not == nil
+
+  end
+  
+  describe "operations" do
+    before(:each) do
+      @usd = Currency::Money.new(123.45, :USD)
+      @cad = Currency::Money.new(123.45, :CAD)
+    end
+    
+    it "should work" do
+      @usd.should_not == nil
+      @cad.should_not == nil
+    end
+    
+    it "handle negative money" do
+      # - Currency::Money => Currency::Money
+      (- @usd).rep.should == -123450000
+      (- @usd).currency.code.should == :USD
+
+      (- @cad).rep.should == -123450000
+      (- @cad).currency.code.should == :CAD
+    end
+    
+    it "should add monies of the same currency" do
+      m = (@usd + @usd)
+      m.should be_kind_of(Currency::Money)
+      m.rep.should == 246900000
+      m.currency.code.should == :USD
+    end
+    
+    it "should add monies of different currencies and return USD" do
+      m = (@usd + @cad)
+      m.should be_kind_of(Currency::Money)
+      m.rep.should == 228890724
+      m.currency.code.should == :USD
+    end
+    
+    it "should add monies of different currencies and return CAD" do
+      m = (@cad + @usd)
+      m.should be_kind_of(Currency::Money) 
+      m.rep.should == 267985260
+      m.currency.code.should == :CAD
+    end
+    
+    it "should subtract monies of the same currency" do
+      m = (@usd - @usd)
+      m.should be_kind_of(Currency::Money) 
+      m.rep.should == 0
+      m.currency.code.should == :USD
+    end
+    
+    it "should subtract monies of different currencies and return USD" do
+      m = (@usd - @cad)
+      m.should be_kind_of(Currency::Money) 
+      m.rep.should == 18009276
+      m.currency.code.should == :USD
+    end
+    
+    it "should subtract monies of different currencies and return CAD" do
+      m = (@cad - @usd)
+      m.should be_kind_of(Currency::Money) 
+      m.rep.should == -21085260
+      m.currency.code.should == :CAD
+    end
+    
+    it "should multiply by numerics and return money" do
+      m = (@usd * 0.5)
+      m.should be_kind_of(Currency::Money)
+      m.rep.should == 61725000
+      m.currency.code.should == :USD
+    end
+    
+    it "should divide by numerics and return money" do
+      m = @usd / 3
+      m.should be_kind_of(Currency::Money)
+      m.rep.should == 41150000
+      m.currency.code.should == :USD
+    end
+    
+    it "should divide by monies of the same currency and return numeric" do
+      m = @usd / Currency::Money.new("41.15", :USD)
+      m.should be_kind_of(Numeric)
+      m.should be_close(3.0, 1.0e-8)
+    end
+    
+    it "should divide by monies of different currencies and return numeric" do
+      m = (@usd / @cad)
+      m.should be_kind_of(Numeric)
+      m.should be_close(Currency::Exchange::Rate::Source::Test.USD_CAD, 0.0001)
+    end
+  end
+
+  it "pivot conversions" do
+    # Using default get_rate
+    cad = Currency::Money.new(123.45, :CAD)
+    cad.should_not == nil
+    eur = cad.convert(:EUR)
+    eur.should_not == nil
+    m = (eur.to_f / cad.to_f)
+    m.should be_kind_of(Numeric) 
+    m_expected = (1.0 / Currency::Exchange::Rate::Source::Test.USD_CAD) * Currency::Exchange::Rate::Source::Test.USD_EUR
+    m.should be_close(m_expected, 0.001)
+
+
+    gbp = Currency::Money.new(123.45, :GBP)
+    gbp.should_not == nil
+    eur = gbp.convert(:EUR)
+    eur.should_not == nil
+    m = (eur.to_f / gbp.to_f)
+    m.should be_kind_of(Numeric) 
+    m_expected = (1.0 / Currency::Exchange::Rate::Source::Test.USD_GBP) * Currency::Exchange::Rate::Source::Test.USD_EUR
+    m.should be_close(m_expected, 0.001)
+  end
+
+
+  it "invalid currency code" do
+    lambda {Currency::Money.new(123, :asdf)}.should raise_error(Currency::Exception::InvalidCurrencyCode)
+    lambda {Currency::Money.new(123, 5)}.should raise_error(Currency::Exception::InvalidCurrencyCode)
+  end
+
+
+  it "time default" do
+    Currency::Money.default_time = nil
+
+    usd = Currency::Money.new(123.45, :USD)
+    usd.should_not == nil
+    usd.time.should == nil
+
+    Currency::Money.default_time = Time.now
+    usd = Currency::Money.new(123.45, :USD)
+    usd.should_not == nil
+    Currency::Money.default_time.should == usd.time
+  end
+
+
+  it "time now" do
+    Currency::Money.default_time = :now
+
+    usd = Currency::Money.new(123.45, :USD)
+    usd.should_not == nil
+    usd.time.should_not == nil
+
+    sleep 1
+
+    usd2 = Currency::Money.new(123.45, :USD)
+    usd2.should_not == nil
+    usd2.time.should_not == nil
+    (usd.time != usd2.time).should_not == nil
+
+    Currency::Money.default_time = nil
+  end
+
+
+  it "time fixed" do
+    Currency::Money.default_time = Time.new
+
+    usd = Currency::Money.new(123.45, :USD)
+    usd.should_not == nil
+    usd.time.should_not == nil
+
+    sleep 1
+
+    usd2 = Currency::Money.new(123.45, :USD)
+    usd2.should_not == nil
+    usd2.time.should_not == nil
+    usd.time.should == usd2.time
+  end
+end
+