octoshark 0.1.2 → 0.3.0

data/lib/octoshark/current_connection.rb

@@ -0,0 +1,37 @@
+module Octoshark
+  module CurrentConnection
+    def current_connection
+      Thread.current[identifier] || raise(Octoshark::Error::NoCurrentConnection, "No current connection")
+    end
+
+    def current_connection?
+      !Thread.current[identifier].nil?
+    end
+
+    def current_or_default_connection
+      Thread.current[identifier] || ActiveRecord::Base.connection_pool.connection
+    end
+
+    def without_connection(&block)
+      change_connection_reference(nil) do
+        yield
+      end
+    end
+
+    def identifier
+      @identifier ||= "octoshark_#{object_id}"
+    end
+
+    private
+    def change_connection_reference(connection, &block)
+      previous_connection = Thread.current[identifier]
+      Thread.current[identifier] = connection
+
+      begin
+        yield
+      ensure
+        Thread.current[identifier] = previous_connection
+      end
+    end
+  end
+end

data/lib/octoshark/version.rb

@@ -1,3 +1,3 @@
 module Octoshark
-  VERSION = "0.1.2"
+  VERSION = "0.3.0"
 end

data/octoshark.gemspec

@@ -20,10 +20,9 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "activerecord", ">= 3.0"
 
-  spec.add_development_dependency "bundler",  "~> 1.5"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec",    "~> 3.0.0"
-  spec.add_development_dependency "sqlite3",  "~> 1.3.0"
-  spec.add_development_dependency "mysql2",   "~> 0.3.14"
+  spec.add_development_dependency "rspec",    "~> 3.7.0"
+  spec.add_development_dependency "sqlite3",  "~> 1.4.1"
+  spec.add_development_dependency "mysql2",   "~> 0.5.2"
   spec.add_development_dependency "appraisal"
 end

data/spec/octoshark/active_record_extensions_spec.rb

@@ -8,7 +8,7 @@ describe "ActiveRecord Extensions" do
 
     ActiveRecord::Base.logger = logger
 
-    manager = Octoshark::ConnectionManager.new(configs)
+    manager = Octoshark::ConnectionPoolsManager.new(configs)
     manager.with_connection(:db1) do |connection|
       connection.execute("SELECT 1")
     end
@@ -25,8 +25,8 @@ describe "ActiveRecord Extensions" do
 
     ActiveRecord::Base.logger = logger
 
-    manager = Octoshark::ConnectionManager.new(mysql2_configs)
-    manager.use_database(:db1, database_name) do |connection|
+    manager = Octoshark::ConnectionPoolsManager.new(mysql2_configs)
+    manager.with_connection(:db1, database_name) do |connection|
       connection.execute("SELECT 1")
     end
 
@@ -41,7 +41,7 @@ describe "ActiveRecord Extensions" do
 
     ActiveRecord::Base.logger = logger
 
-    manager = Octoshark::ConnectionManager.new(configs)
+    manager = Octoshark::ConnectionPoolsManager.new(configs)
     manager.with_connection(:db1) do |connection|
       ActiveRecord::Base.connection.execute("SELECT 1")
     end

data/spec/octoshark/connection_manager_spec.rb

@@ -1,245 +1,48 @@
 require 'spec_helper'
 
 describe Octoshark::ConnectionManager do
-  describe "#initialize" do
-    it "initializes connection manager with default connection" do
+  describe "#with_connection", mysql2: true do
+    it "creates temporary connection to database server" do
       manager = Octoshark::ConnectionManager.new
+      connection_reference = nil
 
