active_scaffold 3.7.12 → 4.0.0.rc1

data/test/config/show_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-module Config
-  class ShowTest < Minitest::Test
-    def setup
-      @config = ActiveScaffold::Config::Core.new :model_stub
-      @default_link = @config.show.link
-    end
-
-    def teardown
-      @config.show.link = @default_link
-    end
-
-    def test_link_defaults
-      link = @config.show.link
-      refute link.page?
-      refute link.popup?
-      refute link.confirm?
-      assert_equal 'show', link.action
-      assert_equal 'Show', link.label
-      assert link.inline?
-      blank = {}
-      assert_equal blank, link.html_options
-      assert_equal :get, link.method
-      assert_equal :member, link.type
-      assert_equal :read, link.crud_type
-      assert_equal :show_authorized?, link.security_method
-    end
-
-    def test_setting_link
-      @config.show.link = ActiveScaffold::DataStructures::ActionLink.new('update', :label => 'Monkeys')
-      refute_equal @default_link, @config.show.link
-    end
-
-    def test_label
-      label = 'show monkeys'
-      @config.show.label = label
-      assert_equal label, @config.show.label
-      I18n.backend.store_translations :en, :active_scaffold => {:view_model => 'View %<model>s'}
-      @config.show.label = :view_model
-      assert_equal 'View Model stub', @config.show.label
-      assert_equal 'View record', @config.show.label('record')
-    end
-  end
-end

data/test/config/subform_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-module Config
-  class SubformTest < Minitest::Test
-    def setup
-      @config = ActiveScaffold::Config::Core.new :model_stub
-    end
-
-    def test_defaults
-      assert_equal :horizontal, @config.subform.layout
-    end
-
-    def test_setting_layout
-      layout = :vertical
-      @config.subform.layout = layout
-      assert_equal layout, @config.subform.layout
-    end
-  end
-end

data/test/config/update_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-module Config
-  class UpdateTest < Minitest::Test
-    include ActiveScaffold::Helpers::ControllerHelpers
-
-    def setup
-      @config = ActiveScaffold::Config::Core.new :model_stub
-    end
-
-    def test_copy_columns_from_create
-      @config.create.columns = %i[a c d]
-      assert_equal %i[a d], @config.create.columns.visible_columns_names
-      @config.update.columns = @config.create.columns
-      assert_equal %i[a c d], @config.update.columns.visible_columns_names
-    end
-
-    def test__params_for_columns__returns_all_params
-      @config.columns[:a].params.add :keep_a, :a_temp
-      assert @config.columns[:a].params.include?(:keep_a)
-      assert @config.columns[:a].params.include?(:a_temp)
-    end
-
-    def test_default_options
-      refute @config.update.persistent
-      refute @config.update.nested_links
-      assert_equal 'Model stub', @config.update.label
-    end
-
-    def test_persistent
-      @config.update.persistent = true
-      assert @config.update.persistent
-    end
-
-    def test_nested_links
-      old = @config.update.nested_links
-      @config.update.nested_links = true
-      assert @config.update.nested_links
-      @config.update.nested_links = old
-    end
-
-    def test_label
-      label = 'update new monkeys'
-      @config.update.label = label
-      assert_equal label, @config.update.label
-      I18n.backend.store_translations :en, :active_scaffold => {:change_model => 'Change %<model>s'}
-      @config.update.label = :change_model
-      assert_equal 'Change Model stub', @config.update.label
-      assert_equal 'Change record', @config.update.label('record')
-    end
-  end
-end

data/test/const_mocker.rb

@@ -1,32 +0,0 @@
-class ConstMocker
-  def initialize(const_name, parent = Object)
-    @parent = parent
-    @const_name = const_name
-    @const_state = nil
-    @const_state = @parent.const_defined?(@const_name) ? @parent.const_get(@const_name) : nil
-  end
-
-  def remove
-    @parent.send :remove_const, @const_name if @parent.const_defined?(@const_name)
-  end
-
-  def declare
-    @parent.const_set @const_name, Class.new
-  end
-
-  def restore
-    remove
-    @parent.const_set @const_name, @const_state if @const_state
-  end
-
-  def const
-    @parent.const_get @const_name if @parent.const_defined?(@const_name)
-  end
-
-  def self.mock(const_name, parent = Object, &block)
-    cm = new(const_name, parent)
-    yield(cm)
-    cm.restore
-    true
-  end
-end

data/test/data_structures/action_columns_test.rb

