activerecord-sqlserver-adapter 4.2.6 → 4.2.8

data/test/cases/coerced_tests.rb

@@ -601,6 +601,20 @@ class SchemaDumperTest < ActiveRecord::TestCase
   # This is a poorly written test and really does not catch the bottom'ness it is meant too. Ours throw it off.
   coerce_tests! :test_foreign_keys_are_dumped_at_the_bottom_to_circumvent_dependency_issues
 
+  # Fall through false positive with no filter.
+  coerce_tests! :test_schema_dumps_partial_indices
+  def test_schema_dumps_partial_indices_coerced
+    index_definition = standard_dump.split(/\n/).grep(/add_index.*company_partial_index/).first.strip
+    assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index", where: "([rating]>(10))"', index_definition
+  end
+
+end
+
+class SchemaDumperDefaultsTest < ActiveRecord::TestCase
+
+  # These date formats do not match ours. We got these covered in our dumper tests.
+  coerce_tests! :test_schema_dump_defaults_with_universally_supported_types
+
 end
 
 

data/test/cases/column_test_sqlserver.rb

@@ -284,7 +284,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       col = column('date')
       col.sql_type.must_equal           'date'
       col.null.must_equal               true
-      col.default.must_equal            '0001-01-01' # TODO: None type casted default. Really want Date.civil(0001, 1, 1).
+      col.default.must_equal            connection_dblib_73? ? Date.civil(0001, 1, 1) : '0001-01-01'
       obj.date.must_equal               Date.civil(0001, 1, 1)
       col.default_function.must_equal   nil
       type = col.cast_type
@@ -312,8 +312,8 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       col = column('datetime')
       col.sql_type.must_equal           'datetime'
       col.null.must_equal               true
-      col.default.must_equal            Time.utc(1753, 01, 01, 00, 00, 00, 000)
-      obj.datetime.must_equal           Time.utc(1753, 01, 01, 00, 00, 00, 000)
+      col.default.must_equal            Time.utc(1753, 01, 01, 00, 00, 00, 123000), "Microseconds were <#{col.default.usec}> vs <123000>"
+      obj.datetime.must_equal           Time.utc(1753, 01, 01, 00, 00, 00, 123000), "Microseconds were <#{obj.datetime.usec}> vs <123000>"
       col.default_function.must_equal   nil
       type = col.cast_type
       type.must_be_instance_of          Type::DateTime
@@ -322,7 +322,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       type.limit.must_equal             nil
       type.precision.must_equal         nil
       type.scale.must_equal             nil
-      # Can save .003 seconds and return again.
+      # Can save to proper accuracy and return again.
       obj.datetime = Time.utc(2010, 01, 01, 12, 34, 56, 3000)
       obj.datetime.must_equal           Time.utc(2010, 01, 01, 12, 34, 56, 3000), "Microseconds were <#{obj.datetime.usec}> vs <3000>"
       obj.save!
@@ -334,6 +334,80 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       obj.reload.datetime.must_equal    Time.utc(2010, 01, 01, 12, 34, 56, 233000), "Microseconds were <#{obj.reload.datetime.usec}> vs <233000>"
     end
 
