tiny_tds 1.0.4 → 2.1.5

data/test/result_test.rb

@@ -80,7 +80,7 @@ class ResultTest < TinyTds::TestCase
         @client.execute("DELETE FROM [datatypes]").do
         @client.execute("INSERT INTO [datatypes] ([char_10], [varchar_50]) VALUES ('1', '2')").do
         result = @client.execute("SELECT TOP (1) [char_10] + 'test' + [varchar_50] AS [test] FROM [datatypes]").each.first['test']
-        result.must_equal "1         test2"
+        _(result).must_equal "1         test2"
       end
     end
 
@@ -135,10 +135,10 @@ class ResultTest < TinyTds::TestCase
         text = 'test affected rows sql'
         @client.execute("DELETE FROM [datatypes]").do
         afrows = @client.execute("SELECT @@ROWCOUNT AS AffectedRows").each.first['AffectedRows']
-        assert_instance_of Fixnum, afrows
+        _(['Fixnum', 'Integer']).must_include afrows.class.name
         @client.execute("INSERT INTO [datatypes] ([varchar_50]) VALUES ('#{text}')").do
         pk1 = @client.execute(@client.identity_sql).each.first['Ident']
-        assert_instance_of Fixnum, pk1, 'we it be able to CAST to bigint'
+        _(['Fixnum', 'Integer']).must_include pk1.class.name, 'we it be able to CAST to bigint'
         @client.execute("UPDATE [datatypes] SET [varchar_50] = NULL WHERE [varchar_50] = '#{text}'").do
         afrows = @client.execute("SELECT @@ROWCOUNT AS AffectedRows").each.first['AffectedRows']
         assert_equal 1, afrows
@@ -215,34 +215,34 @@ class ResultTest < TinyTds::TestCase
       @client.execute("DELETE FROM [datatypes]").do
       @client.execute("ROLLBACK TRANSACTION").do
       count = @client.execute("SELECT COUNT(*) AS [count] FROM [datatypes]").each.first['count']
-      0.wont_equal count
+      _(count).wont_equal 0
     end
 
     it 'has a #fields accessor with logic default and valid outcome' do
       result = @client.execute(@query1)
-      result.fields.must_equal ['one']
+      _(result.fields).must_equal ['one']
       result.each
-      result.fields.must_equal ['one']
+      _(result.fields).must_equal ['one']
     end
 
     it 'always returns an array for fields for all sql' do
       result = @client.execute("USE [tinytdstest]")
-      result.fields.must_equal []
+      _(result.fields).must_equal []
       result.do
-      result.fields.must_equal []
+      _(result.fields).must_equal []
     end
 
     it 'returns fields even when no results are found' do
       no_results_query = "SELECT [id], [varchar_50] FROM [datatypes] WHERE [varchar_50] = 'NOTFOUND'"
       # Fields before each.
       result = @client.execute(no_results_query)
-      result.fields.must_equal ['id','varchar_50']
+      _(result.fields).must_equal ['id','varchar_50']
       result.each
-      result.fields.must_equal ['id','varchar_50']
+      _(result.fields).must_equal ['id','varchar_50']
       # Each then fields
       result = @client.execute(no_results_query)
       result.each
-      result.fields.must_equal ['id','varchar_50']
+      _(result.fields).must_equal ['id','varchar_50']
     end
 
     it 'allows the result to be canceled before reading' do
@@ -254,27 +254,27 @@ class ResultTest < TinyTds::TestCase
     it 'works in tandem with the client when needing to find out if client has sql sent and result is canceled or not' do
       # Default state.
       @client = TinyTds::Client.new(connection_options)
-      @client.sqlsent?.must_equal false
-      @client.canceled?.must_equal false
+      _(@client.sqlsent?).must_equal false
+      _(@client.canceled?).must_equal false
       # With active result before and after cancel.
       result = @client.execute(@query1)
-      @client.sqlsent?.must_equal true
-      @client.canceled?.must_equal false
+      _(@client.sqlsent?).must_equal true
+      _(@client.canceled?).must_equal false
       result.cancel
-      @client.sqlsent?.must_equal false
-      @client.canceled?.must_equal true
+      _(@client.sqlsent?).must_equal false
+      _(@client.canceled?).must_equal true
       assert result.cancel, 'must be safe to call again'
       # With each and no block.
       @client.execute(@query1).each
-      @client.sqlsent?.must_equal false
-      @client.canceled?.must_equal false
+      _(@client.sqlsent?).must_equal false
+      _(@client.canceled?).must_equal false
       # With each and block.
       @client.execute(@query1).each do |row|
-        @client.sqlsent?.must_equal true, 'when iterating over each row in a block'
-        @client.canceled?.must_equal false
+        _(@client.sqlsent?).must_equal true, 'when iterating over each row in a block'
+        _(@client.canceled?).must_equal false
       end
