currency 0.3.3 → 0.4.0

data/test/ar_simple_test.rb

@@ -1,4 +1,7 @@
-require 'test/ar_test_base'
+# 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'
@@ -8,7 +11,7 @@ require 'currency/active_record'
 
 module Currency
 
-class ArSimpleTest < ArTestBase
+class ArSimpleTest < ArTestCore
 
   def test_simple
     insert_records

data/test/ar_test_base.rb

@@ -1,3 +1,6 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
 require 'test/test_base'
 require 'currency'
 
@@ -13,30 +16,6 @@ module Currency
 
 class ArTestBase < TestBase
 
-  ##################################################
-  # 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
-    money :amount
-  end 
-
   ##################################################
 
   def setup
@@ -44,31 +23,50 @@ class ArTestBase < TestBase
     AR_B.establish_connection(database_spec)
 
     # Subclasses can override this.
-    @currency_test_migration ||= CurrencyTestMigration 
-    @currency_test ||= CurrencyTest
+    @currency_test_migration ||= nil
+    @currency_test ||= nil
 
     # schema_down
 
     schema_up
   end
 
+
   def teardown
     super
     # schema_down
   end
 
+
   def database_spec
     # TODO: Get from ../config/database.yml:test
+    # Create test database on:
+
+    # MYSQL:
+    #
+    # sudo mysqladmin create test;
+    # sudo mysql
+    # grant all on test.* to test@localhost identified by 'test';
+    # flush privileges;
+
+    # POSTGRES:
+    #
+    # CREATE USER test PASSWORD 'test';
+    # CREATE DATABASE test WITH OWNER = test;
+    #
+
     @database_spec = {
-      :adapter  => "mysql",
-      :host     => "localhost",
-      :username => "test",
-      :password => "test",
-      :database => "test"
+      :adapter  => ENV['TEST_DB_ADAPTER'] || 'mysql',
+      :host     => ENV['TEST_DB_HOST']    || 'localhost',
+      :username => ENV['TEST_DB_USER']    || 'test',
+      :password => ENV['TEST_DB_PASS']    || 'test',
+      :database => ENV['TEST_DB_TEST']    || 'test'
     }
   end
 
+
   def schema_up
+    return unless @currency_test_migration
     begin
       @currency_test_migration.migrate(:up)
     rescue Object =>e
@@ -76,7 +74,9 @@ class ArTestBase < TestBase
     end
   end
 
+
   def schema_down
+    return unless @currency_test_migration
     begin
       @currency_test_migration.migrate(:down)
     rescue Object => e
@@ -84,6 +84,7 @@ class ArTestBase < TestBase
     end
   end
 
+
   ##################################################
   # Scaffold
   # 
@@ -100,12 +101,15 @@ class ArTestBase < TestBase
     @cad.save
   end
 
+
   def delete_records
     @currency_test.destroy_all
   end
 
+
   ##################################################
 
+
   def assert_equal_money(a,b)
     assert_not_nil a
     assert_not_nil b
@@ -121,8 +125,8 @@ class ArTestBase < TestBase
     assert_equal   a.amount.convert(b.amount.currency).rep, b.amount.rep
   end
 
-  def assert_equal_currency(a,b)
 
+  def assert_equal_currency(a,b)
     assert_equal_money a, b
 
     assert_equal   a.amount.rep, b.amount.rep
@@ -131,12 +135,14 @@ class ArTestBase < TestBase
 
   end
 
+
   ##################################################
   # 
   # 
+
   
   def test_dummy
-    insert_records
+    
   end
 
 end

data/test/ar_test_core.rb

@@ -0,0 +1,64 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+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 
+
+
+  ##################################################
+
+
+  def setup
+    @currency_test_migration ||= CurrencyTestMigration 
+    @currency_test           ||= CurrencyTest
+    super
+  end
+
+
+  def teardown
+    super
+    # schema_down
+  end
+
+
+  ##################################################
+  # 
+  # 
+  
+
+  def test_insert
+    insert_records
+  end
+
+end
+
+end # module
+

data/test/formatter_test.rb

