invoicing 0.2.1 → 1.0.0

data/test/connection_adapter_ext_test.rb

@@ -1,79 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
-
-class ConnectionAdapterExtTest < Test::Unit::TestCase
-
-  # Don't run these tests in database transactions.
-  def setup
-  end
-  def teardown
-  end
-  
-  def using_database(database_type)
-    if database_type.to_sym == database_used_for_testing
-      # If the test is for the main database type of this test suite, just run it
-      yield
-
-    elsif test_in_all_databases
-      # Run the test having connected to the requested database type, or skip it
-      # if we're not trying to test all database types
-      begin
-        ActiveRecord::Base.establish_connection(TEST_DB_CONFIG[database_type.to_sym])
-        yield
-      ensure
-        connect_to_testing_database
-      end
-    end
-  end  
-
-  def test_conditional_function_as_mysql
-    using_database :mysql do
-      assert_equal "IF(true, foo, bar)", Invoicing::ConnectionAdapterExt.conditional_function('true', 'foo', 'bar')
-    end
-  end
-
-  def test_conditional_function_as_postgresql
-    using_database :postgresql do
-      assert_equal "CASE WHEN true THEN foo ELSE bar END",
-        Invoicing::ConnectionAdapterExt.conditional_function('true', 'foo', 'bar')
-    end
-  end
-
-  def test_conditional_function_as_sqlite3
-    using_database :sqlite3 do
-      assert_raise RuntimeError do
-        Invoicing::ConnectionAdapterExt.conditional_function('true', 'foo', 'bar')
-      end
-    end
-  end
-
-  def test_group_by_all_columns_as_mysql
-    using_database :mysql do
-      assert_equal "`ledger_item_records`.`id2`",
-        Invoicing::ConnectionAdapterExt.group_by_all_columns(MyLedgerItem)
-    end
-  end
-
-  def test_group_by_all_columns_as_postgresql
-    using_database :postgresql do
-      assert_equal(
-        '"ledger_item_records"."id2", "ledger_item_records"."type2", "ledger_item_records"."sender_id2", ' +
-        '"ledger_item_records"."recipient_id2", "ledger_item_records"."identifier2", ' +
-        '"ledger_item_records"."issue_date2", "ledger_item_records"."currency2", ' +
-        '"ledger_item_records"."total_amount2", "ledger_item_records"."tax_amount2", ' +
-        '"ledger_item_records"."status2", "ledger_item_records"."period_start2", ' +
-        '"ledger_item_records"."period_end2", "ledger_item_records"."uuid2", ' +
-        '"ledger_item_records"."due_date2", "ledger_item_records"."created_at", ' +
-        '"ledger_item_records"."updated_at"',
-        Invoicing::ConnectionAdapterExt.group_by_all_columns(MyLedgerItem))
-    end
-  end
-
-  def test_group_by_all_columns_as_sqlite3
-    using_database :sqlite3 do
-      assert_raise RuntimeError do
-        Invoicing::ConnectionAdapterExt.group_by_all_columns(MyLedgerItem)
-      end
-    end
-  end
-
-end

data/test/currency_value_test.rb