-      @client.sqlsent?.must_equal false
-      @client.canceled?.must_equal false
+      _(@client.sqlsent?).must_equal false
+      _(@client.canceled?).must_equal false
       # With each and block canceled half way thru.
       count = @client.execute("SELECT COUNT([id]) AS [count] FROM [datatypes]").each[0]['count']
       assert count > 10, 'since we want to cancel early for test'
@@ -284,25 +284,25 @@ class ResultTest < TinyTds::TestCase
         break if index > 10
         index += 1
       end
-      @client.sqlsent?.must_equal true
-      @client.canceled?.must_equal false
+      _(@client.sqlsent?).must_equal true
+      _(@client.canceled?).must_equal false
       result.cancel
-      @client.sqlsent?.must_equal false
-      @client.canceled?.must_equal true
+      _(@client.sqlsent?).must_equal false
+      _(@client.canceled?).must_equal true
       # With do method.
       @client.execute(@query1).do
-      @client.sqlsent?.must_equal false
-      @client.canceled?.must_equal true
+      _(@client.sqlsent?).must_equal false
+      _(@client.canceled?).must_equal true
       # With insert method.
       rollback_transaction(@client) do
         @client.execute("INSERT INTO [datatypes] ([varchar_50]) VALUES ('test')").insert
-        @client.sqlsent?.must_equal false
-        @client.canceled?.must_equal true
+        _(@client.sqlsent?).must_equal false
+        _(@client.canceled?).must_equal true
       end
       # With first
       @client.execute("SELECT [id] FROM [datatypes]").each(:first => true)
-      @client.sqlsent?.must_equal false
-      @client.canceled?.must_equal true
+      _(@client.sqlsent?).must_equal false
+      _(@client.canceled?).must_equal true
     end
 
     it 'use same string object for hash keys' do
@@ -335,6 +335,11 @@ class ResultTest < TinyTds::TestCase
       assert_nil result.return_code
     end
 
+    it 'with LOGINPROPERTY function' do
+      v = @client.execute("SELECT LOGINPROPERTY('sa', 'IsLocked') as v").first['v']
+      _(v).must_equal 0
+    end
+
     describe 'with multiple result sets' do
 
       before do
@@ -573,7 +578,7 @@ class ResultTest < TinyTds::TestCase
 
       it 'returns nil for NULL' do
         value = @client.execute('SELECT NULL AS [null]').each.first['null']
-        assert_equal nil, value
+        assert_nil value
       end
 
     end
@@ -609,6 +614,88 @@ class ResultTest < TinyTds::TestCase
 
       if sqlserver?
 
+        describe 'using :message_handler option' do
+          let(:messages) { Array.new }
+
+          before do
+            close_client
+            @client = new_connection message_handler: Proc.new { |m| messages << m }
+          end
+
+          after do
+            messages.clear
+          end
+
+          it 'has a message handler that responds to call' do
+            assert @client.message_handler.respond_to?(:call)
+          end
+
+          it 'calls the provided message handler when severity is 10 or less' do
+            (1..10).to_a.each do |severity|
+              messages.clear
+              msg = "Test #{severity} severity"
+              state = rand(1..255)
+              @client.execute("RAISERROR(N'#{msg}', #{severity}, #{state})").do
+              m = messages.first
+              assert_equal 1, messages.length, 'there should be one message after one raiserror'
+              assert_equal msg, m.message, 'message text'
+              assert_equal severity, m.severity, 'message severity' unless severity == 10 && m.severity.to_i == 0
+              assert_equal state, m.os_error_number, 'message state'
+            end
+          end
+
+          it 'calls the provided message handler for `print` messages' do
+            messages.clear
+            msg = 'hello'
+            @client.execute("PRINT '#{msg}'").do
+            m = messages.first
+            assert_equal 1, messages.length, 'there should be one message after one print statement'
+            assert_equal msg, m.message, 'message text'
+          end
+
+          it 'must raise an error preceded by a `print` message' do
+            messages.clear
+            action = lambda { @client.execute("EXEC tinytds_TestPrintWithError").do }
+            assert_raise_tinytds_error(action) do |e|
+              assert_equal 'hello', messages.first.message, 'message text'
+
+              assert_equal "Error following print", e.message
+              assert_equal 16, e.severity
+              assert_equal 50000, e.db_error_number
+            end
+          end
+
+          it 'calls the provided message handler for each of a series of `print` messages' do
+            messages.clear
+            @client.execute("EXEC tinytds_TestSeveralPrints").do
+            assert_equal ['hello 1', 'hello 2', 'hello 3'], messages.map { |e| e.message }, 'message list'
+          end
+
+          it 'should flush info messages before raising error in cases of timeout' do
+            @client = new_connection timeout: 1, message_handler: Proc.new { |m| messages << m }
+            action = lambda { @client.execute("print 'hello'; waitfor delay '00:00:02'").do }
+            messages.clear
+            assert_raise_tinytds_error(action) do |e|
+              assert_match %r{timed out}i, e.message, 'ignore if non-english test run'
+              assert_equal 6, e.severity
+              assert_equal 20003, e.db_error_number
+              assert_equal 'hello', messages.first&.message, 'message text'
+            end
+          end
+
+          it 'should print info messages before raising error in cases of timeout' do
+            @client = new_connection timeout: 1, message_handler: Proc.new { |m| messages << m }
+            action = lambda { @client.execute("raiserror('hello', 1, 1) with nowait; waitfor delay '00:00:02'").do }
+            messages.clear
+            assert_raise_tinytds_error(action) do |e|
+              assert_match %r{timed out}i, e.message, 'ignore if non-english test run'
+              assert_equal 6, e.severity
+              assert_equal 20003, e.db_error_number
+              assert_equal 'hello', messages.first&.message, 'message text'
+            end
+          end
+        end
+
         it 'must not raise an error when severity is 10 or less' do
           (1..10).to_a.each do |severity|
             @client.execute("RAISERROR(N'Test #{severity} severity', #{severity}, 1)").do
