active_scaffold 3.3.3 → 3.4.0

data/test/misc/calculation_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class ClassWithFinder
+  include ActiveScaffold::Finder
+  def conditions_for_collection; end
+  def conditions_from_params; end
+  def conditions_from_constraints; end
+  def joins_for_collection; end
+  def custom_finder_options
+    {}
+  end
+  def beginning_of_chain
+    active_scaffold_config.model
+  end
+  def conditional_get_support?; end
+  def params; {}; end
+end
+
+class CalculationTest < MiniTest::Test
+  def setup
+    @buildings = []
+    @buildings << Building.create {|b| b.create_owner(:first_name => 'foo')}
+    @buildings << Building.create(:name => 'foo bar')
+    @buildings << Building.create
+    
+    @klass = ClassWithFinder.new
+    @klass.stubs(:active_scaffold_config).returns(mock { stubs(:model).returns(Building) })
+    @klass.stubs(:active_scaffold_session_storage).returns({})
+  end
+  
+  def teardown
+    @buildings.each(&:destroy).map(&:owner).compact.each(&:destroy)
+  end
+
+  def test_calculation_with_conditions
+    @klass.expects(:conditions_for_collection).returns(['"buildings"."name" LIKE ? OR "people"."first_name" LIKE ?', '%foo%', '%foo%'])
+    @klass.expects(:active_scaffold_references).returns([:owner])
+    @klass.active_scaffold_config.expects(:list).returns(mock { stubs(:count_includes).returns(nil) })
+
+    column = mock { stubs(:field).returns('"buildings"."id"') }
+    @klass.active_scaffold_config.expects(:columns).returns(mock { stubs(:"[]").returns(column) })
+    query = @klass.send :calculate_query
+    assert_equal 2, query.count
+  end
+
+  def test_calculation_without_conditions
+    @klass.stubs(:active_scaffold_references).returns([:owner])
+    @klass.active_scaffold_config.expects(:list).returns(mock { stubs(:count_includes).returns(nil) })
+
+    column = mock { stubs(:field).returns('"buildings"."id"') }
+    @klass.active_scaffold_config.expects(:columns).returns(mock { stubs(:"[]").returns(column) })
+    query = @klass.send :calculate_query
+    assert_equal Building.count, query.count
+  end
+end

data/test/misc/configurable_test.rb

@@ -6,8 +6,15 @@ class ConfigurableClass
   def self.foo; FOO end
 end
 
+class IncludedClass < ConfigurableClass
+  include ActiveScaffold::Configurable
+end
+
+class ExtendedClass < ConfigurableClass
+  extend ActiveScaffold::Configurable
+end
 
-class ConfigurableTest < Test::Unit::TestCase
+class ConfigurableTest < MiniTest::Test
   ##
   ## constants and methods for tests to check against
   ##
@@ -15,19 +22,17 @@ class ConfigurableTest < Test::Unit::TestCase
   HELLO = 'world'
 
   def test_instance_configuration
-    ConfigurableClass.send :include, ActiveScaffold::Configurable
-
-    configurable_class = ConfigurableClass.new
+    configurable_class = IncludedClass.new
 
     ##
     ## sanity checks
     ##
     # make sure the configure method is available
-    assert ConfigurableClass.respond_to?(:configure)
+    assert configurable_class.respond_to?(:configure)
     # make sure real functions still work
     assert_equal 'bar', configurable_class.foo
     # make sure other functions still don't work
-    assert_raise NoMethodError do
+    assert_raises NoMethodError do
       configurable_class.i_do_not_exist
     end
 
@@ -52,45 +57,41 @@ class ConfigurableTest < Test::Unit::TestCase
   end
 
   def test_class_configuration
-    ConfigurableClass.send :extend, ActiveScaffold::Configurable
-
     ##
     ## sanity checks
     ##
     # make sure the configure method is available
-    assert ConfigurableClass.respond_to?(:configure)
+    assert ExtendedClass.respond_to?(:configure)
     # make sure real functions still work
-    assert_equal 'bar', ConfigurableClass.foo
+    assert_equal 'bar', ExtendedClass.foo
     # make sure other functions still don't work
-    assert_raise NoMethodError do
-      ConfigurableClass.i_do_not_exist
+    assert_raises NoMethodError do
+      ExtendedClass.i_do_not_exist
     end
 
     ##
     ## test normal block behaviors
     ##
     # functions
-    assert_equal hello, ConfigurableClass.configure {hello}
+    assert_equal hello, ExtendedClass.configure {hello}
     # variables
-    assert_equal ConfigurableClass, ConfigurableClass.configure {ConfigurableClass}
+    assert_equal ExtendedClass, ExtendedClass.configure {ExtendedClass}
     # constants