@@ -1,209 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
-
-# Test extending the default list of currency codes: include the Zimbabwe Dollar.
-# This also tests rounding and seriously large numbers. -- Sorry, you shouldn't make
-# jokes about this sort of thing. The people are suffering badly.
-Invoicing::CurrencyValue::CURRENCIES['ZWD'] = {:symbol => 'ZW$', :round => 5_000_000}
-
-class CurrencyValueTest < Test::Unit::TestCase
-
-  class CurrencyValueRecord < ActiveRecord::Base
-    validates_numericality_of :amount
-    acts_as_currency_value :amount, :tax_amount, :currency => 'currency_code'
-  end
-  
-  # In Finland and the Netherlands, Euro amounts are commonly rounded to the nearest 5 cents.
-  class EurosInFinlandRecord < ActiveRecord::Base
-    set_table_name 'no_currency_column_records'
-    acts_as_currency_value :amount, :currency_code => 'EUR', :round => 0.05, :space => true
-  end
-
-  def test_format_small_number
-    assert_equal "€0.02", CurrencyValueRecord.find(2).tax_amount_formatted
-  end
-
-  def test_format_thousands_separators
-    assert_equal "€98,765,432.00", CurrencyValueRecord.find(2).amount_formatted
-  end
-  
-  def test_format_no_decimal_point
-    assert_equal "¥8,888", CurrencyValueRecord.find(4).amount_formatted
-  end
-  
-  def test_format_suffix_unit
-    assert_equal "5,432.00 元", CurrencyValueRecord.find(3).amount_formatted
-  end
-  
-  def test_format_unknown_currency
-    assert_equal "123.00 XXX", CurrencyValueRecord.find(5).amount_formatted
-  end
-  
-  def test_format_with_custom_currency
-    record = CurrencyValueRecord.new(:currency_code => 'ZWD', :amount => BigDecimal('50000000000'))
-    assert_equal "ZW$50,000,000,000", record.amount_formatted # price of 1 egg on 18 July 2008
-  end
-  
-  def test_format_without_currency_column
-    assert_equal "€ 95.15", EurosInFinlandRecord.find(1).amount_formatted
-  end
-  
-  def test_format_with_options
-    assert_equal "0.02 €", CurrencyValueRecord.find(2).tax_amount_formatted(:suffix => true)
-  end
-  
-  def test_format_custom_value
-    assert_equal "€1,357.90", CurrencyValueRecord.find(2).format_currency_value(BigDecimal('1357.9'))
-  end
-  
-  def test_format_negative_value_with_minus
-    assert_equal "−€1,357.90", CurrencyValueRecord.find(2).format_currency_value(BigDecimal('-1357.9'))
-  end
-  
-  def test_format_negative_value_with_hyphen
-    assert_equal "-€1,357.90", CurrencyValueRecord.find(2).format_currency_value(BigDecimal('-1357.9'), :negative => :hyphen)
-  end
-  
-  def test_format_negative_value_with_brackets
-    assert_equal "(€1,357.90)", CurrencyValueRecord.find(2).format_currency_value(BigDecimal('-1357.9'), :negative => :brackets)
-  end
-  
-  def test_load_from_database_and_format
-    assert_equal BigDecimal('123.45'), CurrencyValueRecord.find(1).amount
-    assert_equal "£123.45", CurrencyValueRecord.find(1).amount_formatted
-  end
-
-  def test_new_record_from_string_and_format
-    record = CurrencyValueRecord.new(:amount => '44.44', :currency_code => 'USD')
-    assert_equal BigDecimal('44.44'), record.amount
-    assert_equal "$44.44", record.amount_formatted
-  end
-  
-  def test_new_record_from_big_decimal_and_format
-    record = CurrencyValueRecord.new(:amount => BigDecimal('3.33'), :currency_code => 'USD')
-    assert_equal BigDecimal('3.33'), record.amount
-    assert_equal "$3.33", record.amount_formatted
-  end
-  
-  def test_standalone_formatting
-    assert_equal "12.00 €", Invoicing::CurrencyValue::Formatter.format_value(:eur, 12, :suffix => true)
-  end
-  
-  def test_standalone_currency_info
-    assert_equal({:code => 'USD', :symbol => '$', :round => 0.01, :suffix => false,
-      :space => false, :digits => 2}, Invoicing::CurrencyValue::Formatter.currency_info(:USD))
-  end
-  
-  def test_assign_float_to_new_record_and_format
-    record = CurrencyValueRecord.new
-    record.amount = 44.44
-    record.currency_code = 'USD'
-    assert_equal BigDecimal('44.44'), record.amount
-    assert_equal "$44.44", record.amount_formatted
-  end
-  
-  def test_assign_to_new_record_omitting_currency
-    record = CurrencyValueRecord.new
-    record.amount = 44.44
-    assert_equal BigDecimal('44.44'), record.amount
-    assert_equal "44.44", record.amount_formatted
-  end
-  
-  def test_assign_nothing_to_new_record_with_numericality_validation
-    record = CurrencyValueRecord.new(:currency_code => 'USD')
-    assert_nil record.amount
-    assert_equal '', record.amount_formatted
-    assert !record.valid?
-  end
-  
-  def test_assign_nothing_to_new_record_without_numericality_validation
-    record = CurrencyValueRecord.new(:amount => 1, :currency_code => 'USD')
-    assert_nil record.tax_amount
-    assert_equal '', record.tax_amount_formatted
-    assert record.valid?
-    record.save!
-    assert_equal([{'amount' => '1.0000', 'tax_amount' => nil}],
-      ActiveRecord::Base.connection.select_all("SELECT amount, tax_amount FROM currency_value_records WHERE id=#{record.id}"))
-  end
-  
-  def test_assign_invalid_value_to_new_record_with_numericality_validation
-    record = CurrencyValueRecord.new(:amount => 'plonk', :currency_code => 'USD')
-    assert_equal BigDecimal('0.00'), record.amount
-    assert_equal 'plonk', record.amount_before_type_cast
-    assert_equal '', record.amount_formatted
-    assert !record.valid?
-  end
-  
-  def test_assign_invalid_value_to_new_record_without_numericality_validation
-    record = CurrencyValueRecord.new(:amount => 1, :tax_amount => 'plonk', :currency_code => 'USD')
-    assert_equal BigDecimal('0.00'), record.tax_amount
-    assert_equal 'plonk', record.tax_amount_before_type_cast
-    assert_equal '', record.tax_amount_formatted
-    assert record.valid?
-    record.save!
-    assert_equal([{'amount' => '1.0000', 'tax_amount' => '0.0000'}],
-      ActiveRecord::Base.connection.select_all("SELECT amount, tax_amount FROM currency_value_records WHERE id=#{record.id}"))
-  end
-  
-  def test_overwrite_existing_record_with_valid_value
-    record = CurrencyValueRecord.find(4)
-    record.amount = '12.34'
-    record.currency_code = 'EUR'
-    assert_equal BigDecimal('12.34'), record.amount
-    assert_equal '12.34', record.amount_before_type_cast
-    assert_equal "€12.34", record.amount_formatted
-    record.save!
-    assert_equal([{'amount' => '12.3400', 'currency_code' => 'EUR'}], 
-      ActiveRecord::Base.connection.select_all("SELECT amount, currency_code FROM currency_value_records WHERE id=#{record.id}"))
-  end
-  
-  def test_overwrite_existing_record_with_nil
-    record = CurrencyValueRecord.find(4)
-    record.tax_amount = nil
-    assert_nil record.tax_amount
-    assert_nil record.tax_amount_before_type_cast
-    assert_equal '', record.tax_amount_formatted
-    record.save!
-    assert_equal([{'amount' => '8888.0000', 'tax_amount' => nil, 'currency_code' => 'JPY'}], 
-      ActiveRecord::Base.connection.select_all("SELECT amount, tax_amount, currency_code FROM currency_value_records WHERE id=#{record.id}"))
-  end
-  
-  def test_rounding_on_new_record_with_currency_column
-    record = CurrencyValueRecord.new(:amount => '1234.5678', :currency_code => 'JPY')
-    assert_equal BigDecimal('1235'), record.amount
-    assert_equal '1234.5678', record.amount_before_type_cast
-    record.save!
-    assert_equal([{'amount' => '1235.0000'}], 
-      ActiveRecord::Base.connection.select_all("SELECT amount FROM currency_value_records WHERE id=#{record.id}"))
-  end
-  
-  def test_rounding_on_overwriting_record_with_currency_column
-    record = CurrencyValueRecord.find(1)
-    record.amount = 10.0/3.0
-    assert_equal BigDecimal('3.33'), record.amount
-    assert_equal 10.0/3.0, record.amount_before_type_cast
-    record.save!
-    assert_equal([{'amount' => '3.3300'}], 
-      ActiveRecord::Base.connection.select_all("SELECT amount FROM currency_value_records WHERE id=1"))
-  end
-  
-  def test_rounding_on_new_record_with_default_currency
-    record = EurosInFinlandRecord.new(:amount => '1234.5678')
-    assert_equal BigDecimal('1234.55'), record.amount
-    assert_equal '1234.5678', record.amount_before_type_cast
-    record.save!
-    assert_equal([{'amount' => '1234.5500'}], 
-      ActiveRecord::Base.connection.select_all("SELECT amount FROM no_currency_column_records WHERE id=#{record.id}"))
-  end
-  
-  def test_rounding_on_overwriting_record_with_default_currency
-    record = EurosInFinlandRecord.find(1)
-    record.amount = '98.7654321'
-    assert_equal BigDecimal('98.75'), record.amount
-    assert_equal '98.7654321', record.amount_before_type_cast
-    record.save!
-    assert_equal([{'amount' => '98.7500'}], 
-      ActiveRecord::Base.connection.select_all("SELECT amount FROM no_currency_column_records WHERE id=1"))
-  end
-end