@@ -639,7 +726,7 @@ class ResultTest < TinyTds::TestCase
       end
 
       it 'throws an error when you execute another query with other results pending' do
-        result1 = @client.execute(@query1)
+        @client.execute(@query1)
         action = lambda { @client.execute(@query1) }
         assert_raise_tinytds_error(action) do |e|
           assert_match %r|with results pending|i, e.message
@@ -672,22 +759,22 @@ class ResultTest < TinyTds::TestCase
       it 'must not error at all from reading non-convertable charcters and just use ? marks' do
         close_client
         @client = new_connection :encoding => 'ASCII'
-        @client.charset.must_equal 'ASCII'
-        find_value(202, :nvarchar_50).must_equal 'test nvarchar_50 ??'
+        _(@client.charset).must_equal 'ASCII'
+        _(find_value(202, :nvarchar_50)).must_equal 'test nvarchar_50 ??'
       end
 
       it 'must error gracefully from writing non-convertable characters' do
         close_client
         @client = new_connection :encoding => 'ASCII'
-        @client.charset.must_equal 'ASCII'
+        _(@client.charset).must_equal 'ASCII'
         rollback_transaction(@client) do
           text = 'Test ✓'
           @client.execute("DELETE FROM [datatypes] WHERE [nvarchar_50] IS NOT NULL").do
           action = lambda { @client.execute("INSERT INTO [datatypes] ([nvarchar_50]) VALUES ('#{text}')").do }
           assert_raise_tinytds_error(action) do |e|
-            e.message.must_match %r{Unclosed quotation mark}i
-            e.severity.must_equal 15
-            e.db_error_number.must_equal 105
+            _(e.message).must_match %r{Unclosed quotation mark}i
+            _(e.severity).must_equal 15
+            _(e.db_error_number).must_equal 105
           end
           assert_followup_query
         end
@@ -725,4 +812,3 @@ class ResultTest < TinyTds::TestCase
   end
 
 end
-

data/test/schema/sqlserver_2016.sql

