ar-octopus 0.8.5 → 0.10.2

data/spec/octopus/model_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 
 describe Octopus::Model do
   describe '#using method' do
+    it 'raise when Model#using receives a block' do
+      expect { User.using(:master) { true } }.to raise_error(Octopus::Exception, /User\.using is not allowed to receive a block/)
+    end
+
     it 'should allow to send a block to the master shard' do
       Octopus.using(:master) do
         User.create!(:name => 'Block test')
@@ -16,6 +20,16 @@ describe Octopus::Model do
       expect(User.using('canada').find_by_name('Rafael Pilha')).not_to be_nil
     end
 
+    it 'should allow comparison of a string shard name with symbol shard name' do
+      u = User.using('canada').create!(:name => 'Rafael Pilha')
+      expect(u).to eq(User.using(:canada).find_by_name('Rafael Pilha'))
+    end
+
+    it 'should allow comparison of a symbol shard name with string shard name' do
+      u = User.using(:canada).create!(:name => 'Rafael Pilha')
+      expect(u).to eq(User.using('canada').find_by_name('Rafael Pilha'))
+    end
+
     it 'should allow to pass a string as the shard name to a block' do
       Octopus.using('canada') do
         User.create!(:name => 'Rafael Pilha')
@@ -49,6 +63,28 @@ describe Octopus::Model do
       expect(User.all).to eq([u1])
     end
 
+    it "should allow the #select method to fetch the correct data when using a block" do
+      canadian_user = User.using(:canada).create!(:name => 'Rafael Pilha')
+
+      Octopus.using('canada') do
+        @all_canadian_user_ids = User.select('id').to_a
+      end
+
+      expect(@all_canadian_user_ids).to eq([canadian_user])
+    end
+
+    it "should allow objects to be fetch using different blocks - GH #306" do
+      canadian_user = User.using(:canada).create!(:name => 'Rafael Pilha')
+
+      Octopus.using(:canada) { @users = User.where('id is not null') }
+      Octopus.using(:canada) { @user = @users.first }
+
+      Octopus.using(:canada) { @user2 = User.where('id is not null').first }
+
+      expect(@user).to eq(canadian_user)
+      expect(@user2).to eq(canadian_user)
+    end
+
     describe 'multiple calls to the same scope' do
       it 'works with nil response' do
         scope = User.using(:canada)
@@ -76,11 +112,26 @@ describe Octopus::Model do
         Octopus.using(:canada) do
           fail 'Some Exception'
         end
-      end.to raise_error
+      end.to raise_error(RuntimeError)
 
       expect(ActiveRecord::Base.connection.current_shard).to eq(:master)
     end
 
+    it 'should ensure that the connection will be cleaned with custom master' do
+      OctopusHelper.using_environment :octopus do
+        Octopus.config[:master_shard] = :brazil
+        expect(ActiveRecord::Base.connection.current_shard).to eq(:brazil)
+        expect do
+          Octopus.using(:canada) do
+            fail 'Some Exception'
+          end
+        end.to raise_error(RuntimeError)
+
+        expect(ActiveRecord::Base.connection.current_shard).to eq(:brazil)
+        Octopus.config[:master_shard] = nil
+      end
+    end
+
     it 'should allow creating more than one user' do
       User.using(:canada).create([{ :name => 'America User 1' }, { :name => 'America User 2' }])
       User.create!(:name => 'Thiago')
@@ -99,6 +150,15 @@ describe Octopus::Model do
       expect(User.connection.current_shard).to eq(:master)
     end
 
+    it 'should clean #current_shard from proxy when using execute' do
+      OctopusHelper.using_environment :octopus do
+        Octopus.config[:master_shard] = :brazil
+        User.using(:canada).connection.execute('select * from users limit 1;')
+        expect(User.connection.current_shard).to eq(:brazil)
+        Octopus.config[:master_shard] = nil
+      end
+    end
+
     it 'should allow scoping dynamically' do
       User.using(:canada).using(:master).using(:canada).create!(:name => 'oi')
       expect(User.using(:canada).using(:master).count).to eq(0)
@@ -246,15 +306,19 @@ describe Octopus::Model do
 
   describe 'using a postgresql shard' do
     it 'should update the Arel Engine' do
