active_scaffold 3.3.3 → 3.4.0

data/test/data_structures/action_links_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ActionLinksTest < Test::Unit::TestCase
+class ActionLinksTest < MiniTest::Test
   def setup
     @links = ActiveScaffold::DataStructures::ActionLinks.new
   end
@@ -38,15 +38,15 @@ class ActionLinksTest < Test::Unit::TestCase
   def test_empty
     assert @links.empty?
     @links.add 'a'
-    assert !@links.empty?
+    refute @links.empty?
   end
 
   def test_cloning
     @links.add 'foo/bar'
     @links_copy = @links.clone
 
-    assert !@links.equal?(@links_copy)
-    assert !@links['foo/bar'].equal?(@links_copy['foo/bar'])
+    refute @links.equal?(@links_copy)
+    refute @links['foo/bar'].equal?(@links_copy['foo/bar'])
   end
 
   def test_each
@@ -69,10 +69,10 @@ class ActionLinksTest < Test::Unit::TestCase
     assert @links['foo'].nil?
     begin
       @links.delete :foo
-    @links.delete 'foo'
+      @links.delete 'foo'
     rescue
       assert false, "deleting from action links when item doesn't exist should not throw an error"
     end
-    assert !@links['bar'].nil?
+    refute @links['bar'].nil?
   end
 end

data/test/data_structures/actions_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ActionsTest < Test::Unit::TestCase
+class ActionsTest < MiniTest::Test
   def setup
     @actions = ActiveScaffold::DataStructures::Actions.new(:a, 'b')
   end
@@ -8,17 +8,17 @@ class ActionsTest < Test::Unit::TestCase
   def test_initialization
     assert @actions.include?('a')
     assert @actions.include?(:b)
-    assert !@actions.include?(:c)
+    refute @actions.include?(:c)
   end
 
   def test_exclude
     assert @actions.include?('b')
     @actions.exclude :b
-    assert !@actions.include?(:b)
+    refute @actions.include?(:b)
   end
 
   def test_add
-    assert !@actions.include?(:c)
+    refute @actions.include?(:c)
     @actions.add 'c'
     assert @actions.include?('c')
   end

data/test/data_structures/association_column_test.rb

@@ -1,14 +1,14 @@
 require 'test_helper'
 require 'model_stub'
 
-class AssociationColumnTest < Test::Unit::TestCase
+class AssociationColumnTest < MiniTest::Test
   def setup
     @association_column = ActiveScaffold::DataStructures::Column.new('other_model', ModelStub)
   end
 
   def test_virtuality
     assert @association_column.association
-    assert !@association_column.virtual?
+    refute @association_column.virtual?
   end
 
   def test_sorting
@@ -32,10 +32,10 @@ class AssociationColumnTest < Test::Unit::TestCase
 
   def test_plurality
     assert @association_column.singular_association?
-    assert !@association_column.plural_association?
+    refute @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?
+    refute plural_association_column.singular_association?
   end
 end

data/test/data_structures/column_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ColumnTest < Test::Unit::TestCase
+class ColumnTest < MiniTest::Test
   def setup
     @column = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
     @association_col = ActiveScaffold::DataStructures::Column.new(:b, ModelStub)
@@ -33,12 +33,12 @@ class ColumnTest < Test::Unit::TestCase
     assert_equal 'style_me', @column.css_class
 
     # required
-    assert !@column.required?, 'default is false'
+    refute @column.required?, 'default is false'
     @column.required = true
     assert @column.required?, 'can be changed'
 
     # calculation
-    assert !@column.calculation?, 'default is nil'
+    refute @column.calculation?, 'default is nil'
     @column.calculate = :sum
     assert @column.calculation?, 'can be changed'
   end
@@ -107,14 +107,14 @@ class ColumnTest < Test::Unit::TestCase
 
   def test_searchable
     @column.search_sql = nil
-    assert !@column.searchable?
+    refute @column.searchable?
     @column.search_sql = true
     assert @column.searchable?
   end
 
   def test_sortable
     @column.sort = nil
-    assert !@column.sortable?
+    refute @column.sortable?
     @column.sort = true
     assert @column.sortable?
   end
@@ -143,10 +143,10 @@ class ColumnTest < Test::Unit::TestCase
   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"  }
+    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