@@ -0,0 +1,140 @@
+
+/*
+
+  * Binary Data - Our test binary data is a 1 pixel gif. The basic (raw) data is below. Quoting this data
+    would involve this (encode) method and be (encoded) with the 0x prefix for raw SQL. In other clients the
+    (raw_db) value without the 0x prefix would need to be (packed) again yield the original (raw) value.
+
+    (raw)     - "GIF89a\001\000\001\000\221\000\000\377\377\377\377\377\377\376\001\002\000\000\000!\371\004\004\024\000\377\000,\000\000\000\000\001\000\001\000\000\002\002D\001\000;"
+    (encode)  - "0x#{raw.unpack("H*")[0]}"
+    (encoded) - "0x47494638396101000100910000fffffffffffffe010200000021f904041400ff002c00000000010001000002024401003b"
+    (raw_db)  - "47494638396101000100910000fffffffffffffe010200000021f904041400ff002c00000000010001000002024401003b"
+    (packed)  - [raw_db].pack('H*')
+
+*/
+
+CREATE TABLE [dbo].[datatypes] (
+  [id] [int] NOT NULL IDENTITY(1,1) PRIMARY KEY,
+	[bigint] [bigint] NULL,
+	[binary_50] [binary](50) NULL,
+	[bit] [bit] NULL,
+	[char_10] [char](10) NULL,
+	[date] [date] NULL,
+	[datetime] [datetime] NULL,
+	[datetime2_7] [datetime2](7) NULL,
+	[datetime2_2] [datetime2](2) NULL,
+	[datetimeoffset_2] [datetimeoffset](2) NULL,
+	[datetimeoffset_7] [datetimeoffset](7) NULL,
+	[decimal_9_2] [decimal](9, 2) NULL,
+	[decimal_16_4] [decimal](16, 4) NULL,
+	[float] [float] NULL,
+	[geography] [geography] NULL,
+	[geometry] [geometry] NULL,
+	[hierarchyid] [hierarchyid] NULL,
+	[image] [image] NULL,
+	[int] [int] NULL,
+	[money] [money] NULL,
+	[nchar_10] [nchar](10) NULL,
+	[ntext] [ntext] NULL,
+	[numeric_18_0] [numeric](18, 0) NULL,
+	[numeric_36_2] [numeric](36, 2) NULL,
+	[nvarchar_50] [nvarchar](50) NULL,
+	[nvarchar_max] [nvarchar](max) NULL,
+	[real] [real] NULL,
+	[smalldatetime] [smalldatetime] NULL,
+	[smallint] [smallint] NULL,
+	[smallmoney] [smallmoney] NULL,
+	[text] [text] NULL,
+	[time_2] [time](2) NULL,
+	[time_7] [time](7) NULL,
+	[timestamp] [timestamp] NULL,
+	[tinyint] [tinyint] NULL,
+	[uniqueidentifier] [uniqueidentifier] NULL,
+	[varbinary_50] [varbinary](50) NULL,
+	[varbinary_max] [varbinary](max) NULL,
+	[varchar_50] [varchar](50) NULL,
+	[varchar_max] [varchar](max) NULL,
+	[xml] [xml] NULL
+) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
+
+SET IDENTITY_INSERT [datatypes] ON
+
+INSERT INTO [datatypes] ([id], [bigint])            VALUES ( 11, -9223372036854775807 )
+INSERT INTO [datatypes] ([id], [bigint])            VALUES ( 12, 9223372036854775806 )
+INSERT INTO [datatypes] ([id], [binary_50])         VALUES ( 21, 0x47494638396101000100910000fffffffffffffe010200000021f904041400ff002c00000000010001000002024401003b )
+INSERT INTO [datatypes] ([id], [bit])               VALUES ( 31, 1 )
+INSERT INTO [datatypes] ([id], [bit])               VALUES ( 32, 0 )
+INSERT INTO [datatypes] ([id], [char_10])           VALUES ( 41, '1234567890' )
+INSERT INTO [datatypes] ([id], [char_10])           VALUES ( 42, '12345678' )
+INSERT INTO [datatypes] ([id], [date])              VALUES ( 51, '0001-01-01' )
+INSERT INTO [datatypes] ([id], [date])              VALUES ( 52, '9999-12-31' )
+INSERT INTO [datatypes] ([id], [datetime])          VALUES ( 61, '1753-01-01T00:00:00.000' )
+INSERT INTO [datatypes] ([id], [datetime])          VALUES ( 62, '9999-12-31T23:59:59.997' )
+INSERT INTO [datatypes] ([id], [datetime])          VALUES ( 63, '2010-01-01T12:34:56.123' )
+INSERT INTO [datatypes] ([id], [datetime2_7])       VALUES ( 71, '0001-01-01 00:00:00.0000000' )
+INSERT INTO [datatypes] ([id], [datetime2_7])       VALUES ( 72, '1984-01-24 04:20:00.0000000' )
+INSERT INTO [datatypes] ([id], [datetime2_7])       VALUES ( 73, '9999-12-31 23:59:59.9999999' )
+INSERT INTO [datatypes] ([id], [datetime2_2])       VALUES ( 74, '9999-12-31 23:59:59.123456789' )
+INSERT INTO [datatypes] ([id], [datetimeoffset_2])  VALUES ( 81, '1984-01-24T04:20:00.1234567-08:00' ) -- 1984-01-24 04:20:00.00 -08:00
+INSERT INTO [datatypes] ([id], [datetimeoffset_2])  VALUES ( 82, '1984-01-24T04:20:00.0000000Z' )      -- 1984-01-24 04:20:00.00 +00:00
+INSERT INTO [datatypes] ([id], [datetimeoffset_2])  VALUES ( 83, '9999-12-31T23:59:59.9999999Z' )      -- 9999-12-31 23:59:59.99 +00:00
+INSERT INTO [datatypes] ([id], [datetimeoffset_7])  VALUES ( 84, '1984-01-24T04:20:59.1234567-08:00' ) -- 1984-01-24 04:20:59.1234567 -08:00
+INSERT INTO [datatypes] ([id], [datetimeoffset_7])  VALUES ( 85, '1984-01-24T04:20:00.0000000Z' )      -- 1984-01-24 04:20:00.0000000 +00:00
+INSERT INTO [datatypes] ([id], [datetimeoffset_7])  VALUES ( 86, '9999-12-31T23:59:59.9999999Z' )      -- 9999-12-31 23:59:59.9999999 +00:00
+INSERT INTO [datatypes] ([id], [decimal_9_2])       VALUES ( 91, 12345.01 )
+INSERT INTO [datatypes] ([id], [decimal_9_2])       VALUES ( 92, 1234567.89 )
+INSERT INTO [datatypes] ([id], [decimal_16_4])      VALUES ( 93, 0.0 )
+INSERT INTO [datatypes] ([id], [decimal_16_4])      VALUES ( 94, 123456789012.3456 )
+INSERT INTO [datatypes] ([id], [float])             VALUES ( 101, 123.00000001 )
+INSERT INTO [datatypes] ([id], [float])             VALUES ( 102, 0.0 )
+INSERT INTO [datatypes] ([id], [float])             VALUES ( 103, 123.45 )
+INSERT INTO [datatypes] ([id], [geography])         VALUES ( 111, geography::STGeomFromText('LINESTRING(-122.360 47.656, -122.343 47.656)', 4326) ) -- 0xE610000001148716D9CEF7D34740D7A3703D0A975EC08716D9CEF7D34740CBA145B6F3955EC0
+INSERT INTO [datatypes] ([id], [geometry])          VALUES ( 121, geometry::STGeomFromText('LINESTRING (100 100, 20 180, 180 180)', 0) ) -- 0x0000000001040300000000000000000059400000000000005940000000000000344000000000008066400000000000806640000000000080664001000000010000000001000000FFFFFFFF0000000002
+INSERT INTO [datatypes] ([id], [hierarchyid])       VALUES ( 131, CAST('/1/' AS hierarchyid) ) -- 0x58
+INSERT INTO [datatypes] ([id], [hierarchyid])       VALUES ( 132, CAST('/2/' AS hierarchyid) ) -- 0x68
+INSERT INTO [datatypes] ([id], [image])             VALUES ( 141, 0x47494638396101000100910000fffffffffffffe010200000021f904041400ff002c00000000010001000002024401003b )
+INSERT INTO [datatypes] ([id], [int])               VALUES ( 151, -2147483647 )
+INSERT INTO [datatypes] ([id], [int])               VALUES ( 152, 2147483646 )
+INSERT INTO [datatypes] ([id], [money])             VALUES ( 161, 4.20 )
+INSERT INTO [datatypes] ([id], [money])             VALUES ( 162, -922337203685477.5807 )
+INSERT INTO [datatypes] ([id], [money])             VALUES ( 163, 922337203685477.5806 )
+INSERT INTO [datatypes] ([id], [nchar_10])          VALUES ( 171, N'1234567890' )
+INSERT INTO [datatypes] ([id], [nchar_10])          VALUES ( 172, N'123456åå' )
+INSERT INTO [datatypes] ([id], [nchar_10])          VALUES ( 173, N'abc123' )
+INSERT INTO [datatypes] ([id], [ntext])             VALUES ( 181, N'test ntext' )
+INSERT INTO [datatypes] ([id], [ntext])             VALUES ( 182, N'test ntext åå' )
+INSERT INTO [datatypes] ([id], [numeric_18_0])      VALUES ( 191, 191 )
+INSERT INTO [datatypes] ([id], [numeric_18_0])      VALUES ( 192, 123456789012345678 )
+INSERT INTO [datatypes] ([id], [numeric_36_2])      VALUES ( 193, 12345678901234567890.01 )
+INSERT INTO [datatypes] ([id], [numeric_36_2])      VALUES ( 194, 123.46 )
+INSERT INTO [datatypes] ([id], [nvarchar_50])       VALUES ( 201, N'test nvarchar_50' )
+INSERT INTO [datatypes] ([id], [nvarchar_50])       VALUES ( 202, N'test nvarchar_50 åå' )
+INSERT INTO [datatypes] ([id], [nvarchar_max])      VALUES ( 211, N'test nvarchar_max' )
+INSERT INTO [datatypes] ([id], [nvarchar_max])      VALUES ( 212, N'test nvarchar_max åå' )
+INSERT INTO [datatypes] ([id], [real])              VALUES ( 221, 123.45 )
+INSERT INTO [datatypes] ([id], [real])              VALUES ( 222, 0.0 )
+INSERT INTO [datatypes] ([id], [real])              VALUES ( 223, 0.00001 )
+INSERT INTO [datatypes] ([id], [smalldatetime])     VALUES ( 231, '1901-01-01T15:45:00.000Z' ) -- 1901-01-01 15:45:00
+INSERT INTO [datatypes] ([id], [smalldatetime])     VALUES ( 232, '2078-06-05T04:20:00.000Z' ) -- 2078-06-05 04:20:00
+INSERT INTO [datatypes] ([id], [smallint])          VALUES ( 241, -32767 )
+INSERT INTO [datatypes] ([id], [smallint])          VALUES ( 242, 32766 )
+INSERT INTO [datatypes] ([id], [smallmoney])        VALUES ( 251, 4.20 )
+INSERT INTO [datatypes] ([id], [smallmoney])        VALUES ( 252, -214748.3647 )
+INSERT INTO [datatypes] ([id], [smallmoney])        VALUES ( 253, 214748.3646 )
+INSERT INTO [datatypes] ([id], [text])              VALUES ( 271, 'test text' )
+INSERT INTO [datatypes] ([id], [time_2])            VALUES ( 281, '15:45:00.709714966' ) -- 15:45:00.71
+INSERT INTO [datatypes] ([id], [time_2])            VALUES ( 282, '04:20:00.288321545' ) -- 04:20:00.29
+INSERT INTO [datatypes] ([id], [time_7])            VALUES ( 283, '15:45:00.709714966' ) -- 15:45:00.709714900
+INSERT INTO [datatypes] ([id], [time_7])            VALUES ( 284, '04:20:00.288321545' ) -- 04:20:00.288321500
+INSERT INTO [datatypes] ([id], [tinyint])           VALUES ( 301, 0 )
+INSERT INTO [datatypes] ([id], [tinyint])           VALUES ( 302, 255 )
+INSERT INTO [datatypes] ([id], [uniqueidentifier])  VALUES ( 311, NEWID() )
+INSERT INTO [datatypes] ([id], [varbinary_50])      VALUES ( 321, 0x47494638396101000100910000fffffffffffffe010200000021f904041400ff002c00000000010001000002024401003b )
+INSERT INTO [datatypes] ([id], [varbinary_max])     VALUES ( 331, 0x47494638396101000100910000fffffffffffffe010200000021f904041400ff002c00000000010001000002024401003b )
+INSERT INTO [datatypes] ([id], [varchar_50])        VALUES ( 341, 'test varchar_50' )
+INSERT INTO [datatypes] ([id], [varchar_max])       VALUES ( 351, 'test varchar_max' )
+INSERT INTO [datatypes] ([id], [xml])               VALUES ( 361, '<foo><bar>batz</bar></foo>' )
+
+SET IDENTITY_INSERT [datatypes] OFF
+
+

