active_scaffold-sequel 0.3.0

data/test/data_structures/association_column_test.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+require File.join(File.dirname(__FILE__), '../model_stub')
+
+class AssociationColumnTest < Test::Unit::TestCase
+  def setup
+    @association_column = ActiveScaffold::DataStructures::Column.new('other_model', ModelStub)
+  end
+
+  def test_virtuality
+    assert @association_column.association
+    assert !@association_column.virtual?
+  end
+
+  def test_sorting
+    # sorting on association columns is method-based
+    hash = {:method => "other_model.to_s"}
+    assert_equal hash, @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?(ActiveRecord::Reflection::AssociationReflection)
+  end
+
+  def test_includes
+    assert_equal [:other_model], @association_column.includes
+  end
+
+  def test_plurality
+    assert @association_column.singular_association?
+    assert !@association_column.plural_association?
+
+    plural_association_column = ActiveScaffold::DataStructures::Column.new('other_models', ModelStub)
+    assert plural_association_column.plural_association?
+    assert !plural_association_column.singular_association?
+  end
+end

data/test/data_structures/column_test.rb

@@ -0,0 +1,185 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ColumnTest < Test::Unit::TestCase
+  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.instance_variable_set(:@association, true)
+  end
+
+  def test_column
+    assert @column.column.is_a?(ActiveRecord::ConnectionAdapters::Column)
+    assert @column.column.name == 'a'
+  end
+
+  def test_basic_properties
+    # test that it was set during initialization
+    assert_equal @column.name, :a
+    # test that we can change it
+    @column.name = :b
+    assert_equal @column.name, :b
+
+    # 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
+    assert !@column.required?, 'default is false'
+    @column.required = true
+    assert @column.required?, 'can be changed'
+
+    # calculation
+    assert !@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)
+    assert columns != @column
+
+    # create a separate action_columns object, and make sure it's not ==
+    columns = ActiveScaffold::DataStructures::ActionColumns.new(:a, :b)
+    assert columns != @column
+
+    # identity
+    assert @column == @column
+
+    # string comparison
+    assert @column == 'a'
+    assert @column != 'fake'
+
+    # symbol comparison
+    assert @column == :a
+    assert @column != :fake
+
+    # comparison with different object of same type
+    column2 = ActiveScaffold::DataStructures::Column.new(:fake, ModelStub)
+    assert @column != column2
+    column2.name = 'a'
+    assert @column == column2
+
+    # special comparisons
+    assert @column != nil
+    assert @column != ''
+    assert @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
+    assert !@column.searchable?
+    @column.search_sql = true
+    assert @column.searchable?
+  end
+
+  def test_sortable
+    @column.sort = nil
+    assert !@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_raise(ArgumentError) { @column.sort_by :proc => "invalid config"  }
+    assert_raise(ArgumentError) { @column.sort={:proc => "invalid config" } }
+    assert_nothing_raised(ArgumentError) {@column.sort_by :method => "method"  }
+    assert_nothing_raised(ArgumentError) {@column.sort_by :sql => "method"  }
+  end
+  
+  def test_config_block
+    @column.configure do |config|
+      # we can use the config object
+      config.name = 'foo'
+      # or not
+      self.label = 'hello'
+    end
+
+    assert_equal 'foo', @column.name
+    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_equal [], @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)
+  end
+end

