active_scaffold 3.7.13 → 4.0.0.rc1

data/test/data_structures/columns_test.rb

@@ -1,68 +0,0 @@
-require 'test_helper'
-
-class ColumnsTest < Minitest::Test
-  def setup
-    @columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b)
-  end
-
-  def test_initialization
-    assert_equal ModelStub, @columns.active_record_class
-
-    assert @columns.include?('a'), 'checking via string'
-    assert @columns.include?(:b), 'checking via symbol'
-    refute @columns.include?(:c)
-  end
-
-  def test_add
-    refute @columns.include?(:c)
-    @columns.add 'c'
-    assert @columns.include?('c')
-
-    # test the alias
-    refute @columns.include?(:d)
-    @columns << :d
-    assert @columns.include?(:d)
-
-    # try adding an array of columns
-    refute @columns.include?(:f)
-    @columns.add %i[f g]
-    assert @columns.include?(:f)
-    assert @columns.include?(:g)
-  end
-
-  def test_finders
-    # test some basic assumptions before testing the finders
-    assert @columns.include?(:a)
-    assert @columns[:a].is_a?(ActiveScaffold::DataStructures::Column)
-
-    # test the single finders
-    assert @columns.find_by_name(:a).name == :a
-    assert @columns[:b].name == :b
-
-    # 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 })
-  end
-
-  def test_each
-    @columns.each do |column|
-      assert %i[a b].include?(column.name)
-    end
-  end
-
-  def test_block_config
-    refute @columns.include?(:d)
-    refute @columns.include?(:c)
-
-    @columns.configure do |config|
-      # test that we can use the config object
-      config << :d
-      # but test that we don't have to
-      add 'c'
-    end
-
-    assert @columns.include?(:d)
-    assert @columns.include?(:c)
-  end
-end

data/test/data_structures/set_test.rb

@@ -1,84 +0,0 @@
-require 'test_helper'
-
-class SetTest < Minitest::Test
-  def setup
-    @items = ActiveScaffold::DataStructures::Set.new(:a, :b)
-  end
-
-  def test_initialization
-    assert @items.include?(:a)
-    assert @items.include?(:b)
-    refute @items.include?(:c)
-  end
-
-  def test_exclude
-    # exclude with a symbol
-    assert @items.include?(:b)
-    @items.exclude :b
-    refute @items.include?(:b)
-
-    # exclude with a string
-    assert @items.include?(:a)
-    @items.exclude 'a'
-    refute @items.include?(:a)
-  end
-
-  def test_exclude_array
-    # exclude with a symbol
-    assert @items.include?(:b)
-    @items.exclude %i[a b]
-    refute @items.include?(:b)
-    refute @items.include?(:a)
-  end
-
-  def test_remove
-    assert @items.include?(:a)
-    @items.remove 'a'
-    refute @items.include?(:a)
-  end
-
-  def test_add
-    # try adding a simple column using a string
-    refute @items.include?(:c)
-    @items.add 'c'
-    assert @items.include?(:c)
-
-    # try adding a simple column using a symbol
-    refute @items.include?(:d)
-    @items.add :d
-    assert @items.include?(:d)
-
-    # test that << also adds
-    refute @items.include?(:e)
-    @items << 'e'
-    assert @items.include?(:e)
-
-    # try adding an array of columns
-    refute @items.include?(:f)
-    @items.add %i[f g]
-    assert @items.include?(:f)
-    assert @items.include?(:g)
-  end
-
-  def test_length
-    assert_equal 2, @items.length
-  end
-
-  def test_block_config
-    @items.configure do |config|
-      # we may use the config argument
-      config.add :c
-      # or we may not
-      exclude :b
-    end
-
-    assert @items.include?(:c)
-    refute @items.include?(:b)
-  end
-
-  def test_include
-    assert @items.include?(:a)
-    assert @items.include?(:b)
-    refute @items.include?(:d)
-  end
-end

data/test/data_structures/sorting_test.rb

