active_scaffold 3.4.17 → 3.4.18

data/test/data_structures/action_link_test.rb

@@ -20,6 +20,7 @@ class ActionLinkTest < MiniTest::Test
     refute @link.confirm
     @link.confirm = true
     assert @link.confirm
+    assert @link.confirm?
 
     assert_equal 'bar_authorized?', @link.security_method
 

data/test/data_structures/action_links_test.rb

@@ -9,19 +9,19 @@ class ActionLinksTest < MiniTest::Test
     # test adding with a shortcut
     @links.add 'foo/bar'
 
-    assert_equal 1, @links.find_all{true}.size
-    assert_equal 'foo/bar', @links.find_all{true}[0].action
+    assert_equal 1, @links.find_all { true }.size
+    assert_equal 'foo/bar', @links.find_all { true }[0].action
     assert_equal 'foo/bar', @links['foo/bar'].action
 
     # test adding an ActionLink object directly
     @links.add ActiveScaffold::DataStructures::ActionLink.new('hello/world')
 
-    assert_equal 2, @links.find_all{true}.size
+    assert_equal 2, @links.find_all { true }.size
 
     # test the << alias
     @links << 'a/b'
 
-    assert_equal 3, @links.find_all{true}.size
+    assert_equal 3, @links.find_all { true }.size
   end
 
   def test_array_access
@@ -60,7 +60,7 @@ class ActionLinksTest < MiniTest::Test
       assert_equal 'bar', link.action
     end
   end
-  
+
   def test_delete
     @links.add 'foo'
     @links.add 'bar'

data/test/data_structures/column_test.rb

@@ -61,7 +61,7 @@ class ColumnTest < MiniTest::Test
     assert columns != @column
 
     # identity
-    assert @column == @column
+    assert @column == @column # rubocop:disable Lint/UselessComparison
 
     # string comparison
     assert @column == 'a'
@@ -78,7 +78,7 @@ class ColumnTest < MiniTest::Test
     assert @column == column2
 
     # special comparisons
-    assert @column != nil
+    refute @column.nil?
     assert @column != ''
     assert @column != 0
   end
@@ -135,7 +135,7 @@ class ColumnTest < MiniTest::Test
     hash = {:sql => 'foobar'}
     assert_equal hash, @column.sort
 
-    some_proc = proc {'foobar'}
+    some_proc = proc { 'foobar' }
     @column.sort_by :method => some_proc
     hash = {:method => some_proc}
     assert_equal hash, @column.sort
@@ -143,12 +143,12 @@ class ColumnTest < MiniTest::Test
   end
 
   def test_custom_sort__should_assert_keys
-    assert_raises(ArgumentError) { @column.sort_by :proc => "invalid config"  }
-    assert_raises(ArgumentError) { @column.sort={:proc => "invalid config" } }
-    assert_equal({:method => "method"}, @column.sort_by(:method => "method"))
-    assert_equal({:sql => "method"}, @column.sort_by(:sql => "method"))
+    assert_raises(ArgumentError) { @column.sort_by :proc => 'invalid config'  }
+    assert_raises(ArgumentError) { @column.sort = {:proc => 'invalid config'} }
+    assert_equal({:method => 'method'}, @column.sort_by(:method => 'method'))
+    assert_equal({:sql => 'method'}, @column.sort_by(:sql => 'method'))
   end
-  
+
   def test_config_block
     @column.configure do |config|
       # we can use the config object
@@ -173,7 +173,7 @@ class ColumnTest < MiniTest::Test
 
   def test_includes
     assert_equal nil, @column.includes
-    
+
     # make sure that when a non-array comes in, an array comes out
     @column.includes = :column_name
     assert_equal([:column_name], @column.includes)

data/test/data_structures/columns_test.rb

@@ -41,8 +41,8 @@ class ColumnsTest < MiniTest::Test
 
     # test the collection finders
     found = @columns.find_by_names(:a, :b)
-    assert found.any? {|c| c.name == :a}
-    assert found.any? {|c| c.name == :b}
+    assert found.any? { |c| c.name == :a }
+    assert found.any? { |c| c.name == :b }
   end
 
   def test_each