data/test/data_structures/columns_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ColumnsTest < Test::Unit::TestCase
+class ColumnsTest < MiniTest::Test
   def setup
     @columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b)
   end
@@ -10,21 +10,21 @@ class ColumnsTest < Test::Unit::TestCase
 
     assert @columns.include?('a'), 'checking via string'
     assert @columns.include?(:b), 'checking via symbol'
-    assert !@columns.include?(:c)
+    refute @columns.include?(:c)
   end
 
   def test_add
-    assert !@columns.include?(:c)
+    refute @columns.include?(:c)
     @columns.add 'c'
     assert @columns.include?('c')
 
     # test the alias
-    assert !@columns.include?(:d)
+    refute @columns.include?(:d)
     @columns << :d
     assert @columns.include?(:d)
 
     # try adding an array of columns
-    assert !@columns.include?(:f)
+    refute @columns.include?(:f)
     @columns.add [:f, :g]
     assert @columns.include?(:f)
     assert @columns.include?(:g)
@@ -52,8 +52,8 @@ class ColumnsTest < Test::Unit::TestCase
   end
 
   def test_block_config
-    assert !@columns.include?(:d)
-    assert !@columns.include?(:c)
+    refute @columns.include?(:d)
+    refute @columns.include?(:c)
 
     @columns.configure do |config|
       # test that we can use the config object

data/test/data_structures/error_message_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ErrorMessageTest < Test::Unit::TestCase
+class ErrorMessageTest < MiniTest::Test
   def setup
     @error = ActiveScaffold::DataStructures::ErrorMessage.new 'foo'
   end
@@ -19,9 +19,7 @@ class ErrorMessageTest < Test::Unit::TestCase
 
   def test_yaml
     yml = nil
-    assert_nothing_raised do
-      yml = YAML.load(@error.to_yaml)
-    end
+    yml = YAML.load(@error.to_yaml)
     assert yml.has_key?(:error)
     assert_equal 'foo', yml[:error]
   end

data/test/data_structures/set_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class SetTest < Test::Unit::TestCase
+class SetTest < MiniTest::Test
   def setup
     @items = ActiveScaffold::DataStructures::Set.new(:a, :b)
   end
@@ -8,53 +8,53 @@ class SetTest < Test::Unit::TestCase
   def test_initialization
     assert @items.include?(:a)
     assert @items.include?(:b)
-    assert !@items.include?(:c)
+    refute @items.include?(:c)
   end
 
   def test_exclude
     # exclude with a symbol
     assert @items.include?(:b)
     @items.exclude :b
-    assert !@items.include?(:b)
+    refute @items.include?(:b)
 
     # exclude with a string
     assert @items.include?(:a)
     @items.exclude 'a'
-    assert !@items.include?(:a)
+    refute @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)
+    refute @items.include?(:b)
+    refute @items.include?(:a)
   end
 
   def test_remove
     assert @items.include?(:a)
     @items.remove 'a'
-    assert !@items.include?(:a)
+    refute @items.include?(:a)
   end
 
   def test_add
     # try adding a simple column using a string
-    assert !@items.include?(:c)
+    refute @items.include?(:c)
     @items.add 'c'
     assert @items.include?(:c)
 
     # try adding a simple column using a symbol
-    assert !@items.include?(:d)
+    refute @items.include?(:d)
     @items.add :d
     assert @items.include?(:d)
 
     # test that << also adds
-    assert !@items.include?(:e)
+    refute @items.include?(:e)
     @items << "e"
     assert @items.include?(:e)
 
     # try adding an array of columns
-    assert !@items.include?(:f)
+    refute @items.include?(:f)
     @items.add [:f, :g]
     assert @items.include?(:f)
     assert @items.include?(:g)
@@ -74,12 +74,12 @@ class SetTest < Test::Unit::TestCase
     end
 
     assert @items.include?(:c)
-    assert !@items.include?(:b)
+    refute @items.include?(:b)
   end
 
   def test_include
     assert @items.include?(:a)
     assert @items.include?(:b)
-    assert !@items.include?(:d)
+    refute @items.include?(:d)
   end
 end

data/test/data_structures/sorting_test.rb

@@ -1,8 +1,8 @@
 require 'test_helper'
 
-class SortingTest < Test::Unit::TestCase
+class SortingTest < MiniTest::Test
   def setup
