acvwilson-acvwilson-currency 0.5.0

data/spec/historical_writer_spec.rb

@@ -0,0 +1,187 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+require 'test/ar_test_base'
+
+require 'rubygems'
+require 'active_record'
+require 'active_record/migration'
+
+require 'currency' # For :type => :money
+
+require 'currency/exchange/rate/source/historical'
+require 'currency/exchange/rate/source/historical/writer'
+require 'currency/exchange/rate/source/xe'
+require 'currency/exchange/rate/source/new_york_fed'
+
+
+module Currency
+
+class HistoricalWriterTest < ArTestBase
+
+  RATE_CLASS = Exchange::Rate::Source::Historical::Rate
+  TABLE_NAME = RATE_CLASS.table_name
+
+  class HistoricalRateMigration < AR_M
+    def self.up
+      RATE_CLASS.__create_table(self)
+    end
+
+    def self.down
+      drop_table TABLE_NAME.intern
+    end
+  end
+
+
+  def initialize(*args)
+    @currency_test_migration = HistoricalRateMigration
+    super
+
+    @src = Exchange::Rate::Source::Xe.new
+    @src2 = Exchange::Rate::Source::NewYorkFed.new
+  end
+
+
+  before do
+    super
+    
+  end
+
+  
+  it "writer" do
+    src = @src.should.not == nil
+    writer = Exchange::Rate::Source::Historical::Writer.new().should.not == nil
+    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
+  end
+  
+
+  def writer_src
+    writer = test_writer
+    writer.source = @src
+    rates = writer.write_rates
+    rates.should.not == nil
+    rates.size.should > 0
+    12, rates.size.should.not == nil
+    assert_h_rates(rates, writer)
+  end
+
+
+  def writer_src2
+    writer = test_writer
+    writer.source = @src2
+    return unless writer.source.available?
+    rates = writer.write_rates
+    rates.should.not == nil
+    rates.size.should > 0
+    rates.size.should == 12
+    assert_h_rates(rates, writer)
+  end
+
+
+  def xxx_test_required_failure
+    writer = Exchange::Rate::Source::Historical::Writer.new().should.not == nil
+    src = @src.should.not == nil
+    writer.source = src
+    writer.required_currencies = [ :USD, :GBP, :EUR, :CAD, :ZZZ ]
+    writer.preferred_currencies = writer.required_currencies
+    assert_raises(::RuntimeError) { writer.selected_rates }
+  end
+
+
+  it "historical rates" do
+    # Make sure there are historical Rates avail for today.
+    writer_src
+    writer_src2
+    
+    # Force Historical Rate Source.
+    source = Exchange::Rate::Source::Historical.new
+    deriver = Exchange::Rate::Deriver.new(:source => source)
+    Exchange::Rate::Source.default = deriver
+
+    rates = source.get_raw_rates.should.not == nil
+     rates.empty?.should.not == true
+    # $stderr.puts "historical rates = #{rates.inspect}"
+
+    rates = source.get_rates.should.not == nil
+     rates.empty?.should.not == true
+    # $stderr.puts "historical rates = #{rates.inspect}"
+    
+    m_usd = ::Currency.Money('1234.56', :USD, :now).should.not == nil
+    # $stderr.puts "m_usd = #{m_usd.to_s(:code => true)}"
+    m_eur = m_usd.convert(:EUR).should.not == nil
+    # $stderr.puts "m_eur = #{m_eur.to_s(:code => true)}"
+
+  end
+
+
+  def assert_h_rates(rates, writer = nil)
+    hr0 = rates[0].should.not == nil
+    rates.each do | hr |
+      found_hr = nil
+      begin
+        found_hr = hr.find_matching_this(:first).should.not == nil
+      rescue Object => err
+        raise "#{hr.inspect}: #{err}:\n#{err.backtrace.inspect}"
+      end
+
+      hr0.should.not == nil
+
+      hr.date.should == hr0.date
+      hr.date_0.should == hr0.date_0
+      hr.date_1.should == hr0.date_1
+      hr.source.should == hr0.source
+
+      assert_equal_rate(hr, found_hr)
+      assert_rate_defaults(hr, writer)
+    end
+  end
+
+
+  def assert_equal_rate(hr0, hr)
+    hr.c1.to_s.should == hr0.c1.to_s
+    hr.c2.to_s.should == hr0.c2.to_s
+    hr.source.should == hr0.source
+    assert_equal_float hr0.rate, hr.rate
+    assert_equal_float hr0.rate_avg, hr.rate_avg
+    hr.rate_samples.should == hr0.rate_samples
+    assert_equal_float hr0.rate_lo, hr.rate_lo
+    assert_equal_float hr0.rate_hi, hr.rate_hi
+    assert_equal_float hr0.rate_date_0, hr.rate_date_0
+    assert_equal_float hr0.rate_date_1, hr.rate_date_1
+    hr.date.should == hr0.date
+    hr.date_0.should == hr0.date_0
+    hr.date_1.should == hr0.date_1
+    hr.derived.should == hr0.derived
+  end
+
+
+  def assert_rate_defaults(hr, writer)
+    hr.source if writer.should == writer.source.name
+    hr.rate_avg.should == hr.rate
+    1.should == hr.rate_samples
+    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
+
+
+  def assert_equal_float(x1, x2, eps = 0.00001)
+    eps = (x1 * eps).abs
+    assert((x1 - eps) <= x2)
+    assert((x1 + eps) >= x2)
+  end
+
+
+end
+
+end # module
+

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,347 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe Currency::Money do
+
+  it "create" 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 "object 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
+  end
+
+  def zero_money
+    @zero_money ||= Currency::Money.new(0)
+  end
+  
+  it "zero" do
+    zero_money.negative?.should_not == true
+    zero_money.zero?.should_not == nil
+    zero_money.positive?.should_not == true
+  end
+  
+  def negative_money
+    @negative_money ||= Currency::Money.new(-1.00, :USD)
+  end
+  
+  it "negative" do
+    negative_money.negative?.should_not == nil
+    negative_money.zero?.should_not == true
+    negative_money.positive?.should_not == true
+  end
+
+  def positive_money
+    @positive_money ||= Currency::Money.new(2.99, :USD)
+  end
+  it "positive" do
+    positive_money.negative?.should_not == true
+    positive_money.zero?.should_not == true
+    positive_money.positive?.should_not == nil
+  end
+
+  it "relational" do
+    n = negative_money
+    z = zero_money
+    p = positive_money
+
+    (n.should < p)
+     (n > p).should_not == true
+     (p < n).should_not == 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
+