ar-octopus-master 0.9.2.master → 0.9.2.1

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

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+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')
+      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
+    OctopusHelper.using_environment :production_replicated do
+      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
+    OctopusHelper.using_environment :production_replicated do
+      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
+
+  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
+
+        cat.save!
+      end
+    end
+  end
+
+  context 'when querying' do
+    it 'Reads from slave' do
+      OctopusHelper.using_environment :replicated_with_one_slave do
+        expect(master_connection).not_to receive(:select)
+
+        Cat.where(:name => 'Catman2').first
+      end
+    end
+  end
+
+  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? ? 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
+      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
+    OctopusHelper.using_environment :production_replicated do
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.count).to eq(0)
+    end
+  end
+
+  def active_support_subscribed(callback, *args, &_block)
+    subscriber = ActiveSupport::Notifications.subscribe(*args, &callback)
+    yield
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+end
+
+describe 'when the database is replicated and the entire application is replicated' do
+  before(:each) do
+    allow(Octopus).to receive(:env).and_return('production_fully_replicated')
+    OctopusHelper.clean_connection_proxy
+  end
+
+  it 'should send all writes queries to master' do
+    OctopusHelper.using_environment :production_fully_replicated do
+      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
+    OctopusHelper.using_environment :production_fully_replicated do
+      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')
+
+    OctopusHelper.using_environment :production_fully_replicated do
+      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
+    OctopusHelper.using_environment :production_fully_replicated do
+      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
+
+  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

@@ -0,0 +1,97 @@
+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)
+
+    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
+    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

data/spec/octopus/sharded_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'when the database is not entire sharded' do
+  before(:each) do
+    allow(Octopus).to receive(:env).and_return('not_entire_sharded')
+    OctopusHelper.clean_connection_proxy
+  end
+
+  it 'should not send all queries to the specified slave' do
+    skip
+    # User.create!(:name => "Thiago")
+    #
+    # using_environment :not_entire_sharded do
+    #   Octopus.using(:russia) do
+    #     User.create!(:name => "Thiago")
+    #   end
+    # end
+    #
+    # User.count.should == 2
+  end
+
+  it 'should pick the shard based on current_shard when you have a sharded model' do
+    Cat.create!(:name => 'Thiago')
+
+    OctopusHelper.using_environment :not_entire_sharded do
+      Octopus.using(:russia) do
+        Cat.create!(:name => 'Thiago')
+      end
+    end
+
+    expect(Cat.count).to eq(1)
+  end
+end