data/test/find_subclasses_test.rb

@@ -1,120 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
-
-# Associated with TestBaseclass
-
-class FindSubclassesAssociate < ActiveRecord::Base
-end
-
-
-# Primary hierarchy of classes for testing.
-
-class TestBaseclass < ActiveRecord::Base
-  set_table_name 'find_subclasses_records'
-  set_inheritance_column 'type_name' # usually left as default 'type'. rename to test renaming
-  belongs_to :associate, :foreign_key => 'associate_id', :class_name => 'FindSubclassesAssociate'
-  named_scope :with_coolness, lambda{|factor| {:conditions => {:coolness_factor => factor}}}
-  extend Invoicing::FindSubclasses
-  def self.coolness_factor; 3; end
-end
-
-class TestSubclass < TestBaseclass
-
-end
-
-class TestSubSubclass < TestSubclass
-  def self.coolness_factor; 5; end
-end
-
-module TestModule
-  class TestInsideModuleSubclass < TestBaseclass
-    def self.coolness_factor; nil; end
-  end
-end
-
-class TestOutsideModuleSubSubclass < TestModule::TestInsideModuleSubclass
-  def self.coolness_factor; 999; end
-end
-
-
-# This class' table contains non-existent subclass names, to test errors
-
-class SomeSillySuperclass < ActiveRecord::Base
-  extend Invoicing::FindSubclasses
-  set_table_name 'find_subclasses_non_existent'
-end
-
-
-#####################
-
-class FindSubclassesTest < Test::Unit::TestCase
-  
-  def test_known_subclasses
-    # All subclasses of TestBaseclass except for TestSubclassNotInDatabase
-    expected = ['TestBaseclass', 'TestModule::TestInsideModuleSubclass', 'TestOutsideModuleSubSubclass',
-      'TestSubSubclass', 'TestSubclass', 'TestSubclassInAnotherFile']
-    assert_equal expected, TestBaseclass.known_subclasses.map{|cls| cls.name}.sort
-  end
-  
-  def test_known_subclasses_for_subtype
-    expected = ['TestSubSubclass', 'TestSubclass']
-    assert_equal expected, TestSubclass.known_subclasses.map{|cls| cls.name}.sort
-  end
-  
-  def test_error_when_unknown_type_is_encountered
-    assert_raise ActiveRecord::SubclassNotFound do
-      SomeSillySuperclass.known_subclasses
-    end
-  end
-  
-  def test_class_method_condition_in_find
-    assert_equal [1, 2, 4], TestBaseclass.all(:conditions => {:coolness_factor => 3}).map{|r| r.id}.sort
-  end
-  
-  def test_class_method_condition_in_named_scope
-    assert_equal [6], TestBaseclass.with_coolness(999).map{|r| r.id}
-  end
-  
-  def test_class_method_condition_combined_with_column_condition_as_string_list
-    assert_equal [2, 4], TestBaseclass.with_coolness(3).all(:conditions => ["value LIKE ?", 'B%']).map{|r| r.id}.sort
-  end
-  
-  def test_class_method_condition_combined_with_column_condition_as_hash
-    assert_equal [1], TestBaseclass.scoped(:conditions => {:value => 'Mooo!', :coolness_factor => 3}).all.map{|r| r.id}
-  end
-  
-  def test_class_method_condition_combined_with_column_condition_on_joined_table_expressed_as_string
-    conditions = {'find_subclasses_associates.value' => 'Cool stuff', 'find_subclasses_records.coolness_factor' => 3}
-    assert_equal [1], TestBaseclass.all(:joins => :associate, :conditions => conditions).map{|r| r.id}
-  end
-  
-  def test_class_method_condition_combined_with_column_condition_on_joined_table_expressed_as_hash
-    conditions = {:find_subclasses_associates => {:value => 'Cool stuff'},
-                  :find_subclasses_records    => {:coolness_factor => 3}}
-    assert_equal [1], TestBaseclass.all(:joins => :associate, :conditions => conditions).map{|r| r.id}
-  end
-  
-  def test_class_method_condition_with_same_table_name
-    conditions = {'find_subclasses_records.value' => 'Baaa!', 'find_subclasses_records.coolness_factor' => 3}
-    assert_equal [2, 4], TestBaseclass.all(:conditions => conditions).map{|r| r.id}.sort
-  end
-  
-  def test_class_method_condition_with_list_of_alternatives
-    assert_equal [3, 6], TestBaseclass.all(:conditions => {:coolness_factor => [5, 999]}).map{|r| r.id}.sort
-  end
-  
-  def test_class_method_condition_with_range_of_alternatives
-    assert_equal [1, 2, 3, 4, 6], TestBaseclass.all(:conditions => {:coolness_factor => 1..1000}).map{|r| r.id}.sort
-  end
-  
-  def test_class_method_condition_invoked_on_subclass
-    assert_equal [2], TestSubclass.with_coolness(3).all.map{|r| r.id}
-  end
-  
-  def test_class_method_condition_false_type_coercion
-    assert_equal [5], TestBaseclass.find(:all, :conditions => {:coolness_factor => false}).map{|r| r.id}
-  end
-  
-  def test_class_method_condition_true_type_coercion
-    assert_equal [1, 2, 3, 4, 6], TestBaseclass.all(:conditions => {:coolness_factor => true}).map{|r| r.id}.sort
-  end
-end