-    @columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b, :c, :d)
+    @columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b, :c, :d, :id)
     @sorting = ActiveScaffold::DataStructures::Sorting.new(@columns)
   end
 
@@ -53,7 +53,7 @@ class SortingTest < Test::Unit::TestCase
 
     @sorting.set :b, 'DESC'
     assert @sorting.instance_variable_get('@clauses').size == 1
-    assert !@sorting.sorts_on?(:a)
+    refute @sorting.sorts_on?(:a)
     assert @sorting.sorts_on?(:b)
     assert_equal 'DESC', @sorting.direction_of(:b)
   end
@@ -64,7 +64,7 @@ class SortingTest < Test::Unit::TestCase
 
     assert @sorting.sorts_on?(:a)
     assert @sorting.sorts_on?(:b)
-    assert !@sorting.sorts_on?(:c)
+    refute @sorting.sorts_on?(:c)
   end
 
   def test_direction_of
@@ -83,14 +83,14 @@ class SortingTest < Test::Unit::TestCase
     assert @sorting.sorts_by_method?
 
     #test mixed sql/method sorting: raise error
-    assert_raise ArgumentError do
+    assert_raises ArgumentError do
       @sorting.add :b
     end
     
     #test pure sql sorting: false
     @sorting.clear
     @sorting.add :b
-    assert !@sorting.sorts_by_method?
+    refute @sorting.sorts_by_method?
   end
 
   def test_build_order_clause
@@ -104,7 +104,7 @@ class SortingTest < Test::Unit::TestCase
   
   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' }
+    model_stub_with_default_scope.class_eval { default_scope lambda { order('a') } }
     @sorting.set_default_sorting model_stub_with_default_scope
     
     assert @sorting.sorts_on?(:a)
@@ -114,7 +114,7 @@ class SortingTest < Test::Unit::TestCase
 
   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' }
+    model_stub_with_default_scope.class_eval { default_scope lambda { order('a DESC, players.last_name ASC') } }
     @sorting.set_default_sorting model_stub_with_default_scope
     
     assert @sorting.sorts_on?(:a)

data/test/data_structures/standard_column_test.rb

@@ -1,13 +1,13 @@
 require 'test_helper'
 
-class StandardColumnTest < Test::Unit::TestCase
+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
-    assert !@standard_column.virtual?
+    refute @standard_column.virtual?
   end
 
   def test_sorting

data/test/data_structures/validation_reflection_test.rb

@@ -1,9 +1,9 @@
 require 'test_helper'
 
-class ValidationReflectionTest < Test::Unit::TestCase
+class ValidationReflectionTest < MiniTest::Test
   def test_set_required_for_validates_presence_of
     column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    assert !column.required?
+    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?
@@ -11,7 +11,7 @@ class ValidationReflectionTest < Test::Unit::TestCase
 
   def test_set_required_for_validates_inclusion_of
     column = ActiveScaffold::DataStructures::Column.new(:name, Company)
-    assert !column.required?
+    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?
@@ -20,24 +20,24 @@ class ValidationReflectionTest < Test::Unit::TestCase
   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)
-    assert !column.required?
+    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)
-    assert !column.required?
+    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)
-    assert !column.required?
+    refute column.required?
   end
 
   def test_set_required_for_validates_presence_of_in_association
     column = ActiveScaffold::DataStructures::Column.new(:main_company, Company)
-    assert !column.required?
+    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?
@@ -46,6 +46,6 @@ class ValidationReflectionTest < Test::Unit::TestCase
   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)
-    assert !column.required?
+    refute column.required?
   end
 end

data/test/data_structures/virtual_column_test.rb

@@ -1,23 +1,23 @@
 require 'test_helper'
 
-class VirtualColumnTest < Test::Unit::TestCase
+class VirtualColumnTest < MiniTest::Test
   def setup
     @virtual_column = ActiveScaffold::DataStructures::Column.new(:fake, ModelStub)
   end
 
   def test_virtuality
-    assert !@virtual_column.column
-    assert !@virtual_column.association
+    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
-    assert !@virtual_column.sortable?
+    refute @virtual_column.sortable?
   end
 
   def test_searching
     # right now, there's no intelligent searching on virtual columns
-    assert !@virtual_column.searchable?
+    refute @virtual_column.searchable?
   end
 end