cleanconscience-currency 0.7.0.11

data/spec/new_york_fed_spec.rb

@@ -0,0 +1,73 @@
+# 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/new_york_fed'
+
+module Currency
+
+class NewYorkFedTest < 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: NewYorkFed unavailable on Saturday and Sunday, skipping tests."
+    end
+    @@available
+  end
+
+
+  def get_rate_source
+    # Force NewYorkFed Exchange.
+    verbose = false
+    source = @source = Exchange::Rate::Source::NewYorkFed.new(:verbose => verbose)
+    deriver = Exchange::Rate::Deriver.new(:source => source, :verbose => source.verbose)
+  end
+
+
+
+  it "usd cad" do
+    return unless available?
+
+    rates = Exchange::Rate::Source.default.source.raw_rates.should_not == nil
+    rates[:USD].should_not == nil
+    usd_cad = rates[:USD][:CAD].should_not == nil
+
+    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
+    rates[:USD].should_not == nil
+    usd_cad = rates[:USD][:CAD].should_not == nil
+    usd_eur = rates[:USD][:EUR].should_not == nil
+
+    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/parser_spec.rb

@@ -0,0 +1,105 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Currency::Parser do
+  before do
+    @parser = ::Currency::Currency.USD.parser_or_default
+  end
+
+  describe "is great at parsing strings" do
+    it "can use a string that uses the thousands-separator (comma)" do
+      @parser.parse("1234567.89").rep.should == 123456789
+      @parser.parse("1,234,567.89").rep.should == 123456789
+    end
+
+
+    it "parses cents" do
+      @parser.parse("1234567.89").rep.should == 123456789
+      @parser.parse("1234567").rep.should == 123456700
+      @parser.parse("1234567.").rep.should == 123456700
+      @parser.parse("1234567.8").rep.should == 123456780
+      @parser.parse("1234567.891").rep.should == 123456789
+      @parser.parse("-1234567").rep.should == -123456700
+      @parser.parse("+1234567").rep.should == 123456700
+    end
+  end
+
+  describe "can convert the right hand side argument" do
+    it "converts the right hand argument to the left hand side currency if needed" do
+      m = "123.45 USD".money + "100 CAD"
+      m.should_not == nil
+      m.rep.should == ("123.45".money(:USD) + "100 CAD".money(:USD)).rep
+    end
+
+    it "uses the left hand sides currency if the right hand side argument does provide currency info" do
+      m = "123.45 USD".money
+      (m + 100).rep.should == (m + "100".money(:USD)).rep
+    end
+  end
+
+  describe "can use the inspect method as a serialization of self" do
+    it "can recreate a money object by using a .inspect-string" do
+      ::Currency::Currency.default = :USD
+      m = ::Currency::Money("1234567.89", :CAD)
+      m2 = ::Currency::Money(m.inspect)
+
+      m2.rep.should == m.rep
+      m2.currency.should == m.currency
+
+      m2.inspect.should == m.inspect
+    end
+
+
+    it "can recreate a money objectby using a .inspect-string and keep the time parameter as well" do
+      ::Currency::Currency.default = :USD
+      time = Time.now.getutc
+      m = ::Currency::Money("1234567.89", :CAD, time)
+      m.time.should_not == nil
+
+      m2 = ::Currency::Money(m.inspect)
+      m2.time.should_not == nil
+
+      m.should_not be(m2)
+
+      m2.rep.should == m.rep
+      m2.currency.should == m.currency
+      m2.time.to_i.should == m.time.to_i
+      m2.inspect.should == m.inspect
+    end
+  end
+
+  describe "deals with time when creating money objects" do
+    before do
+      @parser = ::Currency::Parser.new
+    end
+    
+    it "can parse even though the parser time is nil" do
+      @parser.time = nil
+
+      m = @parser.parse("$1234.55")
+      m.time.should == nil
+    end
+
+
+    it "parses money strings into money object using the parsers time" do
+      @parser.time = Time.now
+
+      m = @parser.parse("$1234.55")
+      m.time.should == @parser.time
+    end
+
+
+    it "when re-initializing a money object, the time is also re-initialized" do
+      @parser.time = :now
+
+      m = @parser.parse("$1234.55")
+      m1_time = m.time
+
+      m = @parser.parse("$1234.55")
+      m2_time = m.time
+
+      m1_time.should_not == m2_time
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+require 'spec'
+require File.dirname(__FILE__) + '/../lib/currency'
+require File.dirname(__FILE__) + '/../lib/currency/exchange/rate/source/test'
+
+def setup(source = nil)
+  rate_source ||= get_rate_source(source)
+  Currency::Exchange::Rate::Source.default = rate_source
+
+  # Force non-historical money values.
+  Currency::Money.default_time = nil
+end
+
+def get_rate_source(source = nil)
+  source ||= Currency::Exchange::Rate::Source::Test.instance
+  Currency::Exchange::Rate::Deriver.new(:source => source)
+end
+
+Spec::Runner.configure do |config|
+  config.before(:all) {setup}
+end
+
+