data/test/data_structures/error_message_test.rb

@@ -6,21 +6,20 @@ class ErrorMessageTest < MiniTest::Test
   end
 
   def test_attributes
-    assert @error.public_attributes.has_key?(:error)
+    assert @error.public_attributes.key?(:error)
     assert_equal 'foo', @error.public_attributes[:error]
   end
 
   def test_xml
     xml = Hash.from_xml(@error.to_xml)
-    assert xml.has_key?('errors')
-    assert xml['errors'].has_key?('error')
+    assert xml.key?('errors')
+    assert xml['errors'].key?('error')
     assert_equal 'foo', xml['errors']['error']
   end
 
   def test_yaml
-    yml = nil
     yml = YAML.load(@error.to_yaml)
-    assert yml.has_key?(:error)
+    assert yml.key?(:error)
     assert_equal 'foo', yml[:error]
   end
 end

data/test/data_structures/set_test.rb

@@ -50,7 +50,7 @@ class SetTest < MiniTest::Test
 
     # test that << also adds
     refute @items.include?(:e)
-    @items << "e"
+    @items << 'e'
     assert @items.include?(:e)
 
     # try adding an array of columns
@@ -58,7 +58,6 @@ class SetTest < MiniTest::Test
     @items.add [:f, :g]
     assert @items.include?(:f)
     assert @items.include?(:g)
-
   end
 
   def test_length

data/test/data_structures/sorting_test.rb

@@ -90,18 +90,18 @@ class SortingTest < MiniTest::Test
   end
 
   def test_sorts_by_method
-    @columns[:a].sort_by :method => proc{0}
+    @columns[:a].sort_by :method => proc { 0 }
 
-    #test pure method sorting: true
+    # test pure method sorting: true
     @sorting.add :a
     assert @sorting.sorts_by_method?
 
-    #test mixed sql/method sorting: raise error
+    # test mixed sql/method sorting: raise error
     assert_raises ArgumentError do
       @sorting.add :b
     end
-    
-    #test pure sql sorting: false
+
+    # test pure sql sorting: false
     @sorting.clear
     @sorting.add :b
     refute @sorting.sorts_by_method?
@@ -115,12 +115,12 @@ class SortingTest < MiniTest::Test
 
     assert_equal '"model_stubs"."a" DESC, "model_stubs"."b" ASC', @sorting.clause.join(', ')
   end
-  
+
   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 lambda { order('a') } }
+    model_stub_with_default_scope.class_eval { default_scope -> { order('a') } }
     @sorting.set_default_sorting model_stub_with_default_scope
-    
+
     assert @sorting.sorts_on?(:a)
     assert_equal 'ASC', @sorting.direction_of(:a)
     assert_nil @sorting.clause
@@ -128,9 +128,9 @@ 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 lambda { order('a DESC, players.last_name ASC') } }
+    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
-    
+
     assert @sorting.sorts_on?(:a)
     assert_equal 'DESC', @sorting.direction_of(:a)
     assert_equal 1, @sorting.instance_variable_get(:@clauses).size

data/test/data_structures/validation_reflection_test.rb

@@ -48,4 +48,12 @@ class ValidationReflectionTest < MiniTest::Test
     column = ActiveScaffold::DataStructures::Column.new(:main_company, Company)
     refute column.required?
   end
+
+  def test_override_required
+    Company.expects(:validators_on).with(:name).returns([ActiveModel::Validations::PresenceValidator.new(:attributes => :name)])
+    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
+    assert column.required?
+    column.required = false
+    refute column.required?
+  end
 end

data/test/extensions/routing_mapper_test.rb