+    it 'datetime2' do
+      skip 'datetime2 not supported in this protocal version' unless connection_dblib_73?
+      col = column('datetime2_7')
+      col.sql_type.must_equal           'datetime2(7)'
+      col.null.must_equal               true
+      col.default.must_equal            Time.utc(9999, 12, 31, 23, 59, 59, Rational(999999900, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <999999900>"
+      obj.datetime2_7.must_equal        Time.utc(9999, 12, 31, 23, 59, 59, Rational(999999900, 1000)), "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <999999900>"
+      col.default_function.must_equal   nil
+      type = col.cast_type
+      type.must_be_instance_of          Type::DateTime2
+      type.type.must_equal              :datetime2
+      type.wont_be                      :number?
+      type.limit.must_equal             nil
+      type.precision.must_equal         7
+      type.scale.must_equal             nil
+      # Can save 100 nanosecond precisoins and return again.
+      obj.datetime2_7 = Time.utc(9999, 12, 31, 23, 59, 59, Rational(123456755, 1000))
+      obj.datetime2_7.must_equal           Time.utc(9999, 12, 31, 23, 59, 59, Rational(123456800, 1000)), "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <123456800>"
+      obj.save!
+      obj.reload.datetime2_7.must_equal    Time.utc(9999, 12, 31, 23, 59, 59, Rational(123456800, 1000)), "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <123456800>"
+      # With other precisions.
+      time = Time.utc 9999, 12, 31, 23, 59, 59, Rational(123456789, 1000)
+      col = column('datetime2_3')
+      col.cast_type.precision.must_equal 3
+      obj.datetime2_3 = time
+      obj.datetime2_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetime2_3.nsec}> vs <123000000>"
+      obj.save! ; obj.reload
+      obj.datetime2_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetime2_3.nsec}> vs <123000000>"
+      col = column('datetime2_1')
+      col.cast_type.precision.must_equal 1
+      obj.datetime2_1 = time
+      obj.datetime2_1.must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
+      obj.save! ; obj.reload
+      obj.datetime2_1.must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
+    end
+
+    it 'datetimeoffset' do
+      skip 'datetimeoffset not supported in this protocal version' unless connection_dblib_73?
+      col = column('datetimeoffset_7')
+      col.sql_type.must_equal           'datetimeoffset(7)'
+      col.null.must_equal               true
+      col.default.must_equal            Time.new(1984, 01, 24, 04, 20, 00, -28800).change(nsec: 123456700), "Nanoseconds <#{col.default.nsec}> vs <123456700>"
+      obj.datetimeoffset_7.must_equal   Time.new(1984, 01, 24, 04, 20, 00, -28800).change(nsec: 123456700), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <999999900>"
+      col.default_function.must_equal   nil
+      type = col.cast_type
+      type.must_be_instance_of          Type::DateTimeOffset
+      type.type.must_equal              :datetimeoffset
+      type.wont_be                      :number?
+      type.limit.must_equal             nil
+      type.precision.must_equal         7
+      type.scale.must_equal             nil
+      # Can save 100 nanosecond precisoins and return again.
+      obj.datetimeoffset_7 = Time.new(2010, 01, 01, 12, 34, 56, +18000).change(nsec: 123456755)
+      obj.datetimeoffset_7.must_equal   Time.new(2010, 01, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+      obj.save! ; obj.reload
+      obj.datetimeoffset_7.must_equal   Time.new(2010, 01, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+      # With other precisions.
+      time = ActiveSupport::TimeZone['America/Los_Angeles'].local 2010, 12, 31, 23, 59, 59, Rational(123456755, 1000)
+      col = column('datetimeoffset_3')
+      col.cast_type.precision.must_equal 3
+      obj.datetimeoffset_3 = time
+      obj.datetimeoffset_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetimeoffset_3.nsec}> vs <123000000>"
+      # TODO: FreeTDS date bug fixed: https://github.com/FreeTDS/freetds/issues/44
+      return
+      obj.save! ; obj.reload
+      obj.datetimeoffset_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetimeoffset_3.nsec}> vs <123000000>"
+      col = column('datetime2_1')
+      col.cast_type.precision.must_equal 1
+      obj.datetime2_1 = time
+      obj.datetime2_1.must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
+      obj.save! ; obj.reload
+      obj.datetime2_1.must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
+    end
+
     it 'smalldatetime' do
       col = column('smalldatetime')
       col.sql_type.must_equal           'smalldatetime'
@@ -343,7 +417,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       col.default_function.must_equal   nil
       type = col.cast_type
       type.must_be_instance_of          Type::SmallDateTime
-      type.type.must_equal              :datetime
+      type.type.must_equal              :smalldatetime
       type.wont_be                      :number?
       type.limit.must_equal             nil
       type.precision.must_equal         nil
@@ -355,7 +429,41 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       obj.reload.smalldatetime.must_equal   Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.reload.smalldatetime.usec}> vs <0>"
     end
 