data/test/schema_test.rb

@@ -14,7 +14,7 @@ class SchemaTest < TinyTds::TestCase
     describe 'for shared types' do
 
       it 'casts bigint' do
-        assert_equal -9223372036854775807, find_value(11, :bigint)
+        assert_equal (-9223372036854775807), find_value(11, :bigint)
         assert_equal 9223372036854775806, find_value(12, :bigint)
       end
 
@@ -27,7 +27,7 @@ class SchemaTest < TinyTds::TestCase
       it 'casts bit' do
         assert_equal true, find_value(31, :bit)
         assert_equal false, find_value(32, :bit)
-        assert_equal nil, find_value(21, :bit)
+        assert_nil find_value(21, :bit)
       end
 
       it 'casts char' do
@@ -76,10 +76,10 @@ class SchemaTest < TinyTds::TestCase
 
       it 'casts decimal' do
         assert_instance_of BigDecimal, find_value(91, :decimal_9_2)
-        assert_equal BigDecimal.new('12345.01'), find_value(91, :decimal_9_2)
-        assert_equal BigDecimal.new('1234567.89'), find_value(92, :decimal_9_2)
-        assert_equal BigDecimal.new('0.0'), find_value(93, :decimal_16_4)
-        assert_equal BigDecimal.new('123456789012.3456'), find_value(94, :decimal_16_4)
+        assert_equal BigDecimal('12345.01'), find_value(91, :decimal_9_2)
+        assert_equal BigDecimal('1234567.89'), find_value(92, :decimal_9_2)
+        assert_equal BigDecimal('0.0'), find_value(93, :decimal_16_4)
+        assert_equal BigDecimal('123456789012.3456'), find_value(94, :decimal_16_4)
       end
 
       it 'casts float' do
