ar-octopus 0.8.1 → 0.10.2

data/spec/octopus/relation_proxy_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Octopus::RelationProxy do
+  describe 'shard tracking' do
+    before :each do
+      @client = Client.using(:canada).create!
+      @client.items << Item.using(:canada).create!
+      @relation = @client.items
+    end
+
+    it 'remembers the shard on which a relation was created' do
+      expect(@relation.current_shard).to eq(:canada)
+    end
+
+    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
+
+    context 'when comparing to other Relation objects' do
+      before :each do
+        @relation.reset
+      end
+
+      it 'is equal to its clone' do
+        expect(@relation).to eq(@relation.clone)
+      end
+    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 "can deliver methods in ActiveRecord::Batches correctly as an enumerator" do
+      expect { @relation.find_each.each(&:inspect) }.not_to raise_error
+    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
+
+    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
+
+    context 'when no explicit shard context is provided' do
+      it 'uses the correct shard' do
+        expect(@relation.count).to eq(1)
+      end
+
+      it 'lazily evaluates on the correct shard' do
+        # Do something to force Client.connection_proxy.current_shard to change
+        _some_count = Client.using(:brazil).count
+        expect(@relation.select(:client_id).count).to eq(1)
+      end
+    end
+
+    context 'when an explicit, but different, shard context is provided' do
+      it 'uses the correct shard' do
+        expect(Item.using(:brazil).count).to eq(0)
+        _clients_on_brazil = Client.using(:brazil).all
+        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)
+        Octopus.using(:brazil) do
+          expect(@relation.select(:client_id).count).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/octopus/replicated_slave_grouped_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe 'when the database is replicated and has slave groups' do
+
+  it 'should pick the slave group based on current_slave_grup when you have a replicated model' do
+
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      # The following two calls of `create!` both creates cats in :master(The database `octopus_shard_1`)
+      # which is configured through RAILS_ENV and database.yml
+      Cat.create!(:name => 'Thiago1')
+      Cat.create!(:name => 'Thiago2')
+
+      # See "replicated_slave_grouped" defined in shards.yml
+      # We have:
+      #   The database `octopus_shard_1` as :slave21 which is a member of the slave group :slaves2, and as :master
+      #   The databse `octopus_shard_2` as :slave11 which is a member of the slave group :slaves1
+      # When a select-count query is sent to `octopus_shard_1`, it should return 2 because we have create two cats in :master .
+      # When a select-count query is sent to `octopus_shard_2`, it should return 0.
+
+      # The query goes to `octopus_shard_1`
+      expect(Cat.using(:master).count).to eq(2)
+      # The query goes to `octopus_shard_1`
+      expect(Cat.count).to eq(2)
+      # The query goes to `octopus_shard_2`
+      expect(Cat.using(:slave_group => :slaves1).count).to eq(0)
+      # The query goes to `octopus_shard_1`
+      expect(Cat.using(:slave_group => :slaves2).count).to eq(2)
+    end
+  end
+
+  it 'should distribute queries between slaves in a slave group in round-robin' do
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      # The query goes to :master(`octopus_shard_1`)
+      Cat.create!(:name => 'Thiago1')
+      # The query goes to :master(`octopus_shard_1`)
+      Cat.create!(:name => 'Thiago2')
+
+      # The query goes to :slave32(`octopus_shard_2`)
+      expect(Cat.using(:slave_group => :slaves3).count).to eq(0)
+      # The query goes to :slave31(`octopus_shard_1`)
+      expect(Cat.using(:slave_group => :slaves3).count).to eq(2)
+      # The query goes to :slave32(`octopus_shard_2`)
+      expect(Cat.using(:slave_group => :slaves3).count).to eq(0)
+    end
+  end
+
+  it 'should make queries to master when slave groups are configured but not selected' do
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      # All the queries go to :master(`octopus_shard_1`)
+
+      Cat.create!(:name => 'Thiago1')
+      Cat.create!(:name => 'Thiago2')
+
+      # In `database.yml` and `shards.yml`, we have configured 1 master and 4 slaves.
+      # So we can ensure Octopus is not distributing queries between them
+      # by asserting 1 + 4 = 5 queries go to :master(`octopus_shard_1`)
+      expect(Cat.count).to eq(2)
+      expect(Cat.count).to eq(2)
+      expect(Cat.count).to eq(2)
+      expect(Cat.count).to eq(2)
+      expect(Cat.count).to eq(2)
+    end
+  end
+
+  it 'should keep sending to slaves in a using block' do
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      Cat.create!(:name => 'Thiago1')
+      Cat.create!(:name => 'Thiago2')
+
+      expect(Cat.count).to eq(2)
+      Octopus.using(:slave_group => :slaves1) do
+        expect(Cat.count).to eq(0)
+        expect(Cat.count).to eq(0)
+      end
+    end
+  end
+  
+  it 'should restore previous slave group after a using block' do
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      Cat.create!(:name => 'Thiago1')
+      Cat.create!(:name => 'Thiago2')
+
+      Octopus.using(:slave_group => :slaves1) do
+        Octopus.using(:slave_group => :slaves2) do
+          expect(Cat.count).to eq(2)
+        end
+        expect(Cat.count).to eq(0)
+      end
+    end
+  end
+end