-      expect(User.using(:postgresql_shard).arel_engine.connection.adapter_name).to eq('PostgreSQL')
-      expect(User.using(:alone_shard).arel_engine.connection.adapter_name).to eq('Mysql2')
+      if Octopus.atleast_rails52?
+        expect(User.using(:postgresql_shard).connection.adapter_name).to eq('PostgreSQL')
+        expect(User.using(:alone_shard).connection.adapter_name).to eq('Mysql2')
+      else 
+        expect(User.using(:postgresql_shard).arel_engine.connection.adapter_name).to eq('PostgreSQL')
+        expect(User.using(:alone_shard).arel_engine.connection.adapter_name).to eq('Mysql2')
+      end
     end
 
     it 'should works with writes and reads' do
       u = User.using(:postgresql_shard).create!(:name => 'PostgreSQL User')
       expect(User.using(:postgresql_shard).all).to eq([u])
       expect(User.using(:alone_shard).all).to eq([])
-      User.connection_handler.connection_pools['ActiveRecord::Base'] = User.connection.instance_variable_get(:@shards)[:master]
     end
   end
 
@@ -263,6 +327,12 @@ describe Octopus::Model do
       expect(CustomConnection.connection.current_database).to eq('octopus_shard_2')
     end
 
+    it 'reuses parent model connection' do
+      klass = Class.new(CustomConnection)
+
+      expect(klass.connection).to be klass.connection
+    end
+
     it 'should not mess with custom connection table names' do
       expect(Advert.connection.current_database).to eq('octopus_shard_1')
       Advert.create!(:name => 'Teste')
@@ -328,6 +398,18 @@ describe Octopus::Model do
       expect(User.using(:master).maximum(:number)).to eq(12)
     end
 
+    it 'sum' do
+      u = User.using(:brazil).create!(:name => 'Teste', :number => 11)
+      v = User.using(:master).create!(:name => 'Teste', :number => 12)
+
+      expect(User.using(:master).sum(:number)).to eq(12)
+      expect(User.using(:brazil).sum(:number)).to eq(11)
+
+      expect(User.where(id: v.id).sum(:number)).to eq(12)
+      expect(User.using(:brazil).where(id: u.id).sum(:number)).to eq(11)
+      expect(User.using(:master).where(id: v.id).sum(:number)).to eq(12)
+    end
+
     describe 'any?' do
       before { User.using(:brazil).create!(:name => 'User1') }
 
@@ -418,19 +500,113 @@ describe Octopus::Model do
       expect(user.as_json(:except => [:created_at, :updated_at, :id])).to eq('admin' => nil, 'name' => 'User1', 'number' => nil)
     end
 
-    it 'transaction' do
-      _u = User.create!(:name => 'Thiago')
+    describe 'transaction' do
+      context 'without assigning a database' do
+        it 'works as expected' do
+          _u = User.create!(:name => 'Thiago')
 
-      expect(User.using(:brazil).count).to eq(0)
-      expect(User.using(:master).count).to eq(1)
+          expect(User.using(:brazil).count).to eq(0)
+          expect(User.using(:master).count).to eq(1)
+
+          User.using(:brazil).transaction do
+            expect(User.find_by_name('Thiago')).to be_nil
+            User.create!(:name => 'Brazil')
+          end
 
-      User.using(:brazil).transaction do
-        expect(User.find_by_name('Thiago')).to be_nil
-        User.create!(:name => 'Brazil')
+          expect(User.using(:brazil).count).to eq(1)
+          expect(User.using(:master).count).to eq(1)
+        end
       end
 
-      expect(User.using(:brazil).count).to eq(1)
-      expect(User.using(:master).count).to eq(1)
+      context 'when assigning a database' do
+        it 'works as expected' do
+          klass = User.using(:brazil)
+
+          klass.transaction do
+            klass.create!(:name => 'Brazil')
+          end
+
+          expect(klass.find_by_name('Brazil')).to be_present
+        end
+      end
+    end
+
+    describe "#finder methods" do
+      before(:each) do
+        @user1 = User.using(:brazil).create!(:name => 'User1')
+        @user2 = User.using(:brazil).create!(:name => 'User2')
+        @user3 = User.using(:brazil).create!(:name => 'User3')
+      end
+
+      it "#find_each should work with a block" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([@user1, @user2, @user3])
+      end
+
+      it "#find_each should work with a where.not(...)" do
+        result_array = []
+
+        User.using(:brazil).where.not(:name => 'User2').find_each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([@user1, @user3])
+      end
+
+      it "#find_each should work as an enumerator" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_each.each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([@user1, @user2, @user3])
+      end
+
+      it "#find_each should work as a lazy enumerator" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_each.lazy.each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([@user1, @user2, @user3])
+      end
+
+      it "#find_in_batches should work with a block" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_in_batches(batch_size: 1) do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([[@user1], [@user2], [@user3]])
+      end
+
+      it "#find_in_batches should work as an enumerator" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_in_batches(batch_size: 1).each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([[@user1], [@user2], [@user3]])
+      end
+
+      it "#find_in_batches should work as a lazy enumerator" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_in_batches(batch_size: 1).lazy.each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([[@user1], [@user2], [@user3]])
+      end
     end
 
     describe 'deleting a record' do