@@ -1,148 +0,0 @@
-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, ModelStub)
-  end
-
-  def test_add
-    @sorting.add :a, 'ASC'
-    # test adding by symbol
-    assert @sorting.sorts_on?(:a)
-    # test adding an uppercase string direction
-    assert_equal 'ASC', @sorting.direction_of(:a)
-
-    @sorting.add 'b', :ASC
-    # test adding by string
-    assert @sorting.sorts_on?(:b)
-    # test adding an uppercase symbol direction
-    assert_equal 'ASC', @sorting.direction_of(:b)
-
-    @sorting.add @columns[:c], 'desc'
-    # test adding by object
-    assert @sorting.sorts_on?(:c)
-    # test adding a lowercase string direction
-    assert_equal 'DESC', @sorting.direction_of(:c)
-
-    @sorting << %i[d desc]
-    # testing adding with the alias
-    assert @sorting.sorts_on?(:d)
-    assert_equal 'DESC', @sorting.direction_of(:d)
-
-    @sorting.clear
-
-    # test adding without a direction (test default)
-    @sorting.add :a
-    assert_equal 'ASC', @sorting.direction_of(:a)
-
-    # test adding a bad column
-    assert_raises ArgumentError do
-      @sorting.add :foo
-    end
-
-    # test adding a bad direction
-    assert_raises ArgumentError do
-      @sorting.add :b, :FOO
-    end
-  end
-
-  def test_set
-    @sorting.add :a, 'ASC'
-    assert @sorting.sorts_on?(:a)
-
-    @sorting.set :b, 'DESC'
-    assert @sorting.instance_variable_get('@clauses').size == 1
-    refute @sorting.sorts_on?(:a)
-    assert @sorting.sorts_on?(:b)
-    assert_equal 'DESC', @sorting.direction_of(:b)
-
-    @sorting.set :a => 'DESC', :b => 'ASC'
-    assert @sorting.instance_variable_get('@clauses').size == 2
-    assert @sorting.sorts_on?(:a)
-    assert_equal 'DESC', @sorting.direction_of(:a)
-    assert @sorting.sorts_on?(:b)
-    assert_equal 'ASC', @sorting.direction_of(:b)
-
-    @sorting.set({a: 'DESC'}, {b: 'ASC'})
-    assert @sorting.instance_variable_get('@clauses').size == 2
-    assert @sorting.sorts_on?(:a)
-    assert_equal 'DESC', @sorting.direction_of(:a)
-    assert @sorting.sorts_on?(:b)
-    assert_equal 'ASC', @sorting.direction_of(:b)
-
-    @sorting.set [:a, 'DESC'], [:b, 'ASC']
-    assert @sorting.instance_variable_get('@clauses').size == 2
-    assert @sorting.sorts_on?(:a)
-    assert_equal 'DESC', @sorting.direction_of(:a)
-    assert @sorting.sorts_on?(:b)
-    assert_equal 'ASC', @sorting.direction_of(:b)
-  end
-
-  def test_sorts_on
-    @sorting.add :a
-    @sorting.add :b
-
-    assert @sorting.sorts_on?(:a)
-    assert @sorting.sorts_on?(:b)
-    refute @sorting.sorts_on?(:c)
-  end
-
-  def test_direction_of
-    @sorting.add :a, 'ASC'
-    @sorting.add :b, :DESC
-
-    assert_equal 'ASC', @sorting.direction_of(:a)
-    assert_equal 'DESC', @sorting.direction_of(:b)
-  end
-
-  def test_sorts_by_method
-    @columns[:a].sort_by :method => proc { 0 }
-
-    # test pure method sorting: true
-    @sorting.add :a
-    assert @sorting.sorts_by_method?
-
-    # test mixed sql/method sorting: raise error
-    assert_raises ArgumentError do
-      @sorting.add :b
-    end
-
-    # test pure sql sorting: false
-    @sorting.clear
-    @sorting.add :b
-    refute @sorting.sorts_by_method?
-  end
-
-  def test_build_order_clause
-    assert @sorting.clause.nil?
-
-    @sorting << [:a, 'desc']
-    @sorting << [:b, 'asc']
-
-    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 -> { order('a') } }
-    @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)
-    assert_nil @sorting.clause
-  end
-
-  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 = 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)
-    assert_equal 1, @sorting.instance_variable_get(:@clauses).size
-    assert_nil @sorting.clause
-  end
-end