@@ -1,112 +0,0 @@
-require 'test_helper'
-# require 'test/model_stub'
-# require File.join(File.dirname(__FILE__), '../../lib/active_scaffold/data_structures/set.rb')
-
-class ActionColumnsTest < Minitest::Test
-  def setup
-    @columns = ActiveScaffold::DataStructures::ActionColumns.new(%i[a b])
-    @columns.action = stub(core: stub(model_id: 'model_stub'), user_settings_key: :"model_stub_active_scaffold/config/test")
-  end
-
-  def test_label
-    refute_equal 'foo', @columns.label
-    @columns.label = 'foo'
-    assert_equal 'foo', @columns.label
-  end
-
-  def test_initialization
-    assert @columns.include?(:a)
-    assert @columns.include?(:b)
-    refute @columns.include?(:c)
-  end
-
-  def test_exclude
-    # exclude with a symbol
-    assert @columns.include?(:b)
-    @columns.exclude :b
-    refute @columns.include?(:b)
-
-    # exclude with a string
-    assert @columns.include?(:a)
-    @columns.exclude 'a'
-    refute @columns.include?(:a)
-  end
-
-  def test_exclude_array
-    # exclude with a symbol
-    assert @columns.include?(:b)
-    @columns.exclude %i[a b]
-    refute @columns.include?(:b)
-    refute @columns.include?(:a)
-  end
-
-  def test_add
-    # try adding a simple column using a string
-    refute @columns.include?(:c)
-    @columns.add 'c'
-    assert @columns.include?(:c)
-
-    # try adding a simple column using a symbol
-    refute @columns.include?(:d)
-    @columns.add :d
-    assert @columns.include?(:d)
-
-    # test that << also adds
-    refute @columns.include?(:e)
-    @columns << :e
-    assert @columns.include?(:e)
-
-    # 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_length
-    assert_equal 2, @columns.length
-  end
-
-  def test_add_subgroup
-    # first, use @columns.add directly
-    @c2 = ActiveScaffold::DataStructures::ActionColumns.new
-    @columns.add @c2
-    assert(@columns.any? { |c| c == @c2 })
-
-    # then use the shortcut
-    @columns.add_subgroup 'foo' do
-    end
-    assert(@columns.any? { |c| c.respond_to?(:label) && c.label == 'foo' })
-  end
-
-  def test_block_config
-    @columns.configure do |config|
-      # we may use the config argument
-      config.add :c
-      # or we may not
-      exclude :b
-      add_subgroup 'my subgroup' do
-        add :e
-      end
-    end
-
-    assert @columns.include?(:c)
-    refute @columns.include?(:b)
-    @columns.each do |c|
-      next unless c.is_a? ActiveScaffold::DataStructures::Columns
-      assert c.include?(:e)
-      assert_equal 'my subgroup', c.name
-    end
-  end
-
-  def test_include
-    @columns.add_subgroup 'foo' do
-      add :c
-    end
-
-    assert @columns.include?(:a)
-    assert @columns.include?(:b)
-    assert @columns.include?(:c)
-    refute @columns.include?(:d)
-  end
-end

data/test/data_structures/action_link_test.rb

@@ -1,79 +0,0 @@
-require 'test_helper'
-
-class ActionLinkTest < Minitest::Test
-  def setup
-    @link = ActiveScaffold::DataStructures::ActionLink.new('foo')
-  end
-
-  def test_simple_attributes
-    assert_equal 'foo', @link.action
-    @link.action = 'bar'
-    assert_equal 'bar', @link.action
-
-    hash = {:a => :b}
-    @link.parameters = hash
-    assert_equal hash, @link.parameters
-
-    @link.label = 'hello world'
-    assert_equal 'hello world', @link.label
-
-    refute @link.confirm
-    @link.confirm = true
-    assert @link.confirm
-    assert @link.confirm?
-
-    assert_equal 'bar_authorized?', @link.security_method
-
-    assert_equal false, @link.security_method_set?
-    @link.security_method = 'blueberry_pie'
-    assert_equal true, @link.security_method_set?
-    assert_equal 'blueberry_pie', @link.security_method
-
-    @link.type = :collection
-    assert_equal :collection, @link.type
-    @link.type = :member
-    assert_equal :member, @link.type
-
-    assert_equal :get, @link.method
-    @link.method = :put
-    assert_equal :put, @link.method
-  end
-
-  def test_position
-    @link.position = true
-
-    @link.type = :collection
-    assert_equal :top, @link.position
-
-    @link.type = :member
-    assert_equal :replace, @link.position
-
-    @link.position = :before
-    assert_equal :before, @link.position
-
-    @link.position = false
-    assert_equal false, @link.position
-  end
-
-  def test_presentation_style
-    # default
-    assert @link.inline?
-    refute @link.popup?
-    refute @link.page?
-
-    @link.popup = true
-    refute @link.inline?
-    assert @link.popup?
-    refute @link.page?
-
-    @link.page = true
-    refute @link.inline?
-    refute @link.popup?
-    assert @link.page?
-
-    @link.inline = true
-    assert @link.inline?
-    refute @link.popup?
-    refute @link.page?
-  end
-end