-    assert_equal ConfigurableTest::HELLO, ConfigurableClass.configure {ConfigurableTest::HELLO}
+    assert_equal ConfigurableTest::HELLO, ExtendedClass.configure {ConfigurableTest::HELLO}
 
     ##
     ## test extra "localized" block behavior
     ##
     # functions
-    assert_equal ConfigurableClass.foo, ConfigurableClass.configure {foo}
+    assert_equal ExtendedClass.foo, ExtendedClass.configure {foo}
     # constants - not working
-#    assert_equal ConfigurableClass.FOO, ConfigurableClass.configure {FOO}
+#    assert_equal ExtendedClass.FOO, ExtendedClass.configure {FOO}
   end
 
   def test_arity
-    ConfigurableClass.send :extend, ActiveScaffold::Configurable
-
     # this is the main style
-    assert_equal 'foo', ConfigurableClass.configure {'foo'}
+    assert_equal 'foo', ExtendedClass.configure {'foo'}
     # but we want to let people accept the configurable class as the first argument, too
-    assert_equal 'bar', ConfigurableClass.configure {|a| a.foo}
+    assert_equal 'bar', ExtendedClass.configure {|a| a.foo}
   end
 end

data/test/misc/constraints_test.rb

@@ -3,7 +3,8 @@ require 'test_helper'
 module ModelStubs
   class ModelStub < ActiveRecord::Base
     abstract_class = true
-    def self.columns; [ActiveRecord::ConnectionAdapters::Column.new('foo', '')] end
+    def self.columns; @columns ||= [ColumnMock.new('foo', '')] end
+    def self.columns_hash; @hash ||= Hash[@columns.map{|c| [c.name, c]}] end
     def self.table_name
       @table_name || to_s.split('::').last.underscore.pluralize
     end
@@ -83,7 +84,8 @@ end
 class ConstraintsTestObject
   # stub out what the mixin expects to find ...
   def self.before_filter(*args); end
-  attr_accessor :active_scaffold_includes
+  attr_accessor :active_scaffold_preload
+  attr_accessor :active_scaffold_references
   attr_accessor :active_scaffold_habtm_joins
   attr_accessor :active_scaffold_config
   attr_accessor :params
@@ -98,13 +100,14 @@ class ConstraintsTestObject
   attr_accessor :active_scaffold_constraints
 
   def initialize
-    @active_scaffold_includes = []
+    @active_scaffold_preload = []
+    @active_scaffold_references = []
     @active_scaffold_habtm_joins = []
     @params = {}
   end
 end
 
-class ConstraintsTest < Test::Unit::TestCase
+class ConstraintsTest < MiniTest::Test
   def setup
     @test_object = ConstraintsTestObject.new
   end
@@ -114,12 +117,12 @@ class ConstraintsTest < Test::Unit::TestCase
     # has_one (vs belongs_to)
     assert_constraint_condition({:subscription => 5}, [{'subscriptions.id' => 5}], 'find the user with subscription #5')
     # habtm (vs habtm)
-    assert_constraint_condition({:roles => 4}, [{'roles_users.role_id' => 4}], 'find all users with role #4')
+    assert_constraint_condition({:roles => 4}, [{'roles.id' => 4}], 'find all users with role #4')
     # has_one (vs polymorphic)
     assert_constraint_condition({:address => 11}, [{'addresses.id' => 11}], 'find the user with address #11')
     # reverse of a has_many :through
     assert_constraint_condition({:subscription => {:service => 5}}, [{'services.id' => 5}], 'find all users subscribed to service #5')
-    assert(@test_object.active_scaffold_includes.include?({:subscription => :service}), 'multi-level association include')
+    assert(@test_object.active_scaffold_references.include?({:subscription => :service}), 'multi-level association include')
 
     @test_object.active_scaffold_config = config_for('subscription')
     # belongs_to (vs has_one)
@@ -144,7 +147,7 @@ class ConstraintsTest < Test::Unit::TestCase
     # has_one (vs belongs_to)
     assert_constraint_condition({:other_subscription => 5}, [{'subscriptions.id' => 5}], 'find the user with subscription #5')
     # habtm (vs habtm)
-    assert_constraint_condition({:other_roles => 4}, [{'roles_users.role_id' => 4}], 'find all users with role #4')
+    assert_constraint_condition({:other_roles => 4}, [{'roles.id' => 4}], 'find all users with role #4')
     # has_one (vs polymorphic)
     assert_constraint_condition({:other_address => 11}, [{'addresses.id' => 11}], 'find the user with address #11')
     # reverse of a has_many :through