@@ -96,15 +96,15 @@ class SchemaTest < TinyTds::TestCase
       end
 
       it 'casts int' do
-        assert_equal -2147483647, find_value(151, :int)
+        assert_equal (-2147483647), find_value(151, :int)
         assert_equal 2147483646, find_value(152, :int)
       end
 
       it 'casts money' do
         assert_instance_of BigDecimal, find_value(161, :money)
-        assert_equal BigDecimal.new('4.20'), find_value(161, :money)
-        assert_equal BigDecimal.new('922337203685477.5806'), find_value(163 ,:money)
-        assert_equal BigDecimal.new('-922337203685477.5807'), find_value(162 ,:money)
+        assert_equal BigDecimal('4.20'), find_value(161, :money)
+        assert_equal BigDecimal('922337203685477.5806'), find_value(163 ,:money)
+        assert_equal BigDecimal('-922337203685477.5807'), find_value(162 ,:money)
       end
 
       it 'casts nchar' do
@@ -170,15 +170,15 @@ class SchemaTest < TinyTds::TestCase
       end
 
       it 'casts smallint' do
-        assert_equal -32767, find_value(241, :smallint)
+        assert_equal (-32767), find_value(241, :smallint)
         assert_equal 32766, find_value(242, :smallint)
       end
 
       it 'casts smallmoney' do
         assert_instance_of BigDecimal, find_value(251, :smallmoney)