data/spec/octopus/replication_spec.rb

@@ -1,69 +1,138 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe "when the database is replicated" do
-  it "should send all writes/reads queries to master when you have a non replicated model" do
+describe 'when the database is replicated' do
+  let(:slave_pool) do
+    ActiveRecord::Base.connection_proxy.shards['slave1']
+  end
+
+  let(:slave_connection) do
+    slave_pool.connection
+  end
+
+  let(:master_pool) do
+    ActiveRecord::Base.connection_proxy.shards['master']
+  end
+
+  let(:master_connection) do
+    master_pool.connection
+  end
+
+  it 'should send all writes/reads queries to master when you have a non replicated model' do
     OctopusHelper.using_environment :production_replicated do
-      u = User.create!(:name => "Replicated")
-      User.count.should == 1
-      User.find(u.id).should == u
+      u = User.create!(:name => 'Replicated')
+      expect(User.count).to eq(1)
+      expect(User.find(u.id)).to eq(u)
     end
   end
 
-  it "should send all writes queries to master" do
+  it 'should send all writes queries to master' do
     OctopusHelper.using_environment :production_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.find_by_name("Slave Cat").should be_nil
-      Client.create!(:name => "Slave Client")
-      Client.find_by_name("Slave Client").should_not be_nil
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.find_by_name('Slave Cat')).to be_nil
+      Client.create!(:name => 'Slave Client')
+      expect(Client.find_by_name('Slave Client')).not_to be_nil
     end
   end
 
-  it "should allow to create multiple models on the master" do
+  it 'should allow to create multiple models on the master' do
     OctopusHelper.using_environment :production_replicated do
-      Cat.create!([{:name => "Slave Cat 1"}, {:name => "Slave Cat 2"}])
-      Cat.find_by_name("Slave Cat 1").should be_nil
-      Cat.find_by_name("Slave Cat 2").should be_nil
+      Cat.create!([{ :name => 'Slave Cat 1' }, { :name => 'Slave Cat 2' }])
+      expect(Cat.find_by_name('Slave Cat 1')).to be_nil
+      expect(Cat.find_by_name('Slave Cat 2')).to be_nil
     end
   end
 
-  describe "When enabling the query cache" do
-    include_context "with query cache enabled"
+  context 'when updating model' do
+    it 'should send writes to master' do
+      OctopusHelper.using_environment :replicated_with_one_slave do
+        Cat.using(:slave1).create!(:name => 'Cat')
+        cat = Cat.find_by_name('Cat')
+        cat.name = 'New name'
+
+        expect(master_connection).to receive(:update).and_call_original
 
-    it "should do the queries with cache" do
-      OctopusHelper.using_environment :replicated_with_one_slave  do
-        cat1 = Cat.using(:master).create!(:name => "Master Cat 1")
-        cat2 = Cat.using(:master).create!(:name => "Master Cat 2")
-        Cat.using(:master).find(cat1.id).should eq(cat1)
-        Cat.using(:master).find(cat1.id).should eq(cat1)
-        Cat.using(:master).find(cat1.id).should eq(cat1)
+        cat.save!
+      end
+    end
+  end
 
-        cat3 = Cat.using(:slave1).create!(:name => "Slave Cat 3")
-        cat4 = Cat.using(:slave1).create!(:name => "Slave Cat 4")
-        Cat.find(cat3.id).id.should eq(cat3.id)
-        Cat.find(cat3.id).id.should eq(cat3.id)
-        Cat.find(cat3.id).id.should eq(cat3.id)
+  context 'when querying' do
+    it 'Reads from slave' do
+      OctopusHelper.using_environment :replicated_with_one_slave do
+        expect(master_connection).not_to receive(:select)
 
