ar-octopus-ruby-3 0.11.2

data/spec/octopus/octopus_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Octopus, :shards => [] do
+  describe '#config' do
+    it 'should load shards.yml file to start working' do
+      expect(Octopus.config).to be_kind_of(HashWithIndifferentAccess)
+    end
+
+    describe "when config file doesn't exist" do
+      before(:each) do
+        allow(Octopus).to receive(:directory).and_return('/tmp')
+        Octopus.instance_variable_set(:@config, nil)
+      end
+
+      it 'should return an empty HashWithIndifferentAccess' do
+        expect(Octopus.config).to eq(HashWithIndifferentAccess.new)
+      end
+    end
+  end
+
+  describe '#directory' do
+    it 'should return the directory that contains the shards.yml file' do
+      expect(Octopus.directory).to eq(File.expand_path(File.dirname(__FILE__) + '/../'))
+    end
+  end
+
+  describe '#env' do
+    it "should return 'production' when is outside of a rails application" do
+      expect(Octopus.env).to eq('octopus')
+    end
+  end
+
+  describe '#shards=' do
+    after(:each) do
+      Octopus.instance_variable_set(:@config, nil)
+      Octopus::Model.send(:class_variable_set, :@@connection_proxy, nil)
+    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(RuntimeError)
+
+      Octopus.setup do |config|
+        config.shards = { :crazy_shard => { :adapter => 'mysql2', :database => 'octopus_shard_5', :username => "#{ENV['MYSQL_USER'] || 'root'}", :password => ENV['MYSQL_PASSWORD'] } }
+      end
+
+      expect { User.using(:crazy_shard).create!(:name => 'Joaquim')  }.not_to raise_error
+    end
+  end
+
+  describe '#setup' do
+    it 'should have the default octopus environment as production' do
+      expect(Octopus.environments).to eq(['production'])
+    end
+
+    it 'should allow the user to configure the octopus environments' do
+      Octopus.setup do |config|
+        config.environments = [:production, :staging]
+      end
+
+      expect(Octopus.environments).to eq(%w(production staging))
+
+      Octopus.setup do |config|
+        config.environments = [:production]
+      end
+    end
+  end
+
+  describe '#enabled?' do
+    before do
+      Rails = double
+    end
+
+    after do
+      Object.send(:remove_const, :Rails)
+    end
+
+    it 'should be if octopus is configured and should hook into current environment' do
+      allow(Rails).to receive(:env).and_return('production')
+
+      expect(Octopus).to be_enabled
+    end
+
+    it 'should not be if octopus should not hook into current environment' do
+      allow(Rails).to receive(:env).and_return('staging')
+
+      expect(Octopus).not_to be_enabled
+    end
+  end
+
+  describe '#fully_replicated' do
+    before do
+      OctopusHelper.using_environment :production_replicated do
+        OctopusHelper.clean_all_shards([:slave1, :slave2, :slave3, :slave4])
+        4.times { |i| User.using(:"slave#{i + 1}").create!(:name => 'Slave User') }
+      end
+    end
+
+    it 'sends queries to slaves' do
+      OctopusHelper.using_environment :production_replicated do
+        expect(User.count).to eq(0)
+        4.times do |_i|
+          Octopus.fully_replicated do
+            expect(User.count).to eq(1)
+          end
+        end
+      end
+    end
+
+    it 'allows nesting' do
+      OctopusHelper.using_environment :production_replicated do
+        Octopus.fully_replicated do
+          expect(User.count).to eq(1)
+
+          Octopus.fully_replicated do
+            expect(User.count).to eq(1)
+          end
+
+          expect(User.count).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/octopus/proxy_spec.rb

