Move to Shoulda syntax for adapter specific tests.

Author: metaskills

test/cases/aaaa_create_tables_test_sqlserver.rb

@@ -2,8 +2,8 @@
 require 'cases/sqlserver_helper'
 
 class AAAACreateTablesTestSqlserver < ActiveRecord::TestCase
-
-  def test_load_sqlserver_specific_schema
+  
+  should 'load sqlserver specific schema' do
     sqlserver_specific_schema_file = File.expand_path(File.join(File.dirname(__FILE__), '..', 'schema', 'sqlserver_specific_schema.rb'))
     eval(File.read(sqlserver_specific_schema_file))
     assert true

test/cases/adapter_test_sqlserver.rb

@@ -9,38 +9,62 @@ def setup
   end
 
 
-  def test_update_sql_statement_invalid
+  should 'raise invalid statement error' do
     assert_raise(ActiveRecord::StatementInvalid) { Topic.connection.update_sql("UPDATE XXX") }
   end
 
-  def test_real_column_has_float_type
+  should 'return real_number as float' do
     assert_equal :float, TableWithRealColumn.columns_hash["real_number"].type
   end
 
-  def test_date_insertion_when_language_is_german
-    @connection.execute("SET LANGUAGE deutsch")
-    assert_nothing_raised do
-      Task.create(:starting => Time.utc(2000, 1, 31, 5, 42, 0), :ending => Date.new(2006, 12, 31))
+  context 'With different language' do
+
+    teardown do
+      @connection.execute("SET LANGUAGE us_english") rescue nil
+    end
+
+    should 'do a date insertion when language is german' do
+      @connection.execute("SET LANGUAGE deutsch")
+      assert_nothing_raised do
+        Task.create(:starting => Time.utc(2000, 1, 31, 5, 42, 0), :ending => Date.new(2006, 12, 31))
+      end
     end
-  ensure
-    @connection.execute("SET LANGUAGE us_english") rescue nil
+
   end
 
-  def test_indexes_with_descending_order
-    @connection.execute "CREATE INDEX idx_credit_limit ON accounts (credit_limit DESC)" rescue nil
-    assert_equal ["credit_limit"], @connection.indexes('accounts').first.columns
-  ensure
-    @connection.execute "DROP INDEX accounts.idx_credit_limit"
+  context 'For indexes' do
+    
+    setup do
+      @connection.execute "CREATE INDEX idx_credit_limit ON accounts (credit_limit DESC)" rescue nil
+    end
+    
+    teardown do
+      @connection.execute "DROP INDEX accounts.idx_credit_limit"
+    end
+
+    should 'have indexes with descending order' do
+      assert_equal ["credit_limit"], @connection.indexes('accounts').first.columns
+    end
+
   end
 
-  def test_escaped_table_name
-    old_table_name, new_table_name = Topic.table_name, '[topics]'
-    Topic.table_name = new_table_name
-    assert_nothing_raised { ActiveRecord::Base.connection.select_all "SELECT * FROM #{new_table_name}" }
-    assert_equal new_table_name, Topic.table_name
-    assert_equal 12, Topic.columns.length
-  ensure
-    Topic.table_name = old_table_name
+  context 'For .table_name' do
+
+    setup do
+      @old_table_name, @new_table_name = Topic.table_name, '[topics]'
+      Topic.table_name = @new_table_name
+    end
+    
+    teardown do
+      Topic.table_name = @old_table_name
+    end
+    
+    should 'escape table name' do
+      assert_nothing_raised { @connection.select_all "SELECT * FROM #{@new_table_name}" }
+      assert_equal @new_table_name, Topic.table_name
+      assert_equal 12, Topic.columns.length
+    end
+
   end
 
 

test/cases/column_test_sqlserver.rb

@@ -6,7 +6,7 @@ def setup
     @column_klass = ActiveRecord::ConnectionAdapters::SQLServerColumn
   end
 
-  def test_placeholder
+  should 'be a placeholder' do
     assert true 
   end
 

test/cases/connection_test_sqlserver.rb

@@ -13,7 +13,7 @@ def setup
   end
 
 
-  def test_affected_rows
+  should 'affecte rows' do
     assert Topic.connection.instance_variable_get("@connection")["AutoCommit"]
     topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
     updated = Topic.update(topic_data.keys, topic_data.values)
@@ -23,33 +23,33 @@ def test_affected_rows
     assert_equal 2, Topic.delete([1, 2])        
   end
 
-  def test_execute_without_block_closes_statement
+  should 'execute without block closes statement' do
     assert_all_statements_used_are_closed do
       @connection.execute("SELECT 1")
     end
   end
 
-  def test_execute_with_block_closes_statement
+  should 'execute with block closes statement' do
     assert_all_statements_used_are_closed do
       @connection.execute("SELECT 1") do |sth|
         assert !sth.finished?, "Statement should still be alive within block"
       end
     end
   end
 
-  def test_insert_with_identity_closes_statement
+  should 'insert with identity closes statement' do
     assert_all_statements_used_are_closed do
       @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)")
     end
   end
 