-        counter.query_count.should eq(16)
+        Cat.where(:name => 'Catman2').first
       end
     end
   end
 
-  it "should allow #using syntax to send queries to master" do
-    Cat.create!(:name => "Master Cat")
+  context 'When record is read from slave' do
+    it 'Should write associations to master' do
+      OctopusHelper.using_environment :replicated_with_one_slave do
+        client = Client.using(:slave1).create!(:name => 'Client')
+
+        client = Client.find(client.id)
+
+        expect(master_connection).to receive(:insert).and_call_original
+
+        client.items.create!(:name => 'Item')
+      end
+    end
+  end
+
+
+  describe 'When enabling the query cache' do
+    include_context 'with query cache enabled' do
+      it 'should do the queries with cache' do
+        OctopusHelper.using_environment :replicated_with_one_slave do
+          cat1 = Cat.using(:master).create!(:name => 'Master Cat 1')
+          _ct2 = Cat.using(:master).create!(:name => 'Master Cat 2')
+          expect(Cat.using(:master).find(cat1.id)).to eq(cat1)
+          expect(Cat.using(:master).find(cat1.id)).to eq(cat1)
+          expect(Cat.using(:master).find(cat1.id)).to eq(cat1)
+
+          cat3 = Cat.using(:slave1).create!(:name => 'Slave Cat 3')
+          _ct4 = Cat.using(:slave1).create!(:name => 'Slave Cat 4')
+          expect(Cat.find(cat3.id).id).to eq(cat3.id)
+          expect(Cat.find(cat3.id).id).to eq(cat3.id)
+          expect(Cat.find(cat3.id).id).to eq(cat3.id)
+
+          # Rails 5.1 count the cached queries as regular queries.
+          # TODO: How we can verify if the queries are using cache on Rails 5.1? - @thiagopradi
+          expected_records = Octopus.rails51? || Octopus.rails52? ? 19 : 14
+
+          expect(counter.query_count).to eq(expected_records)
+        end
+      end
+    end
+  end
+
+  describe 'When enabling the query cache with slave unavailable' do
+    it "should not raise can't connect error" do
+      OctopusHelper.using_environment :replicated_with_one_slave_unavailable do
+        expect {
+          ActiveRecord::Base.connection.enable_query_cache!
+        }.to_not raise_error
+      end
+    end
+  end
+
+  it 'should allow #using syntax to send queries to master' do
+    Cat.create!(:name => 'Master Cat')
 
     OctopusHelper.using_environment :production_fully_replicated do
-      Cat.using(:master).find_by_name("Master Cat").should_not be_nil
+      expect(Cat.using(:master).find_by_name('Master Cat')).not_to be_nil
     end
   end
 
-  it "should send the count query to a slave" do
+  it 'should send the count query to a slave' do
     OctopusHelper.using_environment :production_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.count.should == 0
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.count).to eq(0)
     end
   end
 
-  def active_support_subscribed(callback, *args, &block)
+  def active_support_subscribed(callback, *args, &_block)
     subscriber = ActiveSupport::Notifications.subscribe(*args, &callback)
     yield
   ensure
@@ -71,51 +140,57 @@ describe "when the database is replicated" do
   end
 end
 
-
-describe "when the database is replicated and the entire application is replicated" do
+describe 'when the database is replicated and the entire application is replicated' do
   before(:each) do
-    Octopus.stub(:env).and_return("production_fully_replicated")
-    OctopusHelper.clean_connection_proxy()
+    allow(Octopus).to receive(:env).and_return('production_fully_replicated')
+    OctopusHelper.clean_connection_proxy
   end
 
-  it "should send all writes queries to master" do
+  it 'should send all writes queries to master' do
     OctopusHelper.using_environment :production_fully_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.find_by_name("Slave Cat").should be_nil
-      Client.create!(:name => "Slave Client")
-      Client.find_by_name("Slave Client").should be_nil
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.find_by_name('Slave Cat')).to be_nil
+      Client.create!(:name => 'Slave Client')
+      expect(Client.find_by_name('Slave Client')).to be_nil
     end
   end
 
-  it "should send all writes queries to master" do
+  it 'should send all writes queries to master' do
     OctopusHelper.using_environment :production_fully_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.find_by_name("Slave Cat").should be_nil