@@ -622,20 +798,21 @@ describe Octopus::Model do
     it 'should work correctly when using validations' do
       @key = Keyboard.create!(:name => 'Key')
       expect { Keyboard.using(:brazil).create!(:name => 'Key') }.not_to raise_error
-      expect { Keyboard.create!(:name => 'Key') }.to raise_error
+      expect { Keyboard.create!(:name => 'Key') }.to raise_error(ActiveRecord::RecordInvalid)
     end
 
     it 'should work correctly when using validations with using syntax' do
       @key = Keyboard.using(:brazil).create!(:name => 'Key')
       expect { Keyboard.create!(:name => 'Key') }.not_to raise_error
-      expect { Keyboard.using(:brazil).create!(:name => 'Key') }.to raise_error
+      expect { Keyboard.using(:brazil).create!(:name => 'Key') }
+        .to raise_error(ActiveRecord::RecordInvalid)
     end
   end
 
   describe '#replicated_model method' do
     it 'should be replicated' do
       OctopusHelper.using_environment :production_replicated do
-        expect(ActiveRecord::Base.connection_proxy.instance_variable_get(:@replicated)).to be true
+        expect(ActiveRecord::Base.connection_proxy.replicated).to be true
       end
     end
 
@@ -645,5 +822,16 @@ describe Octopus::Model do
         expect(Cat.replicated).to be true
       end
     end
+
+    it "should work on a fully replicated environment" do
+      OctopusHelper.using_environment :production_fully_replicated do
+        User.using(:slave1).create!(name: 'Thiago')
+        User.using(:slave2).create!(name: 'Thiago')
+
+        replicated_cat = User.find_by_name 'Thiago'
+
+        expect(replicated_cat.current_shard.to_s).to match(/master/)
+      end
+    end
   end
 end

data/spec/octopus/octopus_spec.rb

@@ -37,10 +37,10 @@ describe Octopus, :shards => [] do
     end
 
     it 'should permit users to configure shards on initializer files, instead of on a yml file.' do
-      expect { User.using(:crazy_shard).create!(:name => 'Joaquim') }.to raise_error
+      expect { User.using(:crazy_shard).create!(:name => 'Joaquim') }.to raise_error(RuntimeError)
 
       Octopus.setup do |config|
-        config.shards = { :crazy_shard => { :adapter => 'mysql2', :database => 'octopus_shard_5', :username => 'root', :password => '' } }
+        config.shards = { :crazy_shard => { :adapter => 'mysql2', :database => 'octopus_shard_5', :username => "#{ENV['MYSQL_USER'] || 'root'}", :password => '' } }
       end
 
       expect { User.using(:crazy_shard).create!(:name => 'Joaquim')  }.not_to raise_error

data/spec/octopus/proxy_spec.rb

@@ -6,10 +6,10 @@ describe Octopus::Proxy do
   describe 'creating a new instance', :shards => [] do
     it 'should initialize all shards and groups' do
       # FIXME: Don't test implementation details
