mysql_framework 2.1.8 → 2.3.0

data/spec/lib/mysql_framework/connector_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 describe MysqlFramework::Connector do
-  let(:start_pool_size) { Integer(ENV.fetch('MYSQL_START_POOL_SIZE')) }
   let(:max_pool_size) { Integer(ENV.fetch('MYSQL_MAX_POOL_SIZE')) }
   let(:default_options) do
     {
@@ -11,8 +10,8 @@ describe MysqlFramework::Connector do
       username: ENV.fetch('MYSQL_USERNAME'),
       password: ENV.fetch('MYSQL_PASSWORD'),
       reconnect: true,
-      read_timeout: ENV.fetch('MYSQL_READ_TIMEOUT', 30),
-      write_timeout: ENV.fetch('MYSQL_WRITE_TIMEOUT', 10)
+      read_timeout: Integer(ENV.fetch('MYSQL_READ_TIMEOUT', 30)),
+      write_timeout: Integer(ENV.fetch('MYSQL_WRITE_TIMEOUT', 10))
     }
   end
   let(:options) do
@@ -25,28 +24,24 @@ describe MysqlFramework::Connector do
       reconnect: false
     }
   end
-  let(:client) { double(close: true, ping: true, closed?: false) }
+  let(:client) { double(close: true, ping: true, closed?: false, abandon_results!: nil) }
   let(:gems) { MysqlFramework::SqlTable.new('gems') }
   let(:existing_client) { Mysql2::Client.new(default_options) }
   let(:connection_pooling_enabled) { 'true' }
 
   subject { described_class.new }
 
-  before(:each) do
-    original_fetch = ENV.method(:fetch)
-
-    allow(ENV).to receive(:fetch) do |var, default|
-      if var == 'MYSQL_CONNECTION_POOL_ENABLED'
-        connection_pooling_enabled
-      else
-        original_fetch.call(var, default)
-      end
-    end
+  before do
+    allow(ENV).to receive(:fetch).and_call_original
+    allow(ENV).to receive(:fetch).with('MYSQL_CONNECTION_POOL_ENABLED', 'true')
+      .and_return(connection_pooling_enabled)
 
     subject.setup
   end
 
-  after(:each) { subject.dispose }
+  after do
+    subject.dispose
+  end
 
   describe '#initialize' do
     context 'when options are not provided' do
@@ -66,8 +61,8 @@ describe MysqlFramework::Connector do
           username: ENV.fetch('MYSQL_USERNAME'),
           password: ENV.fetch('MYSQL_PASSWORD'),
           reconnect: false,
-          read_timeout: ENV.fetch('MYSQL_READ_TIMEOUT', 30),
-          write_timeout: ENV.fetch('MYSQL_WRITE_TIMEOUT', 10)
+          read_timeout: Integer(ENV.fetch('MYSQL_READ_TIMEOUT', 30)),
+          write_timeout: Integer(ENV.fetch('MYSQL_WRITE_TIMEOUT', 10))
         }
 
         expect(subject.instance_variable_get(:@options)).to eq(expected)
@@ -84,10 +79,13 @@ describe MysqlFramework::Connector do
 
   describe '#setup' do
     context 'when connection pooling is enabled' do
-      it 'creates a connection pool with the specified number of conections' do
+      it 'creates a connection pool with expected stats' do
         subject.setup
 
-        expect(subject.connections.length).to eq(start_pool_size)
+        expect(subject.connection_pool).to be_a(MysqlFramework::MysqlConnectionPool)
+        expect(subject.connection_pool.pool_stats[:size]).to eq(max_pool_size)
+        expect(subject.connection_pool.pool_stats[:available]).to be >= 0
+        expect(subject.connection_pool.pool_stats[:idle]).to be >= 0
       end
     end
 
@@ -97,182 +95,147 @@ describe MysqlFramework::Connector do
       it "doesn't create a connection pool" do
         subject.setup
 
-        expect(subject.connections).to be_nil
+        expect(subject.connection_pool).to be_nil
       end
     end
   end
 
   describe '#dispose' do