@@ -0,0 +1,303 @@
+require 'spec_helper'
+
+describe Octopus::Proxy do
+  let(:proxy) { subject }
+
+  describe 'creating a new instance', :shards => [] do
+    it 'should initialize all shards and groups' do
+      # FIXME: Don't test implementation details
+      expect(proxy.shards).to include('canada', 'brazil', 'master', 'sqlite_shard', 'russia', 'alone_shard',
+                                                               'aug2009', 'postgresql_shard', 'aug2010', 'aug2011')
+
+      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)
+
+      expect(proxy.has_group?('history_shards')).to be true
+      expect(proxy.shards_for_group('history_shards')).to include(:aug2009, :aug2010, :aug2011)
+    end
+
+    it 'should initialize the block attribute as false' do
+      expect(proxy.block).to be_falsey
+    end
+
+    it 'should initialize replicated attribute as false' do
+      expect(proxy.replicated).to be_falsey
+    end
+
+    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("#{ENV['MYSQL_USER'] || 'root'}")
+    end
+
+    unless Octopus.rails50? || Octopus.rails51?|| Octopus.rails52? || Octopus.rails60?
+      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
+      expect(proxy.respond_to?(:primary_key)).to be true
+    end
+
+    context 'when an adapter that modifies the config' do
+      before { OctopusHelper.octopus_env = 'modify_config' }
+      after  { OctopusHelper.octopus_env = 'octopus'       }
+
+      it 'should not fail with missing adapter second time round' do
+        skip 'This test was actually failing because of a typo in the error message.'
+        Thread.current['octopus.current_shard'] = :modify_config_read
+
+        expect { Octopus::Proxy.new(Octopus.config) }.not_to raise_error
+
+        Thread.current['octopus.current_shard'] = nil
+      end
+    end
+
+    describe 'should raise error if you have duplicated shard names' do
+      before(:each) do
+        OctopusHelper.octopus_env = 'production_raise_error'
+      end
+
+      it 'should raise the error' do
+        expect { proxy }.to raise_error('You have duplicated shard names!')
+      end
+    end
+
+    describe "should initialize just the master when you don't have a shards.yml file" do
+      before(:each) do
+        OctopusHelper.octopus_env = 'crazy_environment'
+      end
+
+      it 'should initialize just the master shard' do
+        expect(proxy.shards.keys).to eq(['master'])
+      end
+
+      it 'should not initialize replication' do
+        expect(proxy.replicated).to be_nil
+      end
+    end
+  end
+
+  describe 'when you have a replicated environment' do
+    before(:each) do
+      OctopusHelper.octopus_env = 'production_replicated'
+    end
+
+    it 'should have the replicated attribute as true' do
+      expect(proxy.replicated).to be true
+    end
+
+    it 'should initialize the list of shards' do
+      expect(proxy.slaves_list).to eq(%w(slave1 slave2 slave3 slave4))
+    end
+  end
+
+  describe 'when you have a rails application' do
+    before(:each) do
+      Rails = double
+      OctopusHelper.octopus_env = 'octopus_rails'
+    end
+
+    after(:each) do
+      Object.send(:remove_const, :Rails)
+      Octopus.instance_variable_set(:@config, nil)
+      Octopus.instance_variable_set(:@rails_env, nil)
+      OctopusHelper.clean_connection_proxy
+    end
+
+    it 'should initialize correctly octopus common variables for the environments' do
+      allow(Rails).to receive(:env).and_return('staging')
+      Octopus.instance_variable_set(:@rails_env, nil)
+      Octopus.instance_variable_set(:@environments, nil)
+      Octopus.config
+
+      expect(proxy.replicated).to be true
+      expect(Octopus.environments).to eq(%w(staging production))
+    end
+
+    it 'should initialize correctly the shards for the staging environment' do
+      allow(Rails).to receive(:env).and_return('staging')
+      Octopus.instance_variable_set(:@rails_env, nil)
+      Octopus.instance_variable_set(:@environments, nil)
+      Octopus.config
+
+      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
+      allow(Rails).to receive(:env).and_return('staging')
+      Octopus.instance_variable_set(:@rails_env, nil)
+      Octopus.instance_variable_set(:@environments, nil)
+      Octopus.config
+
+      expect(proxy.shards['slave1'].spec.config).to have_key :octopus_shard
+    end
+
+    it 'should initialize correctly the shards for the production environment' do
+      allow(Rails).to receive(:env).and_return('production')
+      Octopus.instance_variable_set(:@rails_env, nil)
+      Octopus.instance_variable_set(:@environments, nil)
+      Octopus.config
+
+      expect(proxy.shards.keys.to_set).to eq(Set.new(%w(slave3 slave4 master)))
+    end
+
+    describe 'using the master connection', :shards => [:russia, :master]  do
+      before(:each) do
+        allow(Rails).to receive(:env).and_return('development')
+      end
+
+      it 'should use the master connection' do
+        user = User.create!(:name => 'Thiago')
+        user.name = 'New Thiago'
+        user.save
+        expect(User.find_by_name('New Thiago')).not_to be_nil
+      end
+
+      it 'should work when using using syntax' do
+        user = User.using(:russia).create!(:name => 'Thiago')
+
+        user.name = 'New Thiago'
+        user.save
+
+        expect(User.using(:russia).find_by_name('New Thiago')).to eq(user)
+        expect(User.find_by_name('New Thiago')).to eq(user)
+      end
+
+      it 'should work when using blocks' do
+        Octopus.using(:russia) do
+          @user = User.create!(:name => 'Thiago')
+        end
+
+        expect(User.find_by_name('Thiago')).to eq(@user)
+      end
+
+      it 'should work with associations' do
+        u = Client.create!(:name => 'Thiago')
+        i = Item.create(:name => 'Item')
+        u.items << i
+        u.save
+      end
+    end
+  end
+
+  describe 'returning the correct connection' do
+    describe 'should return the shard name' do
+      it 'when current_shard is empty' 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)
+      end
+
+      it 'when current_shard is more than one shard' do
+        proxy.current_shard = [:russia, :brazil]
+        expect(proxy.shard_name).to eq(:russia)
+      end
+    end
+
+    describe 'should return the connection based on shard_name' do
+      it 'when current_shard is empty' do
+        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.shards[:canada].connection)
+      end
+    end
+  end
+
+  describe 'saving multiple sharded objects at once' do
+    before :each do
+      @p = MmorpgPlayer.using(:alone_shard).create!(:player_name => 'Thiago')
+    end
+
+    subject { @p.save! }
+
+    context 'when the objects are created with #new and saved one at a time' do
+      before :each do
+        @p.weapons.create!(:name => 'battleaxe', :hand => 'right')
+        @p.skills.create!(:name => 'smiting', :weapon => @p.weapons[0])
+      end
+
+      it 'should save all associated objects on the correct shard' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context 'when the objects are created with #new and saved at the same time' do
+      before :each do
+        @p.weapons.new(:name => 'battleaxe', :hand => 'right')
+        @p.skills.new(:name => 'smiting', :weapon => @p.weapons[0])
+      end
+
+      it 'should save all associated objects on the correct shard' do
+        expect { subject }.to_not raise_error
+      end
+    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
+      @item_canada_conn = Item.using(:canada).new(:name => 'Canada Item').class.connection.select_connection
+    end
+
+    it 'reuses connections' do
+      expect(Item.using(:brazil).new(:name => 'Another Brazil Item').class.connection.select_connection).to eq(@item_brazil_conn)
+      expect(Item.using(:canada).new(:name => 'Another Canada Item').class.connection.select_connection).to eq(@item_canada_conn)
+    end
+
+    it 'reuses connections after clear_active_connections! is called' do
+      expect(Item.using(:brazil).new(:name => 'Another Brazil Item').class.connection.select_connection).to eq(@item_brazil_conn)
+      expect(Item.using(:canada).new(:name => 'Another Canada Item').class.connection.select_connection).to eq(@item_canada_conn)
+    end
+
+    it 'creates new connections after clear_all_connections! is called' do
+      Item.clear_all_connections!
+      expect(Item.using(:brazil).new(:name => 'Another Brazil Item').class.connection.select_connection).not_to eq(@item_brazil_conn)
+      expect(Item.using(:canada).new(:name => 'Another Canada Item').class.connection.select_connection).not_to eq(@item_canada_conn)
+    end
+
+    it 'is consistent with connected?' do
+      expect(Item.connected?).to be true
+      expect(ActiveRecord::Base.connected?).to be true
+
+      Item.clear_all_connections!
+
+      expect(Item.connected?).to be false
+      expect(ActiveRecord::Base.connected?).to be false
+    end
+  end
+end

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

@@ -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