+    it 'time(7)' do
+      skip 'time() not supported in this protocal version' unless connection_dblib_73?
+      col = column('time_7')
+      col.sql_type.must_equal           'time(7)'
+      col.null.must_equal               true
+      col.default.must_equal            Time.utc(1900, 01, 01, 04, 20, 00, Rational(288321500, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <288321500>"
+      col.default_function.must_equal   nil
+      type = col.cast_type
+      type.must_be_instance_of          Type::Time
+      type.type.must_equal              :time
+      type.wont_be                      :number?
+      type.limit.must_equal             nil
+      type.precision.must_equal         7
+      type.scale.must_equal             nil
+      # Time's #usec precision (low micro)
+      obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, 300)
+      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
+      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
+      obj.save! ; obj.reload
+      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
+      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
+      # Time's #usec precision (high micro)
+      obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, 234567)
+      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
+      obj.save! ; obj.reload
+      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
+      # Time's #usec precision (high nano rounded)
+      obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321545, 1000))
+      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
+      obj.save! ; obj.reload
+      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
+    end
+
     it 'time(2)' do
+      skip 'time() not supported in this protocal version' unless connection_dblib_73?
       col = column('time_2')
       col.sql_type.must_equal           'time(2)'
       col.null.must_equal               true
@@ -368,56 +476,21 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       type.limit.must_equal             nil
       type.precision.must_equal         2
       type.scale.must_equal             nil
-      # Always uses ActiveRecord's 2000-01-01 convention too.
+      # Always uses TinyTDS/Windows 2000-01-01 convention too.
       obj.time_2 = Time.utc(2015, 01, 10, 15, 45, 00, 0)
       obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0)
-      obj.save!
-      obj.reload.time_2.must_equal      Time.utc(2000, 01, 01, 15, 45, 00, 0)
-      # Midnight the beggining of the day.
-      obj.time_2 = Time.utc(2000, 01, 01).midnight.change(usec: 0)
-      obj.time_2.must_equal             Time.utc(2000, 01, 01, 00, 00, 00, 0)
-      obj.save!
-      obj.reload.time_2.must_equal      Time.utc(2000, 01, 01, 00, 00, 00, 0)
-      # The end of day.
-      obj.time_2 = Time.utc(2000, 01, 01).end_of_day.change(usec: 0)
-      obj.time_2.must_equal             Time.utc(2000, 01, 01, 23, 59, 59, 0)
-      obj.save!
-      obj.reload.time_2.must_equal      Time.utc(2000, 01, 01, 23, 59, 59, 0)
+      obj.save! ; obj.reload
+      obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0)
       # Time's #usec precision (barely in 2 precision equal to 0.03 seconds)
       obj.time_2 = Time.utc(2000, 01, 01, 15, 45, 00, 30000)
       obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
-      obj.save!
-      obj.reload.time_2.must_equal      Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.reload.time_2.usec}> vs <30000>"
+      obj.save! ; obj.reload
+      obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
       # Time's #usec precision (below 2 precision)
       obj.time_2 = Time.utc(2000, 01, 01, 15, 45, 00, 4000)
       obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
-      obj.save!
-      obj.reload.time_2.must_equal      Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.reload.time_2.usec}> vs <0>"
-    end
-
-    it 'time(7)' do
-      col = column('time_7')
-      col.sql_type.must_equal           'time(7)'
-      col.null.must_equal               true
-      col.default.must_equal            nil
-      col.default_function.must_equal   nil
-      type = col.cast_type
-      type.must_be_instance_of          Type::Time
-      type.type.must_equal              :time
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
-      type.precision.must_equal         nil, 'so it is clean in schema dumper'
-      type.scale.must_equal             nil
-      # Time's #usec precision (low)
-      obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, 300)
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <300>"
-      obj.save!
-      obj.reload.time_7.must_equal      Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.reload.time_7.usec}> vs <300>"
-      # Time's #usec precision (high)
-      obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, 234567)
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
-      obj.save!
-      obj.reload.time_7.must_equal      Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.reload.time_7.usec}> vs <234567>"
+      obj.save! ; obj.reload
+      obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
     end
 
     # Character Strings

data/test/cases/connection_test_sqlserver.rb

@@ -29,7 +29,7 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
       connection.use_database
       assert_equal 'activerecord_unittest', connection.current_database, 'Would default back to connection options'
     end
-  end unless sqlserver_azure?
+  end unless connection_sqlserver_azure?
 
   describe 'ODBC connection management' do
 
@@ -83,7 +83,7 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-  end if connection_mode_odbc?
+  end if connection_odbc?
 
 
   describe 'Connection management' do
@@ -115,7 +115,7 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
   private
 
   def disconnect_raw_connection!
