tiny_tds 2.1.3 → 2.1.4.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '009faf9814321046171c7dfe6a0cbf86b137f4295ae079c1b8ae47067a940d10'
-  data.tar.gz: 6a20fcde7f6863f3e876f3484c4c93ded56511d93ac76de355c43f365758539d
+  metadata.gz: ef24128290a7b007a49222ec2d4307a834930f2aa6606fc9bc2b464b2d7400bb
+  data.tar.gz: e960731768896511f5592e4abd9768df0cf4a63ba089dd7c391bf845c0924788
 SHA512:
-  metadata.gz: 6572f896cf1a4812b652417d1b353487d49998df7dac8518de7310123cce5c295d775e102a184355b8501a3fa3b1f9f66f892026a33fc97bfde56e3cb9912a36
-  data.tar.gz: d05b4c50dbbe86f920a34cc6a6fc9bd20b9b27564d75b2e05f214b1600504898e22f5935ba1183f82646095a95d8bbbcba3f1fcc2548920e35d87b11c7bf0cd4
+  metadata.gz: 44a3b20f0bb91e24d325305fff06046cecc57d16fc6d8f8f7cc530e12689444b1f6b2c6346857cd11d779e0c30c64ebd856a0c9a9b473fdc1ffcc29edf356f30
+  data.tar.gz: 55c8753d62b46cb1f745f2d6b0a9a3f5e270e83f7a956dc03be540e4ed08aa1a7754c4c6462ba9ed58ad15c37c9f8a5be8f1b8236996999dec13d425cf9aadc5

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## (unreleased)
 
+## 2.1.4
+
+* todo: changelog for info messages
+* todo: changelog for network timeouts
+
 ## 2.1.3
 
 * Removed old/unused appveyor config
@@ -215,6 +220,8 @@ Use both dbsetversion() vs. dbsetlversion. Partially reverts #62.
   state of the client and the need to use Result#cancel to stop processing active results. It is also
   safe to call Result#cancel over and over again.
 * Look for the syb headers only.
+* Fix minitest global matchers warnings.
+* Fix test warnings.
 
 
 ## 0.3.2

data/README.md

