invoicing 0.1.0

data/lib/invoicing/version.rb

@@ -0,0 +1,21 @@
+module Invoicing
+  module Version
+    MAJOR   = 0
+    MINOR   = 1
+    BUILD   = 0
+
+    def to_a 
+      [MAJOR, MINOR, BUILD]
+    end
+
+    def to_s
+      to_a.join(".")
+    end
+
+    module_function :to_a
+    module_function :to_s
+
+    STRING = Version.to_s
+  end
+  VERSION = Version.to_s
+end

data/test/cached_record_test.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class CachedRecordTest < Test::Unit::TestCase
+    
+  class CachedRecord < ActiveRecord::Base
+    set_primary_key 'id2'
+    acts_as_cached_record :id => 'id2'
+    has_many :referrers, :class_name => 'RefersToCachedRecord', :foreign_key => 'cached_record_id'
+  end
+  
+  class RefersToCachedRecord < ActiveRecord::Base
+    belongs_to :cached_record
+  end
+  
+  class CachedRecordMockDatabase < ActiveRecord::Base
+    set_table_name 'cached_records'
+    set_primary_key 'id2'
+    acts_as_cached_record :id => 'id2'
+    
+    def self.connection
+      @connection_mock ||= FlexMock.new('connection')
+    end
+  end
+  
+  
+  def test_find_with_valid_id_should_return_record
+    record = CachedRecord.find(1)
+    assert_not_nil record
+    assert record.kind_of?(CachedRecord)
+  end
+  
+  def test_find_with_invalid_id_should_raise_exception
+    assert_raise ActiveRecord::RecordNotFound do
+      CachedRecord.find(99)
+    end
+  end
+  
+  def test_find_with_valid_id_should_not_access_database
+    CachedRecordMockDatabase.connection.should_receive(:select).and_throw('should not access database')
+    assert_not_nil CachedRecordMockDatabase.find(1)
+  end
+  
+  def test_find_with_invalid_id_should_not_access_database
+    CachedRecordMockDatabase.connection.should_receive(:select).and_throw('should not access database')
+    assert_raise ActiveRecord::RecordNotFound do
+      CachedRecordMockDatabase.find(99)
+    end
+  end
+  
+  def test_find_with_conditions_should_still_work
+    assert_equal CachedRecord.find_by_value('Two'), CachedRecord.find(2)
+  end
+  
+  def test_find_with_conditions_should_not_use_the_cache
+    assert !CachedRecord.find_by_value('Two').equal?(CachedRecord.find(2))    
+  end
+  
+  def test_find_without_ids_should_raise_exception
+    assert_raise ActiveRecord::RecordNotFound do
+      CachedRecord.find
+    end
+  end
+  
+  def test_find_with_empty_list_of_ids_should_raise_exception
+    assert_raise ActiveRecord::RecordNotFound do
+      CachedRecord.find(:conditions => {:id => []})
+    end
+  end
+  
+  def test_find_with_list_of_ids_should_return_list_of_objects
+    expected = CachedRecord.cached_record_list.sort{|r1, r2| r1.id - r2.id}
+    assert_equal expected, CachedRecord.find([1,2])
+  end
+  
+  def test_cached_record_associations_should_still_work
+    assert_equal 2, CachedRecord.find(1).referrers.length
+  end
+  
+  def test_foreign_key_to_cached_record_should_use_cache
+    assert RefersToCachedRecord.find(1).cached_record.equal?(CachedRecord.find(1))
+  end
+  
+  def test_cached_record_list_should_return_all_objects
+    assert_equal 2, CachedRecord.cached_record_list.length
+  end
+  
+  def test_cached_record_list_should_not_access_database
+    CachedRecordMockDatabase.connection.should_receive(:select).and_throw('should not access database')
+    assert_not_nil CachedRecordMockDatabase.cached_record_list
+  end
+  
+  def test_reload_cache_should_do_what_it_says_on_the_tin
+    CachedRecord.connection.execute "insert into cached_records (id2, value) values(3, 'Three')"
+    CachedRecord.reload_cache
+    record = CachedRecord.find(3)
+    assert_not_nil record
+    assert record.kind_of?(CachedRecord)
+    assert_equal 3, CachedRecord.cached_record_list.length    
+  end
+end

data/test/class_info_test.rb