-      expect(manager.connection_pools.length).to eq(0)
-      expect(manager.connection_pools[:default]).to be_nil
-    end
-
-    it "initializes connection manager with custom connections" do
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      expect(manager.connection_pools.length).to eq(2)
-      expect(manager.connection_pools[:db1]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
-      expect(manager.connection_pools[:db2]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
-    end
-
-    it "accepts configs with string keys" do
-      configs = { 'db1' => { 'adapter' => "sqlite3", 'database' => "tmp/db1.sqlite" } }
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      expect { manager.connection_pools[:db1].connection }.not_to raise_error
-    end
-  end
+      config = mysql2_configs[:db1]
 
-  describe "#identifier" do
-    it "has unique identifiers" do
-      manager1 = Octoshark::ConnectionManager.new
-      manager2 = Octoshark::ConnectionManager.new
-      expect(manager1.identifier).to_not eq(manager2.identifier)
-    end
-  end
+      manager.with_connection(config.except(:database)) do |connection|
+        connection_reference = connection
 
-  describe "#current_connection" do
-    it "returns last used connection as current one" do
-      manager = Octoshark::ConnectionManager.new(configs)
-      manager.with_connection(:db1) do |connection|
-        expect(manager.current_connection).to eq(connection)
+        connection.execute("SELECT 1")
+        expect(connection.database_name).to be_nil
       end
-    end
 
-    it "raises error when no current connection" do
-      manager = Octoshark::ConnectionManager.new
-
-      expect { manager.current_connection }.to raise_error(Octoshark::Error::NoCurrentConnection)
-    end
-  end
-
-  describe "#current_connection?" do
-    it "returns true if current one" do
-      manager = Octoshark::ConnectionManager.new(configs)
-      manager.with_connection(:db1) do
-        expect(manager.current_connection?).to be_truthy
-      end
+      expect(connection_reference.active?).to eq(false)
     end
 
-    it "returns false if no current one" do
+    it "creates temporary connection to specific database", mysql2: true do
       manager = Octoshark::ConnectionManager.new
+      connection_reference = nil
 
-      expect(manager.current_connection?).to be_falsey
-    end
-  end
+      config = mysql2_configs[:db1]
+      database_name = config.fetch('database')
 
-  describe "#current_or_default_connection" do
-    it "returns current connection" do
-      manager = Octoshark::ConnectionManager.new(configs)
-      manager.with_connection(:db1) do |db1|
-        expect(manager.current_or_default_connection).to eq(db1)
-      end
-    end
-
-    it "returns default connection when no current connection" do
-      manager = Octoshark::ConnectionManager.new
+      manager.with_connection(config) do |connection|
+        connection_reference = connection
 
-      expect(manager.current_or_default_connection).to eq(ActiveRecord::Base.connection_pool.connection)
-    end
-  end
-
-  describe '#find_connection_pool' do
-    it "can find connection pool by name" do
-      manager = Octoshark::ConnectionManager.new(configs)
-      expect(manager.find_connection_pool(:db1)).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
-    end
-
-    it "raises Octoshark::Error::NoConnection when no pool with that name" do
-      manager = Octoshark::ConnectionManager.new({})
-      expect { manager.find_connection_pool(:invalid) }.to raise_error(Octoshark::Error::NoConnection)
-    end
-  end
-
-  describe '#with_connection' do
-    it "can use multiple connections" do
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      manager.with_connection(:db1) do
-        expect(db(manager.current_connection)).to eq("db1")
-      end
-
-      manager.with_connection(:db2) do
-        expect(db(manager.current_connection)).to eq("db2")
+        connection.execute("SELECT 1")
+        expect(connection.database_name).to eq(database_name)
       end
-    end
-
-    it "can nest connection" do
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      manager.with_connection(:db1) do
-        expect(db(manager.current_connection)).to eq("db1")
-
-        manager.with_connection(:db2) do
-          expect(db(manager.current_connection)).to eq("db2")
-        end
-
-        expect(db(manager.current_connection)).to eq("db1")
-      end
-    end
-
-    it "returns value from execution" do
-      manager = Octoshark::ConnectionManager.new(configs)
-      result = manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
-      expect(result).to eq([{"1"=>1, 0=>1}])
-    end
-
-    it "raises Octoshark::Error::NoConnection" do
-      manager = Octoshark::ConnectionManager.new({})
-
-      expect { manager.with_connection(:invalid) }.to raise_error(Octoshark::Error::NoConnection)
-    end
-  end
-
-  describe "#with_new_connection" do
-    it "creates temporary connection" do
-      manager = Octoshark::ConnectionManager.new
-      result = manager.with_new_connection(:db1, configs[:db1]) { |connection| connection.execute("SELECT 1") }
 
-      expect(manager.connection_pools).to be_blank
+      expect(connection_reference.active?).to eq(false)
     end
 
     it "returns query results with temporary connection" do
       manager = Octoshark::ConnectionManager.new
-      result = manager.with_new_connection(:db1, configs[:db1]) { |connection| connection.execute("SELECT 1") }
-
-      expect(result).to eq([{"1"=>1, 0=>1}])
-    end
-
-    it "creates persistent connection" do
-      connection_id = nil
-      manager = Octoshark::ConnectionManager.new
-      expect(manager.connection_pools.length).to eq(0)
-
-      manager.with_new_connection(:db1, configs[:db1], reusable: true) do |connection|
-        connection_id = connection.object_id
+      config = configs[:db1]
+      result = manager.with_connection(config) do |connection|
+        connection.execute("SELECT 1")
       end
-      expect(manager.connection_pools.length).to eq(1)
-
-      manager.with_new_connection(:db1, configs[:db1], reusable: true) do |connection|
-        expect(connection.object_id).to eq(connection_id)
-      end
-      expect(manager.connection_pools.length).to eq(1)
-    end
-
-    it "returns query results with persistent connection" do
-      manager = Octoshark::ConnectionManager.new
-
-      result = manager.with_new_connection(:db1, configs[:db1], reusable: true) { |connection| connection.execute("SELECT 1") }
-      expect(result).to eq([{"1"=>1, 0=>1}])
-
-      result = manager.with_new_connection(:db1, configs[:db1], reusable: true) { |connection| connection.execute("SELECT 1") }
-      expect(result).to eq([{"1"=>1, 0=>1}])
-    end
-  end
-
-  describe "#use_database" do
-    it "can nest connection", mysql2: true do
-      manager = Octoshark::ConnectionManager.new(mysql2_configs)
-
-      db1 = mysql2_configs[:db1]['database']
-      db2 = mysql2_configs[:db2]['database']
-
-      manager.use_database(:db1, db1) do
-        expect(db(manager.current_connection)).to eq(db1)
-
-        manager.use_database(:db2, db2) do
-          expect(db(manager.current_connection)).to eq(db2)
-        end
-
-        expect(db(manager.current_connection)).to eq(db1)
-      end
-    end
-
-    it "returns value from execution", mysql2: true do
-      manager = Octoshark::ConnectionManager.new(mysql2_configs)
-      db1 = mysql2_configs[:db1]['database']
-      result = manager.use_database(:db1, db1) { |connection| connection.execute("SELECT 1") }.to_a
-      expect(result).to eq([[1]])
-    end
-  end
-
-  describe '#without_connection' do
-    it "can reset current connection temporarily inside nested connection block" do
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      manager.with_connection(:db1) do
-        expect(db(manager.current_connection)).to eq("db1")
-
-        manager.without_connection do
-          expect { manager.current_connection }.to raise_error(Octoshark::Error::NoCurrentConnection)
-        end
-
-        expect(db(manager.current_connection)).to eq("db1")
-      end
-    end
-  end
-
-  describe "#disconnect!" do
-    it "removes all connections from connection pools" do
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
-      expect(manager.find_connection_pool(:db1)).to be_connected
-
-      manager.disconnect!
-
-      expect(manager.find_connection_pool(:db1)).to_not be_connected
-    end
-  end
-
-  describe ".reset!" do
-    it "gets new connection pools ready to rock" do
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
-      expect(manager.connection_pools[:db1].connections.count).to eq(1)
-
-      manager.reset!
-
-      expect(manager.connection_pools[:db1].connections.count).to eq(0)
 
-      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
-      expect(manager.connection_pools[:db1].connections.count).to eq(1)
+      expect(result.first['1']).to eq(1)
     end
   end
 end

data/spec/octoshark/connection_pools_manager_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe Octoshark::ConnectionPoolsManager do
+  describe "#initialize" do
+    it "initializes connection manager with default connection" do
+      manager = Octoshark::ConnectionPoolsManager.new
+
+      expect(manager.connection_pools.length).to eq(0)
+      expect(manager.connection_pools[:default]).to be_nil
+    end
+
+    it "initializes connection manager with custom connections" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      expect(manager.connection_pools.length).to eq(2)
+      expect(manager.connection_pools[:db1]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
+      expect(manager.connection_pools[:db2]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
+    end
+
+    it "accepts configs with string keys" do
+      configs = { 'db1' => { 'adapter' => "sqlite3", 'database' => "tmp/db1.sqlite" } }
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      expect { manager.connection_pools[:db1].connection }.not_to raise_error
+    end
+  end
+
+  describe '#find_connection_pool' do
+    it "can find connection pool by name" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+      expect(manager.find_connection_pool(:db1)).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
+    end
+
+    it "raises Octoshark::Error::NoConnection when no pool with that name" do
+      manager = Octoshark::ConnectionPoolsManager.new({})
+      expect { manager.find_connection_pool(:invalid) }.to raise_error(Octoshark::Error::NoConnection)
+    end
+  end
+
+  describe '#with_connection' do
+    it "can use multiple connections" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      manager.with_connection(:db1) do
+        expect(db(manager.current_connection)).to eq("db1")
+      end
+
+      manager.with_connection(:db2) do
+        expect(db(manager.current_connection)).to eq("db2")
+      end
+    end
+
+    it "can nest connection" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      manager.with_connection(:db1) do
+        expect(db(manager.current_connection)).to eq("db1")
+
+        manager.with_connection(:db2) do
+          expect(db(manager.current_connection)).to eq("db2")
+        end
+
+        expect(db(manager.current_connection)).to eq("db1")
+      end
+    end
+
+    it "returns value from execution" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+      result = manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      expect(result.first['1']).to eq(1)
+    end
+
+    it "raises Octoshark::Error::NoConnection" do
+      manager = Octoshark::ConnectionPoolsManager.new({})
+
+      expect { manager.with_connection(:invalid) }.to raise_error(Octoshark::Error::NoConnection)
+    end
+
+    context "using specific database", mysql2: true do
+      it "can use specific database" do
+        manager = Octoshark::ConnectionPoolsManager.new(mysql2_configs)
+
+        db1 = mysql2_configs[:db1]['database']
+        db2 = mysql2_configs[:db2]['database']
+
+        manager.with_connection(:db1, db1) do
+          expect(db(manager.current_connection)).to eq(db1)
+
+          manager.with_connection(:db2, db2) do
+            expect(db(manager.current_connection)).to eq(db2)
+          end
+
+          expect(db(manager.current_connection)).to eq(db1)
+        end
+      end
+
+      it "sets database name on the connection" do
+        manager = Octoshark::ConnectionPoolsManager.new(mysql2_configs)
+
+        db1 = mysql2_configs[:db1]['database']
+
+        manager.with_connection(:db1, db1) do |connection|
+          expect(connection.database_name).to eq('octoshark_db1')
+        end
+      end
+
+      it "returns value from execution" do
+        manager = Octoshark::ConnectionPoolsManager.new(mysql2_configs)
+        db1 = mysql2_configs[:db1]['database']
+        result = manager.with_connection(:db1, db1) { |connection| connection.execute("SELECT 1") }.to_a
+        expect(result).to eq([[1]])
+      end
+    end
+  end
+
+  describe "#disconnect!" do
+    it "removes all connections from connection pools" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      expect(manager.find_connection_pool(:db1)).to be_connected
+
+      manager.disconnect!
+
+      expect(manager.find_connection_pool(:db1)).to_not be_connected
+    end
+  end
+
+  describe ".reset!" do
+    it "gets new connection pools ready to rock" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      expect(manager.connection_pools[:db1].connections.count).to eq(1)
+
+      manager.reset!
+
+      expect(manager.connection_pools[:db1].connections.count).to eq(0)
+
+      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      expect(manager.connection_pools[:db1].connections.count).to eq(1)
+    end
+  end
+
+  describe ".reset_connection_managers!" do
+    it "resets connection managers" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+      old_pools = manager.connection_pools.map(&:object_id)
+
+      Octoshark::ConnectionPoolsManager.reset_connection_managers!
+
+      new_pools = manager.connection_pools.map(&:object_id)
+      expect(new_pools).to_not eq(old_pools)
+    end
+  end
+
+  describe ".disconnect!" do
+    it "disconnects connection managers" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      Octoshark::ConnectionPoolsManager.disconnect!
+
+      expect(Octoshark::ConnectionPoolsManager.connection_managers).to be_blank
+    end
+
+    it "cleans old connections" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      manager.with_connection(:db2) { |connection| connection.execute("SELECT 1") }
+      expect(manager.connection_pools[:db1].connections.count).to eq(1)
+      expect(manager.connection_pools[:db2].connections.count).to eq(1)
+
+      Octoshark::ConnectionPoolsManager.disconnect!
+
+      expect(manager.connection_pools[:db1].connections.count).to eq(0)
+      expect(manager.connection_pools[:db2].connections.count).to eq(0)
+    end
+  end
+end