-  def test_insert_without_identity_closes_statement
+  should 'insert without identity closes statement' do
     assert_all_statements_used_are_closed do
       @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)")
     end
   end
 
-  def test_active_closes_statement
+  should 'active closes statement' do
     assert_all_statements_used_are_closed do
       @connection.active?
     end

test/cases/offset_and_limit_test_sqlserver.rb

@@ -1,70 +1,82 @@
 require 'cases/sqlserver_helper'
 require 'models/book'
 
-class WhenSelectingWithLimitOffsetAndLimitTest < ActiveRecord::TestCase
+class OffsetAndLimitTestSqlserver < ActiveRecord::TestCase
+  
+  class Account < ActiveRecord::Base; end
+  
   def setup
     @connection = ActiveRecord::Base.connection
-    @select_sql = 'SELECT * FROM schema'
   end
+  
+  context 'When selecting with limit' do
 
-  def test_should_alter_SQL_to_limit_number_of_records_returned
-    options = { :limit => 10 }
-    assert_equal('SELECT TOP 10 * FROM schema', @connection.add_limit_offset!(@select_sql, options))
-  end
+    setup do
+      @select_sql = 'SELECT * FROM schema'
+    end
 
-  def test_should_only_allow_integers_for_limit
-    options = { :limit => 'ten' }
-    assert_raise(ArgumentError) {@connection.add_limit_offset!(@select_sql, options) }
-  end
+    should 'alter SQL to limit number of records returned' do
+      options = { :limit => 10 }
+      assert_equal('SELECT TOP 10 * FROM schema', @connection.add_limit_offset!(@select_sql, options))
+    end
 
-  def test_should_convert_strings_which_look_like_integers_to_integers
-    options = { :limit => '42' }
-    assert_nothing_raised(ArgumentError) {@connection.add_limit_offset!(@select_sql, options)}
-  end
+    should 'only allow integers for limit' do
+      options = { :limit => 'ten' }
+      assert_raise(ArgumentError) {@connection.add_limit_offset!(@select_sql, options) }
+    end
 
-  def test_should_not_allow_sql_injection_via_limit
-    options = { :limit => '1 * FROM schema; DELETE * FROM table; SELECT TOP 10 *'}
-    assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
-  end
-end
+    should 'convert strings which look like integers to integers' do
+      options = { :limit => '42' }
+      assert_nothing_raised(ArgumentError) {@connection.add_limit_offset!(@select_sql, options)}
+    end
+
+    should 'not allow sql injection via limit' do
+      options = { :limit => '1 * FROM schema; DELETE * FROM table; SELECT TOP 10 *'}
+      assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
+    end
 
-class WhenSelectingWithLimitAndOffsetOffsetAndLimitTest < ActiveRecord::TestCase
-  class Account < ActiveRecord::Base; end
-  def setup
-    @connection = ActiveRecord::Base.connection
-    # we have to use a real table as we need the counts
-    @select_sql = 'SELECT * FROM books'
-    @books = (1..10).map {|i| Book.create!}
-  end
-  
-  def teardown
-    @books.each {|b| b.destroy}
   end
 
-  def test_should_have_limit_if_offset_is_passed
-    options = { :offset => 1 }
-    assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
-  end
+  context 'When selecting with limit and offset' do
 
-  def test_should_only_allow_integers_for_offset
-    options = { :limit => 10, :offset => 'five' }
-    assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options)}
-  end
+    setup do
+      @select_sql = 'SELECT * FROM books'
+      @books = (1..10).map {|i| Book.create!}
+    end
+    
+    teardown do
+      @books.each {|b| b.destroy}
+    end
 
-  def test_should_convert_strings_which_look_like_integers_to_integers
-    options = { :limit => 10, :offset => '5' }
-    assert_nothing_raised(ArgumentError) {@connection.add_limit_offset!(@select_sql, options)}
-  end
+    should 'have limit if offset is passed' do
+      options = { :offset => 1 }
+      assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
+    end
 
-  def test_should_alter_SQL_to_limit_number_of_records_returned_offset_by_specified_amount
-    options = { :limit => 3, :offset => 5 }
-    expected_sql = %&SELECT * FROM (SELECT TOP 3 * FROM (SELECT TOP 8 * FROM books) AS tmp1) AS tmp2&
-    assert_equal(expected_sql, @connection.add_limit_offset!(@select_sql, options))
-  end
+    should 'only allow integers for offset' do
+      options = { :limit => 10, :offset => 'five' }
+      assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options)}
+    end
+
+    should 'convert strings which look like integers to integers' do
+      options = { :limit => 10, :offset => '5' }
+      assert_nothing_raised(ArgumentError) {@connection.add_limit_offset!(@select_sql, options)}
+    end
+
+    should 'alter SQL to limit number of records returned offset by specified amount' do
+      options = { :limit => 3, :offset => 5 }
+      expected_sql = %&SELECT * FROM (SELECT TOP 3 * FROM (SELECT TOP 8 * FROM books) AS tmp1) AS tmp2&
+      assert_equal(expected_sql, @connection.add_limit_offset!(@select_sql, options))
+    end
+
+    # Not really sure what an offset sql injection might look like
+    should 'not allow sql injection via offset' do
+      options = { :limit => 10, :offset => '1 * FROM schema; DELETE * FROM table; SELECT TOP 10 *'}
+      assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
+    end
 