data/test/data_structures/columns_test.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class ColumnsTest < Test::Unit::TestCase
+  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'
+    assert !@columns.include?(:c)
+  end
+
+  def test_add
+    assert !@columns.include?(:c)
+    @columns.add 'c'
+    assert @columns.include?('c')
+
+    # test the alias
+    assert !@columns.include?(:d)
+    @columns << :d
+    assert @columns.include?(:d)
+
+    # try adding an array of columns
+    assert !@columns.include?(:f)
+    @columns.add [: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 [:a, :b].include?(column.name)
+    end
+  end
+
+  def test_block_config
+    assert !@columns.include?(:d)
+    assert !@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/error_message_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ErrorMessageTest < Test::Unit::TestCase
+  def setup
+    @error = ActiveScaffold::DataStructures::ErrorMessage.new 'foo'
+  end
+
+  def test_attributes
+    assert @error.public_attributes.has_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_equal 'foo', xml['errors']['error']
+  end
+
+  def test_yaml
+    yml = nil
+    assert_nothing_raised do
+      yml = YAML.load(@error.to_yaml)
+    end
+    assert yml.has_key?(:error)
+    assert_equal 'foo', yml[:error]
+  end
+end

data/test/data_structures/set_test.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class SetTest < Test::Unit::TestCase
+  def setup
+    @items = ActiveScaffold::DataStructures::Set.new(:a, :b)
+  end
+
+  def test_initialization
+    assert @items.include?(:a)
+    assert @items.include?(:b)
+    assert !@items.include?(:c)
+  end
+
+  def test_exclude
+    # exclude with a symbol
+    assert @items.include?(:b)
+    @items.exclude :b
+    assert !@items.include?(:b)
+
+    # exclude with a string
+    assert @items.include?(:a)
+    @items.exclude 'a'
+    assert !@items.include?(:a)
+  end
+
+  def test_exclude_array
+    # exclude with a symbol
+    assert @items.include?(:b)
+    @items.exclude [:a, :b]
+    assert !@items.include?(:b)
+    assert !@items.include?(:a)
+  end
+
+  def test_remove
+    assert @items.include?(:a)
+    @items.remove 'a'
+    assert !@items.include?(:a)
+  end
+
+  def test_add
+    # try adding a simple column using a string
+    assert !@items.include?(:c)
+    @items.add 'c'
+    assert @items.include?(:c)
+
+    # try adding a simple column using a symbol
+    assert !@items.include?(:d)
+    @items.add :d
+    assert @items.include?(:d)
+
+    # test that << also adds
+    assert !@items.include?(:e)
+    @items << "e"
+    assert @items.include?(:e)
+
+    # try adding an array of columns
+    assert !@items.include?(:f)
+    @items.add [: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)
+    assert !@items.include?(:b)
+  end
+
+  def test_include
+    assert @items.include?(:a)
+    assert @items.include?(:b)
+    assert !@items.include?(:d)
+  end
+end

data/test/data_structures/sorting_test.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class SortingTest < Test::Unit::TestCase
+  def setup
+    @columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b, :c, :d)
+    @sorting = ActiveScaffold::DataStructures::Sorting.new(@columns)
+  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 << [: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
+    assert !@sorting.sorts_on?(:a)
+    assert @sorting.sorts_on?(:b)
+    assert_equal 'DESC', @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)
+    assert !@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_raise ArgumentError do
+      @sorting.add :b
+    end
+    
+    #test pure sql sorting: false
+    @sorting.clear
+    @sorting.add :b
+    assert !@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
+  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.set_default_sorting model_stub_with_default_scope
+    
+    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.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
+    assert_nil @sorting.clause
+  end
+end

data/test/data_structures/standard_column_test.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class StandardColumnTest < Test::Unit::TestCase
+  def setup
+    @standard_column = ActiveScaffold::DataStructures::Column.new(ModelStub.columns.first.name, ModelStub)
+  end
+
+  def test_virtuality
+    assert @standard_column.column
+    assert !@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/virtual_column_test.rb

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

data/test/extensions/active_record_test.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+#require 'test/model_stub'
+
+class ActiveRecordTest < Test::Unit::TestCase
+  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
+
+    assert_equal 'to_s', @record.to_label
+
+    class << @record
+      def title
+        'title'
+      end
+    end
+
+    assert_equal 'title', @record.to_label
+
+    class << @record
+      def label
+        'label'
+      end
+    end
+
+    assert_equal 'label', @record.to_label
+
+    class << @record
+      def name
+        'name'
+      end
+    end
+
+    assert_equal 'name', @record.to_label
+  end
+end

data/test/extensions/array_test.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ArrayTest < Test::Unit::TestCase
+  def test_after
+    @sequence = ['a', 'b', 'c']
+
+    assert_equal 'b', @sequence.after('a')
+    assert_equal 'c', @sequence.after('b')
+    assert_equal 'a', @sequence.after('c')
+    assert_equal nil, @sequence.after('d')
+  end
+end

data/test/helpers/form_column_helpers_test.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class FormColumnHelpersTest < ActionView::TestCase
+  include ActiveScaffold::Helpers::FormColumnHelpers
+
+  def setup
+    @column = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
+    @record = stub(:a => nil)
+  end
+
+  def test_choices_for_select_form_ui_for_simple_column
+    @column.options[:options] = [:value_1, :value_2, :value_3]
+    assert_dom_equal '<select name="record[a]" id="record_a"><option value="value_1">Value 1</option><option value="value_2">Value 2</option><option value="value_3">Value 3</option></select>', active_scaffold_input_select(@column, {})
+
+    @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><option value="value_2">value_2</option><option value="value_3">value_3</option></select>', active_scaffold_input_select(@column, {})
+
+    @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><option value="value_2">text_2</option><option value="value_3">text_3</option></select>', active_scaffold_input_select(@column, {})
+
+    @column.options[:options] = [[:text_1, :value_1], [:text_2, :value_2], [:text_3, :value_3]]
+    assert_dom_equal '<select name="record[a]" id="record_a"><option value="value_1">Text 1</option><option value="value_2">Text 2</option><option value="value_3">Text 3</option></select>', active_scaffold_input_select(@column, {})
+  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[:html_options] = {:class => 'big'}
+    assert_dom_equal '<select name="record[a]" class="big" id="record_a"><option value="">None</option><option disabled="disabled" value="value_1">value_1</option><option selected="selected" value="value_2">value_2</option><option disabled="disabled" value="value_3">value_3</option></select>', active_scaffold_input_select(@column, {})
+  end
+end