data/test/data_structures/standard_column_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-class StandardColumnTest < Minitest::Test
-  def setup
-    @standard_column = ActiveScaffold::DataStructures::Column.new(ModelStub.columns.first.name, ModelStub)
-  end
-
-  def test_virtuality
-    assert @standard_column.column
-    refute @standard_column.virtual?
-  end
-
-  def test_sorting
-    hash = {:sql => '"model_stubs"."a"'}
-    assert @standard_column.sortable?
-    assert_equal hash, @standard_column.sort # check default
-  end
-
-  def test_searching
-    assert @standard_column.searchable?
-    assert_equal ['"model_stubs"."a"'], @standard_column.search_sql # check default
-  end
-end

data/test/data_structures/validation_reflection_test.rb

@@ -1,69 +0,0 @@
-require 'test_helper'
-
-class ValidationReflectionTest < Minitest::Test
-  def test_set_required_for_validates_presence_of
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    refute column.required?
-    Company.expects(:validators_on).with(:name).returns([ActiveModel::Validations::PresenceValidator.new(:attributes => :name)])
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    assert column.required?
-  end
-
-  def test_set_required_for_validates_presence_of_with_on
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    refute column.required?
-    Company.expects(:validators_on).with(:name).returns([ActiveModel::Validations::PresenceValidator.new(:attributes => :name, :on => [:create])])
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    assert column.required?
-    assert column.required?(:create)
-    refute column.required?(:update)
-  end
-
-  def test_set_required_for_validates_inclusion_of
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    refute column.required?
-    Company.expects(:validators_on).with(:name).returns([ActiveModel::Validations::InclusionValidator.new(:attributes => :name, :in => [])])
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    assert column.required?
-  end
-
-  def test_not_set_required_for_validates_inclusion_of_and_allow_nil
-    Company.expects(:validators_on).with(:name).returns([ActiveModel::Validations::InclusionValidator.new(:attributes => :name, :in => [], :allow_nil => true)])
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    refute column.required?
-  end
-
-  def test_not_set_required_for_validates_inclusion_of_and_allow_blank
-    Company.expects(:validators_on).with(:name).returns([ActiveModel::Validations::InclusionValidator.new(:attributes => :name, :in => [], :allow_blank => true)])
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    refute column.required?
-  end
-
-  def test_not_set_required_for_no_validation
-    Company.expects(:validators_on).with(:name).returns([])
-    column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    refute column.required?
-  end
-
-  def test_set_required_for_validates_presence_of_in_association
-    column = ActiveScaffold::DataStructures::Column.new(:main_company, Company)
-    refute column.required?
-    Company.expects(:validators_on).with(:main_company).returns([ActiveModel::Validations::PresenceValidator.new(:attributes => :main_company)])
-    column = ActiveScaffold::DataStructures::Column.new(:main_company, Company)
-    assert column.required?
-  end
-
-  def test_not_set_required_for_no_validation_in_association_neither_foreign_key
-    Company.expects(:validators_on).returns([])
-    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/data_structures/virtual_column_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-class VirtualColumnTest < Minitest::Test
-  def setup
-    @virtual_column = ActiveScaffold::DataStructures::Column.new(:fake, ModelStub)
-  end
-
-  def test_virtuality
-    refute @virtual_column.column
-    refute @virtual_column.association
-    assert @virtual_column.virtual?
-  end
-
-  def test_sorting
-    # right now, there's no intelligent sorting on virtual columns
-    refute @virtual_column.sortable?
-  end
-
-  def test_searching
-    # right now, there's no intelligent searching on virtual columns
-    refute @virtual_column.searchable?
-  end
-end