-    before do
-      subject.connections.clear
-      subject.connections.push(client)
-    end
-
-    it 'closes the idle connections and disposes of the queue' do
-      expect(client).to receive(:close)
+    context 'when connection pooling is enabled' do
+      it 'disposes of the pool and clears connector reference' do
+        pool = instance_double(MysqlFramework::MysqlConnectionPool, dispose: true)
+        allow(pool).to receive(:dispose)
+        subject.instance_variable_set(:@connection_pool, pool)
 
-      subject.dispose
+        expect(pool).to receive(:dispose)
+        subject.dispose
 
-      expect(subject.connections).to be_nil
+        expect(subject.connection_pool).to be_nil
+      end
     end
-  end
 
-  describe '#check_out' do
-    it 'calls synchronize on the mutex' do
-      expect(subject.instance_variable_get(:@mutex)).to receive(:synchronize)
+    context 'when connection pooling is disabled' do
+      let(:connection_pooling_enabled) { 'false' }
 
-      subject.check_out
+      it 'does not perform more actions' do
+        expect { subject.dispose }.not_to raise_error
+        expect(subject.connection_pool).to be_nil
+      end
     end
+  end
 
+  describe '#check_out' do
     context 'when connection pooling is enabled' do
-      context 'when there are available connections' do
-        before do
-          subject.connections.clear
-          subject.connections.push(client)
-        end
-
-        it 'returns a client instance from the pool' do
-          expect(subject.check_out).to eq(client)
-        end
-
-        context 'and :reconnect is set to true' do
-          let(:options) do
-            {
-              host: ENV.fetch('MYSQL_HOST'),
-              port: ENV.fetch('MYSQL_PORT'),
-              database: "#{ENV.fetch('MYSQL_DATABASE')}_2",
-              username: ENV.fetch('MYSQL_USERNAME'),
-              password: ENV.fetch('MYSQL_PASSWORD'),
-              reconnect: true
-            }
-          end
-
-          subject { described_class.new(options) }
-
-          it 'pings the server to force a reconnect' do
-            expect(client).to receive(:ping)
-
-            subject.check_out
-          end
-        end
-
-        context 'and :reconnect is set to false' do
-          subject { described_class.new(options) }
-
-          it 'pings the server to force a reconnect' do
-            expect(client).not_to receive(:ping)
+      it 'checks out pooled connection' do
+        pool = instance_double(MysqlFramework::MysqlConnectionPool, dispose: true)
+        client = instance_double(Mysql2::Client)
+        allow(pool).to receive(:check_out).and_return(client)
+        subject.instance_variable_set(:@connection_pool, pool)
 
-            subject.check_out
-          end
-        end
+        expect(pool).to receive(:check_out)
+        expect(subject.check_out).to eq(client)
       end
+    end
 
-      context 'when connection pooling is disabled' do
-        let(:connection_pooling_enabled) { 'false' }
+    context 'when pooling is disabled' do
+      let(:connection_pooling_enabled) { 'false' }
 
-        it 'instantiates and returns a new connection directly' do
-          expect(subject.connections).not_to receive(:pop)
-          expect(Mysql2::Client).to receive(:new)
+      it 'returns a new client directly' do
+        new_client = instance_double(Mysql2::Client)
+        allow(Mysql2::Client).to receive(:new).and_return(new_client)
 
-          subject.check_out
-        end
+        expect(subject.check_out).to eq(new_client)
       end
     end
+  end
 
-    context "when there are no available connections, and the pool's max size has not been reached" do
-      before do
-        subject.connections.clear
-        subject.connections.push(client)
-      end
-
-      it 'instantiates a new connection and returns it' do
-        subject.check_out
+  describe '#check_in' do
+    context 'when connection pooling is enabled' do
+      it 'checks in a pooled connection' do
+        pool = instance_double(MysqlFramework::MysqlConnectionPool, dispose: true)
+        allow(pool).to receive(:check_in)
+        subject.instance_variable_set(:@connection_pool, pool)
 
-        expect(Mysql2::Client).to receive(:new).with(default_options).and_return(client)
-        expect(subject.check_out).to eq(client)
+        expect(pool).to receive(:check_in)
+        subject.check_in(client)
       end
     end
 
-    context "when there are no available connections, and the pool's max size has been reached" do
-      before do
-        subject.connections.clear
-        subject.instance_variable_set(:@created_connections, 5)
+    context 'when pooling is disabled' do
+      let(:connection_pooling_enabled) { 'false' }
 