-  # Not really sure what an offset sql injection might look like
-  def test_should_not_allow_sql_injection_via_offset
-    options = { :limit => 10, :offset => '1 * FROM schema; DELETE * FROM table; SELECT TOP 10 *'}
-    assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
   end
+  
+  
 end
+

test/cases/schema_dumper_test_sqlserver.rb

@@ -5,22 +5,27 @@
 # non-standard id dumping for mysql. We'll do that too.
 class SchemaDumperTestSqlserver < ActiveRecord::TestCase
 
-  def test_schema_dump_includes_limit_constraint_for_integer_columns
-    output = standard_dump(/^(?!integer_limits)/)
-    assert_match %r{c_int_1.*:limit => 2}, output
-    assert_match %r{c_int_2.*:limit => 2}, output
-    assert_match %r{c_int_3.*}, output
-    assert_match %r{c_int_4.*}, output
-    assert_no_match %r{c_int_3.*:limit}, output
-    assert_no_match %r{c_int_4.*:limit}, output
+  context 'In schema dump' do
+    
+    should 'include limit constraint for integer columns' do
+      output = standard_dump(/^(?!integer_limits)/)
+      assert_match %r{c_int_1.*:limit => 2}, output
+      assert_match %r{c_int_2.*:limit => 2}, output
+      assert_match %r{c_int_3.*}, output
+      assert_match %r{c_int_4.*}, output
+      assert_no_match %r{c_int_3.*:limit}, output
+      assert_no_match %r{c_int_4.*:limit}, output
+    end
+    
+    should 'honor nonstandard primary keys' do
+      output = standard_dump
+      match = output.match(%r{create_table "movies"(.*)do})
+      assert_not_nil(match, "nonstandardpk table not found")
+      assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
+    end
+    
   end
 
-  def test_sqlserver_schema_dump_should_honor_nonstandard_primary_keys
-    output = standard_dump
-    match = output.match(%r{create_table "movies"(.*)do})
-    assert_not_nil(match, "nonstandardpk table not found")
-    assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
-  end
 
   private
 

test/cases/schema_statement_test_sqlserver.rb

@@ -6,28 +6,29 @@ def setup
     @connection = ActiveRecord::Base.connection
   end
 
-  def test_should_create_integers_when_no_limit_supplied
+  should 'create integers when no limit supplied' do
     assert_equal 'integer', @connection.type_to_sql(:integer)
   end
 
-  def test_should_create_integers_when_limit_is_4
+  should 'create integers when limit is 4' do
     assert_equal 'integer', @connection.type_to_sql(:integer, 4)
   end
 
-  def test_should_create_integers_when_limit_is_3
+  should 'create integers when limit is 3' do
     assert_equal 'integer', @connection.type_to_sql(:integer, 3)
   end
 
-  def test_should_create_smallints_when_limit_is_less_than_3
+  should 'create smallints when limit is less than 3' do
     assert_equal 'smallint', @connection.type_to_sql(:integer, 2)
     assert_equal 'smallint', @connection.type_to_sql(:integer, 1)
   end
 
-  def test_should_create_bigints_when_limit_is_greateer_than_4
+  should 'create bigints when limit is greateer than 4' do
     assert_equal 'bigint', @connection.type_to_sql(:integer, 5)
     assert_equal 'bigint', @connection.type_to_sql(:integer, 6)
     assert_equal 'bigint', @connection.type_to_sql(:integer, 7)
     assert_equal 'bigint', @connection.type_to_sql(:integer, 8)
   end
-
+  
+  
 end

test/cases/specific_schema_test_sqlserver.rb

@@ -3,8 +3,8 @@
 class StringDefaults < ActiveRecord::Base; end;
 
 class SpecificSchemaTestSqlserver < ActiveRecord::TestCase
-
-  def test_sqlserver_default_strings_before_save
+  
+  should 'default strings before save' do
     default = StringDefaults.new
     assert_equal nil, default.string_with_null_default
     assert_equal 'null', default.string_with_pretend_null_one
@@ -13,13 +13,13 @@ def test_sqlserver_default_strings_before_save
     assert_equal '(NULL)', default.string_with_pretend_null_four
   end
 
-  def test_sqlserver_default_strings_after_save
+  should 'default strings after save' do
     default = StringDefaults.create
     assert_equal nil, default.string_with_null_default
     assert_equal 'null', default.string_with_pretend_null_one
     assert_equal '(null)', default.string_with_pretend_null_two
     assert_equal 'NULL', default.string_with_pretend_null_three
     assert_equal '(NULL)', default.string_with_pretend_null_four
   end
-
+  
 end

test/cases/sqlserver_helper.rb

@@ -1,3 +1,5 @@
+require 'rubygems'
+require 'shoulda'
 require 'cases/helper'
 
 ActiveRecord::Migration.verbose = false