data/test/extensions/action_view_rendering_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-class ActionViewRenderingTest < ActionController::TestCase
-  setup do
-    @controller = PeopleController.new
-  end
-
-  test 'render :super twice' do
-    get :index
-    assert_select '#controller', 1
-    assert_select '#app', 1
-  end
-
-  test 'render partial override with render :super twice' do
-    get :new
-    assert_select '#first_name_field', 1
-    assert_select '#controller_form', 1
-    assert_select '#app_form', 1
-  end
-end

data/test/extensions/active_record_test.rb

@@ -1,44 +0,0 @@
-require 'test_helper'
-
-class ActiveRecordTest < Minitest::Test
-  def setup
-    @record = ModelStub.new
-  end
-
-  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)
-
-    class << @record
-      def to_s
-        'to_s'
-      end
-    end
-    RequestStore.clear!
-    assert_equal 'to_s', @record.to_label
-
-    class << @record
-      def title
-        'title'
-      end
-    end
-    RequestStore.clear!
-    assert_equal 'title', @record.to_label
-
-    class << @record
-      def label
-        'label'
-      end
-    end
-    RequestStore.clear!
-    assert_equal 'label', @record.to_label
-
-    class << @record
-      def name
-        'name'
-      end
-    end
-    RequestStore.clear!
-    assert_equal 'name', @record.to_label
-  end
-end

data/test/extensions/routing_mapper_test.rb

@@ -1,73 +0,0 @@
-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: :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/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', method: :post }
-    assert_raises(ActionController::RoutingError) { @routes.recognize_path '/cars/1' }
-    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

@@ -1,34 +0,0 @@
-require 'test_helper'
-
-class FormColumnHelpersTest < ActionView::TestCase
-  include ActiveScaffold::Helpers::FormColumnHelpers
-  include ActiveScaffold::Helpers::ViewHelpers
-
-  def setup
-    @column = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
-    @record = ModelStub.new(a: nil)
-  end
-
-  def test_choices_for_select_form_ui_for_simple_column
-    opts = {object: @record}
-    @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, opts.dup)
-
-    @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, opts.dup)
-
-    @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, opts.dup)
-
-    @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, opts.dup)
-  end
-
-  def test_options_for_select_form_ui_for_simple_column
-    opts = {object: @record}
-    @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, opts)
-  end
-end

data/test/helpers/list_column_helpers_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-class ListColumnHelpersTest < ActionView::TestCase
-  include ActiveScaffold::Helpers::ListColumnHelpers
-  include ActiveScaffold::Helpers::ViewHelpers
-  include ::ERB::Util
-
-  def setup
-    @column = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
-    @column.form_ui = :select
-    @record = stub(:a => 'value_2')
-    @config = stub(:list => stub(:empty_field_text => '-', :association_join_text => ', '), :actions => [:list])
-    @association_column = ActiveScaffold::DataStructures::Column.new(:b, ModelStub)
-    @association_column.stubs(:association).returns(stub(:collection? => true))
-  end
-
-  def test_options_for_select_list_ui_for_simple_column
-    @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]
-    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]]
-    assert_equal 'text_2', format_column_value(@record, @column)
-
-    @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/>')
-    remove_instance_variable :@_association_join_text
-    assert_equal '1,&lt;br/&gt;2,&lt;br/&gt;3,&lt;br/&gt;… (4)', format_association_value(value, @association_column, value.size)
-    @config.list.stubs(:association_join_text => ',<br/>'.html_safe) # rubocop:disable Rails/OutputSafety
-    remove_instance_variable :@_association_join_text
-    assert_equal '1,<br/>2,<br/>3,<br/>… (4)', format_association_value(value, @association_column, value.size)
-  end
-
-  private
-
-  def grouped_search?
-    false
-  end
-
-  def active_scaffold_config
-    @config
-  end
-end