-      expect(proxy.instance_variable_get(:@shards)).to include('canada', 'brazil', 'master', 'sqlite_shard', 'russia', 'alone_shard',
+      expect(proxy.shards).to include('canada', 'brazil', 'master', 'sqlite_shard', 'russia', 'alone_shard',
                                                                'aug2009', 'postgresql_shard', 'aug2010', 'aug2011')
 
-      expect(proxy.instance_variable_get(:@shards)).to include('protocol_shard')
+      expect(proxy.shards).to include('protocol_shard')
 
       expect(proxy.has_group?('country_shards')).to be true
       expect(proxy.shards_for_group('country_shards')).to include(:canada, :brazil, :russia)
@@ -23,24 +23,20 @@ describe Octopus::Proxy do
     end
 
     it 'should initialize replicated attribute as false' do
-      expect(proxy.instance_variable_get(:@replicated)).to be_falsey
+      expect(proxy.replicated).to be_falsey
     end
 
-    it 'should work with thiking sphinx' do
-      config = proxy.instance_variable_get(:@config)
+    it 'should work with thinking sphinx' do
+      config = proxy.config
       expect(config[:adapter]).to eq('mysql2')
       expect(config[:database]).to eq('octopus_shard_1')
-      expect(config[:username]).to eq('root')
+      expect(config[:username]).to eq("#{ENV['MYSQL_USER'] || 'root'}")
     end
 
-    it 'should create a set with all adapters, to ensure that is needed to clean the table name.' do
-      adapters = proxy.instance_variable_get(:@adapters)
-      expect(adapters).to be_kind_of(Set)
-      expect(adapters.to_a).to match_array(%w(sqlite3 mysql2 postgresql))
-    end
-
-    it 'should respond correctly to respond_to?(:pk_and_sequence_for)' do
-      expect(proxy.respond_to?(:pk_and_sequence_for)).to be true
+    unless Octopus.rails50? || Octopus.rails51?|| Octopus.rails52?
+      it 'should respond correctly to respond_to?(:pk_and_sequence_for)' do
+        expect(proxy.respond_to?(:pk_and_sequence_for)).to be true
+      end
     end
 
     it 'should respond correctly to respond_to?(:primary_key)' do
@@ -61,22 +57,6 @@ describe Octopus::Proxy do
       end
     end
 
-    describe '#should_clean_table_name?' do
-      it 'should return true when you have a environment with multiple database types' do
-        expect(proxy.should_clean_table_name?).to be true
-      end
-
-      context 'when using a environment with a single table name' do
-        before(:each) do
-          OctopusHelper.octopus_env = 'production_replicated'
-        end
-
-        it 'should return false' do
-          expect(proxy.should_clean_table_name?).to be false
-        end
-      end
-    end
-
     describe 'should raise error if you have duplicated shard names' do
       before(:each) do
         OctopusHelper.octopus_env = 'production_raise_error'
@@ -93,11 +73,11 @@ describe Octopus::Proxy do
       end
 
       it 'should initialize just the master shard' do
-        expect(proxy.instance_variable_get(:@shards).keys).to eq(['master'])
+        expect(proxy.shards.keys).to eq(['master'])
       end
 
       it 'should not initialize replication' do
-        expect(proxy.instance_variable_get(:@replicated)).to be_nil
+        expect(proxy.replicated).to be_nil
       end
     end
   end
@@ -108,11 +88,11 @@ describe Octopus::Proxy do
     end
 
     it 'should have the replicated attribute as true' do
-      expect(proxy.instance_variable_get(:@replicated)).to be true
+      expect(proxy.replicated).to be true
     end
 
     it 'should initialize the list of shards' do
-      expect(proxy.instance_variable_get(:@slaves_list)).to eq(%w(slave1 slave2 slave3 slave4))
+      expect(proxy.slaves_list).to eq(%w(slave1 slave2 slave3 slave4))
     end
   end
 
@@ -135,7 +115,7 @@ describe Octopus::Proxy do
       Octopus.instance_variable_set(:@environments, nil)
       Octopus.config
 
-      expect(proxy.instance_variable_get(:@replicated)).to be true
+      expect(proxy.replicated).to be true
       expect(Octopus.environments).to eq(%w(staging production))
     end
 
@@ -145,7 +125,7 @@ describe Octopus::Proxy do
       Octopus.instance_variable_set(:@environments, nil)
       Octopus.config
 
-      expect(proxy.instance_variable_get(:@shards).keys.to_set).to eq(Set.new(%w(slave1 slave2 master)))
+      expect(proxy.shards.keys.to_set).to eq(Set.new(%w(slave1 slave2 master)))
     end
 
     it 'should initialize correctly the shard octopus_shard value for logging' do
@@ -154,7 +134,7 @@ describe Octopus::Proxy do
       Octopus.instance_variable_set(:@environments, nil)
       Octopus.config
 
-      expect(proxy.instance_variable_get(:@shards)['slave1'].spec.config).to have_key :octopus_shard
+      expect(proxy.shards['slave1'].spec.config).to have_key :octopus_shard
     end
 
     it 'should initialize correctly the shards for the production environment' do
@@ -163,7 +143,7 @@ describe Octopus::Proxy do
       Octopus.instance_variable_set(:@environments, nil)
       Octopus.config
 
-      expect(proxy.instance_variable_get(:@shards).keys.to_set).to eq(Set.new(%w(slave3 slave4 master)))
+      expect(proxy.shards.keys.to_set).to eq(Set.new(%w(slave3 slave4 master)))
     end
 
     describe 'using the master connection', :shards => [:russia, :master]  do
@@ -211,6 +191,14 @@ describe Octopus::Proxy do
         expect(proxy.shard_name).to eq(:master)
       end
 
+      it 'when current_shard is empty with custom master' do
+        OctopusHelper.using_environment :octopus do
+          Octopus.config[:master_shard] = :brazil
+          expect(proxy.shard_name).to eq(:brazil)
+          Octopus.config[:master_shard] = nil
+        end
+      end
+
       it 'when current_shard is a single shard' do
         proxy.current_shard = :canada
         expect(proxy.shard_name).to eq(:canada)
@@ -224,12 +212,12 @@ describe Octopus::Proxy do
 
     describe 'should return the connection based on shard_name' do
       it 'when current_shard is empty' do
-        expect(proxy.select_connection).to eq(proxy.instance_variable_get(:@shards)[:master].connection)
+        expect(proxy.select_connection).to eq(proxy.shards[:master].connection)
       end
 
       it 'when current_shard is a single shard' do
         proxy.current_shard = :canada
-        expect(proxy.select_connection).to eq(proxy.instance_variable_get(:@shards)[:canada].connection)
+        expect(proxy.select_connection).to eq(proxy.shards[:canada].connection)
       end
     end
   end
@@ -264,6 +252,22 @@ describe Octopus::Proxy do
     end
   end
 
+
+  describe 'cleaning the connection proxy' do
+    it 'should not clean #current_shard from proxy when using a block and calling #execute' do
+      Octopus.using(:canada) do
+        expect(User.connection.current_shard).to eq(:canada)
+
+        connection = User.connection
+
+        result = connection.execute('select * from users limit 1;')
+        result = connection.execute('select * from users limit 1;')
+
+        expect(User.connection.current_shard).to eq(:canada)
+      end
+    end
+  end
+
   describe 'connection reuse' do
     before :each do
       @item_brazil_conn = Item.using(:brazil).new(:name => 'Brazil Item').class.connection.select_connection

data/spec/octopus/query_cache_for_shards_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+unless Octopus.rails4? || Octopus.rails50?
+  describe Octopus::ConnectionPool::QueryCacheForShards do
+    subject(:query_cache_on_shard) { ActiveRecord::Base.using(:brazil).connection.query_cache_enabled }
+
+    context 'Octopus enabled' do
+      context 'when query cache is enabled on the primary connection_pool' do
+        before { ActiveRecord::Base.connection_pool.enable_query_cache! }
+        it { is_expected.to be true }
+      end
+
+      context 'when query cache is disabled on the primary connection_pool' do
+        before { ActiveRecord::Base.connection_pool.disable_query_cache! }
+        it { is_expected.to be false }
+      end
+    end
+
+    context 'Octopus disabled' do
+      before do
+        Rails = double
+        allow(Rails).to receive(:env).and_return('staging')
+      end
+
+      after do
+        Object.send(:remove_const, :Rails)
+      end
+
+      context 'when query cache is enabled on the primary connection_pool' do
+        before { ActiveRecord::Base.connection_pool.enable_query_cache! }
+        it { is_expected.to be true }
+      end
+
+      context 'when query cache is disabled on the primary connection_pool' do
+        before { ActiveRecord::Base.connection_pool.disable_query_cache! }
+        it { is_expected.to be false }
+      end
+    end
+  end
+end

data/spec/octopus/relation_proxy_spec.rb

@@ -12,10 +12,39 @@ describe Octopus::RelationProxy do
       expect(@relation.current_shard).to eq(:canada)
     end
 
-    unless Octopus.rails3?
-      it 'can define collection association with the same name as ancestor private method' do
-        @client.comments << Comment.using(:canada).create!(open: true)
-        expect(@client.comments.open).to be_a_kind_of(ActiveRecord::Relation)
+    it 'can define collection association with the same name as ancestor private method' do
+      @client.comments << Comment.using(:canada).create!(open: true)
+      expect(@client.comments.open).to be_a_kind_of(ActiveRecord::Relation)
+    end
+
+    it 'can be dumped and loaded' do
+      expect(Marshal.load(Marshal.dump(@relation))).to eq @relation
+    end
+
+    it 'maintains the current shard when using where.not(...)' do
+      where_chain = @relation.where
+      expect(where_chain.current_shard).to eq(@relation.current_shard)
+      not_relation = where_chain.not("1=0")
+      expect(not_relation.current_shard).to eq(@relation.current_shard)
+    end
+
+    context 'when a new relation is constructed from the original relation' do
+      context 'and a where(...) is used' do
+        it 'does not tamper with the original relation' do
+          relation = Item.using(:canada).where(id: 1)
+          original_sql = relation.to_sql
+          new_relation = relation.where(id: 2)
+          expect(relation.to_sql).to eq(original_sql)
+        end
+      end
+
+      context 'and a where.not(...) is used' do
+        it 'does not tamper with the original relation' do
+          relation = Item.using(:canada).where(id: 1)
+          original_sql = relation.to_sql
+          new_relation = relation.where.not(id: 2)
+          expect(relation.to_sql).to eq(original_sql)
+        end
       end
     end
 
@@ -29,26 +58,36 @@ describe Octopus::RelationProxy do
       end
     end
 
-    if Octopus.rails4?
-      context 'under Rails 4' do
-        it 'is an Octopus::RelationProxy' do
-          expect{@relation.ar_relation}.not_to raise_error
-        end
+    it "can deliver methods in ActiveRecord::Batches correctly when given a block" do
+      expect { @relation.find_each(&:inspect) }.not_to raise_error
+    end
 
-        it 'should be able to return its ActiveRecord::Relation' do
-          expect(@relation.ar_relation.is_a?(ActiveRecord::Relation)).to be true
-        end
+    it "can deliver methods in ActiveRecord::Batches correctly as an enumerator" do
+      expect { @relation.find_each.each(&:inspect) }.not_to raise_error
+    end
 
-        it 'is equal to an identically-defined, but different, RelationProxy' do
-          i = @client.items
-          expect(@relation).to eq(i)
-          expect(@relation.__id__).not_to eq(i.__id__)
-        end
+    it "can deliver methods in ActiveRecord::Batches correctly as a lazy enumerator" do
+      expect { @relation.find_each.lazy.each(&:inspect) }.not_to raise_error
+    end
 
-        it 'is equal to its own underlying ActiveRecord::Relation' do
-          expect(@relation).to eq(@relation.ar_relation)
-          expect(@relation.ar_relation).to eq(@relation)
-        end
+    context 'under Rails 4' do
+      it 'is an Octopus::RelationProxy' do
+        expect{@relation.ar_relation}.not_to raise_error
+      end
+
+      it 'should be able to return its ActiveRecord::Relation' do
+        expect(@relation.ar_relation.is_a?(ActiveRecord::Relation)).to be true
+      end
+
+      it 'is equal to an identically-defined, but different, RelationProxy' do
+        i = @client.items
+        expect(@relation).to eq(i)
+        expect(@relation.__id__).not_to eq(i.__id__)
+      end
+
+      it 'is equal to its own underlying ActiveRecord::Relation' do
+        expect(@relation).to eq(@relation.ar_relation)
+        expect(@relation.ar_relation).to eq(@relation)
       end
     end
 
@@ -68,14 +107,23 @@ describe Octopus::RelationProxy do
       it 'uses the correct shard' do
         expect(Item.using(:brazil).count).to eq(0)
         _clients_on_brazil = Client.using(:brazil).all
-        Client.using(:brazil) do
+        Octopus.using(:brazil) do
           expect(@relation.count).to eq(1)
         end
       end
 
+      it 'uses the correct shard in block when method_missing is triggered on CollectionProxy objects' do
+        Octopus.using(:brazil) do
+          @client.items.each do |item|
+            expect(item.current_shard).to eq(:canada)
+            expect(ActiveRecord::Base.connection.current_shard).to eq(:brazil)
+          end
+        end
+      end
+
       it 'lazily evaluates on the correct shard' do
         expect(Item.using(:brazil).count).to eq(0)
-        Client.using(:brazil) do
+        Octopus.using(:brazil) do
           expect(@relation.select(:client_id).count).to eq(1)
         end
       end