-      Client.create!(:name => "Slave Client")
-      Client.find_by_name("Slave Client").should be_nil
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.find_by_name('Slave Cat')).to be_nil
+      Client.create!(:name => 'Slave Client')
+      expect(Client.find_by_name('Slave Client')).to be_nil
     end
   end
 
-  it "should work with validate_uniquess_of" do
-    Keyboard.create!(:name => "thiago")
+  it 'should work with validate_uniquess_of' do
+    Keyboard.create!(:name => 'thiago')
 
     OctopusHelper.using_environment :production_fully_replicated do
-      k = Keyboard.new(:name => "thiago")
-      k.save.should be_false
-      k.errors.full_messages.should == ["Name has already been taken"]
+      k = Keyboard.new(:name => 'thiago')
+      expect(k.save).to be false
+      expect(k.errors.full_messages).to eq(['Name has already been taken'])
     end
   end
 
-  it "should reset current shard if slave throws an exception" do
+  it 'should reset current shard if slave throws an exception' do
     OctopusHelper.using_environment :production_fully_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.connection.current_shard.should eql(:master)
-      begin
-        Cat.where(:rubbish => true)
-      rescue
-      end
-      Cat.connection.current_shard.should eql(:master)
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.connection.current_shard).to eql(:master)
+      Cat.where(:rubbish => true)
+      expect(Cat.connection.current_shard).to eql(:master)
     end
   end
-end
 
+  it 'should reset current shard if slave throws an exception with custom master' do
+    OctopusHelper.using_environment :production_fully_replicated do
+      Octopus.config[:master_shard] = :slave2
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.connection.current_shard).to eql(:slave2)
+      Cat.where(:rubbish => true)
+      expect(Cat.connection.current_shard).to eql(:slave2)
+      Octopus.config[:master_shard] = nil
+    end
+  end
+end

data/spec/octopus/scope_proxy_spec.rb

@@ -1,17 +1,97 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Octopus::ScopeProxy do
-  it "should allow nested queries" do
-    @user1 = User.using(:brazil).create!(:name => "Thiago P", :number => 3)
-    @user2 = User.using(:brazil).create!(:name => "Thiago", :number => 1)
-    @user3 = User.using(:brazil).create!(:name => "Thiago", :number => 2)
-
-    User.using(:brazil).where(:name => "Thiago").where(:number => 4).order(:number).all.should == []
-    User.using(:brazil).where(:name => "Thiago").using(:canada).where(:number => 2).using(:brazil).order(:number).all.should == [@user3]
-    User.using(:brazil).where(:name => "Thiago").using(:canada).where(:number => 4).using(:brazil).order(:number).all.should == []
+  it 'should allow nested queries' do
+    @user1 = User.using(:brazil).create!(:name => 'Thiago P', :number => 3)
+    @user2 = User.using(:brazil).create!(:name => 'Thiago', :number => 1)
+    @user3 = User.using(:brazil).create!(:name => 'Thiago', :number => 2)
+
+    expect(User.using(:brazil).where(:name => 'Thiago').where(:number => 4).order(:number).all).to eq([])
+    expect(User.using(:brazil).where(:name => 'Thiago').using(:canada).where(:number => 2).using(:brazil).order(:number).all).to eq([@user3])
+    expect(User.using(:brazil).where(:name => 'Thiago').using(:canada).where(:number => 4).using(:brazil).order(:number).all).to eq([])
+  end
+
+  context 'When array-like-selecting an item in a group' do
+    before(:each) do
+      User.using(:brazil).create!(:name => 'Evan', :number => 1)
+      User.using(:brazil).create!(:name => 'Evan', :number => 2)
+      User.using(:brazil).create!(:name => 'Evan', :number => 3)
+      @evans = User.using(:brazil).where(:name => 'Evan')
+    end
+
+    it 'allows a block to select an item' do
+      expect(@evans.select { |u| u.number == 2 }.first.number).to eq(2)
+    end
+  end
+
+  context 'When selecting a field within a scope' do
+    before(:each) do
+      User.using(:brazil).create!(:name => 'Evan', :number => 4)
+      @evan = User.using(:brazil).where(:name => 'Evan')
+    end
+
+    it 'allows single field selection' do
+      expect(@evan.select('name').first.name).to eq('Evan')
+    end
+
+    it 'allows selection by array' do
+      expect(@evan.select(['name']).first.name).to eq('Evan')
+    end
+
+    it 'allows multiple selection by string' do
+      expect(@evan.select('id, name').first.id).to be_a(Fixnum)
+    end
+
+    it 'allows multiple selection by array' do
+      expect(@evan.select(%w(id name)).first.id).to be_a(Fixnum)
+    end
+
+    it 'allows multiple selection by symbol' do
+      expect(@evan.select(:id, :name).first.id).to be_a(Fixnum)
+    end
+
+    it 'allows multiple selection by string and symbol' do
+      expect(@evan.select(:id, 'name').first.id).to be_a(Fixnum)
+    end
   end
 
   it "should raise a exception when trying to send a query to a shard that don't exists" do