@@ -13,8 +13,8 @@ class RoutingMapperTest < ActionController::TestCase
 
   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({: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'

data/test/helpers/list_column_helpers_test.rb

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 require 'test_helper'
 
 class ListColumnHelpersTest < ActionView::TestCase
@@ -31,7 +31,7 @@ class ListColumnHelpersTest < ActionView::TestCase
 
   def test_association_join_text
     value = [1, 2, 3, 4].map(&:to_s)
-    value.each {|v| v.stubs(:to_label).returns(v)}
+    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/>')
     assert_equal '1,&lt;br/&gt;2,&lt;br/&gt;3,&lt;br/&gt;… (4)', format_association_value(value, @association_column, value.size)
@@ -40,6 +40,7 @@ class ListColumnHelpersTest < ActionView::TestCase
   end
 
   private
+
   def active_scaffold_config
     @config
   end

data/test/helpers/pagination_helpers_test.rb

@@ -8,7 +8,7 @@ class PaginationHelpersTest < MiniTest::Test
   end
 
   def test_links
-    self.stubs(:pagination_ajax_link).returns('l')
+    stubs(:pagination_ajax_link).returns('l')
 
     assert_equal '1', links(1, 1)
     assert_equal '1 l', links(1, 2)
@@ -31,7 +31,7 @@ class PaginationHelpersTest < MiniTest::Test
   end
 
   def test_links_with_infinite_pagination
-    self.stubs(:pagination_ajax_link).returns('l')
+    stubs(:pagination_ajax_link).returns('l')
 
     assert_equal '1 l l .. l .. l', links(1, nil, 2, true)
     assert_equal 'l 2 l l .. l .. l', links(2, nil, 2, true)
@@ -51,13 +51,14 @@ class PaginationHelpersTest < MiniTest::Test
   end
 
   private
+
   def links(current, last_page, window_size = 2, infinite = false)
-    paginator = stub(:last => last_page = stub(:number => last_page), :infinite? => infinite)
+    paginator = stub(:last => stub(:number => last_page), :infinite? => infinite)
     current_page = stub(:number => current, :pager => paginator)
     pagination_ajax_links(current_page, {}, {}, window_size, 0)
   end
 
-  def content_tag(tag, text, *args)
+  def content_tag(tag, text, *)
     text
   end
 end

data/test/helpers/search_column_helpers_test.rb

@@ -9,6 +9,6 @@ class SearchColumnHelpersTest < ActionView::TestCase
   end
 
   def test_choices_for_boolean_search_ui
-    assert_dom_equal "<select name=\"search[adult]\"><option value=\"\">- select -</option>\n<option value=\"true\">True</option>\n<option value=\"false\" selected=\"selected\">False</option></select>", active_scaffold_search_boolean(@column, :object => @record, :name => "search[adult]", :value => '0')
+    assert_dom_equal "<select name=\"search[adult]\"><option value=\"\">- select -</option>\n<option value=\"true\">True</option>\n<option value=\"false\" selected=\"selected\">False</option></select>", active_scaffold_search_boolean(@column, :object => @record, :name => 'search[adult]', :value => '0')
   end
 end

data/test/misc/active_record_permissions_test.rb

@@ -2,53 +2,66 @@ 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 authorized_for_read?; true; end
+
   def authorized_for_update?; false; end
-  #def authorized_for_create?; end
+  # def authorized_for_create?; end
 
   def a1_authorized?; true; end
+
   def a2_authorized?; false; end
-  #def a3_authorized?; end
+  # def a3_authorized?; end
 
   def b1_authorized?; true; end
+
   def b2_authorized?; false; end
-  #def b3_authorized?; end
+  # def b3_authorized?; end
 
   def c1_authorized?; true; end
+
   def c2_authorized?; false; end
-  #def c3_authorized?; end
+  # def c3_authorized?; end
 
   def a3_authorized_for_create?; true; end
+
   def b3_authorized_for_create?; false; end
-  #def c3_authorized_for_create?; 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 c2_authorized_for_create?; end
   def a1_authorized_for_create?; true; end
+
   def b1_authorized_for_create?; false; end
-  #def c1_authorized_for_create?; end
+  # def c1_authorized_for_create?; end
 
   def a3_authorized_for_read?; true; end
+
   def b3_authorized_for_read?; false; end
-  #def c3_authorized_for_read?; 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 c2_authorized_for_read?; end
   def a1_authorized_for_read?; true; end
+
   def b1_authorized_for_read?; false; end
-  #def c1_authorized_for_read?; end
+  # def c1_authorized_for_read?; end
 
   def a3_authorized_for_update?; true; end
+
   def b3_authorized_for_update?; false; end
-  #def c3_authorized_for_update?; 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 c2_authorized_for_update?; end
   def a1_authorized_for_update?; true; end
+
   def b1_authorized_for_update?; false; end
-  #def c1_authorized_for_update?; end
+  # def c1_authorized_for_update?; end
 end
 
 class ActiveRecordPermissionsTest < MiniTest::Test
@@ -67,41 +80,41 @@ class ActiveRecordPermissionsTest < MiniTest::Test
     end
 
     pass(@model.authorized_for?(:column => :a3), '_a_')
-    fail(@model.authorized_for?(:column => :a2), '_f_')
+    miss(@model.authorized_for?(:column => :a2), '_f_')
     pass(@model.authorized_for?(:column => :a1), '_t_')
 
     pass(@model.authorized_for?(:crud_type => :create), 'a__')
-    fail(@model.authorized_for?(:crud_type => :update), 'f__')
+    miss(@model.authorized_for?(:crud_type => :update), 'f__')
     pass(@model.authorized_for?(:crud_type => :read), 't__')
 
     pass(@model.authorized_for?(:crud_type => :create, :column => :c3), 'aaa')
-    fail(@model.authorized_for?(:crud_type => :create, :column => :b3), 'aaf')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :b3), 'aaf')
     pass(@model.authorized_for?(:crud_type => :create, :column => :a3), 'aat')