-        assert_equal BigDecimal.new("4.20"), find_value(251, :smallmoney)
-        assert_equal BigDecimal.new("-214748.3647"), find_value(252, :smallmoney)
-        assert_equal BigDecimal.new("214748.3646"), find_value(253, :smallmoney)
+        assert_equal BigDecimal("4.20"), find_value(251, :smallmoney)
+        assert_equal BigDecimal("-214748.3647"), find_value(252, :smallmoney)
+        assert_equal BigDecimal("214748.3646"), find_value(253, :smallmoney)
       end
 
       it 'casts text' do
@@ -396,15 +396,15 @@ class SchemaTest < TinyTds::TestCase
         if @client.tds_73?
           assertions = lambda {
             assert_instance_of Time, v
-            assert_equal 1984, v.year,         'Year'
-            assert_equal 1, v.month,           'Month'
-            assert_equal 24, v.day,            'Day'
-            assert_equal 4, v.hour,            'Hour'
-            assert_equal 20, v.min,            'Minute'
-            assert_equal 59, v.sec,            'Second'
-            assert_equal 123456, v.usec,       'Microseconds'
-            assert_equal 123456700, v.nsec,    'Nanoseconds'
-            assert_equal -28800, v.utc_offset, 'Offset'
+            assert_equal 1984, v.year,           'Year'
+            assert_equal 1, v.month,             'Month'
+            assert_equal 24, v.day,              'Day'
+            assert_equal 4, v.hour,              'Hour'
+            assert_equal 20, v.min,              'Minute'
+            assert_equal 59, v.sec,              'Second'
+            assert_equal 123456, v.usec,         'Microseconds'
+            assert_equal 123456700, v.nsec,      'Nanoseconds'
+            assert_equal (-28800), v.utc_offset, 'Offset'
           }
           assertions.call
           v = find_value 84, :datetimeoffset_7, timezone: :local

data/test/test_helper.rb

@@ -2,6 +2,7 @@
 require 'bundler' ; Bundler.require :development, :test
 require 'tiny_tds'
 require 'minitest/autorun'
+require 'toxiproxy'
 
 TINYTDS_SCHEMAS = ['sqlserver_2000', 'sqlserver_2005', 'sqlserver_2008', 'sqlserver_2014', 'sqlserver_azure', 'sybase_ase'].freeze
 