-        5.times { subject.check_in(client) }
-        5.times { subject.check_out }
-      end
+      it 'closes the provided client' do
+        new_client = instance_double(Mysql2::Client, close: nil)
 
-      it 'throws a RuntimeError' do
-        expect { subject.check_out }.to raise_error(RuntimeError)
+        expect(new_client).to receive(:close)
+        subject.check_in(new_client)
       end
     end
   end
 
-  describe '#check_in' do
-    it 'calls synchronize on the mutex' do
-      expect(subject.instance_variable_get(:@mutex)).to receive(:synchronize)
+  describe '#with_client' do
+    context 'when a provided_client is given' do
+      it 'yields the provided client directly' do
+        expect { |b| subject.with_client(client, &b) }.to yield_with_args(client)
+      end
 
-      subject.check_out
-    end
+      it 'does not interact with the connection pool' do
+        expect(subject).not_to receive(:with_new_client)
+        expect(subject.connection_pool).not_to receive(:with_client) if subject.connection_pool
 
-    context 'when connection pooling is enabled' do
-      it 'returns the provided client to the connection pool' do
-        expect(subject.connections).to receive(:push).with(client)
+        subject.with_client(client) { |_c| nil }
+      end
 
-        subject.check_in(client)
+      it 'returns the block result' do
+        result = subject.with_client(client) { |_c| :expected }
+        expect(result).to eq(:expected)
       end
+    end
 
-      context 'when the connection has been closed by the server' do
-        let(:closed_client) { double(close: true, closed?: true) }
+    context 'when no provided_client is given' do
+      context 'when connection pooling is disabled' do
+        let(:connection_pooling_enabled) { 'false' }
 
-        it 'instantiates a new connection and returns it' do
-          expect(Mysql2::Client).to receive(:new).with(default_options).and_return(client)
-          expect(subject.connections).to receive(:push).with(client)
+        it 'delegates to with_new_client' do
+          expect(subject).to receive(:with_new_client).and_yield(client)
 
-          subject.check_in(closed_client)
+          expect { |b| subject.with_client(&b) }.to yield_with_args(client)
         end
-      end
-    end
 
-    context 'when connection pooling is disabled' do
-      let(:connection_pooling_enabled) { 'false' }
-
-      it 'closes the connection and does not add it to the connection pool' do
-        expect(client).to receive(:close)
-        expect(subject.connections).not_to receive(:push)
+        it 'returns the block result' do
+          allow(subject).to receive(:with_new_client).and_yield(client)
 
-        subject.check_in(client)
+          result = subject.with_client { |_c| :expected }
+          expect(result).to eq(:expected)
+        end
       end
-    end
-
-    context 'when client is nil' do
-      let(:client) { nil }
 
       context 'when connection pooling is enabled' do
-        it 'does not raise an error' do
-          expect { subject.check_in(client) }.not_to raise_error
+        it 'delegates to the connection pool' do
+          pool = instance_double(MysqlFramework::MysqlConnectionPool, dispose: true)
+          subject.instance_variable_set(:@connection_pool, pool)
+
+          expect(pool).to receive(:with_client).with(discard_current_pool_connection: false).and_yield(client)
+          expect { |b| subject.with_client(&b) }.to yield_with_args(client)
         end
-      end
 
-      context 'when connection pooling is disabled' do
-        let(:connection_pooling_enabled) { 'false' }
+        it 'passes discard_current_pool_connection: true to the pool when requested' do
+          pool = instance_double(MysqlFramework::MysqlConnectionPool, dispose: true)
+          subject.instance_variable_set(:@connection_pool, pool)
 
-        it 'does not raise an error' do
-          expect { subject.check_in(client) }.not_to raise_error
+          expect(pool).to receive(:with_client).with(discard_current_pool_connection: true).and_yield(client)
+          subject.with_client(discard_current_pool_connection: true) { |_c| nil }
         end
-      end
-    end
-  end
 
-  describe '#with_client' do
-    it 'uses the client that is provided, if passed one' do
-      expect(subject).not_to receive(:check_out)
-      expect { |b| subject.with_client(client, &b) }.to yield_with_args(client)
-    end
+        it 'returns the block result' do
+          pool = instance_double(MysqlFramework::MysqlConnectionPool, dispose: true)
+          subject.instance_variable_set(:@connection_pool, pool)
+          allow(pool).to receive(:with_client).and_yield(client)
 