-    fail(@model.authorized_for?(:crud_type => :create, :column => :c2), 'afa')
-    fail(@model.authorized_for?(:crud_type => :create, :column => :b2), 'aff')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :c2), 'afa')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :b2), 'aff')
     pass(@model.authorized_for?(:crud_type => :create, :column => :a2), 'aft')
     pass(@model.authorized_for?(:crud_type => :create, :column => :c1), 'ata')
-    fail(@model.authorized_for?(:crud_type => :create, :column => :b1), 'atf')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :b1), 'atf')
     pass(@model.authorized_for?(:crud_type => :create, :column => :a1), 'att')
 
-    fail(@model.authorized_for?(:crud_type => :update, :column => :c3), 'faa')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :b3), 'faf')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :c3), 'faa')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :b3), 'faf')
     pass(@model.authorized_for?(:crud_type => :update, :column => :a3), 'fat')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :c2), 'ffa')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :b2), 'fff')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :c2), 'ffa')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :b2), 'fff')
     pass(@model.authorized_for?(:crud_type => :update, :column => :a2), 'fft')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :c1), 'fta')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :b1), 'ftf')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :c1), 'fta')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :b1), 'ftf')
     pass(@model.authorized_for?(:crud_type => :update, :column => :a1), 'ftt')
 
     pass(@model.authorized_for?(:crud_type => :read, :column => :c3), 'taa')
-    fail(@model.authorized_for?(:crud_type => :read, :column => :b3), 'taf')
+    miss(@model.authorized_for?(:crud_type => :read, :column => :b3), 'taf')
     pass(@model.authorized_for?(:crud_type => :read, :column => :a3), 'tat')
-    fail(@model.authorized_for?(:crud_type => :read, :column => :c2), 'tfa')
-    fail(@model.authorized_for?(:crud_type => :read, :column => :b2), 'tff')
+    miss(@model.authorized_for?(:crud_type => :read, :column => :c2), 'tfa')
+    miss(@model.authorized_for?(:crud_type => :read, :column => :b2), 'tff')
     pass(@model.authorized_for?(:crud_type => :read, :column => :a2), 'tft')
     pass(@model.authorized_for?(:crud_type => :read, :column => :c1), 'tta')
-    fail(@model.authorized_for?(:crud_type => :read, :column => :b1), 'ttf')
+    miss(@model.authorized_for?(:crud_type => :read, :column => :b1), 'ttf')
     pass(@model.authorized_for?(:crud_type => :read, :column => :a1), 'ttt')
 
     ActiveScaffold.set_defaults do |config|
@@ -116,42 +129,42 @@ class ActiveRecordPermissionsTest < MiniTest::Test
       config.security.default_permission = false
     end
 