@@ -0,0 +1,81 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+require 'test/test_base'
+require 'currency'
+
+module Currency
+
+class FormatterTest < TestBase
+  def setup
+    super
+  end
+
+  ############################################
+  # Simple stuff.
+  #
+
+  def test_default
+    assert_kind_of Money, m = ::Currency::Money.new_rep(123456789)
+    assert_equal m.currency, Currency.default
+    assert_equal m.currency.code, :USD
+    assert_equal "$1,234,567.89", m.to_s
+
+    m
+  end
+
+
+  def test_thousands
+    m = test_default
+    assert_equal "$1234567.89", m.to_s(:thousands => false)
+    assert_equal "$1,234,567.89", m.to_s(:thousands => true)
+
+    m
+  end
+
+
+  def test_cents
+    m = test_default
+    assert_equal "$1,234,567", m.to_s(:cents => false)
+    assert_equal "$1,234,567.89", m.to_s(:cents => true)
+
+    m
+  end
+
+
+  def test_symbol
+    m = test_default
+    assert_equal "1,234,567.89", m.to_s(:symbol => false)
+    assert_equal "$1,234,567.89", m.to_s(:symbol => true)
+
+    m
+  end
+
+
+  def test_code
+    m = test_default
+    assert_equal "$1,234,567.89", m.to_s(:code => false)
+    assert_equal "$1,234,567.89 USD", m.to_s(:code => true)
+
+    m
+  end
+
+  def test_misc
+    m = ::Currency::Money(12.45, :USD)
+    assert_equal "$12.45 <span class=\"currency_code\">USD</span>", 
+    m.to_s(:html => true, :code => true)
+
+    m = ::Currency::Money(12.45, :EUR)
+    assert_equal "&#8364;12.45 <span class=\"currency_code\">EUR</span>", 
+    m.to_s(:html => true, :code => true)
+
+    m = ::Currency::Money(12.45, :EUR)
+    assert_equal "&#8364;12.45 <span class=\"currency_code\">EUR</span>", 
+    m.to_s(:html => true, :code => true, :thousands_separator => '_')
+  end
+
+
+end
+
+end # module
+

data/test/historical_writer_test.rb

@@ -0,0 +1,184 @@
+# 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
+
+
+  def setup
+    super
+    
+  end
+
+  
+  def test_writer
+    assert_not_nil src = @src
+    assert_not_nil 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
+  end
+  
+
+  def writer_src
+    writer = test_writer
+    writer.source = @src
+    rates = writer.write_rates
+    assert_not_nil rates
+    assert rates.size > 0
+    assert 12, rates.size
+    assert_h_rates(rates, writer)
+  end
+
+
+  def writer_src2
+    writer = test_writer
+    writer.source = @src2
+    rates = writer.write_rates
+    assert_not_nil rates
+    assert rates.size > 0
+    assert_equal 12, rates.size
+    assert_h_rates(rates, writer)
+  end
+
+
+  def xxx_test_required_failure
+    assert_not_nil writer = Exchange::Rate::Source::Historical::Writer.new()
+    assert_not_nil src = @src
+    writer.source = src
+    writer.required_currencies = [ :USD, :GBP, :EUR, :CAD, :ZZZ ]
+    writer.preferred_currencies = writer.required_currencies
+    assert_raises(::RuntimeError) { writer.selected_rates }
+  end
+
+
+  def test_historical_rates
+    # 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
+    #$stderr.puts "historical rates = #{rates.inspect}"
+
+    rates = source.get_rates
+    #$stderr.puts "historical rates = #{rates.inspect}"
+    
+    assert_not_nil m_usd = ::Currency::Money('1234.56', :USD, :now)
+    #$stderr.puts "m_usd = #{m_usd.to_s(:code => true)}"
+    assert_not_nil m_eur = m_usd.convert(:EUR)
+    #$stderr.puts "m_eur = #{m_eur.to_s(:code => true)}"
+
+   end
+
+
+  def assert_h_rates(rates, writer = nil)
+    assert_not_nil hr0 = rates[0]
+    rates.each do | hr |
+      found_hr = nil
+      begin
+        assert_not_nil found_hr = hr.find_matching_this(:first)
+      rescue Object => err
+        raise "#{hr.inspect}: #{err}:\n#{err.backtrace.inspect}"
+      end
+
+      assert_not_nil hr0
+
+      assert_equal hr0.date, hr.date
+      assert_equal hr0.date_0, hr.date_0
+      assert_equal hr0.date_1, hr.date_1
+      assert_equal hr0.source, hr.source
+
+      assert_equal_rate(hr, found_hr)
+      assert_rate_defaults(hr, writer)
+    end
+  end
+
+
+  def assert_equal_rate(hr0, hr)
+    assert_equal hr0.c1.to_s, hr.c1.to_s
+    assert_equal hr0.c2.to_s, hr.c2.to_s
+    assert_equal hr0.source, hr.source
+    assert_equal_float hr0.rate, hr.rate
+    assert_equal_float hr0.rate_avg, hr.rate_avg
+    assert_equal hr0.rate_samples, hr.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
+    assert_equal hr0.date, hr.date
+    assert_equal hr0.date_0, hr.date_0
+    assert_equal hr0.date_1, hr.date_1
+    assert_equal hr0.derived, hr.derived
+  end
+
+
+  def assert_rate_defaults(hr, writer)
+    assert_equal writer.source.name, hr.source if writer
+    assert_equal hr.rate, hr.rate_avg
+    assert_equal hr.rate_samples, 1
+    assert_equal hr.rate, hr.rate_lo
+    assert_equal hr.rate, hr.rate_hi
+    assert_equal hr.rate, hr.rate_date_0
+    assert_equal hr.rate, hr.rate_date_1
+  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
+