-    it 'obtains a client from the pool to use, if no client is provided' do
-      allow(subject).to receive(:check_out).and_return(client)
-      expect { |b| subject.with_client(&b) }.to yield_with_args(client)
+          result = subject.with_client { |_c| :expected }
+          expect(result).to eq(:expected)
+        end
+      end
     end
   end
 
@@ -317,6 +280,7 @@ describe MysqlFramework::Connector do
         allow(mock_statement).to receive(:execute).and_return(mock_result)
 
         allow(mock_client).to receive(:prepare).and_return(mock_statement)
+        allow(mock_client).to receive(:abandon_results!)
       end
 
       it 'frees the result' do
@@ -361,7 +325,7 @@ describe MysqlFramework::Connector do
   end
 
   describe '#query' do
-    before(:each) { allow(subject).to receive(:check_out).and_return(client) }
+    before(:each) { allow(subject).to receive(:with_client).and_yield(client) }
 
     it 'retrieves a client and calls query' do
       expect(client).to receive(:query).with('SELECT 1')
@@ -370,7 +334,7 @@ describe MysqlFramework::Connector do
     end
 
     it 'does not check out a new client when one is provided' do
-      expect(subject).not_to receive(:check_out)
+      expect(subject).to receive(:with_client).with(existing_client).and_yield(existing_client)
       expect(existing_client).to receive(:query).with('SELECT 1')
 
       subject.query('SELECT 1', existing_client)
@@ -378,6 +342,19 @@ describe MysqlFramework::Connector do
   end
 
   describe '#query_multiple_results' do
+    it 'uses with_client with discard_current_pool_connection enabled' do
+      query_call = instance_double(Mysql2::Result, to_a: [], free: true)
+      allow(client).to receive(:query).and_return(query_call)
+      allow(client).to receive(:more_results?).and_return(false)
+      allow(client).to receive(:abandon_results!)
+
+      expect(subject).to receive(:with_client)
+        .with(nil, discard_current_pool_connection: true)
+        .and_yield(client)
+
+      subject.query_multiple_results('call test_procedure')
+    end
+
     it 'returns the results from the stored procedure' do
       query = 'call test_procedure'
       result = subject.query_multiple_results(query)
@@ -402,7 +379,7 @@ describe MysqlFramework::Connector do
   end
 
   describe '#transaction' do
-    before(:each) { allow(subject).to receive(:check_out).and_return(client) }
+    before(:each) { allow(subject).to receive(:with_client).and_yield(client) }
 
     it 'wraps the client call with BEGIN and COMMIT statements' do
       expect(client).to receive(:query).with('BEGIN')