data/test/data_structures/action_links_test.rb

@@ -1,78 +0,0 @@
-require 'test_helper'
-
-class ActionLinksTest < Minitest::Test
-  def setup
-    @links = ActiveScaffold::DataStructures::ActionLinks.new
-  end
-
-  def test_add_and_find
-    # 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 '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
-
-    # test the << alias
-    @links << 'a/b'
-
-    assert_equal 3, @links.find_all { true }.size
-  end
-
-  def test_array_access
-    @link1 = ActiveScaffold::DataStructures::ActionLink.new 'foo/bar'
-    @link2 = ActiveScaffold::DataStructures::ActionLink.new 'hello_world'
-
-    @links.add @link1
-    @links.add @link2
-
-    assert_equal @link1, @links[@link1.action]
-    assert_equal @link2, @links[@link2.action]
-  end
-
-  def test_empty
-    assert @links.empty?
-    @links.add 'a'
-    refute @links.empty?
-  end
-
-  def test_cloning
-    @links.add 'foo/bar'
-    @links_copy = @links.clone
-
-    refute @links.equal?(@links_copy)
-    refute @links['foo/bar'].equal?(@links_copy['foo/bar'])
-  end
-
-  def test_each
-    @links.add 'foo', :type => :collection
-    @links.add 'bar', :type => :member
-
-    @links.collection.each do |link|
-      assert_equal 'foo', link.action
-    end
-    @links.member.each do |link|
-      assert_equal 'bar', link.action
-    end
-  end
-
-  def test_delete
-    @links.add 'foo'
-    @links.add 'bar'
-
-    @links.delete :foo
-    assert @links['foo'].nil?
-    begin
-      @links.delete :foo
-      @links.delete 'foo'
-    rescue StandardError
-      assert false, "deleting from action links when item doesn't exist should not throw an error"
-    end
-    refute @links['bar'].nil?
-  end
-end

data/test/data_structures/actions_test.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-class ActionsTest < Minitest::Test
-  def setup
-    @actions = ActiveScaffold::DataStructures::Actions.new(:a, 'b')
-  end
-
-  def test_initialization
-    assert @actions.include?('a')
-    assert @actions.include?(:b)
-    refute @actions.include?(:c)
-  end
-
-  def test_exclude
-    assert @actions.include?('b')
-    @actions.exclude :b
-    refute @actions.include?(:b)
-  end
-
-  def test_add
-    refute @actions.include?(:c)
-    @actions.add 'c'
-    assert @actions.include?('c')
-  end
-end

data/test/data_structures/association_column_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-require 'model_stub'
-
-class AssociationColumnTest < Minitest::Test
-  def setup
-    @association_column = ActiveScaffold::DataStructures::Column.new('other_model', ModelStub)
-  end
-
-  def test_virtuality
-    assert @association_column.association
-    refute @association_column.virtual?
-  end
-
-  def test_sorting
-    # sorting on association columns is not defined
-    assert_equal false, @association_column.sort
-  end
-
-  def test_searching
-    # by default searching on association columns uses primary key
-    assert @association_column.searchable?
-    assert_equal ['"model_stubs"."id"'], @association_column.search_sql
-  end
-
-  def test_association
-    assert @association_column.association.is_a?(ActiveScaffold::DataStructures::Association::Abstract)
-  end
-
-  def test_includes
-    assert_equal [:other_model], @association_column.includes
-  end
-
-  def test_plurality
-    assert @association_column.association.singular?
-    refute @association_column.association.collection?
-
-    plural_association_column = ActiveScaffold::DataStructures::Column.new('other_models', ModelStub)
-    assert plural_association_column.association.collection?
-    refute plural_association_column.association.singular?
-  end
-end

data/test/data_structures/column_test.rb