@@ -75,8 +76,8 @@ module TinyTds
       username = (sqlserver_azure? ? ENV['TINYTDS_UNIT_AZURE_USER'] : ENV['TINYTDS_UNIT_USER']) || 'tinytds'
       password = (sqlserver_azure? ? ENV['TINYTDS_UNIT_AZURE_PASS'] : ENV['TINYTDS_UNIT_PASS']) || ''
       { :dataserver    => sqlserver_azure? ? nil : ENV['TINYTDS_UNIT_DATASERVER'],
-        :host          => ENV['TINYTDS_UNIT_HOST'],
-        :port          => ENV['TINYTDS_UNIT_PORT'],
+        :host          => ENV['TINYTDS_UNIT_HOST'] || 'localhost',
+        :port          => ENV['TINYTDS_UNIT_PORT'] || '1433',
         :tds_version   => ENV['TINYTDS_UNIT_VERSION'],
         :username      => username,
         :password      => password,
@@ -89,11 +90,11 @@ module TinyTds
     end
 
     def connection_timeout
-      sqlserver_azure? ? 20 : 5
+      sqlserver_azure? ? 20 : 8
     end
 
     def assert_client_works(client)
-      client.execute("SELECT 'client_works' as [client_works]").each.must_equal [{'client_works' => 'client_works'}]
+      _(client.execute("SELECT 'client_works' as [client_works]").each).must_equal [{'client_works' => 'client_works'}]
     end
 
     def assert_new_connections_work
@@ -142,6 +143,10 @@ module TinyTds
       RbConfig::CONFIG['host_os'] =~ /ming/
     end
 
+    def ruby_darwin?
+      RbConfig::CONFIG['host_os'] =~ /darwin/
+    end
+
     def load_current_schema
       loader = new_connection
       schema_file = File.expand_path File.join(File.dirname(__FILE__), 'schema', "#{current_schema}.sql")
@@ -149,6 +154,8 @@ module TinyTds
       loader.execute(drop_sql).do
       loader.execute(schema_sql).do
       loader.execute(sp_sql).do
+      loader.execute(sp_error_sql).do
+      loader.execute(sp_several_prints_sql).do
       loader.close
       true
     end
@@ -163,7 +170,16 @@ module TinyTds
         ) DROP TABLE datatypes
         IF EXISTS(
           SELECT 1 FROM sysobjects WHERE type = 'P' AND name = 'tinytds_TestReturnCodes'
-        ) DROP PROCEDURE tinytds_TestReturnCodes|
+        ) DROP PROCEDURE tinytds_TestReturnCodes
+        IF EXISTS(
+          SELECT 1 FROM sysobjects WHERE type = 'P' AND name = 'tinytds_TestPrintWithError'
+        ) DROP PROCEDURE tinytds_TestPrintWithError
+        IF EXISTS(
+          SELECT 1 FROM sysobjects WHERE type = 'P' AND name = 'tinytds_TestPrintWithError'
+        ) DROP PROCEDURE tinytds_TestPrintWithError
+        IF EXISTS(
+          SELECT 1 FROM sysobjects WHERE type = 'P' AND name = 'tinytds_TestSeveralPrints'
+        ) DROP PROCEDURE tinytds_TestSeveralPrints|
     end
 
     def drop_sql_microsoft
@@ -177,7 +193,15 @@ module TinyTds
         IF EXISTS (
           SELECT name FROM sysobjects
           WHERE name = 'tinytds_TestReturnCodes' AND type = 'P'
-        ) DROP PROCEDURE tinytds_TestReturnCodes|
+        ) DROP PROCEDURE tinytds_TestReturnCodes
+        IF EXISTS (
+          SELECT name FROM sysobjects
+          WHERE name = 'tinytds_TestPrintWithError' AND type = 'P'
+        ) DROP PROCEDURE tinytds_TestPrintWithError
+        IF EXISTS (
+          SELECT name FROM sysobjects
+          WHERE name = 'tinytds_TestSeveralPrints' AND type = 'P'
+        ) DROP PROCEDURE tinytds_TestSeveralPrints|
     end
 
     def sp_sql
@@ -187,6 +211,21 @@ module TinyTds
         RETURN(420) |
     end
 
+    def sp_error_sql
+      %|CREATE PROCEDURE tinytds_TestPrintWithError
+        AS
+        PRINT 'hello'
+        RAISERROR('Error following print', 16, 1)|
+    end
+
+    def sp_several_prints_sql
+      %|CREATE PROCEDURE tinytds_TestSeveralPrints
+        AS
+        PRINT 'hello 1'
+        PRINT 'hello 2'
+        PRINT 'hello 3'|
+    end
+
     def find_value(id, column, query_options={})
       query_options[:timezone] ||= :utc
       sql = "SELECT [#{column}] FROM [datatypes] WHERE [id] = #{id}"
@@ -208,6 +247,25 @@ module TinyTds
       client.execute("ROLLBACK TRANSACTION").do
     end
 
+    def init_toxiproxy
+      return if ENV['APPVEYOR_BUILD_FOLDER'] # only for CI using docker
+
+      # In order for toxiproxy to work for local docker instances of mssql, the containers must be on the same network
+      # and the host used below must match the mssql container name so toxiproxy knows where to proxy to.
+      # localhost from the perspective of toxiproxy's container is its own container an *not* the mssql container it needs to proxy to.
+      # docker-compose.yml handles this automatically for us. In instances where someone is using their own local mssql container they'll
+      # need to set up the networks manually and set TINYTDS_UNIT_HOST to their mssql container name
+      # For anything other than localhost just use the environment config
+      env_host = ENV['TINYTDS_UNIT_HOST_TEST'] || ENV['TINYTDS_UNIT_HOST'] || 'localhost'
+      host = ['localhost', '127.0.0.1', '0.0.0.0'].include?(env_host) ? 'sqlserver' : env_host
+      port = ENV['TINYTDS_UNIT_PORT'] || 1433
+      Toxiproxy.populate([
+        {
+          name: "sqlserver_test",
+          listen: "0.0.0.0:1234",
+          upstream: "#{host}:#{port}"
+        }
+      ])
+    end
   end
 end
-