data/test/misc/convert_numbers_format_test.rb

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+class NumberModel < ActiveRecord::Base
+  include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Model
+  abstract_class = true
+  def self.columns
+    @columns ||= [ColumnMock.new('number', '', 'double(10,2)')]
+  end
+  def self.columns_hash
+    @hash ||= Hash[@columns.map{|c| [c.name, c]}]
+  end
+end
+
+class ConvertNumbersFormatTest < MiniTest::Test
+  include ActiveScaffold::AttributeParams
+  include ActiveScaffold::Finder
+
+  def setup
+    I18n.backend.store_translations :en, :number => {:format => {
+      :delimiter => ',',
+      :separator => '.'
+    }}
+    I18n.backend.store_translations :es, :number => {:format => {
+      :delimiter => '.',
+      :separator => ','
+    }}
+    I18n.backend.store_translations :ru, :number => {:currency => {
+      :format => {
+        :separator => ',',
+        :delimiter => ''
+      }
+    }}
+
+    @config = config_for('number_model')
+    @config.columns[:number].form_ui = nil
+    @config.create.columns.set_columns @config.columns
+  end
+
+  def teardown
+    I18n.locale = :en
+  end
+
+  def test_english_format_with_decimal_separator_using_english_language
+    I18n.locale = :en
+    assert_equal 0.1, convert_number('.1')
+    assert_equal 0.1, convert_number('.100')
+    assert_equal 0.1, convert_number('0.1')
+    assert_equal 0.345, convert_number('0.345')
+    assert_equal 0.345, convert_number('+0.345')
+    assert_equal -0.345, convert_number('-0.345')
+    assert_equal 9.345, convert_number('9.345')
+    assert_equal 9.1, convert_number('9.1')
+    assert_equal 90.1, convert_number('90.1')
+  end
+
+  def test_english_format_with_thousand_delimiter_using_english_language
+    I18n.locale = :en
+    assert_equal 1000, convert_number('1,000')
+    assert_equal 1000, convert_number('+1,000')
+    assert_equal -1000, convert_number('-1,000')
+    assert_equal 1000000, convert_number('1,000,000')
+  end
+
+  def test_english_format_with_separator_and_delimiter_using_english_language
+    I18n.locale = :en
+    assert_equal 1234.1, convert_number('1,234.1')
+    assert_equal 1234.1, convert_number('1,234.100')
+    assert_equal 1234.345, convert_number('+1,234.345')
+    assert_equal -1234.345, convert_number('-1,234.345')
+    assert_equal 1234000.1, convert_number('1,234,000.100')
+  end
+
+  def test_english_format_with_decimal_separator_using_spanish_language
+    I18n.locale = :es
+    assert_equal 0.1, convert_number('.1')
+    assert_equal 0.1, convert_number('0.1')
+    assert_equal 0.12, convert_number('+0.12')
+    assert_equal -0.12, convert_number('-0.12')
+    assert_equal 9.1, convert_number('9.1')
+    assert_equal 90.1, convert_number('90.1')
+  end
+
+  def test_spanish_format_with_decimal_separator_using_spanish_language
+    I18n.locale = :es
+    assert_equal 0.1, convert_number(',1')
+    assert_equal 0.1, convert_number(',100')
+    assert_equal 0.1, convert_number('0,1')
+    assert_equal 0.345, convert_number('0,345')
+    assert_equal 0.345, convert_number('+0,345')
+    assert_equal -0.345, convert_number('-0,345')
+    assert_equal 9.1, convert_number('9,1')
+    assert_equal 90.1, convert_number('90,1')
+    assert_equal 9.1, convert_number('9,100')
+  end
+
+  def test_spanish_format_with_thousand_delimiter_using_spanish_language
+    I18n.locale = :es
+    assert_equal 1000, convert_number('1.000')
+    assert_equal 1000, convert_number('+1.000')
+    assert_equal -1000, convert_number('-1.000')
+    assert_equal 1000000, convert_number('1.000.000')
+  end
+
+  def test_spanish_format_with_separator_and_decimal_using_spanish_language
+    I18n.locale = :es
+    assert_equal 1230.1, convert_number('1.230,1')
+    assert_equal 1230.1, convert_number('1.230,100')
+    assert_equal 1234.345, convert_number('+1.234,345')
+    assert_equal -1234.345, convert_number('-1.234,345')
+    assert_equal 1234000.1, convert_number('1.234.000,100')
+  end
+
+  def test_english_currency_format_with_decimal_separator_using_russian_language
+    I18n.locale = :ru
+    assert_equal 0.1, convert_number('.1', :currency)
+    assert_equal 0.1, convert_number('0.1', :currency)
+    assert_equal 0.12, convert_number('+0.12', :currency)
+    assert_equal -0.12, convert_number('-0.12', :currency)
+    assert_equal 9.1, convert_number('9.1', :currency)
+    assert_equal 90.1, convert_number('90.1', :currency)
+  end
+
+  def test_russian_currency_format_with_decimal_separator_using_russian_language
+    I18n.locale = :ru
+    assert_equal 0.1, convert_number(',1', :currency)
+    assert_equal 0.1, convert_number(',100', :currency)
+    assert_equal 0.1, convert_number('0,1', :currency)
+    assert_equal 0.345, convert_number('0,345', :currency)
+    assert_equal 0.345, convert_number('+0,345', :currency)
+    assert_equal -0.345, convert_number('-0,345', :currency)
+    assert_equal 9.1, convert_number('9,1', :currency)
+    assert_equal 90.1, convert_number('90,1', :currency)
+    assert_equal 9.1, convert_number('9,100', :currency)
+  end
+
+  def test_english_format_with_decimal_separator_with_no_localized_format
+    I18n.locale = :ru
+    assert_equal 0.1, convert_number('.1')
+    assert_equal 0.1, convert_number('0.1')
+  end
+
+  private
+  def convert_number(value, format = nil)
+    record = NumberModel.new
+    @config.columns[:number].options[:format] = format unless format.nil?
+    update_record_from_params(record, @config.create.columns, HashWithIndifferentAccess.new({:number => value}))
+    record.number
+  end
+end