@@ -3,7 +3,6 @@
 * [![TravisCI](https://travis-ci.org/rails-sqlserver/tiny_tds.svg?branch=master)](https://travis-ci.org/rails-sqlserver/tiny_tds) - TravisCI
 * [![Build Status](https://ci.appveyor.com/api/projects/status/g2bhhbsdkx0mal55/branch/master?svg=true)](https://ci.appveyor.com/project/rails-sqlserver/tiny-tds/branch/master) - Appveyor
 * [![Gem Version](https://img.shields.io/gem/v/tiny_tds.svg)](https://rubygems.org/gems/tiny_tds) - Gem Version
-* [![Dependency Status](https://dependencyci.com/github/rails-sqlserver/tiny_tds/badge)](https://dependencyci.com/github/rails-sqlserver/tiny_tds) - Dependency Status
 * [![Gitter chat](https://img.shields.io/badge/%E2%8A%AA%20GITTER%20-JOIN%20CHAT%20%E2%86%92-brightgreen.svg?style=flat)](https://gitter.im/rails-sqlserver/activerecord-sqlserver-adapter) - Community
 
 
@@ -111,7 +110,7 @@ Creating a new client takes a hash of options. For valid iconv encoding options,
 * :appname - Short string seen in SQL Servers process/activity window.
 * :tds_version - TDS version. Defaults to "7.3".
 * :login_timeout - Seconds to wait for login. Default to 60 seconds.
-* :timeout - Seconds to wait for a response to a SQL command. Default 5 seconds. Prior to 1.0rc5, FreeTDS was unable to set the timeout on a per-client basis, permitting only a global timeout value. This means that if you're using an older version, the timeout values for all clients will be overwritten each time you instantiate a new `TinyTds::Client` object. If you are using 1.0rc5 or later, all clients will have an independent timeout setting as you'd expect.
+* :timeout - Seconds to wait for a response to a SQL command. Default 5 seconds. Prior to 1.0rc5, FreeTDS was unable to set the timeout on a per-client basis, permitting only a global timeout value. This means that if you're using an older version, the timeout values for all clients will be overwritten each time you instantiate a new `TinyTds::Client` object. If you are using 1.0rc5 or later, all clients will have an independent timeout setting as you'd expect. Timeouts caused by network failure will raise a timeout error 1 second after the configured timeout limit is hit (see [#481](https://github.com/rails-sqlserver/tiny_tds/pull/481) for details).
 * :encoding - Any valid iconv value like CP1251 or ISO-8859-1. Default UTF-8.
 * :azure - Pass true to signal that you are connecting to azure.
 * :contained - Pass true to signal that you are connecting with a contained database user.
@@ -323,6 +322,10 @@ By default row caching is turned on because the SQL Server adapter for ActiveRec
 TinyTDS takes an opinionated stance on how we handle encoding errors. First, we treat errors differently on reads vs. writes. Our opinion is that if you are reading bad data due to your client's encoding option, you would rather just find `?` marks in your strings vs being blocked with exceptions. This is how things wold work via ODBC or SMS. On the other hand, writes will raise an exception. In this case we raise the SYBEICONVO/2402 error message which has a description of `Error converting characters into server's character set. Some character(s) could not be converted.`. Even though the severity of this message is only a `4` and TinyTDS will automatically strip/ignore unknown characters, we feel you should know that you are inserting bad encodings. In this way, a transaction can be rolled back, etc. Remember, any database write that has bad characters due to the client encoding will still be written to the database, but it is up to you rollback said write if needed. Most ORMs like ActiveRecord handle this scenario just fine.
 
 
+## Timeout Error Handling
+
+TinyTDS will raise a `TinyTDS::Error` when a timeout is reached based on the options supplied to the client. Depending on the reason for the timeout, the connection could be dead or alive. When db processing is the cause for the timeout, the connection should still be usable after the error is raised. When network failure is the cause of the timeout, the connection will be dead. If you attempt to execute another command batch on a dead connection you will see a `DBPROCESS is dead or not enabled` error. Therefore, it is recommended to check for a `dead?` connection before trying to execute another command batch.
+
 ## Binstubs
 
 The TinyTDS gem uses binstub wrappers which mirror compiled [FreeTDS Utilities](http://www.freetds.org/userguide/usefreetds.htm) binaries. These native executables are usually installed at the system level when installing FreeTDS. However, when using MiniPortile to install TinyTDS as we do with Windows binaries, these binstubs will find and prefer local gem `exe` directory executables. These are the following binstubs we wrap.

data/VERSION

@@ -1 +1 @@
-2.1.3
+2.1.4.pre

data/appveyor.yml

@@ -19,7 +19,19 @@ install:
   - perl --version
   - ruby --version
   - gem --version
-
+  # Update keyring according to https://www.msys2.org/news/#2020-06-29-new-packagers
+  - C:\msys64\usr\bin\curl -O http://repo.msys2.org/msys/x86_64/msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz
+  - C:\msys64\usr\bin\curl -O http://repo.msys2.org/msys/x86_64/msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz.sig
+  - ridk exec bash -c "pacman-key --verify msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz.sig"
+  - ridk exec bash -c "pacman -U --noconfirm --config <(echo) msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz"
+  # Update zstd and pacman first https://github.com/msys2/MSYS2-packages/issues/2300
+  - C:\msys64\usr\bin\pacman --noconfirm --upgrade https://repo.msys2.org/msys/x86_64/zstd-1.4.7-1-x86_64.pkg.tar.xz # Must come First, or else pacman will install 1.4.8
+  - C:\msys64\usr\bin\pacman --noconfirm --upgrade https://repo.msys2.org/msys/x86_64/pacman-5.2.2-5-x86_64.pkg.tar.xz
+  # update packages
+  - C:\msys64\usr\bin\pacman --noconfirm --ask 20 --sync --refresh --refresh --sysupgrade --sysupgrade
+  # Kill all running msys2 binaries to avoid error "size of shared memory region changed".
+  # See https://github.com/msys2/MSYS2-packages/issues/258
+  - powershell -Command "Get-Process | Where-Object {$_.path -like 'C:\msys64*'} | Stop-Process"
   # prevent freetds to link to wrong ws2_32 lib on i686-w64-mingw32
   - c:/msys64/usr/bin/rm /usr/lib/w32api/libws2_32.a
   # Set up project prerequisits

data/ext/tiny_tds/client.c

@@ -57,6 +57,16 @@ VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int is_message, int cancel, cons
 
 
 // Lib Backend (Memory Management & Handlers)
+static void push_userdata_error(tinytds_client_userdata *userdata, tinytds_errordata error) {
+  // reallocate memory for the array as needed
+  if (userdata->nonblocking_errors_size == userdata->nonblocking_errors_length) {
+    userdata->nonblocking_errors_size *= 2;
+    userdata->nonblocking_errors = realloc(userdata->nonblocking_errors, userdata->nonblocking_errors_size * sizeof(tinytds_errordata));
+  }
+
+  userdata->nonblocking_errors[userdata->nonblocking_errors_length] = error;
+  userdata->nonblocking_errors_length++;
+}
 
 int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr) {
   static const char *source = "error";
@@ -86,7 +96,13 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       but we don't ever want to automatically retry. Instead have the app
       decide what to do.
       */
-      return_value = INT_TIMEOUT;
+      if (userdata->timing_out) {
+        return INT_CANCEL;
+      }
+      else {
+        userdata->timing_out = 1;
+        return_value = INT_TIMEOUT;
+      }
       cancel = 1;
       break;
 
@@ -111,24 +127,16 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       userdata->dbcancel_sent = 1;
     }
 
-    /*
-    If we've already captured an error message, don't overwrite it. This is
-    here because FreeTDS sends a generic "General SQL Server error" message
-    that will overwrite the real message. This is not normally a problem
-    because a ruby exception is normally thrown and we bail before the
-    generic message can be sent.
-    */
-    if (!userdata->nonblocking_error.is_set) {
-      userdata->nonblocking_error.is_message = 0;
-      userdata->nonblocking_error.cancel = cancel;
-      strncpy(userdata->nonblocking_error.error, dberrstr, ERROR_MSG_SIZE);
-      strncpy(userdata->nonblocking_error.source, source, ERROR_MSG_SIZE);
-      userdata->nonblocking_error.severity = severity;
-      userdata->nonblocking_error.dberr = dberr;
-      userdata->nonblocking_error.oserr = oserr;
-      userdata->nonblocking_error.is_set = 1;
-    }
-
+    tinytds_errordata error = {
+      .is_message = 0,
+      .cancel = cancel,
+      .severity = severity,
+      .dberr = dberr,
+      .oserr = oserr
+    };
+    strncpy(error.error, dberrstr, ERROR_MSG_SIZE);
+    strncpy(error.source, source, ERROR_MSG_SIZE);
+    push_userdata_error(userdata, error);
   } else {
     rb_tinytds_raise_error(dbproc, 0, cancel, dberrstr, source, severity, dberr, oserr);
   }
@@ -144,16 +152,21 @@ int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severi
 
   // See tinytds_err_handler() for info about why we do this
   if (userdata && userdata->nonblocking) {
-    if (!userdata->nonblocking_error.is_set) {
-      userdata->nonblocking_error.is_message = !is_message_an_error;
-      userdata->nonblocking_error.cancel = is_message_an_error;
-      strncpy(userdata->nonblocking_error.error, msgtext, ERROR_MSG_SIZE);
-      strncpy(userdata->nonblocking_error.source, source, ERROR_MSG_SIZE);
-      userdata->nonblocking_error.severity = severity;
-      userdata->nonblocking_error.dberr = msgno;
-      userdata->nonblocking_error.oserr = msgstate;
-      userdata->nonblocking_error.is_set = 1;
-    }
+    /*
+    In the case of non-blocking command batch execution we can receive multiple messages
+    (including errors). We keep track of those here so they can be processed once the
+    non-blocking call returns.
+    */
+    tinytds_errordata error = {
+      .is_message = !is_message_an_error,
+      .cancel = is_message_an_error,
+      .severity = severity,
+      .dberr = msgno,
+      .oserr = msgstate
+    };
+    strncpy(error.error, msgtext, ERROR_MSG_SIZE);
+    strncpy(error.source, source, ERROR_MSG_SIZE);
+    push_userdata_error(userdata, error);
 
     if (is_message_an_error && !dbdead(dbproc) && !userdata->closed) {
       dbcancel(dbproc);
@@ -165,13 +178,43 @@ int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severi
   return 0;
 }
 
+/*
+Used by dbsetinterrupt -
+This gets called periodically while waiting on a read from the server
+Right now, we only care about cases where a read from the server is
+taking longer than the specified timeout and dbcancel is not working.
+In these cases we decide that we actually want to handle the interrupt
+*/
+static int check_interrupt(void *ptr) {
+  GET_CLIENT_USERDATA((DBPROCESS *)ptr);
+  return userdata->timing_out;
+}
+
+/*
+Used by dbsetinterrupt -
+This gets called if check_interrupt returns TRUE.
+Right now, this is only used in cases where a read from the server is
+taking longer than the specified timeout and dbcancel is not working.
+Return INT_CANCEL to abort the current command batch.
+*/
+static int handle_interrupt(void *ptr) {
+  GET_CLIENT_USERDATA((DBPROCESS *)ptr);
+  if (userdata->timing_out) {
+    return INT_CANCEL;
+  }
+  return INT_CONTINUE;
+}
+
 static void rb_tinytds_client_reset_userdata(tinytds_client_userdata *userdata) {
   userdata->timing_out = 0;
   userdata->dbsql_sent = 0;
   userdata->dbsqlok_sent = 0;
   userdata->dbcancel_sent = 0;
   userdata->nonblocking = 0;
-  userdata->nonblocking_error.is_set = 0;
+  // the following is mainly done for consistency since the values are reset accordingly in nogvl_setup/cleanup.
+  // the nonblocking_errors array does not need to be freed here. That is done as part of nogvl_cleanup.
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors_size = 0;
 }
 
 static void rb_tinytds_client_mark(void *ptr) {
@@ -381,6 +424,7 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
       }
     }
     dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata);
+    dbsetinterrupt(cwrap->client, check_interrupt, handle_interrupt);
     cwrap->userdata->closed = 0;
     if (!NIL_P(database) && (azure != Qtrue)) {
       dbuse(cwrap->client, StringValueCStr(database));

data/ext/tiny_tds/client.h

@@ -5,9 +5,9 @@
 void init_tinytds_client();
 
 #define ERROR_MSG_SIZE 1024
+#define ERRORS_STACK_INIT_SIZE 2
 
 typedef struct {
-  short int is_set;
   int is_message;
   int cancel;
   char error[ERROR_MSG_SIZE];
@@ -25,7 +25,9 @@ typedef struct {
   RETCODE dbsqlok_retcode;
   short int dbcancel_sent;
   short int nonblocking;
-  tinytds_errordata nonblocking_error;
+  short int nonblocking_errors_length;
+  short int nonblocking_errors_size;
+  tinytds_errordata *nonblocking_errors;
   VALUE message_handler;
 } tinytds_client_userdata;
 

data/ext/tiny_tds/result.c

@@ -86,26 +86,35 @@ static void dbcancel_ubf(DBPROCESS *client) {
 static void nogvl_setup(DBPROCESS *client) {
   GET_CLIENT_USERDATA(client);
   userdata->nonblocking = 1;
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors = malloc(ERRORS_STACK_INIT_SIZE * sizeof(tinytds_errordata));
+  userdata->nonblocking_errors_size = ERRORS_STACK_INIT_SIZE;
 }
 
 static void nogvl_cleanup(DBPROCESS *client) {
   GET_CLIENT_USERDATA(client);
   userdata->nonblocking = 0;
+  userdata->timing_out = 0;
   /*
   Now that the blocking operation is done, we can finally throw any
   exceptions based on errors from SQL Server.
   */
-  if (userdata->nonblocking_error.is_set) {
-    userdata->nonblocking_error.is_set = 0;
+  for (short int i = 0; i < userdata->nonblocking_errors_length; i++) {
+    tinytds_errordata error = userdata->nonblocking_errors[i];
     rb_tinytds_raise_error(client,
-      userdata->nonblocking_error.is_message,
-      userdata->nonblocking_error.cancel,
-      userdata->nonblocking_error.error,
-      userdata->nonblocking_error.source,
-      userdata->nonblocking_error.severity,
-      userdata->nonblocking_error.dberr,
-      userdata->nonblocking_error.oserr);
+      error.is_message,
+      error.cancel,
+      error.error,
+      error.source,
+      error.severity,
+      error.dberr,
+      error.oserr
+    );
   }
+
+  free(userdata->nonblocking_errors);
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors_size = 0;
 }
 
 static RETCODE nogvl_dbsqlok(DBPROCESS *client) {

data/test/client_test.rb

@@ -2,9 +2,7 @@
 require 'test_helper'
 
 class ClientTest < TinyTds::TestCase
-
-  describe 'With valid credentials' do
-
+  describe 'with valid credentials' do
     before do
       @client = new_connection
     end
@@ -67,7 +65,6 @@ class ClientTest < TinyTds::TestCase
         client.close if client
       end
     end unless sqlserver_azure?
-
   end
 
   describe 'With in-valid options' do
@@ -132,14 +129,12 @@ class ClientTest < TinyTds::TestCase
       end
     end
 
-    it 'must run this test to prove we account for dropped connections' do
-      skip
+    it 'raises TinyTds exception with sql batch timeout due to network failure' do
+      skip if ENV['CI'] && ENV['APPVEYOR_BUILD_FOLDER'] # only CI using docker
       begin
-        client = new_connection :login_timeout => 2, :timeout => 2
+        client = new_connection timeout: 2
         assert_client_works(client)
-        STDOUT.puts "Disconnect network!"
-        sleep 10
-        STDOUT.puts "This should not get stuck past 6 seconds!"
+        docker_container('pause', wait_for: 1)
         action = lambda { client.execute('SELECT 1 as [one]').each }
         assert_raise_tinytds_error(action) do |e|
           assert_equal 20003, e.db_error_number
@@ -147,12 +142,11 @@ class ClientTest < TinyTds::TestCase
           assert_match %r{timed out}i, e.message, 'ignore if non-english test run'
         end
       ensure
-        STDOUT.puts "Reconnect network!"
-        sleep 10
+        docker_container('unpause', wait_for: 1)
         action = lambda { client.execute('SELECT 1 as [one]').each }
         assert_raise_tinytds_error(action) do |e|
           assert_equal 20047, e.db_error_number
-          assert_equal 1, e.severity
+          assert_includes [1,9], e.severity
           assert_match %r{dead or not enabled}i, e.message, 'ignore if non-english test run'
         end
         close_client(client)
@@ -174,57 +168,68 @@ class ClientTest < TinyTds::TestCase
 
   end
 
-  describe 'Private methods' do
-
+  describe '#parse_username' do
     let(:client) { @client = new_connection }
 
-    it '#parse_username returns username if azure is not true' do
-      username = 'user@abc123.database.windows.net'
-      client.send(:parse_username, username: username).must_equal username
+    it 'returns username if azure is not true' do
+      _(
+        client.send(:parse_username, username: 'user@abc123.database.windows.net')
+      ).must_equal 'user@abc123.database.windows.net'
     end
 
-    it '#parse_username returns short username if azure is true' do
-      client.send(:parse_username,
-        username: 'user@abc123.database.windows.net',
-        host: 'abc123.database.windows.net',
-        azure: true
+    it 'returns short username if azure is true' do
+      _(
+        client.send(
+          :parse_username,
+          username: 'user@abc123.database.windows.net',
+          host:     'abc123.database.windows.net',
+          azure:    true
+        )
       ).must_equal 'user@abc123'
     end
 
-    it '#parse_username returns full username if azure is false' do
-      client.send(:parse_username,
-        username: 'user@abc123.database.windows.net',
-        host: 'abc123.database.windows.net',
-        azure: false
+    it 'returns full username if azure is false' do
+      _(
+        client.send(
+          :parse_username,
+          username: 'user@abc123.database.windows.net',
+          host:     'abc123.database.windows.net',
+          azure:    false
+        )
       ).must_equal 'user@abc123.database.windows.net'
     end
 
-    it '#parse_username returns short username if passed and azure is true' do
-      client.send(:parse_username,
-        username: 'user@abc123',
-        host: 'abc123.database.windows.net',
-        azure: true
+    it 'returns short username if passed and azure is true' do
+      _(
+        client.send(
+          :parse_username,
+          username: 'user@abc123',
+          host:     'abc123.database.windows.net',
+          azure:    true
+        )
       ).must_equal 'user@abc123'
     end
 
-    it '#parse_username returns username with servername if passed and azure is true' do
-      client.send(:parse_username,
-        username: 'user',
-        host: 'abc123.database.windows.net',
-        azure: true
+    it 'returns username with servername if passed and azure is true' do
+      _(
+        client.send(
+          :parse_username,
+          username: 'user',
+          host:     'abc123.database.windows.net',
+          azure:    true
+        )
       ).must_equal 'user@abc123'
     end
 
-    it '#parse_username returns username with servername if passed and azure is false' do
-      client.send(:parse_username,
-        username: 'user',
-        host: 'abc123.database.windows.net',
-        azure: false
+    it 'returns username with servername if passed and azure is false' do
+      _(
+        client.send(
+          :parse_username,
+          username: 'user',
+          host:     'abc123.database.windows.net',
+          azure:    false
+        )
       ).must_equal 'user'
     end
-
   end
-
-
 end
-

data/test/gem_test.rb

@@ -21,13 +21,13 @@ class GemTest < MiniTest::Spec
       let(:root_path) { TinyTds::Gem.root_path }
 
       it 'should be the root path' do
-        root_path.must_equal gem_root
+        _(root_path).must_equal gem_root
       end
 
       it 'should be the root path no matter the cwd' do
         Dir.chdir '/'
 
-        root_path.must_equal gem_root
+        _(root_path).must_equal gem_root
       end
     end
 
@@ -35,19 +35,19 @@ class GemTest < MiniTest::Spec
       let(:ports_root_path) { TinyTds::Gem.ports_root_path }
 
       it 'should be the ports path' do
-        ports_root_path.must_equal File.join(gem_root,'ports')
+        _(ports_root_path).must_equal File.join(gem_root,'ports')
       end
 
       it 'should be the ports path no matter the cwd' do
         Dir.chdir '/'
 
-        ports_root_path.must_equal File.join(gem_root,'ports')
+        _(ports_root_path).must_equal File.join(gem_root,'ports')
       end
     end
 
     describe '#ports_bin_paths' do
       let(:ports_bin_paths) { TinyTds::Gem.ports_bin_paths }
-        
+
       describe 'when the ports directories exist' do
         let(:fake_bin_paths) do
           ports_host_root = File.join(gem_root, 'ports', 'fake-host-with-dirs')
@@ -74,12 +74,12 @@ class GemTest < MiniTest::Spec
         end
 
         it 'should return all the bin directories' do
-          ports_bin_paths.sort.must_equal fake_bin_paths.sort
+          _(ports_bin_paths.sort).must_equal fake_bin_paths.sort
         end
 
         it 'should return all the bin directories regardless of cwd' do
           Dir.chdir '/'
-          ports_bin_paths.sort.must_equal fake_bin_paths.sort
+          _(ports_bin_paths.sort).must_equal fake_bin_paths.sort
         end
       end
 
@@ -89,19 +89,19 @@ class GemTest < MiniTest::Spec
         end
 
         it 'should return no directories' do
-          ports_bin_paths.must_be_empty
+          _(ports_bin_paths).must_be_empty
         end
 
         it 'should return no directories regardless of cwd' do
           Dir.chdir '/'
-          ports_bin_paths.must_be_empty
+          _(ports_bin_paths).must_be_empty
         end
       end
     end
 
     describe '#ports_lib_paths' do
       let(:ports_lib_paths) { TinyTds::Gem.ports_lib_paths }
-        
+
       describe 'when the ports directories exist' do
         let(:fake_lib_paths) do
           ports_host_root = File.join(gem_root, 'ports', 'fake-host-with-dirs')
@@ -128,12 +128,12 @@ class GemTest < MiniTest::Spec
         end
 
         it 'should return all the lib directories' do
-          ports_lib_paths.sort.must_equal fake_lib_paths.sort
+          _(ports_lib_paths.sort).must_equal fake_lib_paths.sort
         end
 
         it 'should return all the lib directories regardless of cwd' do
           Dir.chdir '/'
-          ports_lib_paths.sort.must_equal fake_lib_paths.sort
+          _(ports_lib_paths.sort).must_equal fake_lib_paths.sort
         end
       end
 
@@ -144,12 +144,12 @@ class GemTest < MiniTest::Spec
 
 
         it 'should return no directories' do
-          ports_lib_paths.must_be_empty
+          _(ports_lib_paths).must_be_empty
         end
 
         it 'should return no directories regardless of cwd' do
           Dir.chdir '/'
-          ports_lib_paths.must_be_empty
+          _(ports_lib_paths).must_be_empty
         end
       end
     end
@@ -169,7 +169,7 @@ class GemTest < MiniTest::Spec
           end
 
           it "should return a #{expected} ports host" do
-            TinyTds::Gem.ports_host.must_equal expected
+            _(TinyTds::Gem.ports_host).must_equal expected
           end
         end
       end

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']
-        ['Fixnum', 'Integer'].must_include afrows.class.name
+        _(['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']
-        ['Fixnum', 'Integer'].must_include pk1.class.name, '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
@@ -337,7 +337,7 @@ class ResultTest < TinyTds::TestCase
 
     it 'with LOGINPROPERTY function' do
       v = @client.execute("SELECT LOGINPROPERTY('sa', 'IsLocked') as v").first['v']
-      v.must_equal 0
+      _(v).must_equal 0
     end
 
     describe 'with multiple result sets' do
@@ -652,6 +652,24 @@ class ResultTest < TinyTds::TestCase
             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
         end
 
         it 'must not raise an error when severity is 10 or less' do
@@ -684,7 +702,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
@@ -717,22 +735,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
@@ -770,4 +788,3 @@ class ResultTest < TinyTds::TestCase
   end
 
 end
-

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
 
@@ -96,7 +96,7 @@ 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
 
@@ -170,7 +170,7 @@ 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
 
@@ -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

@@ -93,7 +93,7 @@ module TinyTds
     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
@@ -153,6 +153,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
@@ -167,7 +169,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
@@ -181,7 +192,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
@@ -191,6 +210,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}"
@@ -212,6 +246,9 @@ module TinyTds
       client.execute("ROLLBACK TRANSACTION").do
     end
 
+    def docker_container(cmd, wait_for: 0)
+      system("docker #{cmd} $(docker ps --format '{{.Names}}' --filter 'ancestor=metaskills/mssql-server-linux-tinytds:2017-GA') > /dev/null")
+      sleep(wait_for) if wait_for > 0
+    end
   end
 end
-

data/test/thread_test.rb

@@ -49,7 +49,7 @@ class ThreadTest < TinyTds::TestCase
             begin
               result = client.execute "select dbname()"
               result.each { |r| puts r }
-            rescue Exception => e
+            rescue Exception => _e
               # We are throwing an error on purpose here since 0.6.1 would
               # segfault on errors thrown in threads
             end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tiny_tds
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.1.4.pre
 platform: ruby
 authors:
 - Ken Collins
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-28 00:00:00.000000000 Z
+date: 2021-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_portile2
@@ -191,12 +191,34 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: TinyTDS - A modern, simple and fast FreeTDS library for Ruby using DB-Library.
-test_files: []
+test_files:
+- test/appveyor/dbsetup.ps1
+- test/appveyor/dbsetup.sql
+- test/benchmark/query.rb
+- test/benchmark/query_odbc.rb
+- test/benchmark/query_tinytds.rb
+- test/bin/install-freetds.sh
+- test/bin/install-openssl.sh
+- test/bin/setup.sh
+- test/client_test.rb
+- test/gem_test.rb
+- test/result_test.rb
+- test/schema/1px.gif
+- test/schema/sqlserver_2000.sql
+- test/schema/sqlserver_2005.sql
+- test/schema/sqlserver_2008.sql
+- test/schema/sqlserver_2014.sql
+- test/schema/sqlserver_2016.sql
+- test/schema/sqlserver_azure.sql
+- test/schema/sybase_ase.sql
+- test/schema_test.rb
+- test/test_helper.rb
+- test/thread_test.rb