active_scaffold 3.4.43 → 3.5.0

data/test/data_structures/association_column_test.rb

@@ -23,7 +23,7 @@ class AssociationColumnTest < MiniTest::Test
   end
 
   def test_association
-    assert @association_column.association.is_a?(ActiveRecord::Reflection::AssociationReflection)
+    assert @association_column.association.is_a?(ActiveScaffold::DataStructures::Association::Abstract)
   end
 
   def test_includes
@@ -31,11 +31,11 @@ class AssociationColumnTest < MiniTest::Test
   end
 
   def test_plurality
-    assert @association_column.singular_association?
-    refute @association_column.plural_association?
+    assert @association_column.association.singular?
+    refute @association_column.association.collection?
 
     plural_association_column = ActiveScaffold::DataStructures::Column.new('other_models', ModelStub)
-    assert plural_association_column.plural_association?
-    refute plural_association_column.singular_association?
+    assert plural_association_column.association.collection?
+    refute plural_association_column.association.singular?
   end
 end

data/test/data_structures/column_test.rb

@@ -5,12 +5,12 @@ class ColumnTest < MiniTest::Test
     @column = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
     @association_col = ActiveScaffold::DataStructures::Column.new(:b, ModelStub)
     @association_col.stubs(:polymorphic_association?).returns(false)
-    @association_col.instance_variable_set(:@association, true)
+    @association_col.stubs(association: stub(polymorphic?: false))
   end
 
   def test_column
     assert @column.column.is_a?(ActiveRecord::ConnectionAdapters::Column)
-    assert @column.column.name == 'a'
+    assert_equal @column.column.name, 'a'
   end
 
   def test_basic_properties
@@ -54,33 +54,33 @@ class ColumnTest < MiniTest::Test
   def test_equality
     # create a separate columns object, and make sure it's not ==
     columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b)
-    assert columns != @column
+    refute_equal columns, @column
 
     # create a separate action_columns object, and make sure it's not ==
     columns = ActiveScaffold::DataStructures::ActionColumns.new(:a, :b)
-    assert columns != @column
+    refute_equal columns, @column
 
     # identity
-    assert @column == @column # rubocop:disable Lint/UselessComparison
+    assert_equal @column, @column
 
     # string comparison
-    assert @column == 'a'
-    assert @column != 'fake'
+    assert_equal @column, 'a'
+    refute_equal @column, 'fake'
 
     # symbol comparison
-    assert @column == :a
-    assert @column != :fake
+    assert_equal @column, :a
+    refute_equal @column, :fake
 
     # comparison with different object of same type
     column2 = ActiveScaffold::DataStructures::Column.new(:fake, ModelStub)
-    assert @column != column2
+    refute_equal @column, column2
     column2.name = 'a'
-    assert @column == column2
+    assert_equal @column, column2
 
     # special comparisons
     refute @column.nil?
-    assert @column != ''
-    assert @column != 0
+    refute_equal @column, ''
+    refute_equal @column, 0
   end
 
   def test_ui
@@ -172,7 +172,7 @@ class ColumnTest < MiniTest::Test
   end
 
   def test_includes
-    assert_equal nil, @column.includes
+    assert_nil @column.includes
 
     # make sure that when a non-array comes in, an array comes out
     @column.includes = :column_name

data/test/data_structures/columns_test.rb

@@ -25,7 +25,7 @@ class ColumnsTest < MiniTest::Test
 
     # try adding an array of columns
     refute @columns.include?(:f)
-    @columns.add [:f, :g]
+    @columns.add %i[f g]
     assert @columns.include?(:f)
     assert @columns.include?(:g)
   end
@@ -47,7 +47,7 @@ class ColumnsTest < MiniTest::Test
 
   def test_each
     @columns.each do |column|
-      assert [:a, :b].include?(column.name)
+      assert %i[a b].include?(column.name)
     end
   end
 

data/test/data_structures/set_test.rb

@@ -26,7 +26,7 @@ class SetTest < MiniTest::Test
   def test_exclude_array
     # exclude with a symbol
     assert @items.include?(:b)