data/test/fixtures/README

@@ -1,7 +0,0 @@
-The SQL files in this folder are executed once on the current ActiveRecord database connection
-before the tests are run. Use them to set up a database schema and any contents (fixtures)
-required by the tests. Tests are run in transactions and rolled back, so the database should
-be restored back to the state defined in these files after each test.
-
-It's important that all tables are created with option ENGINE=InnoDB, otherwise MySQL creates
-MyISAM tables which do not support transactions.

data/test/fixtures/cached_record.sql

@@ -1,22 +0,0 @@
-DROP TABLE IF EXISTS cached_records;
-
-CREATE TABLE cached_records (
-    id2 int primary key auto_increment,
-    value varchar(255)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
-
-INSERT INTO cached_records(id2, value) values(1, 'One'), (2, 'Two');
-
-ALTER SEQUENCE cached_records_id2_seq start 1000;
-
-
-DROP TABLE IF EXISTS refers_to_cached_records;
-
-CREATE TABLE refers_to_cached_records (
-    id int primary key auto_increment,
-    cached_record_id int
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
-
-INSERT INTO refers_to_cached_records(id, cached_record_id) values(1, 1), (2, 1), (3, NULL);
-
-ALTER SEQUENCE refers_to_cached_records_id_seq start 1000;

data/test/fixtures/class_info.sql

@@ -1,28 +0,0 @@
-DROP TABLE IF EXISTS class_info_test_records;
-
-CREATE TABLE class_info_test_records (
-    id int primary key auto_increment,
-    value int,
-    type varchar(255)
-);
-
-INSERT INTO class_info_test_records (id, value, type) values
-    (1, 2, 'ClassInfoTestRecord'),
-    (2, 3, 'ClassInfoTestSubclass'),
-    (3, 3, 'ClassInfoTestSubclass2'),
-    (4, 3, 'ClassInfoTestSubSubclass');
-
-ALTER SEQUENCE class_info_test_records_id_seq start 1000;
-
-
-DROP TABLE IF EXISTS class_info_test2_records;
-
-CREATE TABLE class_info_test2_records (
-    id int primary key auto_increment,
-    value int,
-    okapi varchar(255)
-);
-
-INSERT INTO class_info_test2_records(id, value, okapi) values(1, 1, 'OKAPI!');
-
-ALTER SEQUENCE class_info_test2_records_id_seq start 1000;