@@ -0,0 +1,253 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+# Mini implementation of the ClassInfo pattern, at which we can fire our tests
+
+module MyNamespace
+  module ClassInfoTestModule
+    module ActMethods
+      def acts_as_class_info_test(*args)
+        Invoicing::ClassInfo.acts_as(MyNamespace::ClassInfoTestModule, self, args)
+      end
+    end
+    
+    def get_class_info
+      class_info_test_module_class_info
+    end
+    
+    def my_instance_method
+      class_info_test_module_class_info.the_answer / value
+    end
+    
+    def my_other_instance_method
+      class_info_test_module_class_info.not_the_answer / value
+    end
+    
+    module ClassMethods
+      def my_class_method(number)
+        class_info_test_module_class_info.the_answer / number
+      end
+      
+      def my_other_class_method(number)
+        class_info_test_module_class_info.not_the_answer / number
+      end
+      
+      def get_class_info
+        class_info_test_module_class_info
+      end
+    end
+    
+    class ClassInfo < Invoicing::ClassInfo::Base
+      def foo
+        'foo'
+      end
+      
+      def the_answer
+        all_args.first
+      end
+      
+      def not_the_answer
+        all_args.last
+      end
+      
+      def option_defaults
+        {:option1 => :baa, :option2 => :blah}
+      end
+    end
+  end
+
+
+  module ClassInfoTest2
+    module ActMethods
+      def acts_as_class_info_test2(*args)
+        Invoicing::ClassInfo.acts_as(MyNamespace::ClassInfoTest2, self, args)
+      end
+    end
+    
+    module ClassMethods
+      def test2_class_info
+        class_info_test2_class_info
+      end
+    end
+    
+    class ClassInfo < Invoicing::ClassInfo::Base
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, MyNamespace::ClassInfoTestModule::ActMethods)
+ActiveRecord::Base.send(:extend, MyNamespace::ClassInfoTest2::ActMethods)
+
+
+# Model objects which use the acts_as feature defined above
+
+class ClassInfoTestRecord < ActiveRecord::Base
+  acts_as_class_info_test 42, :option1 => :moo
+  acts_as_class_info_test 84, 42, 168, :option3 => :asdf
+  
+  def self.class_foo
+    class_info_test_module_class_info.foo
+  end
+  
+  def instance_foo
+    class_info_test_module_class_info.foo
+  end
+end
+
+class ClassInfoTestSubclass < ClassInfoTestRecord
+  acts_as_class_info_test 336, :option1 => :quack, :option4 => :fdsa
+end
+
+class ClassInfoTestSubclass2 < ClassInfoTestRecord
+  acts_as_class_info_test2 :option1 => :badger
+end
+
+class ClassInfoTestSubSubclass < ClassInfoTestSubclass2
+  acts_as_class_info_test 112, :option3 => 1234
+end
+
+class ClassInfoTestEmptySubclass < ClassInfoTestRecord
+end
+
+class ClassInfoTest2Record < ActiveRecord::Base
+  acts_as_class_info_test2 :option1 => :okapi, :option3 => :kangaroo
+  
+  def option1; 'this is option1'; end
+  def option2; 'this is option2'; end
+  def kangaroo; 'bounce'; end
+end
+
+
+#######################################################################################
+
+class ClassInfoTest < Test::Unit::TestCase
+  
+  def test_call_into_class_info_via_class
+    assert_equal 'foo', ClassInfoTestRecord.class_foo
+  end
+  
+  def test_call_into_class_info_via_instance
+    assert_equal 'foo', ClassInfoTestRecord.new.instance_foo
+  end
+
+  def test_mixin_superclass_instance_methods
+    assert_equal 21, ClassInfoTestRecord.find(1).my_instance_method
+    assert_equal 84, ClassInfoTestRecord.find(1).my_other_instance_method
+  end
+  
+  def test_mixin_superclass_class_methods
+    assert_equal 14, ClassInfoTestRecord.my_class_method(3)
+    assert_equal 28, ClassInfoTestRecord.my_other_class_method(6)
+  end
+  
+  def test_mixin_subclass_instance_methods
+    assert_equal 14, ClassInfoTestRecord.find(2).my_instance_method
+    assert_equal 112, ClassInfoTestRecord.find(2).my_other_instance_method
+  end
+  
+  def test_mixin_subclass_class_methods
+    assert_equal 14, ClassInfoTestSubclass.my_class_method(3)
+    assert_equal 56, ClassInfoTestSubclass.my_other_class_method(6)
+  end
+  
+  def test_all_args_in_superclass
+    assert_equal [42, 84, 168], ClassInfoTestRecord.get_class_info.all_args
+  end
+  
+  def test_all_args_in_subclass
+    assert_equal [42, 84, 168, 336], ClassInfoTestSubclass.get_class_info.all_args
+  end
+  
+  def test_all_args_in_sub_subclass
+    assert_equal [42, 84, 168, 112], ClassInfoTestSubSubclass.get_class_info.all_args
+  end
+  
+  def test_current_args_in_superclass
+    assert_equal [84, 42, 168], ClassInfoTestRecord.get_class_info.current_args
+  end
+  
+  def test_current_args_in_subclass
+    assert_equal [336], ClassInfoTestSubclass.get_class_info.current_args
+  end
+  
+  def test_current_args_in_sub_subclass
+    assert_equal [112], ClassInfoTestSubSubclass.get_class_info.current_args
+  end
+  
+  def test_new_args_in_superclass
+    assert_equal [84, 168], ClassInfoTestRecord.get_class_info.new_args
+  end
+  
+  def test_new_args_in_subclass
+    assert_equal [336], ClassInfoTestSubclass.get_class_info.new_args
+  end
+  
+  def test_new_args_in_sub_subclass
+    assert_equal [112], ClassInfoTestSubSubclass.get_class_info.new_args
+  end
+  
+  def test_all_options_in_superclass
+    assert_equal :moo,   ClassInfoTestRecord.get_class_info.all_options[:option1]
+    assert_equal :blah,  ClassInfoTestRecord.get_class_info.all_options[:option2]
+    assert_equal :asdf,  ClassInfoTestRecord.get_class_info.all_options[:option3]
+    assert_nil           ClassInfoTestRecord.get_class_info.all_options[:option4]
+  end
+  
+  def test_all_options_in_subclass
+    assert_equal :quack, ClassInfoTestSubclass.get_class_info.all_options[:option1]
+    assert_equal :blah,  ClassInfoTestSubclass.get_class_info.all_options[:option2]
+    assert_equal :asdf,  ClassInfoTestSubclass.get_class_info.all_options[:option3]
+    assert_equal :fdsa,  ClassInfoTestSubclass.get_class_info.all_options[:option4]
+  end
+  
+  def test_all_options_in_sub_subclass
+    assert_equal :moo,   ClassInfoTestSubSubclass.get_class_info.all_options[:option1]
+    assert_equal :blah,  ClassInfoTestSubSubclass.get_class_info.all_options[:option2]
+    assert_equal 1234,   ClassInfoTestSubSubclass.get_class_info.all_options[:option3]
+    assert_nil           ClassInfoTestSubSubclass.get_class_info.all_options[:option4]
+  end
+  
+  def test_current_options_in_superclass
+    assert_equal({:option3 => :asdf}, ClassInfoTestRecord.get_class_info.current_options)
+  end
+  
+  def test_current_options_in_subclass
+    assert_equal({:option1 => :quack, :option4 => :fdsa}, ClassInfoTestSubclass.get_class_info.current_options)
+  end
+  
+  def test_two_features_in_the_same_model
+    assert_equal({:option1 => :badger}, ClassInfoTestSubclass2.test2_class_info.all_options)
+    assert_equal({:option1 => :badger}, ClassInfoTestSubSubclass.test2_class_info.all_options)
+  end
+  
+  def test_the_same_feature_in_two_models
+    assert_equal({:option1 => :okapi, :option3 => :kangaroo}, ClassInfoTest2Record.test2_class_info.all_options)
+  end
+  
+  def test_method_renamed
+    assert_equal 'kangaroo', ClassInfoTest2Record.test2_class_info.method(:option3)
+    assert_equal 'bounce',   ClassInfoTest2Record.test2_class_info.get(ClassInfoTest2Record.find(1), :option3)
+  end
+
+  def test_database_column_renamed
+    assert_equal 'okapi',  ClassInfoTest2Record.test2_class_info.method(:option1)
+    assert_equal 'OKAPI!', ClassInfoTest2Record.test2_class_info.get(ClassInfoTest2Record.find(1), :option1)
+  end
+  
+  def test_method_not_renamed
+    assert_equal 'option2',         ClassInfoTest2Record.test2_class_info.method(:option2)
+    assert_equal 'this is option2', ClassInfoTest2Record.test2_class_info.get(ClassInfoTest2Record.find(1), :option2)
+  end
+  
+  def test_method_on_nil_object
+    assert_nil ClassInfoTest2Record.test2_class_info.get(nil, :option2)
+  end
+  
+  def test_method_not_found_via_class_info
+    assert_nil ClassInfoTest2Record.test2_class_info.get(ClassInfoTest2Record.find(1), :this_method_does_not_exist)
+  end
+  
+  def test_inherited_to_empty_subclass
+    assert_not_nil ClassInfoTestEmptySubclass.new.get_class_info
+    assert_equal ClassInfoTestEmptySubclass.new.get_class_info, ClassInfoTestRecord.new.get_class_info
+  end
+end

data/test/connection_adapter_ext_test.rb

@@ -0,0 +1,71 @@
+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)
+    begin
+      ActiveRecord::Base.establish_connection(TEST_DB_CONFIG[database_type.to_sym])
+      yield
+    ensure
+      connect_to_testing_database
+    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

@@ -0,0 +1,184 @@
+# 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_custom_value
+    assert_equal "€1,357.90", CurrencyValueRecord.find(2).format_currency_value(BigDecimal('1357.9'))
+  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_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