-    @items.exclude [:a, :b]
+    @items.exclude %i[a b]
     refute @items.include?(:b)
     refute @items.include?(:a)
   end
@@ -55,7 +55,7 @@ class SetTest < MiniTest::Test
 
     # try adding an array of columns
     refute @items.include?(:f)
-    @items.add [:f, :g]
+    @items.add %i[f g]
     assert @items.include?(:f)
     assert @items.include?(:g)
   end

data/test/data_structures/sorting_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 class SortingTest < MiniTest::Test
   def setup
     @columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b, :c, :d, :id)
-    @sorting = ActiveScaffold::DataStructures::Sorting.new(@columns)
+    @sorting = ActiveScaffold::DataStructures::Sorting.new(@columns, ModelStub)
   end
 
   def test_add
@@ -25,7 +25,7 @@ class SortingTest < MiniTest::Test
     # test adding a lowercase string direction
     assert_equal 'DESC', @sorting.direction_of(:c)
 
-    @sorting << [:d, :desc]
+    @sorting << %i[d desc]
     # testing adding with the alias
     assert @sorting.sorts_on?(:d)
     assert_equal 'DESC', @sorting.direction_of(:d)
@@ -119,7 +119,8 @@ class SortingTest < MiniTest::Test
   def test_set_default_sorting_with_simple_default_scope
     model_stub_with_default_scope = ModelStub.clone
     model_stub_with_default_scope.class_eval { default_scope -> { order('a') } }
-    @sorting.set_default_sorting model_stub_with_default_scope
+    @sorting = ActiveScaffold::DataStructures::Sorting.new(@columns, model_stub_with_default_scope)
+    @sorting.set_default_sorting
 
     assert @sorting.sorts_on?(:a)
     assert_equal 'ASC', @sorting.direction_of(:a)
@@ -129,7 +130,8 @@ class SortingTest < MiniTest::Test
   def test_set_default_sorting_with_complex_default_scope
     model_stub_with_default_scope = ModelStub.clone
     model_stub_with_default_scope.class_eval { default_scope -> { order('a DESC, players.last_name ASC') } }
-    @sorting.set_default_sorting model_stub_with_default_scope
+    @sorting = ActiveScaffold::DataStructures::Sorting.new(@columns, model_stub_with_default_scope)
+    @sorting.set_default_sorting
 
     assert @sorting.sorts_on?(:a)
     assert_equal 'DESC', @sorting.direction_of(:a)

data/test/extensions/active_record_test.rb

@@ -7,7 +7,7 @@ class ActiveRecordTest < MiniTest::Test
 
   def test_to_label
     # without anything defined, it'll use the to_s method (e.g. #<ModelStub:0xb7379300>)
