activerecord_autoreplica 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4842ab6d5f5cbf12c929f25b2933aca4eb6c034e
+  data.tar.gz: 94caf1b3480ea4ca6170571dc2d264e1d85f1e2d
+SHA512:
+  metadata.gz: e199dcaaa96886e1aeb7d10f022b840280abea1fd00f0ce4d114c6db332e12a81c19e71e43cf1af5cd7327c81df44d626f7fe4e99925653a0e51f98f98e89375
+  data.tar.gz: 475170a5a2e715a729d9da07c5a022866234df582e1caaa0930c318ea9b2c7b31e3ceb722d352b9eaec4735acdfe7eeb561175ad7c7e6b5579f18ce88cdca61b

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitlab-ci.yml

@@ -0,0 +1,28 @@
+# This file is generated by GitLab CI
+rake-ar4:
+  script:
+  - "apt-get update && apt-get install -y libsqlite3-dev"
+  - git submodule update --init
+  - ls -la
+  - gem install bundler
+  - apt-get install libsqlite3-dev -y
+  - bundle config --global jobs 4
+  - bundle config --global path /cache/gems
+  - bundle config build.nokogiri "--use-system-libraries --with-xml2-include=/usr/include/libxml2"
+  - BUNDLE_GEMFILE=gemfiles/Gemfile.rails-4.1.x bundle install
+  - BUNDLE_GEMFILE=gemfiles/Gemfile.rails-4.1.x bundle exec rake
+  tags:
+  - ruby
+rake-ar3:
+  script:
+  - "apt-get update && apt-get install -y libsqlite3-dev"
+  - git submodule update --init
+  - ls -la
+  - gem install bundler
+  - bundle config --global jobs 4
+  - bundle config --global path /cache/gems
+  - bundle config build.nokogiri "--use-system-libraries --with-xml2-include=/usr/include/libxml2"
+  - BUNDLE_GEMFILE=gemfiles/Gemfile.rails-3.2.x bundle install
+  - BUNDLE_GEMFILE=gemfiles/Gemfile.rails-3.2.x bundle exec rake
+  tags:
+  - ruby

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+
+# We test both with AR 4 and AR3, see gemfiles/ for more.
+# To run specs against specific versions of dependencies, use
+#
+#   $ BUNDLE_GEMFILE=gemfiles/Gemfile.rails-4.1.x bundle exec rake
+#
+# etc.
+gem 'activerecord', "> 3.0"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem 'sqlite3'
+  gem "rspec", "~> 2.4"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler"
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2014 Julik Tarkhanov for WeTransfer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,90 @@
+# activerecord_autoreplica
+
+An automatic ActiveRecord connection multiplexer, and is a reimplementation of / greatly inspired by
+the [makara gem](https://github.com/taskrabbit/makara)
+
+Automatically redirects your `SELECT` queries to a different database connection. Can be mighty
+useful when you have a read replica defined and you want to make use of it for reporting or separate
+tasks.
+
+Does not require you to change the format of your `database.yml` or whatnot. Does not support replica weighting,
+randomization, middleware contexts and other things that I do not need - it is very imperative and can be read
+and changed in one sitting.
+
+The only dependency is ActiveRecord itself.
+
+### Usage
+
+The API consists of _one_ method. Pass it a complete ActiveRecord connection specificaton hash, and
+everything within the block is going to use the read slave connections when performing standard
+ActiveRecord `SELECT` queries (not the hand-written ones).
+
+    AutoReplica.using_read_replica_at(:adapter => 'mysql2', :datbase => 'read_replica', ...) do
+      customer = Customer.find(3) # Will SELECT from the replica database at the connection spec passed to the block
+      customer.register_complaint! # Will UPDATE to the master database connection
+    end
+
+Connection strings (URLs) are also supported, just like in ActiveRecord itself:
+  
+    AutoReplica.using_read_replica_at('sqlite3:/replica_db_145.sqlite3') do
+      ...
+    end
+  
+To use in Rails controller context (for all actions of this controller):
+
+    class SlowDataReportsController < ApplicationController
+      around_filter ->{
+        AutoReplica.using_read_replica_at(...) { yield }
+      }
+      ...
+    end
+
+To use in Rack middleware context:
+
+    # Make sure to mount this downstream from ActiveRecord::ConnectionManagement in Rails
+    def call(env)
+      AutoReplica.using_read_replica_at(...) { @app.call(env) }
+    end
+
+Currently there are no runtime switches - once you are _in_ the block the `SELECT` queries composed via Arel will
+all go to the read replica, no exception. If you do not want that - just exit the block.
+
+The library does not make any assumptions about whether your data is up to date on the read slave versus master, so
+act accordingly.
+
+The `using_read_replica_at` block will allocate a `ConnectionPool` like the standard `ActiveRecord` connection
+manager does, and the pool is going to be closed and torn down at the end of the block. Since it only uses the basic
+ActiveRecord facilities (including mutexes) it should be threadsafe (but _not_ thread-local since the connection 
+handler in ActiveRecord isn't).
+
+### Running the specs
+
+You will only need sqlite3 and it's gem. Separate database files are going to be created for the master and replica and those
+files are going to be erased on test completion.
+
+There are Gemfiles for testing against various versions of ActiveRecord. To run those, use:
+
+    $ BUNDLE_GEMFILE=gemfiles/Gemfile.rails-4.1.x bundle exec rake
+    $ BUNDLE_GEMFILE=gemfiles/Gemfile.rails-3.2.x bundle exec rake
+
+The library contains a couple of switches that allow it to function in both Rails versions.
+
+### Versioning
+
+The gem version is specified in the Rakefile.
+
+### Contributing to activerecord_autoreplica
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+### Copyright
+
+Copyright (c) 2014 Julik Tarkhanov for WeTransfer. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.version = '1.1.0'
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "activerecord_autoreplica"
+  gem.homepage = "http://github.com/WeTransfer/activerecord_autoreplica"
+  gem.license = "MIT"
+  gem.summary = %Q{ Palatable-size read replica adapter for ActiveRecord  }
+  gem.description = %Q{ Redirect all SELECT queries to a separate connection within a block }
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik Tarkhanov"]
+  # dependencies defined in Gemfile
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+task :default => :spec

data/activerecord_autoreplica.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: activerecord_autoreplica 1.1.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "activerecord_autoreplica"
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Julik Tarkhanov"]
+  s.date = "2015-10-19"
+  s.description = " Redirect all SELECT queries to a separate connection within a block "
+  s.email = "me@julik.nl"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".gitlab-ci.yml",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "activerecord_autoreplica.gemspec",
+    "gemfiles/Gemfile.rails-3.2.x",
+    "gemfiles/Gemfile.rails-4.1.x",
+    "lib/activerecord_autoreplica.rb",
+    "spec/activerecord_autoreplica_spec.rb",
+    "spec/helper.rb"
+  ]
+  s.homepage = "http://github.com/WeTransfer/activerecord_autoreplica"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Palatable-size read replica adapter for ActiveRecord"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, ["> 3.0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.4"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, ["> 3.0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.4"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, ["> 3.0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.4"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

data/gemfiles/Gemfile.rails-3.2.x

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+gem 'activerecord', "~> 3"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem 'sqlite3'
+  gem "rspec", "~> 2.4"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "1.8.4" # The last without Nokogiri
+end

data/gemfiles/Gemfile.rails-4.1.x

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+gem 'activerecord', "~> 4"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem 'sqlite3'
+  gem "rspec", "~> 2.4"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "1.8.4" # The last without Nokogiri
+end

data/lib/activerecord_autoreplica.rb

@@ -0,0 +1,150 @@
+# The idea is this: we can have ActiveRecord::Base.connection return an Adapter object (that executes the
+# actual SQL queries) and inside that adapter we can redirect all SELECT queries to the read replica instead of
+# the main database. This is however slightly more involved than it looks, because if we keep calling
+# establish_connection willy-nilly we are going to disconnect from the master DB, connect to the read DB, disconnect
+# again and so on.
+#
+# The right approach for this is to maintain a separate connection pool instad just for connections to the read
+# slave. This is exactly what we are doing within AutoReplica.
+#
+# The setup to make it work is a bit involved. If you want to play with how ActiveRecord uses connections,
+# the only actual "official" hook you can use is replacing the connection handler it uses. When a SQL request needs
+# to be run AR walks the following dependency chain to arrive at the actual connection:
+#
+# * SomeRecord.connection calls ActiveRecord::Base.connection_handler
+# * It then asks the connection handler for a connection for this specific ActiveRecord subclass, or barring that
+#   - for the connection for one of it's ancestors, ending with ActiveRecord::Base itself
+# * The ConnectionHandler, in turn, asks one of it's managed ConnectionPool objects to give it a connection for use.
+# * The connection is returned and then the query is ran against it.
+#
+# This is why the only integration point for this is ++ActiveRecord::Base.connection_hanler=++
+# To make our trick work, here is what we do:
+#
+# First we wrap the original ConnectionHandler used by ActiveRecord in our own proxy. That proxy will ask the original
+# ConnectionHandler for a connection to use, but it will also maintain it's own ConnectionPool just for the read
+# replica connections.
+#
+# When a connection is returned by the original Handler, it is wrapped into a Adapter together with the
+# read connection obtained from the special read pool. That proxy will intercept all of the SQL methods for SELECT
+# and redirect them to the read connection instead. All of the other methods (including transactions)
+# are still going to be executed on the master database.
+#
+# Once the block exits, the original connection handler is reassigned to the AR connection_pool.
+module AutoReplica
+  # The first one is used in ActiveRecord 3+, the second one in 4+
+  ConnectionSpecification = ActiveRecord::Base::ConnectionSpecification rescue ActiveRecord::ConnectionAdapters::ConnectionSpecification
+        
+  def self.using_read_replica_at(replica_connection_spec_hash_or_url)
+    return yield if @in_replica_context # This method should not be reentrant
+    
+    # Resolve if there is a URL given
+    # Duplicate the hash so that we can change it if we have to
+    # (say by deleting :adapter)
+    config_hash = if replica_connection_spec_hash_or_url.is_a?(Hash)
+      replica_connection_spec_hash_or_url.dup
+    else
+      resolve_connection_url(replica_connection_spec_hash_or_url).dup
+    end
+    
+    @in_replica_context = true
+    # Wrap the connection handler in our proxy
+    original_connection_handler = ActiveRecord::Base.connection_handler
+    custom_handler = ConnectionHandler.new(original_connection_handler, config_hash)
+    begin
+      ActiveRecord::Base.connection_handler = custom_handler
+      yield
+    ensure
+      ActiveRecord::Base.connection_handler = original_connection_handler
+      custom_handler.disconnect_read_pool!
+      @in_replica_context = false
+    end
+  end
+  
+  # Resolve an ActiveRecord connection URL
+  def self.resolve_connection_url(url_string)
+    if defined?(ActiveRecord::Base::ConnectionSpecification::Resolver) # AR3
+      resolver = ActiveRecord::Base::ConnectionSpecification::Resolver.new(url_string, {})
+      resolver.send(:connection_url_to_hash, url_string) # Because making this public was so hard
+    else  # AR4
+      resolved = ActiveRecord::ConnectionAdapters::ConnectionSpecification::ConnectionUrlResolver.new(url_string).to_hash
+      resolved["database"].gsub!(/^\//, '') # which is not done by the resolver
+      resolved.symbolize_keys # which is also not done by the resolver
+    end
+  end
+  
+  # The connection handler that wraps the ActiveRecord one. Everything gets forwarded to the wrapped
+  # object, but a "spiked" connection adapter gets returned from retrieve_connection.
+  class ConnectionHandler # a proxy for ActiveRecord::ConnectionAdapters::ConnectionHandler
+    def initialize(original_handler, connection_specification_hash)
+      @original_handler = original_handler
+      # We need to maintain our own pool for read replica connections,
+      # aside from the one managed by Rails proper.
+      adapter_method = "%s_connection" % connection_specification_hash[:adapter]
+      connection_specification = ConnectionSpecification.new(connection_specification_hash, adapter_method)
+      @read_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new(connection_specification)
+    end
+    
+    # Overridden method which gets called by ActiveRecord to get a connection related to a specific
+    # ActiveRecord::Base subclass.
+    def retrieve_connection(for_ar_class)
+      connection_for_writes = @original_handler.retrieve_connection(for_ar_class)
+      connection_for_reads = @read_pool.connection
+      Adapter.new(connection_for_writes, connection_for_reads)
+    end
+    
+    # Close all the connections maintained by the read pool
+    def disconnect_read_pool!
+      @read_pool.disconnect!
+    end
+    
+    # Disconnect both the original handler AND the read pool
+    def clear_all_connections!
+      disconnect_read_pool!
+      @original_handler.clear_all_connections!
+    end
+    
+    # The duo for method proxying without delegate
+    def respond_to_missing?(method_name)
+      @original_handler.respond_to?(method_name)
+    end
+    def method_missing(method_name, *args, &blk)
+      @original_handler.public_send(method_name, *args, &blk)
+    end
+  end
+
+  # Acts as a wrapping proxy that replaces an ActiveRecord Adapter object. This is the
+  # "connection adapter" object that ActiveRecord uses internally to run SQL queries
+  # against. We let it dispatch all SELECT queries to the read replica and all
+  # other queries to the master database.
+  #
+  # To achieve this, we make a delegator proxy that sends all methods prefixed with "select_"
+  # to the read connection, and all the others to the master connection.
+  class Adapter # a proxy for ActiveRecord::ConnectionAdapters::AbstractAdapter
+    def initialize(master_connection_adapter, replica_connection_adapter)
+      @master_connection = master_connection_adapter
+      @read_connection = replica_connection_adapter
+    end
+  
+    # Under the hood, ActiveRecord uses methods for the most common database statements
+    # like "select_all", "select_one", "select_value" and so on. Those can be overridden by concrete
+    # connection adapters, but in the basic abstract Adapter they get included from
+    # DatabaseStatements. Therefore we can obtain a list of those methods (that we want to override)
+    # by grepping the instance method names of the DatabaseStatements module.
+    select_methods = ActiveRecord::ConnectionAdapters::DatabaseStatements.instance_methods.grep(/^select_/)
+    # ...and then for each of those "select_something" methods we can make a method override
+    # that will redirect the method to the read connection.
+    select_methods.each do | select_method_name |
+      define_method(select_method_name) do |*method_arguments|
+        @read_connection.send(select_method_name, *method_arguments)
+      end
+    end
+    
+    # The duo for method proxying without delegate
+    def respond_to_missing?(method_name)
+      @master_connection.respond_to?(method_name)
+    end
+    def method_missing(method_name, *args, &blk)
+      @master_connection.public_send(method_name, *args, &blk)
+    end
+  end
+end

data/spec/activerecord_autoreplica_spec.rb

@@ -0,0 +1,179 @@
+require_relative 'helper'
+require 'securerandom'
+
+describe AutoReplica do
+  
+  before :all do
+    test_seed_name = SecureRandom.hex(4)
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ('master_db_%s.sqlite3' % test_seed_name))
+    
+    # Setup the master and replica connections
+    @master_connection_config = ActiveRecord::Base.connection_config.dup
+    @replica_connection_config = @master_connection_config.merge(database: ('replica_db_%s.sqlite3' % test_seed_name))
+    @replica_connection_config_url = 'sqlite3:/replica_db_%s.sqlite3' % test_seed_name
+    
+    ActiveRecord::Migration.suppress_messages do
+      # Create both the master and the replica, with a simple small schema
+      [@master_connection_config, @replica_connection_config].each do | db_config |
+        ActiveRecord::Base.establish_connection(db_config)
+        ActiveRecord::Schema.define(:version => 1) do
+          create_table :things do |t|
+            t.string :description, :null => true
+            t.timestamps :null => false
+          end
+        end
+      end
+    end
+  end
+  
+  after :all do
+    # Ensure database files get killed afterwards
+    [@master_connection_config, @replica_connection_config].map do | connection_config |
+      File.unlink(connection_config[:database]) rescue nil
+    end
+  end
+  
+  before :each do
+    [@replica_connection_config, @master_connection_config].each do | config |
+      ActiveRecord::Base.establish_connection(config)
+      ActiveRecord::Base.connection.execute 'DELETE FROM things' # sqlite has no TRUNCATE
+    end
+  end
+  
+  class TestThing < ActiveRecord::Base
+    self.table_name = 'things'
+  end
+  
+  context 'using_read_replica_at' do
+    it 'has no reentrancy problems' do
+      id = described_class.using_read_replica_at(@replica_connection_config) do
+        described_class.using_read_replica_at(@replica_connection_config) do
+          described_class.using_read_replica_at(@replica_connection_config) do
+            thing = TestThing.create! description: 'A nice Thing in the master database'
+            expect {
+              TestThing.find(thing.id)
+            }.to raise_error(ActiveRecord::RecordNotFound)
+            
+            thing.id # return to the outside of the block
+          end
+        end
+      end
+      found_on_master = TestThing.find(id)
+      expect(found_on_master.description).to eq('A nice Thing in the master database')
+    end
+    
+    it 'executes the SELECT query against the replica database and returns the result of the block' do
+      id = described_class.using_read_replica_at(@replica_connection_config) do
+        thing = TestThing.create! description: 'A nice Thing in the master database'
+        expect {
+          TestThing.find(thing.id)
+        }.to raise_error(ActiveRecord::RecordNotFound)
+        thing.id
+      end
+      found_on_master = TestThing.find(id)
+      expect(found_on_master.description).to eq('A nice Thing in the master database')
+      
+      ActiveRecord::Base.establish_connection(@replica_connection_config)
+      thing_on_slave = TestThing.new(found_on_master.attributes)
+      thing_on_slave.id = found_on_master.id # gets ignored in attributes
+      thing_on_slave.description = 'A nice Thing that is in the slave database'
+      thing_on_slave.save!
+      
+      ActiveRecord::Base.establish_connection(@master_connection_config)
+      described_class.using_read_replica_at(@replica_connection_config) do
+        thing_from_replica = TestThing.find(id)
+        expect(thing_from_replica.description).to eq('A nice Thing that is in the slave database')
+      end
+    end
+    
+    it 'executes the SELECT query against the replica database with replica connection specification given as a URL' do
+      id = described_class.using_read_replica_at(@replica_connection_config_url) do
+        thing = TestThing.create! description: 'A nice Thing in the master database'
+        expect {
+          TestThing.find(thing.id)
+        }.to raise_error(ActiveRecord::RecordNotFound)
+        thing.id
+      end
+      found_on_master = TestThing.find(id)
+      expect(found_on_master.description).to eq('A nice Thing in the master database')
+    end
+  end
+  
+  describe AutoReplica::ConnectionHandler do
+    it 'creates a read pool with the replica connection specification hash' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      expect(ActiveRecord::ConnectionAdapters::ConnectionPool).to receive(:new).
+        with(instance_of(AutoReplica::ConnectionSpecification))
+      
+      AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+    end
+    
+    it 'proxies all methods' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      expect(original_handler).to receive(:do_that_thing) { :yes }
+      subject = AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+      expect(subject.do_that_thing).to eq(:yes)
+    end
+    
+    it 'enhances connection_for and returns an instance of the Adapter' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      adapter_double = double('ActiveRecord_Adapter')
+      expect(original_handler).to receive(:retrieve_connection).with(TestThing) { adapter_double }
+      
+      subject = AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+      connection = subject.retrieve_connection(TestThing)
+      expect(connection).to be_kind_of(AutoReplica::Adapter)
+    end
+    
+    it 'disconnects the read pool when asked to' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      pool_double = double('ConnectionPool')
+      expect(ActiveRecord::ConnectionAdapters::ConnectionPool).to receive(:new).
+        with(instance_of(AutoReplica::ConnectionSpecification)) { pool_double }
+      subject = AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+      
+      expect(pool_double).to receive(:disconnect!)
+      subject.disconnect_read_pool!
+    end
+    
+    it 'performs clear_all_connections! both on the contained handler and on the read pool' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      pool_double = double('ConnectionPool')
+      expect(ActiveRecord::ConnectionAdapters::ConnectionPool).to receive(:new).
+        with(instance_of(AutoReplica::ConnectionSpecification)) { pool_double }
+      
+      expect(original_handler).to receive(:clear_all_connections!)
+      expect(pool_double).to receive(:disconnect!)
+      
+      subject = AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+      subject.clear_all_connections!
+    end
+  end
+  
+  describe AutoReplica::Adapter do
+    it 'mirrors select_ prefixed database statement methods in ActiveRecord::ConnectionAdapters::DatabaseStatements' do
+      master = double()
+      expect(master).not_to receive(:respond_to?)
+      subject = AutoReplica::Adapter.new(master, double())
+      
+      select_methods = ActiveRecord::ConnectionAdapters::DatabaseStatements.instance_methods.grep(/^select_/)
+      expect(select_methods.length).to be > 1
+      
+      select_methods.each do | select_method_in_database_statements |
+        expect(subject).to respond_to(select_method_in_database_statements)
+      end
+    end
+    
+    it 'redirects calls to all select_ methods to the read connection and others to the master connection' do
+      master_adapter = double('Connection to the master DB')
+      replica_adapter = double('Connection to the replica DB')
+      subject = AutoReplica::Adapter.new(master_adapter, replica_adapter)
+      
+      expect(master_adapter).to receive(:some_arbitrary_method) { :from_master }
+      expect(replica_adapter).to receive(:select_values).with(:a, :b, :c) { :from_replica }
+      expect(subject.some_arbitrary_method).to eq(:from_master)
+      expect(subject.select_values(:a, :b, :c)).to eq(:from_replica)
+    end
+  end
+end
+

data/spec/helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup(:default, :development)
+
+require 'active_record'
+require 'activerecord_autoreplica'
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: activerecord_autoreplica
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " Redirect all SELECT queries to a separate connection within a block "
+email: me@julik.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".gitlab-ci.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord_autoreplica.gemspec
+- gemfiles/Gemfile.rails-3.2.x
+- gemfiles/Gemfile.rails-4.1.x
+- lib/activerecord_autoreplica.rb
+- spec/activerecord_autoreplica_spec.rb
+- spec/helper.rb
+homepage: http://github.com/WeTransfer/activerecord_autoreplica
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Palatable-size read replica adapter for ActiveRecord
+test_files: []