-    lambda { User.using(:dont_exists).all }.should raise_exception("Nonexistent Shard Name: dont_exists")
+    expect { User.using(:dont_exists).all }.to raise_exception('Nonexistent Shard Name: dont_exists')
+  end
+
+  context "dup / clone" do
+    before(:each) do
+      User.using(:brazil).create!(:name => 'Thiago', :number => 1)
+    end
+
+    it "should change it's object id" do
+      user = User.using(:brazil).where(id: 1)
+      dupped_object = user.dup
+      cloned_object = user.clone
+
+      expect(dupped_object.object_id).not_to eq(user.object_id)
+      expect(cloned_object.object_id).not_to eq(user.object_id)
+    end
+  end
+
+  context 'When iterated with Enumerable methods' do
+    before(:each) do
+      User.using(:brazil).create!(:name => 'Evan', :number => 1)
+      User.using(:brazil).create!(:name => 'Evan', :number => 2)
+      User.using(:brazil).create!(:name => 'Evan', :number => 3)
+      @evans = User.using(:brazil).where(:name => 'Evan')
+    end
+
+    it 'allows each method' do
+      expect(@evans.each.count).to eq(3)
+    end
+
+    it 'allows each_with_index method' do
+      expect(@evans.each_with_index.to_a.flatten.count).to eq(6)
+    end
+
+    it 'allows map method' do
+      expect(@evans.map(&:number)).to eq([1, 2, 3])
+    end
   end
 end

data/spec/octopus/sharded_replicated_slave_grouped_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'when the database is both sharded and replicated' do
+
+  it 'should pick the shard based on current_shard when you have a sharded model' do
+
+    OctopusHelper.using_environment :sharded_replicated_slave_grouped do
+      Octopus.using(:russia) do
+        Cat.create!(:name => 'Thiago1')
+        Cat.create!(:name => 'Thiago2')
+      end
+
+      # We must stub here to make it effective (not in the `before(:each)` block)
+      allow(Octopus).to receive(:env).and_return('sharded_replicated_slave_grouped')
+
+      expect(Cat.using(:russia).count).to eq(2)
+      # It distributes queries between two slaves in the slave group
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves1).count).to eq(0)
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves1).count).to eq(2)
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves1).count).to eq(0)
+      # It distributes queries between two slaves in the slave group
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves2).count).to eq(2)
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves2).count).to eq(0)
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves2).count).to eq(2)
+
+      expect(Cat.using(:europe).count).to eq(0)
+      expect(Cat.using(:shard => :europe, :slave_group => :slaves1)
+        .count).to eq(0)
+      expect(Cat.using(:shard => :europe, :slave_group => :slaves2)
+        .count).to eq(2)
+    end
+  end
+
+  it 'should make queries to master when slave groups are configured for the shard but not selected' do
+    OctopusHelper.using_environment :sharded_replicated_slave_grouped do
+      Octopus.using(:europe) do
+        # All the queries go to :master(`octopus_shard_1`)
+
+        Cat.create!(:name => 'Thiago1')
+        Cat.create!(:name => 'Thiago2')
+
+        # In `database.yml` and `shards.yml`, we have configured 1 master and 6 slaves for `sharded_replicated_slave_grouped`
+        # So we can ensure Octopus is not distributing queries between them
+        # by asserting 1 + 6 = 7 queries go to :master(`octopus_shard_1`)
+        expect(Cat.count).to eq(2)
+        expect(Cat.count).to eq(2)
+        expect(Cat.count).to eq(2)
+        expect(Cat.count).to eq(2)
+        expect(Cat.count).to eq(2)
+        expect(Cat.count).to eq(2)
+        expect(Cat.count).to eq(2)
+      end
+    end
+  end
+end