acvwilson-currency 0.5.0

data/spec/ar_column_spec.rb

@@ -0,0 +1,76 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+# require 'test/ar_test_core'
+# require 'currency'
+# 
+# require 'rubygems'
+# require 'active_record'
+# require 'active_record/migration'
+# require 'currency/active_record'
+
+require File.dirname(__FILE__) + '/ar_spec_helper'
+
+# module Currency
+# 
+# class ArFieldTest < ArTestCore
+
+  ##################################################
+  # Basic CurrenyTest AR::B class
+  #
+
+  TABLE_NAME = 'currency_column_test'
+
+  class CurrencyColumnTestMigration < AR_M
+    def self.up
+      create_table TABLE_NAME.intern do |t|
+        t.column :name,     :string
+        t.column :amount,   :integer # Money
+        t.column :amount_currency,   :string, :size => 3 # Money.currency.code
+      end
+    end
+
+    def self.down
+      drop_table TABLE_NAME.intern
+    end
+  end
+
+  class CurrencyColumnTest < AR_B
+    set_table_name TABLE_NAME
+    attr_money :amount, :currency_column => true
+  end 
+
+  ##################################################
+
+
+  # def teardown
+  #   super
+  # end
+
+  ##################################################
+
+describe "ActiveRecord macros" do
+  before(:all) do
+    AR_B.establish_connection(database_spec)
+    @currency_test_migration ||= CurrencyColumnTestMigration 
+    @currency_test ||= CurrencyColumnTest
+    # schema_down
+    schema_up
+  end
+  
+  after(:all) do
+    # schema_down
+  end
+
+  it "field" do
+    insert_records
+
+    usd = @currency_test.find(@usd.id)
+    usd.should_not be_nil
+    assert_equal_currency usd, @usd
+
+    cad = @currency_test.find(@cad.id)
+    cad.should_not be_nil
+    assert_equal_currency cad, @cad
+  end
+end

data/spec/ar_core_spec.rb

@@ -0,0 +1,68 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+
+# =================================================================
+# = TODO: IS THIS STUFF ACTUALLY NEEDED? IF SO, MOVE TO AR HELPER =
+# =================================================================
+require 'test/ar_test_base'
+
+module Currency
+
+class ArTestCore < ArTestBase
+
+  ##################################################
+  # Basic CurrenyTest AR::B class
+  #
+
+  TABLE_NAME = 'currency_test'
+
+  class CurrencyTestMigration < AR_M
+    def self.up
+      create_table TABLE_NAME.intern do |t|
+        t.column :name,     :string
+        t.column :amount,   :integer # Money
+      end
+    end
+
+    def self.down
+      drop_table TABLE_NAME.intern
+    end
+  end
+
+
+  class CurrencyTest < AR_B
+    set_table_name TABLE_NAME
+    attr_money :amount
+  end 
+
+
+  ##################################################
+
+
+  before do
+    @currency_test_migration ||= CurrencyTestMigration 
+    @currency_test           ||= CurrencyTest
+    super
+  end
+
+
+  def teardown
+    super
+    # schema_down
+  end
+
+
+  ##################################################
+  # 
+  # 
+  
+
+  it "insert" do
+    insert_records
+  end
+
+end
+
+end # module
+

data/spec/ar_simple_spec.rb

@@ -0,0 +1,23 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# Copyright (C) 2008 Asa Wilson <acvwilson(at)gmail.com>
+# See LICENSE.txt for details.
+
+require File.dirname(__FILE__) + '/ar_spec_helper'
+
+describe Currency::ActiveRecord do
+  it "simple" do
+    # TODO: move insert_records into a before block?
+    insert_records
+
+    usd = @currency_test.find(@usd.id)
+    usd.should_not be_nil
+    assert_equal_currency usd, @usd
+
+    cad = @currency_test.find(@cad.id)
+    cad.should_not == nil
+    assert_equal_money cad, @cad
+
+    cad.amount.currency.code.should == :USD
+  end
+end
+

data/spec/config_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Currency::Config do
+
+  it "should truncate" do
+    Currency::Config.configure do | c |
+      c.float_ref_filter = Proc.new { | x | x }
+    
+      m = Currency::Money.new(1.999999999)
+      m.should be_kind_of(Currency::Money) 
+      m.rep.should == 1999999
+    end
+  end
+  
+  it "should round" do
+    Currency::Config.configure do | c |
+      c.float_ref_filter = Proc.new { | x | x.round }
+
+      m = Currency::Money.new(1.99999999)
+      m.should be_kind_of(Currency::Money)
+      m.rep.should == 2000000
+    end
+
+  end
+
+end # class
+
+
+

data/spec/federal_reserve_spec.rb