-    case connection.instance_variable_get(:@connection_options)[:mode]
+    case connection_options[:mode]
     when :dblib
       connection.raw_connection.close rescue nil
     when :odbc

data/test/cases/fully_qualified_identifier_test_sqlserver.rb

@@ -0,0 +1,76 @@
+require 'cases/helper_sqlserver'
+
+class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
+
+  describe 'local server' do
+
+    it 'should use table name in select projections' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT [table].[name] FROM [table]"
+      assert_equal expected_sql, table.project(table[:name]).to_sql
+    end
+
+  end
+
+  describe 'remote server' do
+
+    before do
+      connection_options[:database_prefix] = "[my.server].db.schema."
+    end
+
+    after do
+      connection_options.delete :database_prefix
+    end
+
+    it 'should use fully qualified table name in select from clause' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT * FROM [my.server].[db].[schema].[table]"
+      assert_equal expected_sql, table.project(Arel.star).to_sql
+    end
+
+    it 'should not use fully qualified table name in select projections' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT [table].[name] FROM [my.server].[db].[schema].[table]"
+      assert_equal expected_sql, table.project(table[:name]).to_sql
+    end
+
+    it 'should not use fully qualified table name in where clause' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT * FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
+      assert_equal expected_sql, table.project(Arel.star).where(table[:id].eq(42)).to_sql
+    end
+
+    it 'should not use fully qualified table name in order clause' do
+      table = Arel::Table.new(:table)
+      expected_sql = "SELECT * FROM [my.server].[db].[schema].[table]  ORDER BY [table].[name]"
+      assert_equal expected_sql, table.project(Arel.star).order(table[:name]).to_sql
+    end
+
+    it 'should use fully qualified table name in insert statement' do
+      manager = Arel::InsertManager.new(Arel::Table.engine)
+      manager.into Arel::Table.new(:table)
+      manager.values = manager.create_values [Arel.sql('*')], %w{ a }
+      expected_sql = "INSERT INTO [my.server].[db].[schema].[table] VALUES (*)"
+      assert_equal expected_sql, manager.to_sql
+    end
+
+    it 'should use fully qualified table name in update statement' do
+      table = Arel::Table.new(:table)
+      manager = Arel::UpdateManager.new(Arel::Table.engine)
+      manager.table(table).where(table[:id].eq(42))
+      manager.set([[table[:name], "Bob"]])
+      expected_sql = "UPDATE [my.server].[db].[schema].[table] SET [name] = N'Bob' WHERE [table].[id] = 42"
+      assert_equal expected_sql, manager.to_sql
+    end
+
+    it 'should use fully qualified table name in delete statement' do
+      table = Arel::Table.new(:table)
+      manager = Arel::DeleteManager.new(Arel::Table.engine)
+      manager.from(table).where(table[:id].eq(42))
+      expected_sql = "DELETE FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
+      assert_equal expected_sql, manager.to_sql
+    end
+
+  end
+
+end

data/test/cases/helper_sqlserver.rb

@@ -1,10 +1,11 @@
-require 'bundler' ; Bundler.require :default, :development, :test
+require 'bundler/setup' ; Bundler.require :default, :development
 require 'support/paths_sqlserver'
 require 'support/minitest_sqlserver'
 require 'cases/helper'
 require 'support/load_schema_sqlserver'
 require 'support/coerceable_test_sqlserver'
 require 'support/sql_counter_sqlserver'
+require 'support/connection_reflection'
 require 'mocha/mini_test'
 
 module ActiveRecord
@@ -12,31 +13,38 @@ module ActiveRecord
 
     SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
 
-    include ARTest::SQLServer::CoerceableTest
+    include ARTest::SQLServer::CoerceableTest,
+            ARTest::SQLServer::ConnectionReflection
 
     let(:logger) { ActiveRecord::Base.logger }
 
-    class << self
-      def connection_mode_dblib? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :dblib ; end
-      def connection_mode_odbc? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :odbc ; end
-      def sqlserver_azure? ; ActiveRecord::Base.connection.sqlserver_azure? ; end
-      def host_windows? ; RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ; end
-    end
 