data/spec/time_quantitizer_spec.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Currency::Exchange::TimeQuantitizerTest do
+
+  def assert_test_day(t0)
+    tq = test_create
+
+    begin
+      t1 = tq.quantitize_time(t0).should_not == nil
+      #$stderr.puts "t0 = #{t0}"
+      #$stderr.puts "t1 = #{t1}"
+      
+      t1.year.should == t0.year
+      t1.month.should == t0.month
+      t1.day.should == t0.day
+      assert_time_beginning_of_day(t1)
+    rescue Object => err
+      raise("#{err}\nDuring quantitize_time(#{t0} (#{t0.to_i}))")
+    end
+
+    t1
+  end
+  
+  def assert_test_minute(t0)
+    tq = TimeQuantitizer.new(:time_quant_size => 60) # 1 minute
+
+    tq.local_timezone_offset
+
+    t1 = tq.quantitize_time(t0).should_not == nil
+    $stderr.puts "t0 = #{t0}"
+    $stderr.puts "t1 = #{t1}"
+
+    t1.year.should == t0.year
+    t1.month.should == t0.month
+    t1.day.should == t0.day
+    assert_time_beginning_of_day(t1)
+
+    t1
+  end
+
+
+  def assert_time_beginning_of_day(t1)
+    t1.hour.should == 0
+    assert_time_beginning_of_hour(t1)
+  end
+
+
+  def assert_time_beginning_of_hour(t1)
+    t1.min.should == 0
+    assert_time_beginning_of_min(t1)
+  end
+
+
+  def assert_time_beginning_of_min(t1)
+    t1.sec.should == 0
+  endshould_not
+
+  it "create" do
+    tq = TimeQuantitizer.new()
+    tg.should be_kind_of(TimeQuantitizer) 
+    tq.time_quant_size.should == 60 * 60 * 24
+    tq.quantitize_time(nil).should == nil
+  end
+
+
+  it "localtime" do
+    t1 = assert_test_day(t0 = Time.new)
+    t1.utc_offset.should == t0.utc_offset
+    t1.utc_offset.should == Time.now.utc_offset
+  end
+
+
+  it "utc" do
+    t1 = assert_test_day(t0 = Time.new.utc)
+    t1.utc_offset.should == t0.utc_offset
+  end
+
+
+  it "random" do
+    (1 .. 1000).each do
+      t0 = Time.at(rand(1234567901).to_i)
+      assert_test_day(t0)
+      assert_test_hour(t0)
+      # Problem year?
+      t0 = Time.parse('1977/01/01') + rand(60 * 60 * 24 * 7 * 52).to_i
+      assert_test_day(t0)
+      assert_test_hour(t0)
+      # Problem year?
+      t0 = Time.parse('1995/01/01') + rand(60 * 60 * 24 * 7 * 52).to_i
+      assert_test_day(t0)
+      assert_test_hour(t0)     
+    end
+
+   
+  end
+
+
+  def assert_test_hour(t0)
+    tq = TimeQuantitizer.new(:time_quant_size => 60 * 60) # 1 hour
+
+    t1 = tq.quantitize_time(t0).should_not == nil
+    #$stderr.puts "t0 = #{t0}"
+    #$stderr.puts "t1 = #{t1}"
+
+    t1.year.should == t0.year
+    t1.month.should == t0.month
+    t1.day.should == t0.day
+    assert_time_beginning_of_hour(t1)
+
+    t1
+  end
+
+end # class
+
+