data/test/misc/finder_test.rb

@@ -12,9 +12,11 @@ class ClassWithFinder
   def beginning_of_chain
     active_scaffold_config.model
   end
+  def conditional_get_support?; end
+  def params; {}; end
 end
 
-class FinderTest < Test::Unit::TestCase
+class FinderTest < MiniTest::Test
   def setup
     @klass = ClassWithFinder.new
     @klass.stubs(:active_scaffold_config).returns(mock { stubs(:model).returns(ModelStub) })
@@ -55,10 +57,7 @@ class FinderTest < Test::Unit::TestCase
     assert_equal collection.sort.reverse, @klass.send(:sort_collection_by_column, collection, column, 'desc')
 
     collection = ['a', nil, 'b']
-    result = nil
-    assert_nothing_raised do
-      result = @klass.send(:sort_collection_by_column, collection, column, 'asc')
-    end
+    result = @klass.send(:sort_collection_by_column, collection, column, 'asc')
     assert_equal [nil, 'a', 'b'], result
 
     column.sort_by :method => 'self'
@@ -68,21 +67,21 @@ class FinderTest < Test::Unit::TestCase
 
   def test_count_with_group
     @klass.expects(:custom_finder_options).returns({:group => :a})
-    ActiveRecord::Relation.any_instance.expects(:count).returns(ActiveSupport::OrderedHash['foo', 5])
-    ActiveRecord::Relation.any_instance.expects(:limit).with(20).returns(ModelStub.where(nil))
-    ActiveRecord::Relation.any_instance.expects(:offset).with(0).returns(ModelStub.where(nil))
+    relation_class.any_instance.expects(:count).returns({'foo' => 5, 'bar' => 4})
+    relation_class.any_instance.expects(:limit).with(20).returns(ModelStub.where(nil))
+    relation_class.any_instance.expects(:offset).with(0).returns(ModelStub.where(nil))
     page = @klass.send :find_page, :per_page => 20, :pagination => true
     page.items
     
     assert_kind_of Integer, page.pager.count
-    assert_equal 1, page.pager.count
-    assert_nothing_raised { page.pager.number_of_pages }
+    assert_equal 2, page.pager.count
+    assert_equal 1, page.pager.number_of_pages
   end
 
   def test_disabled_pagination
-    ActiveRecord::Relation.any_instance.expects(:count).never
-    ActiveRecord::Relation.any_instance.expects(:limit).never
-    ActiveRecord::Relation.any_instance.expects(:offset).never
+    relation_class.any_instance.expects(:count).never
+    relation_class.any_instance.expects(:limit).never
+    relation_class.any_instance.expects(:offset).never
     ModelStub.expects(:count).never
     page = @klass.send :find_page, :per_page => 20, :pagination => false
     page.items
@@ -92,4 +91,9 @@ class FinderTest < Test::Unit::TestCase
     ModelStub.expects(:count).never
     page = @klass.send :find_page, :pagination => :infinite
   end
+
+  private
+  def relation_class
+    @klass.active_scaffold_config.model.send(:relation).class
+  end
 end

data/test/misc/lang_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class LocalizationTest < Test::Unit::TestCase
+class LocalizationTest < MiniTest::Test
 
   def test_localization
     assert_equal "Dutch", as_(:dutch)

data/test/misc/tableless_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class TablelessTest < MiniTest::Test
+  def test_find_all
+    assert_equal [], FileModel.all
+  end
+  
+  def test_find_by_id
+    assert_raises ActiveRecord::RecordNotFound do
+      FileModel.find('filename')
+    end
+  end
+  
+  def test_find_with_association
+    assert_equal [], Person.new.files
+  end
+end
+