-    def connection_mode_dblib? ; self.class.connection_mode_dblib? ; end
-    def connection_mode_odbc? ; self.class.connection_mode_odbc? ; end
-    def sqlserver_azure? ; self.class.sqlserver_azure? ; end
-    def host_windows? ; self.class.host_windows? ; end
+    private
 
-    def connection
-      ActiveRecord::Base.connection
+    def host_windows?
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
     end
 
     def with_use_output_inserted_disabled
-      ActiveRecord::ConnectionAdapters::SQLServerAdapter.use_output_inserted = false
+      klass = ActiveRecord::ConnectionAdapters::SQLServerAdapter
+      klass.use_output_inserted = false
       yield
     ensure
-      ActiveRecord::ConnectionAdapters::SQLServerAdapter.use_output_inserted = true
+      klass.use_output_inserted = true
+    end
+
+    def silence_stream(stream)
+      old_stream = stream.dup
+      stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
+      stream.sync = true
+      yield
+    ensure
+      stream.reopen(old_stream)
+      old_stream.close
+    end
+
+    def quietly
+      silence_stream(STDOUT) { silence_stream(STDERR) { yield } }
     end
 
   end

data/test/cases/migration_test_sqlserver.rb

@@ -58,9 +58,4 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
 
   end
 
-
-  def quietly
-    silence_stream(STDOUT) { silence_stream(STDERR) { yield } }
-  end
-
 end

data/test/cases/rake_test_sqlserver.rb

@@ -4,24 +4,43 @@ class SQLServerRakeTest < ActiveRecord::TestCase
 
   self.use_transactional_fixtures = false
 
+  cattr_accessor :azure_skip
+  self.azure_skip = connection_sqlserver_azure?
+
   let(:db_tasks)              { ActiveRecord::Tasks::DatabaseTasks }
   let(:new_database)          { 'activerecord_unittest_tasks' }
   let(:default_configuration) { ARTest.connection_config['arunit'] }
   let(:configuration)         { default_configuration.merge('database' => new_database) }
 
-  before do
+  before { skip 'on azure' if azure_skip }
+  before { disconnect! unless azure_skip }
+  after  { reconnect unless azure_skip }
+
+  private
+
+  def disconnect!
     connection.disconnect!
   end
 
-  after do
-    ActiveRecord::Base.establish_connection(default_configuration)
-    connection.drop_database(new_database) rescue nil
+  def reconnect
+    config = default_configuration
+    if connection_sqlserver_azure?
+      ActiveRecord::Base.establish_connection(config.merge('database' => 'master'))
+      connection.drop_database(new_database) rescue nil
+      disconnect!
+      ActiveRecord::Base.establish_connection(config)
+    else
+      ActiveRecord::Base.establish_connection(config)
+      connection.drop_database(new_database) rescue nil
+    end
   end
 
 end
 
 class SQLServerRakeCreateTest < SQLServerRakeTest
 
+  self.azure_skip = false
+
   it 'establishes connection to database after create ' do
     db_tasks.create configuration
     connection.current_database.must_equal(new_database)
@@ -47,6 +66,8 @@ end
 
 class SQLServerRakeDropTest < SQLServerRakeTest
 
+  self.azure_skip = false
+
   it 'drops database and uses master' do
     db_tasks.create configuration
     db_tasks.drop configuration
@@ -120,9 +141,8 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
   end
 
   it 'dumps structure and accounts for defncopy oddities' do
-    # CHANGED: [TinyTDS] When utilities are available http://git.io/v3tBk
-    skip if host_windows?
-    db_tasks.structure_dump configuration, filename
+    skip 'debug defncopy on windows later' if host_windows?
+    quietly { db_tasks.structure_dump configuration, filename }
     filedata.wont_match %r{\AUSE.*\z}
     filedata.wont_match %r{\AGO.*\z}
     filedata.must_match %r{email\s+nvarchar\(4000\)}
@@ -131,9 +151,8 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
   end
 
   it 'can load dumped structure' do
-    # CHANGED: [TinyTDS] When utilities are available http://git.io/v3tBk
-    skip if host_windows?
-    db_tasks.structure_dump configuration, filename
+    skip 'debug defncopy on windows later' if host_windows?
+    quietly { db_tasks.structure_dump configuration, filename }
     filedata.must_match %r{CREATE TABLE dbo\.users}
     db_tasks.purge(configuration)
     connection.tables.wont_include 'users'