-    fail(@model.authorized_for?(:column => :a3), '_a_')
-    fail(@model.authorized_for?(:column => :a2), '_f_')
+    miss(@model.authorized_for?(:column => :a3), '_a_')
+    miss(@model.authorized_for?(:column => :a2), '_f_')
     pass(@model.authorized_for?(:column => :a1), '_t_')
 
-    fail(@model.authorized_for?(:crud_type => :create), 'a__')
-    fail(@model.authorized_for?(:crud_type => :update), 'f__')
+    miss(@model.authorized_for?(:crud_type => :create), 'a__')
+    miss(@model.authorized_for?(:crud_type => :update), 'f__')
     pass(@model.authorized_for?(:crud_type => :read), 't__')
 
-    fail(@model.authorized_for?(:crud_type => :create, :column => :c3), 'aaa')
-    fail(@model.authorized_for?(:crud_type => :create, :column => :b3), 'aaf')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :c3), 'aaa')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :b3), 'aaf')
     pass(@model.authorized_for?(:crud_type => :create, :column => :a3), 'aat')
-    fail(@model.authorized_for?(:crud_type => :create, :column => :c2), 'afa')
-    fail(@model.authorized_for?(:crud_type => :create, :column => :b2), 'aff')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :c2), 'afa')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :b2), 'aff')
     pass(@model.authorized_for?(:crud_type => :create, :column => :a2), 'aft')
     pass(@model.authorized_for?(:crud_type => :create, :column => :c1), 'ata')
-    fail(@model.authorized_for?(:crud_type => :create, :column => :b1), 'atf')
+    miss(@model.authorized_for?(:crud_type => :create, :column => :b1), 'atf')
     pass(@model.authorized_for?(:crud_type => :create, :column => :a1), 'att')
 
-    fail(@model.authorized_for?(:crud_type => :update, :column => :c3), 'faa')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :b3), 'faf')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :c3), 'faa')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :b3), 'faf')
     pass(@model.authorized_for?(:crud_type => :update, :column => :a3), 'fat')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :c2), 'ffa')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :b2), 'fff')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :c2), 'ffa')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :b2), 'fff')
     pass(@model.authorized_for?(:crud_type => :update, :column => :a2), 'fft')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :c1), 'fta')
-    fail(@model.authorized_for?(:crud_type => :update, :column => :b1), 'ftf')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :c1), 'fta')
+    miss(@model.authorized_for?(:crud_type => :update, :column => :b1), 'ftf')
     pass(@model.authorized_for?(:crud_type => :update, :column => :a1), 'ftt')
 
     pass(@model.authorized_for?(:crud_type => :read, :column => :c3), 'taa')
-    fail(@model.authorized_for?(:crud_type => :read, :column => :b3), 'taf')
+    miss(@model.authorized_for?(:crud_type => :read, :column => :b3), 'taf')
     pass(@model.authorized_for?(:crud_type => :read, :column => :a3), 'tat')
-    fail(@model.authorized_for?(:crud_type => :read, :column => :c2), 'tfa')
-    fail(@model.authorized_for?(:crud_type => :read, :column => :b2), 'tff')
+    miss(@model.authorized_for?(:crud_type => :read, :column => :c2), 'tfa')
+    miss(@model.authorized_for?(:crud_type => :read, :column => :b2), 'tff')
     pass(@model.authorized_for?(:crud_type => :read, :column => :a2), 'tft')
     pass(@model.authorized_for?(:crud_type => :read, :column => :c1), 'tta')
-    fail(@model.authorized_for?(:crud_type => :read, :column => :b1), 'ttf')
+    miss(@model.authorized_for?(:crud_type => :read, :column => :b1), 'ttf')
     pass(@model.authorized_for?(:crud_type => :read, :column => :a1), 'ttt')
 
     ActiveScaffold.set_defaults do |config|
@@ -165,7 +178,7 @@ class ActiveRecordPermissionsTest < MiniTest::Test
     assert value, "#{message} should pass"
   end
 
-  def fail(value, message = nil)
+  def miss(value, message = nil)
     refute value, "#{message} should fail"
   end
 end