data/spec/lib/mysql_framework/mysql_connection_pool_spec.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+describe MysqlFramework::MysqlConnectionPool do
+  let(:options) do
+    {
+      host: ENV.fetch('MYSQL_HOST'),
+      port: ENV.fetch('MYSQL_PORT'),
+      database: ENV.fetch('MYSQL_DATABASE'),
+      username: ENV.fetch('MYSQL_USERNAME'),
+      password: ENV.fetch('MYSQL_PASSWORD'),
+      reconnect: true
+    }
+  end
+  let(:conn) do
+    double('Mysql2::Client',
+           ping: true,
+           abandon_results!: nil,
+           query: nil,
+           close: nil,
+           closed?: false)
+  end
+  let(:pool) do
+    double('ConnectionPool',
+           checkout: conn,
+           checkin: nil,
+           discard_current_connection: nil,
+           shutdown: nil,
+           size: 5,
+           available: 4,
+           idle: 1)
+  end
+
+  subject { described_class.new(options) }
+
+  after { subject.dispose }
+
+  describe '#initialize' do
+    it 'stores the provided options' do
+      expect(subject.instance_variable_get(:@options)).to eq(options)
+    end
+
+    it 'creates a setup mutex' do
+      expect(subject.instance_variable_get(:@setup_mutex)).to be_a(Mutex)
+    end
+  end
+
+  describe '#setup' do
+    it 'creates a ConnectionPool' do
+      subject.setup
+      expect(subject.connections).to be_a(ConnectionPool)
+    end
+
+    it 'is idempotent — calling setup twice keeps the same pool' do
+      subject.setup
+      first_pool = subject.connections
+      subject.setup
+      expect(subject.connections).to equal(first_pool)
+    end
+  end
+
+  describe '#dispose' do
+    before { subject.setup }
+
+    it 'shuts down the connection pool' do
+      subject.dispose
+      expect(subject.connections).to be_nil
+    end
+
+    it 'is safe to call when already disposed' do
+      subject.dispose
+      expect { subject.dispose }.not_to raise_error
+    end
+  end
+
+  describe '#pool_stats' do
+    context 'when connections have not been set up' do
+      it 'returns zero stats' do
+        expect(subject.pool_stats).to eq(size: 0, available: 0, idle: 0)
+      end
+    end
+
+    context 'when connections are set up' do
+      before { subject.instance_variable_set(:@connections, pool) }
+
+      it 'returns size, available, and idle metrics from the pool' do
+        expect(subject.pool_stats).to eq(size: 5, available: 4, idle: 1)
+      end
+    end
+  end
+
+  describe '#check_out' do
+    before do
+      subject.instance_variable_set(:@connections, pool)
+      allow(conn).to receive(:query).with('ROLLBACK')
+    end
+
+    it 'returns a sanitized connection from the pool' do
+      expect(subject.check_out).to eq(conn)
+    end
+
+    it 'sanitizes the connection before returning it' do
+      expect(conn).to receive(:ping)
+      expect(conn).to receive(:abandon_results!)
+      expect(conn).to receive(:query).with('ROLLBACK')
+      subject.check_out
+    end
+
+    context 'when sanitization raises ConnectionSanitizationError' do
+      before { allow(conn).to receive(:ping).and_raise(Mysql2::Error.new('gone away')) }
+
+      it 'retries the checkout once before raising' do
+        expect(pool).to receive(:checkout).twice.and_return(conn)
+        expect { subject.check_out }.to raise_error(MysqlFramework::MysqlConnectionPool::ConnectionSanitizationError)
+      end
+
+      it 'discards the connection on each sanitization failure' do
+        expect(pool).to receive(:discard_current_connection).at_least(:twice)
+        expect { subject.check_out }.to raise_error(MysqlFramework::MysqlConnectionPool::ConnectionSanitizationError)
+      end
+    end
+
+    context 'when checkout raises Mysql2::Error' do
+      before { allow(pool).to receive(:checkout).and_raise(Mysql2::Error.new('connection refused')) }
+
+      it 'discards the current connection' do
+        expect(pool).to receive(:discard_current_connection)
+        expect { subject.check_out }.to raise_error(Mysql2::Error)
+      end
+
+      it 're-raises the error' do
+        allow(pool).to receive(:discard_current_connection)
+        expect { subject.check_out }.to raise_error(Mysql2::Error)
+      end
+    end
+  end
+
+  describe '#check_in' do
+    before { subject.instance_variable_set(:@connections, pool) }
+
+    it 'returns immediately and does not interact with the pool when client is nil' do
+      expect(pool).not_to receive(:checkin)
+      expect(pool).not_to receive(:discard_current_connection)
+      subject.check_in(nil)
+    end
+
+    context 'when the client is closed' do
+      let(:closed_conn) { double('Mysql2::Client', closed?: true) }
+
+      it 'discards the current pool connection' do
+        expect(pool).to receive(:discard_current_connection)
+        allow(pool).to receive(:checkin)
+        subject.check_in(closed_conn)
+      end
+    end
+
+    context 'when the client is open' do
+      it 'checks the connection back into the pool' do
+        expect(pool).to receive(:checkin)
+        subject.check_in(conn)
+      end
+
+      it 'does not discard the connection' do
+        expect(pool).not_to receive(:discard_current_connection)
+        subject.check_in(conn)
+      end
+    end
+  end
+
+  describe '#with_client' do
+    before do
+      subject.instance_variable_set(:@connections, pool)
+      allow(conn).to receive(:query).with('ROLLBACK')
+      allow(pool).to receive(:with).and_yield(conn)
+    end
+
+    it 'yields a sanitized connection' do
+      expect { |b| subject.with_client(&b) }.to yield_with_args(conn)
+    end
+
+    it 'returns the block result' do
+      result = subject.with_client { |_c| :expected }
+      expect(result).to eq(:expected)
+    end
+
+    it 'sanitizes the connection before yielding' do
+      expect(conn).to receive(:ping)
+      expect(conn).to receive(:abandon_results!)
+      expect(conn).to receive(:query).with('ROLLBACK')
+      subject.with_client { |_c| nil }
+    end
+
+    context 'when discard_current_pool_connection is false (default)' do
+      it 'does not discard the connection after a successful block' do
+        expect(pool).not_to receive(:discard_current_connection)
+        subject.with_client { |_c| nil }
+      end
+    end
+
+    context 'when discard_current_pool_connection is true' do
+      it 'discards the current connection after the block completes' do
+        expect(pool).to receive(:discard_current_connection)
+        subject.with_client(discard_current_pool_connection: true) { |_c| nil }
+      end
+    end
+
+    context 'when sanitization raises ConnectionSanitizationError' do
+      before { allow(conn).to receive(:ping).and_raise(Mysql2::Error.new('gone away')) }
+
+      it 'retries the pool checkout once before raising' do
+        expect(pool).to receive(:with).twice.and_yield(conn)
+        expect { subject.with_client { |_c| nil } }.to raise_error(MysqlFramework::MysqlConnectionPool::ConnectionSanitizationError)
+      end
+
+      it 'discards the connection on each sanitization failure' do
+        allow(pool).to receive(:with).and_yield(conn)
+        expect(pool).to receive(:discard_current_connection).at_least(:once)
+        expect { subject.with_client { |_c| nil } }.to raise_error(MysqlFramework::MysqlConnectionPool::ConnectionSanitizationError)
+      end
+    end
+
+    context 'when the block raises Mysql2::Error' do
+      it 'discards the current connection' do
+        expect(pool).to receive(:discard_current_connection)
+        expect { subject.with_client { |_c| raise Mysql2::Error.new('lost connection') } }.to raise_error(Mysql2::Error)
+      end
+
+      it 're-raises the error' do
+        allow(pool).to receive(:discard_current_connection)
+        expect { subject.with_client { |_c| raise Mysql2::Error.new('lost connection') } }.to raise_error(Mysql2::Error)
+      end
+
+      it 'does not retry for Mysql2::Error raised in the block' do
+        expect(pool).to receive(:with).once.and_yield(conn)
+        allow(pool).to receive(:discard_current_connection)
+        expect { subject.with_client { |_c| raise Mysql2::Error.new('lost connection') } }.to raise_error(Mysql2::Error)
+      end
+    end
+  end
+end