@@ -0,0 +1,75 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+require 'test/test_base'
+
+require 'currency' # For :type => :money
+require 'currency/exchange/rate/source/federal_reserve'
+
+module Currency
+
+class FederalReserveTest < TestBase
+  before do
+    super
+  end
+
+
+  @@available = nil
+
+  # New York Fed rates are not available on Saturday and Sunday.
+  def available?
+    if @@available == nil
+      @@available = @source.available?
+      STDERR.puts "Warning: FederalReserve unavailable on Saturday and Sunday, skipping tests." unless @@available
+    end
+    @@available
+  end
+
+
+  def get_rate_source
+    # Force FederalReserve Exchange.
+    verbose = false
+    source = @source = Exchange::Rate::Source::FederalReserve.new(:verbose => verbose)
+    deriver = Exchange::Rate::Deriver.new(:source => source, :verbose => source.verbose)
+  end
+
+
+
+  it "usd cad" do
+    return unless available?
+
+    # yesterday = Time.now.to_date - 1
+
+    rates = Exchange::Rate::Source.default.source.raw_rates.should.not == nil
+    #assert_not_nil rates[:USD]
+    #assert_not_nil usd_cad = rates[:USD][:CAD]
+
+    usd = Money.new(123.45, :USD).should.not == nil
+    cad = usd.convert(:CAD).should.not == nil
+
+    # assert_kind_of Numeric, m = (cad.to_f / usd.to_f)
+    # $stderr.puts "m = #{m}"
+    # assert_equal_float usd_cad, m, 0.001
+  end
+
+
+  it "cad eur" do
+    return unless available?
+
+    rates = Exchange::Rate::Source.default.source.raw_rates.should.not == nil
+    #assert_not_nil rates[:USD]
+    #assert_not_nil usd_cad = rates[:USD][:CAD]
+    #assert_not_nil usd_eur = rates[:USD][:EUR]
+
+    cad = Money.new(123.45, :CAD).should.not == nil
+    eur = cad.convert(:EUR).should.not == nil
+
+    #assert_kind_of Numeric, m = (eur.to_f / cad.to_f)
+    # $stderr.puts "m = #{m}"
+    #assert_equal_float (1.0 / usd_cad) * usd_eur, m, 0.001
+  end
+
+end
+
+end # module
+

data/spec/formatter_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Currency::Formatter do
+  before(:each) do
+    @time = nil
+    @money = Currency::Money.new_rep(1234567890000, :USD, @time)
+    
+  end
+
+  it "can convert to string" do
+    @money.should be_kind_of(Currency::Money) 
+    @money.currency.should == Currency::Currency.default
+    @money.currency.code.should == :USD
+    @money.to_s.should == "$1,234,567.890000"
+    @money.time.should == @time
+  end
+
+
+  it "handles thousands options" do
+    @money.to_s(:thousands => false).should == "$1234567.890000"
+    @money.to_s(:thousands => true).should == "$1,234,567.890000"
+  end
+
+
+  it "handles cents options" do
+    @money.to_s(:cents => false).should == "$1,234,567"
+    @money.to_s(:cents => true).should == "$1,234,567.890000"
+  end
+
+
+  it "handles symbol options" do
+    @money.to_s(:symbol => false).should == "1,234,567.890000"
+    @money.to_s(:symbol => true).should == "$1,234,567.890000"
+  end
+
+
+  it "handles code options" do
+    @money.to_s(:code => false).should == "$1,234,567.890000"
+    @money.to_s(:code => true).should == "USD $1,234,567.890000"
+  end
+
+
+  it "handles html and more" do
+    m = ::Currency::Money(12.45, :USD)
+    money_string = m.to_s(:html => true, :code => true)
+    money_string.should == "<span class=\"currency_code\">USD</span> $12.450000"
+    
+
+    m = ::Currency::Money(12.45, :EUR)
+    money_string = m.to_s(:html => true, :code => true)
+    money_string.should == "<span class=\"currency_code\">EUR</span> &#8364;12.450000"
+
+    m = ::Currency::Money(12345.45, :EUR)
+    money_string = m.to_s(:html => true, :code => true, :thousands_separator => '_')
+    money_string.should == "<span class=\"currency_code\">EUR</span> &#8364;12_345.450000"
+  end
+
+
+  it "handles time options" do
+    time = Time.new
+    m = Currency::Money.new_rep(1234567890000, :USD, time)
+    m.to_s(:time => false).should == "$1,234,567.890000"
+    m.to_s(:time => true).should == "$1,234,567.890000 #{time.getutc.xmlschema(4)}"
+  end
+
+  it "handles decimal options" do
+    @money = Currency::Money.new_rep(1234567890000, :USD, @time)
+    @money.to_s(:decimals => 2).should == "$1,234,567.89"
+    @money.to_s(:decimals => 3).should == "$1,234,567.890"
+    @money.to_s(:decimals => 4).should == "$1,234,567.8900"
+  end
+end

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
+