@@ -1,186 +0,0 @@
-require 'test_helper'
-
-class ColumnTest < Minitest::Test
-  def setup
-    @column = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
-    @association_col = ActiveScaffold::DataStructures::Column.new(:b, ModelStub)
-    @association_col.stubs(:polymorphic_association?).returns(false)
-    @association_col.stubs(association: stub(polymorphic?: false))
-  end
-
-  def test_column
-    assert @column.column.is_a?(ActiveRecord::ConnectionAdapters::Column)
-    assert_equal @column.column.name, 'a'
-  end
-
-  def test_basic_properties
-    # test that it was set during initialization
-    assert_equal @column.name, :a
-
-    # label
-    @column.label = 'foo'
-    assert_equal 'foo', @column.label
-
-    # description
-    @column.description = 'hello world'
-    assert_equal 'hello world', @column.description
-
-    # css class
-    @column.css_class = 'style_me'
-    assert_equal 'style_me', @column.css_class
-
-    # required
-    refute @column.required?, 'default is false'
-    @column.required = true
-    assert @column.required?, 'can be changed'
-
-    # calculation
-    refute @column.calculation?, 'default is nil'
-    @column.calculate = :sum
-    assert @column.calculation?, 'can be changed'
-  end
-
-  def test_field
-    assert_equal '"model_stubs"."a"', @column.send(:field)
-  end
-
-  def test_table
-    assert_equal 'model_stubs', @column.send(:table)
-  end
-
-  def test_equality
-    # create a separate columns object, and make sure it's not ==
-    columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b)
-    refute_equal columns, @column
-
-    # create a separate action_columns object, and make sure it's not ==
-    columns = ActiveScaffold::DataStructures::ActionColumns.new(:a, :b)
-    refute_equal columns, @column
-
-    # identity
-    assert_equal @column, @column
-
-    # string comparison
-    assert_equal @column, 'a'
-    refute_equal @column, 'fake'
-
-    # symbol comparison
-    assert_equal @column, :a
-    refute_equal @column, :fake
-
-    # comparison with different object of same type
-    column2 = ActiveScaffold::DataStructures::Column.new(:fake, ModelStub)
-    refute_equal @column, column2
-    column2 = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
-    assert_equal @column, column2
-
-    # special comparisons
-    refute @column.nil?
-    refute_equal @column, ''
-    refute_equal @column, 0
-  end
-
-  def test_ui
-    assert_nil @column.form_ui
-    assert_nil @column.list_ui
-    assert_nil @column.search_ui
-    assert_equal :select, @association_col.search_ui
-
-    @column.form_ui = :calendar
-    assert_equal :calendar, @column.form_ui
-    assert_equal :calendar, @column.list_ui
-    assert_equal :calendar, @column.search_ui
-
-    @association_col.form_ui = :record_select
-    assert_equal :record_select, @association_col.form_ui
-    assert_equal :record_select, @association_col.search_ui
-
-    @column.search_ui = :record_select
-    @column.list_ui = :checkbox
-    assert_equal :calendar, @column.form_ui
-    assert_equal :checkbox, @column.list_ui
-    assert_equal :record_select, @column.search_ui
-  end
-
-  def test_searchable
-    @column.search_sql = nil
-    refute @column.searchable?
-    @column.search_sql = true
-    assert @column.searchable?
-  end
-
-  def test_sortable
-    @column.sort = nil
-    refute @column.sortable?
-    @column.sort = true
-    assert @column.sortable?
-  end
-
-  def test_custom_search
-    @column.search_sql = true
-    assert_equal ['"model_stubs"."a"'], @column.search_sql
-    @column.search_sql = 'foobar'
-    assert_equal ['foobar'], @column.search_sql
-    assert @column.searchable?
-  end
-
-  def test_custom_sort
-    @column.sort = true
-    hash = {:sql => '"model_stubs"."a"'}
-    assert_equal hash, @column.sort
-    @column.sort_by :sql => 'foobar'
-    hash = {:sql => 'foobar'}
-    assert_equal hash, @column.sort
-
-    some_proc = proc { 'foobar' }
-    @column.sort_by :method => some_proc
-    hash = {:method => some_proc}
-    assert_equal hash, @column.sort
-    assert @column.sortable?
-  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'))
-  end
-
-  def test_config_block
-    @column.configure do |config|
-      # we can use the config object
-      config.form_ui = :select
-      # or not
-      self.label = 'hello'
-    end
-
-    assert_equal :select, @column.form_ui
-    assert_equal 'hello', @column.label
-  end
-
-  def test_action_link
-    link = ActiveScaffold::DataStructures::ActionLink.new('foo/bar')
-    @column.set_link link
-    assert_equal link, @column.link
-
-    @column.set_link 'hello_world'
-    assert_equal 'hello_world', @column.link.action
-    assert_equal @column.label, @column.link.label
-  end
-
-  def test_includes
-    assert_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)
-
-    # make sure that when a non-array comes in, an array comes out
-    @column.includes = [:column_name]
-    assert_equal([:column_name], @column.includes)
-
-    # make sure that when a non-array comes in, an array comes out
-    @column.includes = nil
-    assert_nil @column.includes
-  end
-end