data/spec/lib/mysql_framework/sql_query_spec.rb

@@ -233,6 +233,33 @@ describe MysqlFramework::SqlQuery do
         expect(subject.sql).to eq('WHERE (`gems`.`author` = ? AND `gems`.`created_at` > ?) AND (`gems`.`name` IN (?, ?))')
       end
     end
+
+    context 'when condition is nil' do
+      context 'when MYSQL_FRAMEWORK_SKIP_NIL_VALUE_VALIDATION is not present' do
+        it 'concats the parameter collections' do
+          expect { subject.where(gems[:created_at].eq(nil)) }.to raise_error ArgumentError
+        end
+      end
+
+      context 'when MYSQL_FRAMEWORK_SKIP_NIL_VALUE_VALIDATION is present' do
+        after(:each) { ENV.delete('MYSQL_FRAMEWORK_SKIP_NIL_VALUE_VALIDATION') }
+
+        context 'when value is false' do
+          it 'concats the parameter collections' do
+            ENV['MYSQL_FRAMEWORK_SKIP_NIL_VALUE_VALIDATION'] =  'false'
+            expect { subject.where(gems[:created_at].eq(nil)) }.to raise_error ArgumentError
+          end
+        end
+
+        context 'when value is true' do
+          it 'concats the parameter collections' do
+            ENV['MYSQL_FRAMEWORK_SKIP_NIL_VALUE_VALIDATION'] =  'true'
+            query = subject.where(gems[:updated_at].eq(nil))
+            expect(query.params).to eq ['sage', '2018-01-01 00:00:00', nil]
+          end
+        end
+      end
+    end
   end
 
   describe '#and' do