-    assert_match /^#<[a-z]+:0x[0-9a-f]+>$/i, @record.to_label
+    assert_match(/^#<[a-z]+:0x[0-9a-f]+>$/i, @record.to_label)
 
     class << @record
       def to_s

data/test/extensions/routing_mapper_test.rb

@@ -2,21 +2,72 @@ require 'test_helper'
 
 class RoutingMapperTest < ActionController::TestCase
   test 'rails routes' do
-    assert_routing 'addresses', :controller => 'addresses', :action => 'index'
-    assert_routing 'addresses/1', :controller => 'addresses', :action => 'show', :id => '1'
-    assert_routing 'addresses/1/list', :controller => 'addresses', :action => 'index', :id => '1'
-    assert_routing 'addresses/1/edit', :controller => 'addresses', :action => 'edit', :id => '1'
-    assert_routing({:method => :put, :path => 'addresses/1'}, {:controller => 'addresses', :action => 'update', :id => '1'})
-    assert_routing({:method => :delete, :path => 'addresses/1'}, {:controller => 'addresses', :action => 'destroy', :id => '1'})
-    assert_routing({:method => :post, :path => 'addresses'}, {:controller => 'addresses', :action => 'create'})
+    assert_routing 'addresses', controller: 'addresses', action: 'index'
+    assert_routing 'addresses/1', controller: 'addresses', action: 'show', id: '1'
+    assert_routing 'addresses/1/list', controller: 'addresses', action: 'index', id: '1'
+    assert_routing 'addresses/1/edit', controller: 'addresses', action: 'edit', id: '1'
+    assert_routing({method: :patch, path: 'addresses/1'}, {controller: 'addresses', action: 'update', id: '1'})
+    assert_routing({method: :delete, path: 'addresses/1'}, {controller: 'addresses', action: 'destroy', id: '1'})
+    assert_routing({method: :post, path: 'addresses'}, {controller: 'addresses', action: 'create'})
   end
 
   test 'active scaffold routes' do
-    assert_routing 'addresses/show_search', :controller => 'addresses', :action => 'show_search'
-    assert_routing({:method => 'post', :path => 'addresses/render_field'}, {:controller => 'addresses', :action => 'render_field'})
-    assert_routing({:method => 'post', :path => 'addresses/2/render_field'}, {:controller => 'addresses', :action => 'render_field', :id => '2'})
-    assert_routing 'addresses/2/render_field', :controller => 'addresses', :action => 'render_field', :id => '2'
-    assert_routing 'addresses/edit_associated', :controller => 'addresses', :action => 'edit_associated'
-    assert_routing 'addresses/2/edit_associated', :controller => 'addresses', :action => 'edit_associated', :id => '2'
+    assert_routing 'addresses/show_search', controller: 'addresses', action: 'show_search'
+    assert_routing({method: 'post', path: 'addresses/mark'}, {controller: 'addresses', action: 'mark'})
+    assert_routing({method: 'post', path: 'addresses/2/mark'}, {controller: 'addresses', action: 'mark', id: '2'})
+    assert_routing({method: 'post', path: 'addresses/render_field'}, {controller: 'addresses', action: 'render_field'})
+    assert_routing({method: 'post', path: 'addresses/2/render_field'}, {controller: 'addresses', action: 'render_field', id: '2'})
+    assert_routing({method: 'post', path: 'addresses/2/update_column'}, {controller: 'addresses', action: 'update_column', id: '2'})
+    assert_routing 'addresses/2/render_field', controller: 'addresses', action: 'render_field', id: '2'
+    assert_routing 'addresses/edit_associated', controller: 'addresses', action: 'edit_associated'
+    assert_routing 'addresses/2/edit_associated', controller: 'addresses', action: 'edit_associated', id: '2'
+    assert_routing 'addresses/new_existing', controller: 'addresses', action: 'new_existing'
+    assert_routing({method: 'post', path: 'addresses/add_existing'}, {controller: 'addresses', action: 'add_existing'})
+    assert_routing({method: 'delete', path: 'addresses/2/destroy_existing'}, {controller: 'addresses', action: 'destroy_existing', id: '2'})
+  end
+
+  test 'rails routes with except' do
+    assert_routing 'buildings/1', controller: 'buildings', action: 'show', id: '1'
+    assert_routing 'buildings/1/edit', controller: 'buildings', action: 'edit', id: '1'
+    assert_routing({method: :patch, path: 'buildings/1'}, {controller: 'buildings', action: 'update', id: '1'})
+    assert_routing({method: :delete, path: 'buildings/1'}, {controller: 'buildings', action: 'destroy', id: '1'})
+    assert_routing({method: :post, path: 'buildings'}, {controller: 'buildings', action: 'create'})
+
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/buildings' }
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/buildings/1/list' }
+  end
+
+  test 'active scaffold routes with except' do
+    assert_routing 'buildings/show_search', controller: 'buildings', action: 'show_search'
+    assert_routing({method: 'post', path: 'buildings/render_field'}, {controller: 'buildings', action: 'render_field'})
+    assert_routing({method: 'post', path: 'buildings/2/render_field'}, {controller: 'buildings', action: 'render_field', id: '2'})
+    assert_routing({method: 'post', path: 'buildings/2/update_column'}, {controller: 'buildings', action: 'update_column', id: '2'})
+    assert_routing 'buildings/2/render_field', controller: 'buildings', action: 'render_field', id: '2'
+    assert_routing 'buildings/edit_associated', controller: 'buildings', action: 'edit_associated'
+    assert_routing 'buildings/2/edit_associated', controller: 'buildings', action: 'edit_associated', id: '2'
+
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/buildings/2/mark', method: :post }
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/buildings/2/destroy_existing', method: :delete }
+  end
+
+  test 'rails routes with only' do
+    assert_routing 'cars/1/edit', controller: 'cars', action: 'edit', id: '1'
+    assert_routing({method: :patch, path: 'cars/1'}, {controller: 'cars', action: 'update', id: '1'})
+
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/cars' }
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/cars/1/list' }
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/cars/1/destroy', method: :delete }
+  end
+
+  test 'active scaffold routes with only' do
+    assert_routing 'cars/show_search', controller: 'cars', action: 'show_search'
+    assert_routing({method: 'post', path: 'cars/render_field'}, {controller: 'cars', action: 'render_field'})
+    assert_routing({method: 'post', path: 'cars/2/render_field'}, {controller: 'cars', action: 'render_field', id: '2'})
+    assert_routing({method: 'post', path: 'cars/2/update_column'}, {controller: 'cars', action: 'update_column', id: '2'})
+    assert_routing 'cars/2/render_field', controller: 'cars', action: 'render_field', id: '2'
+
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/cars/2/edit_associated' }
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/cars/2/mark', method: :post }
+    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/cars/2/destroy_existing', method: :delete }
   end
 end

data/test/helpers/form_column_helpers_test.rb

@@ -9,22 +9,22 @@ class FormColumnHelpersTest < ActionView::TestCase
   end
 
   def test_choices_for_select_form_ui_for_simple_column
-    @column.options[:options] = [:value_1, :value_2, :value_3]
+    @column.options[:options] = %i[value_1 value_2 value_3]
     assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">Value 1</option>\n<option value=\"value_2\">Value 2</option>\n<option value=\"value_3\">Value 3</option></select>", active_scaffold_input_select(@column, :object => @record)
 
-    @column.options[:options] = %w(value_1 value_2 value_3)
+    @column.options[:options] = %w[value_1 value_2 value_3]
     assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">value_1</option>\n<option value=\"value_2\">value_2</option>\n<option value=\"value_3\">value_3</option></select>", active_scaffold_input_select(@column, :object => @record)
 
-    @column.options[:options] = [%w(text_1 value_1), %w(text_2 value_2), %w(text_3 value_3)]
+    @column.options[:options] = [%w[text_1 value_1], %w[text_2 value_2], %w[text_3 value_3]]
     assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">text_1</option>\n<option value=\"value_2\">text_2</option>\n<option value=\"value_3\">text_3</option></select>", active_scaffold_input_select(@column, :object => @record)
 
-    @column.options[:options] = [[:text_1, :value_1], [:text_2, :value_2], [:text_3, :value_3]]
+    @column.options[:options] = [%i[text_1 value_1], %i[text_2 value_2], %i[text_3 value_3]]
     assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">Text 1</option>\n<option value=\"value_2\">Text 2</option>\n<option value=\"value_3\">Text 3</option></select>", active_scaffold_input_select(@column, :object => @record)
   end
 
   def test_options_for_select_form_ui_for_simple_column
-    @column.options = {:include_blank => 'None', :selected => 'value_2', :disabled => %w(value_1 value_3)}
-    @column.options[:options] = %w(value_1 value_2 value_3)
+    @column.options = {:include_blank => 'None', :selected => 'value_2', :disabled => %w[value_1 value_3]}
+    @column.options[:options] = %w[value_1 value_2 value_3]
     @column.options[:html_options] = {:class => 'big'}
     assert_dom_equal "<select name=\"record[a]\" class=\"big\" id=\"record_a\"><option value=\"\">None</option>\n<option disabled=\"disabled\" value=\"value_1\">value_1</option>\n<option selected=\"selected\" value=\"value_2\">value_2</option>\n<option disabled=\"disabled\" value=\"value_3\">value_3</option></select>", active_scaffold_input_select(@column, :object => @record)
   end

data/test/helpers/list_column_helpers_test.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require 'test_helper'
 
 class ListColumnHelpersTest < ActionView::TestCase
@@ -16,21 +15,22 @@ class ListColumnHelpersTest < ActionView::TestCase
   end
 
   def test_options_for_select_list_ui_for_simple_column
-    @column.options[:options] = [:value_1, :value_2, :value_3]
+    @column.options[:options] = %i[value_1 value_2 value_3]
     assert_equal 'Value 2', format_column_value(@record, @column)
 
-    @column.options[:options] = %w(value_1 value_2 value_3)
+    @column.options[:options] = %w[value_1 value_2 value_3]
     assert_equal 'value_2', format_column_value(@record, @column)
 
-    @column.options[:options] = [%w(text_1 value_1), %w(text_2 value_2), %w(text_3 value_3)]
+    @column.options[:options] = [%w[text_1 value_1], %w[text_2 value_2], %w[text_3 value_3]]
     assert_equal 'text_2', format_column_value(@record, @column)
 
-    @column.options[:options] = [[:text_1, :value_1], [:text_2, :value_2], [:text_3, :value_3]]
+    @column.options[:options] = [%i[text_1 value_1], %i[text_2 value_2], %i[text_3 value_3]]
     assert_equal 'Text 2', format_column_value(@record, @column)
   end
 
   def test_association_join_text
     value = [1, 2, 3, 4].map(&:to_s)
+    value.stubs(loaded?: true)
     value.each { |v| v.stubs(:to_label).returns(v) }
     assert_equal '1, 2, 3, … (4)', format_association_value(value, @association_column, value.size)
     @config.list.stubs(:association_join_text => ',<br/>')
@@ -41,6 +41,10 @@ class ListColumnHelpersTest < ActionView::TestCase
 
   private
 
+  def grouped_search?
+    false
+  end
+
   def active_scaffold_config
     @config
   end

data/test/helpers/pagination_helpers_test.rb

@@ -2,6 +2,7 @@ require 'test_helper'
 
 class PaginationHelpersTest < MiniTest::Test
   include ActiveScaffold::Helpers::PaginationHelpers
+  include ActionView::Helpers::OutputSafetyHelper
 
   def active_scaffold_config
     @config ||= config_for('model_stub')

data/test/misc/active_record_permissions_test.rb

@@ -2,7 +2,18 @@ require 'test_helper'
 
 class PermissionModel < ActiveRecord::Base
   include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Model
-  def self.columns; @columns ||= [ColumnMock.new('id', '', 'int(11)')] + %w(a1 a2 a3 b1 b2 b3 c1 c2 c3).map { |c| ColumnMock.new(c, '', 'varchar(255)') }; end
+  def self.columns
+    @columns ||= [ColumnMock.new('id', '', 'int(11)')] +
+                 %w[a1 a2 a3 b1 b2 b3 c1 c2 c3].map { |c| ColumnMock.new(c, '', 'varchar(255)') }
+  end
+
+  def self.columns_hash
+    @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
+  end
+
+  def self.schema_loaded?
+    true
+  end
 
   def authorized_for_read?; true; end
 
@@ -27,10 +38,12 @@ class PermissionModel < ActiveRecord::Base
   def a3_authorized_for_create?; true; end
 
   def b3_authorized_for_create?; false; end
+
   # def c3_authorized_for_create?; end
   def a2_authorized_for_create?; true; end
 
   def b2_authorized_for_create?; false; end
+
   # def c2_authorized_for_create?; end
   def a1_authorized_for_create?; true; end
 
@@ -40,10 +53,12 @@ class PermissionModel < ActiveRecord::Base
   def a3_authorized_for_read?; true; end
 
   def b3_authorized_for_read?; false; end
+
   # def c3_authorized_for_read?; end
   def a2_authorized_for_read?; true; end
 
   def b2_authorized_for_read?; false; end
+
   # def c2_authorized_for_read?; end
   def a1_authorized_for_read?; true; end
 
@@ -53,10 +68,12 @@ class PermissionModel < ActiveRecord::Base
   def a3_authorized_for_update?; true; end
 
   def b3_authorized_for_update?; false; end
+
   # def c3_authorized_for_update?; end
   def a2_authorized_for_update?; true; end
 
   def b2_authorized_for_update?; false; end
+
   # def c2_authorized_for_update?; end
   def a1_authorized_for_update?; true; end
 

data/test/misc/attribute_params_test.rb

@@ -34,13 +34,13 @@ class AttributeParamsTest < MiniTest::Test
   end
 
   def test_saving_multiparameter_attribute
-    model = update_record_from_params(Contact.new, :update, :first_name, :birthday, :first_name => 'Christopher', :last_name => 'Columbus', 'birthday(1i)' => '1451', 'birthday(2i)' => '10', 'birthday(3i)' => '31')
-    assert_equal 'Christopher', model.first_name
-    assert_equal Date.new(1451, 10, 31), model.birthday
+    model = update_record_from_params(Contact.new, :update, :first_name, :birthday, :first_name => 'Diego', :last_name => 'Velazquez', 'birthday(1i)' => '1599', 'birthday(2i)' => '6', 'birthday(3i)' => '6')
+    assert_equal 'Diego', model.first_name
+    assert_equal Date.new(1599, 6, 6), model.birthday
   end
 
   def test_saving_has_many_select
-    buildings = 2.times.map { Building.create }
+    buildings = Array.new(2) { Building.create }
     model = update_record_from_params(Person.new, :create, :first_name, :last_name, :buildings, :first_name => 'First', :last_name => '', :buildings => ['', *buildings.map { |b| b.id.to_s }]) # checkbox_list always add a hidden tag with empty value
     assert_equal 'First', model.first_name
     assert_nil model.last_name
@@ -160,45 +160,45 @@ class AttributeParamsTest < MiniTest::Test
     assert_equal 'Name', model.first_name
     assert model.home.present?
     assert model.floor.present?
-    assert_equal [nil], building.floors(true).map(&:tenant_id), 'floor should not be saved yet'
+    assert_equal [nil], building.floors.reload.map(&:tenant_id), 'floor should not be saved yet'
     assert model.save
     assert_equal model.id, model.floor.tenant_id, 'tenant_id should be saved'
-    assert_equal [nil, model.id], building.floors(true).map(&:tenant_id)
+    assert_equal [nil, model.id], building.floors.reload.map(&:tenant_id)
 
     model = update_record_from_params(model, :update, :first_name, :home, :first_name => 'First', :home => '') { raise ActiveRecord::Rollback }
     assert_equal 'First', model.first_name
-    assert_equal [nil, model.id], building.floors(true).map(&:tenant_id), 'previous floor should not be deleted'
+    assert_equal [nil, model.id], building.floors.reload.map(&:tenant_id), 'previous floor should not be deleted'
     assert_nil model.home, 'home should be cleared'
 
     model.reload
     model = update_record_from_params(model, :update, :first_name, :home, :first_name => 'First', :home => '')
     assert_equal 'First', model.first_name
-    assert_equal [nil], building.floors(true).map(&:tenant_id), 'previous floor should be deleted'
+    assert_equal [nil], building.floors.reload.map(&:tenant_id), 'previous floor should be deleted'
     assert_nil model.home, 'home should be cleared'
     assert model.save
   end
 
   def test_saving_has_many_through_select
-    people = 2.times.map { Person.create }
+    people = Array.new(2) { Person.create }
     assert people.all?(&:persisted?)
 
     model = update_record_from_params(Building.new, :create, :name, :tenants, :name => 'Tower', :tenants => ['', *people.map { |b| b.id.to_s }]) # checkbox_list always add a hidden tag with empty value
     assert_equal 'Tower', model.name
     assert model.tenants.present?
-    assert_equal [nil] * 2, people.map { |p| p.floor(true) }, 'floor should not be saved yet'
+    assert_equal [nil] * 2, people.map { |p| p.respond_to?(:reload_floor) ? p.reload_floor : p.floor(true) }, 'floor should not be saved yet'
     assert model.save
     assert_equal [model.id] * 2, model.floors.map(&:building_id)
-    assert_equal [model.id] * 2, people.map { |p| p.floor(true).building_id }, 'floor should be saved'
+    assert_equal [model.id] * 2, people.map { |p| (p.respond_to?(:reload_floor) ? p.reload_floor : p.floor(true)).building_id }, 'floor should be saved'
 
     model = update_record_from_params(model, :update, :name, :tenants, :name => 'Skyscrapper', :tenants => ['']) { raise ActiveRecord::Rollback }
     assert_equal 'Skyscrapper', model.name
-    assert_equal [model.id] * 2, people.map { |p| p.floor(true).building_id }, 'previous floor should not be deleted'
+    assert_equal [model.id] * 2, people.map { |p| (p.respond_to?(:reload_floor) ? p.reload_floor : p.floor(true)).building_id }, 'previous floor should not be deleted'
     assert model.tenants.empty?, 'tenants should be cleared'
 
     model.reload
     model = update_record_from_params(model, :update, :name, :tenants, :name => 'Skyscrapper', :tenants => [''])
     assert_equal 'Skyscrapper', model.name
-    assert_equal [nil] * 2, people.map { |p| p.floor(true) }, 'previous floor should be deleted'
+    assert_equal [nil] * 2, people.map { |p| p.respond_to?(:reload_floor) ? p.reload_floor : p.floor(true) }, 'previous floor should be deleted'
     assert model.tenants.empty?, 'tenants should be cleared'
     assert model.save
   end
@@ -216,7 +216,7 @@ class AttributeParamsTest < MiniTest::Test
 
   def test_saving_has_many_crud_and_belongs_to_select
     floor = Floor.create
-    people = 2.times.map { Person.create }
+    people = Array.new(2) { Person.create }
     key = Time.now.to_i.to_s
     floors = {'0' => '', floor.id.to_s => {:number => '1', :tenant => '', :id => floor.id.to_s}, key => {:number => '2', 'tenant' => people.first.id.to_s}, key.succ => {:number => '4', 'tenant' => people.last.id.to_s}, key.succ.succ => {:number => '', 'tenant' => ''}}
     model = update_record_from_params(Building.new, :create, :name, :floors, :name => 'First', :floors => floors)
@@ -358,7 +358,7 @@ class AttributeParamsTest < MiniTest::Test
   end
 
   def test_saving_has_many_polymorphic_select
-    contacts = 2.times.map { Contact.create }
+    contacts = Array.new(2) { Contact.create }
 
     model = update_record_from_params(Person.new, :create, :first_name, :contacts, :first_name => 'Me', :contacts => ['', contacts.first.id.to_s])
     assert_equal 'Me', model.first_name
@@ -385,7 +385,7 @@ class AttributeParamsTest < MiniTest::Test
   end
 
   def test_saving_habtm_select
-    roles = 2.times.map { Role.create }
+    roles = Array.new(2) { Role.create }
 
     model = update_record_from_params(Person.new, :create, :first_name, :roles, :first_name => 'Me', :roles => ['', roles.first.id.to_s])
     assert_equal 'Me', model.first_name
@@ -431,7 +431,8 @@ end
 
 class Controller
   def self.helper_method(*); end
-  def self.before_filter(*); end
+
+  def self.before_action(*); end
 
   include ActiveScaffold::Core
   include ActiveScaffold::Helpers::ControllerHelpers
@@ -445,4 +446,12 @@ class Controller
   def flash
     @flash ||= ActionDispatch::Flash::FlashHash.new
   end
+
+  def params_hash?(v)
+    v.is_a? Hash
+  end
+
+  def params_hash(v)
+    v
+  end
 end