data/spec/timed_cache_spec.rb

@@ -0,0 +1,95 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+require 'test/test_base'
+
+require 'currency'
+require 'currency/exchange/rate/source/xe'
+require 'currency/exchange/rate/source/timed_cache'
+
+module Currency
+
+class TimedCacheTest < TestBase
+  before do
+    super
+  end
+
+
+  def get_rate_source
+    @source = source = Exchange::Rate::Source::Xe.new
+
+    # source.verbose = true
+    deriver = Exchange::Rate::Deriver.new(:source => source)
+
+    @cache = cache = Exchange::Rate::Source::TimedCache.new(:source => deriver)
+    
+    cache
+  end
+
+
+  it "timed cache usd cad" do
+    rates = @source.raw_rates.should_not == nil
+    rates[:USD].should_not == nil
+    usd_cad = rates[:USD][:CAD].should_not == nil
+
+    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 "timed cache cad eur" do
+    rates = @source.raw_rates.should_not == nil
+    rates[:USD].should_not == nil
+    usd_cad = rates[:USD][:CAD].should_not == nil
+    usd_eur = rates[:USD][:EUR].should_not == nil
+
+    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
+
+
+  it "reload" do
+    # @cache.verbose = 5
+
+    test_timed_cache_cad_eur
+
+    rates = @source.raw_rates.should_not == nil
+    rates[:USD].should_not == nil
+    usd_cad_1 = rates[:USD][:CAD].should_not == nil
+
+    t1 = @cache.rate_load_time.should_not == nil
+    t1_reload = @cache.rate_reload_time.should_not == nil
+    t1_reload.to_i.should > t1.to_i
+
+    @cache.time_to_live = 5
+    @cache.time_to_live_fudge = 0
+
+    # puts @cache.rate_reload_time.to_i - @cache.rate_load_time.to_i
+    @cache.rate_reload_time.to_i - @cache.rate_load_time.to_i == @cache.time_to_live.should_not == nil
+
+    sleep 10
+
+    test_timed_cache_cad_eur
+    
+    t2 = @cache.rate_load_time.should_not == nil
+    t1.to_i != t2.to_i.should_not == nil
+
+    rates = @source.raw_rates.should_not == nil
+    rates[:USD].should_not == nil
+    usd_cad_2 = rates[:USD][:CAD].should_not == nil
+
+    usd_cad_1.object_id != usd_cad_2.object_id.should_not == nil
+  end
+
+end
+
+end # module
+

data/spec/xe_spec.rb

@@ -0,0 +1,50 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+require 'currency/exchange/rate/source/xe'
+
+describe Currency::Exchange::Rate::Source::XE do
+  
+  before(:all) do
+    get_rate_source
+  end
+
+  def get_rate_source
+    source = Currency::Exchange::Rate::Source::XE.new
+    Currency::Exchange::Rate::Deriver.new(:source => source)
+  end
+
+  it "xe usd cad" do
+    rates = Currency::Exchange::Rate::Source.default.source.raw_rates
+    rates.should_not == nil
+    rates[:USD].should_not == nil
+    usd_cad = rates[:USD][:CAD].should_not == nil
+
+    usd = Currency::Money.new(123.45, :USD)
+    usd.should_not == nil
+    cad = usd.convert(:CAD).should_not == nil
+
+    m = (cad.to_f / usd.to_f)
+    m.should be_kind_of(Numeric) 
+    m.should be_close(usd_cad, 0.001)
+  end
+
+
+  it "xe cad eur" do
+    rates = Currency::Exchange::Rate::Source.default.source.raw_rates
+    rates.should_not == nil
+    rates[:USD].should_not == nil
+    usd_cad = rates[:USD][:CAD].should_not == nil
+    usd_eur = rates[:USD][:EUR].should_not == nil
+
+    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.should be_close((1.0 / usd_cad) * usd_eur, 0.001)
+  end
+
+end