switchman 1.5.0 → 1.5.3

data/spec/lib/active_record/query_cache_spec.rb

@@ -1,346 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe QueryCache do
-      include RSpecHelper
-
-      # call with two blocks. the first will run on a new thread, pausing at
-      # the site of a "cc.call". the second will run on the original thread
-      # while the first is paused. the first will then finish.
-      def threaded(blk1, blk2)
-        mutex = Mutex.new
-        ready1 = ConditionVariable.new
-        ready2 = ConditionVariable.new
-
-        cc = lambda do
-          mutex.synchronize do
-            ready1.signal
-            ready2.wait(mutex)
-          end
-        end
-
-        thread = Thread.new do
-          blk1.call(cc)
-          ::ActiveRecord::Base.connection_pool.release_connection
-        end
-
-        mutex.synchronize do
-          ready1.wait(mutex)
-          blk2.call
-          ready2.signal
-        end
-
-        thread.join
-      end
-
-      before do
-        User.connection.clear_query_cache
-        @orig_enabled = User.connection.query_cache_enabled
-        @orig_cache = User.connection.query_cache.dup
-      end
-
-      after do
-        User.connection.query_cache_enabled = @enabled
-        User.connection.instance_variable_set(:@query_cache, @orig_cache)
-      end
-
-      it "should isolate queries to multiple shards on the same server" do
-        @shard1.activate do
-          User.create!
-          User.create!
-        end
-        @shard3.activate do
-          User.create!
-        end
-        expect(@shard1.activate { User.all.to_a }).not_to eq @shard3.activate { User.all.to_a }
-      end
-
-      describe "query_cache_enabled" do
-        it "should be shared across shards on the same server" do
-          @shard1.activate{ User.connection.query_cache_enabled = true }
-          @shard3.activate{ User.connection.query_cache_enabled = false }
-          @shard1.activate{ expect(User.connection.query_cache_enabled).to eq false }
-        end
-
-        it "should be shared across servers" do
-          @shard1.activate{ User.connection.query_cache_enabled = true }
-          @shard2.activate{ User.connection.query_cache_enabled = false }
-          @shard1.activate{ expect(User.connection.query_cache_enabled).to eq false }
-        end
-
-        it "should be distinct across threads" do
-          User.connection.query_cache_enabled = true
-          threaded(
-            lambda{ |cc| User.connection.query_cache_enabled = false; cc.call },
-            lambda{ expect(User.connection.query_cache_enabled).to eq true })
-        end
-      end
-
-      describe "enable_query_cache!" do
-        it "should only enable for the current thread" do
-          User.connection.query_cache_enabled = false
-          threaded(
-            lambda{ |cc|
-              User.connection.query_cache_enabled = false
-              User.connection.enable_query_cache!
-              expect(User.connection.query_cache_enabled).to eq true
-              cc.call
-            },
-            lambda{ expect(User.connection.query_cache_enabled).to eq false })
-        end
-      end
-
-      describe "disable_query_cache!" do
-        it "should only enable for the current thread" do
-          User.connection.query_cache_enabled = true
-          threaded(
-            lambda{ |cc|
-              User.connection.query_cache_enabled = true
-              User.connection.disable_query_cache!
-              expect(User.connection.query_cache_enabled).to eq false
-              cc.call
-            },
-            lambda{ expect(User.connection.query_cache_enabled).to eq true })
-        end
-      end
-
-      describe "cache" do
-        it "should only enable for the current thread" do
-          # check that query_cache_enabled stays false on this thread while
-          # another thread is in a cache{} block
-          User.connection.disable_query_cache!
-          threaded(
-            lambda{ |cc| User.connection.cache{ cc.call } },
-            lambda{ expect(User.connection.query_cache_enabled).to eq false })
-        end
-
-        it "should only enable for the duration of the block" do
-          User.connection.disable_query_cache!
-          User.connection.cache do
-            expect(User.connection.query_cache_enabled).to eq true
-          end
-          expect(User.connection.query_cache_enabled).to eq false
-        end
-
-        it "should clear query cache if disabling query cache after block" do
-          User.connection.disable_query_cache!
-          User.connection.cache do
-            User.connection.query_cache[:key][:binds] = :value
-          end
-          expect(User.connection.query_cache[:key][:binds]).to be_nil
-        end
-
-        it "should not clear query cache if the cache was already enabled" do
-          User.connection.enable_query_cache!
-          User.connection.cache do
-            User.connection.query_cache[:key][:binds] = :value
-          end
-          expect(User.connection.query_cache[:key][:binds]).to eq :value
-        end
-      end
-
-      describe "uncached" do
-        it "should only disable for the current thread" do
-          # check that query_cache_enabled stays true on this thread while
-          # another thread is in an uncached{} block
-          User.connection.enable_query_cache!
-          threaded(
-            lambda{ |cc| User.connection.uncached{ cc.call } },
-            lambda{ expect(User.connection.query_cache_enabled).to eq true })
-        end
-
-        it "should only disable for the duration of the block" do
-          User.connection.enable_query_cache!
-          User.connection.uncached do
-            expect(User.connection.query_cache_enabled).to eq false
-          end
-          expect(User.connection.query_cache_enabled).to eq true
-        end
-
-        it "should not clear query cache" do
-          User.connection.query_cache[:key][:binds] = :value
-          User.connection.uncached{}
-          expect(User.connection.query_cache[:key][:binds]).to eq :value
-        end
-      end
-
-      describe "select_all" do
-        it "should cache when query cache enabled" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          expect(User.connection.query_cache).not_to be_empty
-        end
-
-        it "should not cache when query cache disabled" do
-          User.connection.disable_query_cache!
-          User.all.to_a
-          expect(User.connection.query_cache).to be_empty
-        end
-
-        it "should not cache when query cache disabled but other thread's enabled" do
-          User.connection.disable_query_cache!
-          threaded(
-            lambda{ |cc| User.connection.cache{ cc.call } },
-            lambda{ User.all.to_a; expect(User.connection.query_cache).to be_empty })
-        end
-
-        it "should not cache when query is locked" do
-          User.connection.enable_query_cache!
-          User.lock.to_a
-          expect(User.connection.query_cache).to be_empty
-        end
-      end
-
-      describe "insert" do
-        it "should clear thread's query cache if enabled" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          User.create!
-          expect(User.connection.query_cache).to be_empty
-        end
-
-        it "should not clear thread's query cache if disabled" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          User.connection.disable_query_cache!
-          User.create!
-          expect(User.connection.query_cache).not_to be_empty
-        end
-
-        it "should not clear thread's query cache if disabled but other thread's enabled" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          User.connection.disable_query_cache!
-          threaded(
-            lambda{ |cc| User.create!; cc.call },
-            lambda{ expect(User.connection.query_cache).not_to be_empty })
-        end
-
-        it "should not clear other thread's query cache" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          User.connection.disable_query_cache!
-          threaded(
-            lambda{ |cc| User.create!; cc.call },
-            lambda{ expect(User.connection.query_cache).not_to be_empty })
-        end
-      end
-
-      describe "update" do
-        before do
-          User.create!
-        end
-
-        it "should clear thread's query cache if enabled" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          User.update_all(updated_at: Time.now)
-          expect(User.connection.query_cache).to be_empty
-        end
-
-        it "should not clear thread's query cache if disabled" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          User.connection.disable_query_cache!
-          User.update_all(updated_at: Time.now)
-          expect(User.connection.query_cache).not_to be_empty
-        end
-
-        context "non-transactional" do
-          unless ::ActiveRecord::Base.connection_pool.spec.config[:adapter_name] == 'PostgreSQL'
-            self.use_transactional_fixtures = false
-
-            after do
-              User.delete_all
-            end
-          end
-
-          it "should not clear thread's query cache if disabled but other thread's enabled" do
-            User.connection.enable_query_cache!
-            User.all.to_a
-            User.connection.disable_query_cache!
-            threaded(
-              lambda{ |cc| User.update_all(updated_at: Time.now); cc.call },
-              lambda{ expect(User.connection.query_cache).not_to be_empty })
-          end
-
-          it "should not clear other thread's query cache" do
-            User.connection.enable_query_cache!
-            User.all.to_a
-            User.connection.disable_query_cache!
-            threaded(
-              lambda{ |cc| User.update_all(updated_at: Time.now); cc.call },
-              lambda{ expect(User.connection.query_cache).not_to be_empty })
-          end
-        end
-      end
-
-      describe "delete" do
-        before do
-          User.create!
-        end
-
-        it "should clear thread's query cache if enabled" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          User.delete_all
-          expect(User.connection.query_cache).to be_empty
-        end
-
-        it "should not clear thread's query cache if disabled" do
-          User.connection.enable_query_cache!
-          User.all.to_a
-          User.connection.disable_query_cache!
-          User.delete_all
-          expect(User.connection.query_cache).not_to be_empty
-        end
-
-        context "non-transactional" do
-          unless ::ActiveRecord::Base.connection_pool.spec.config[:adapter_name] == 'PostgreSQL'
-            self.use_transactional_fixtures = false
-
-            after do
-              User.delete_all
-            end
-          end
-
-          it "should not clear thread's query cache if disabled but other thread's enabled" do
-            User.connection.enable_query_cache!
-            User.all.to_a
-            User.connection.disable_query_cache!
-            threaded(
-              lambda{ |cc| User.delete_all; cc.call },
-              lambda{ expect(User.connection.query_cache).not_to be_empty })
-          end
-
-          it "should not clear other thread's query cache" do
-            User.connection.enable_query_cache!
-            User.all.to_a
-            User.connection.disable_query_cache!
-            threaded(
-              lambda{ |cc| User.delete_all; cc.call },
-              lambda{ expect(User.connection.query_cache).not_to be_empty })
-          end
-
-          it "should clear cache for all connections" do
-            u = User.create!(name: 'a')
-            User.connection.cache do
-              expect(u.reload.name).to eq 'a'
-              ::Shackles.activate(:slave) do
-                expect(u.reload.name).to eq 'a'
-              end
-              expect(u.reload.name).to eq 'a'
-              u.name = 'b'
-              u.save!
-              expect(u.reload.name).to eq 'b'
-              ::Shackles.activate(:slave) do
-                expect(u.reload.name).to eq 'b'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_record/query_methods_spec.rb

@@ -1,166 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe QueryMethods do
-      include RSpecHelper
-
-      before do
-        @user1 = User.create!
-        @appendage1 = @user1.appendages.create!
-        @user2 = @shard1.activate { User.create! }
-        @appendage2 = @user2.appendages.create!
-        @user3 = @shard2.activate { User.create! }
-        @appendage3 = @user3.appendages.create!
-      end
-
-      describe "#primary_shard" do
-        it "should be the shard if it's a shard" do
-          expect(User.shard(Shard.default).primary_shard).to eq Shard.default
-          expect(User.shard(@shard1).primary_shard).to eq @shard1
-        end
-
-        it "should be the first shard of an array of shards" do
-          expect(User.shard([Shard.default, @shard1]).primary_shard).to eq Shard.default
-          expect(User.shard([@shard1, Shard.default]).primary_shard).to eq @shard1
-        end
-
-        it "should be the object's shard if it's a model" do
-          expect(User.shard(@user1).primary_shard).to eq Shard.default
-          expect(User.shard(@user2).primary_shard).to eq @shard1
-        end
-
-        it "should be the default shard if it's a scope of Shard" do
-          expect(User.shard(Shard.all).primary_shard).to eq Shard.default
-          @shard1.activate do
-            expect(User.shard(Shard.all).primary_shard).to eq Shard.default
-          end
-        end
-      end
-
-      it "should default to the current shard" do
-        relation = User.all
-        expect(relation.shard_value).to eq Shard.default
-        expect(relation.shard_source_value).to eq :implicit
-
-        @shard1.activate do
-          expect(relation.shard_value).to eq Shard.default
-
-          relation = User.all
-          expect(relation.shard_value).to eq @shard1
-          expect(relation.shard_source_value).to eq :implicit
-        end
-        expect(relation.shard_value).to eq @shard1
-      end
-
-      describe "with primary key conditions" do
-        it "should be changeable, and change conditions when it is changed" do
-          relation = User.where(:id => @user1).shard(@shard1)
-          expect(relation.shard_value).to eq @shard1
-          expect(relation.shard_source_value).to eq :explicit
-          expect(where_value(predicates(relation).first.right)).to eq @user1.global_id
-        end
-
-        it "should infer the shard from a single argument" do
-          relation = User.where(:id => @user2)
-          # execute on @shard1, with id local to that shard
-          expect(relation.shard_value).to eq @shard1
-          expect(where_value(predicates(relation).first.right)).to eq @user2.local_id
-        end
-
-        it "should infer the shard from multiple arguments" do
-          relation = User.where(:id => [@user2, @user2])
-          # execute on @shard1, with id local to that shard
-          expect(relation.shard_value).to eq @shard1
-          expect(where_value(predicates(relation).first.right)).to eq [@user2.local_id, @user2.local_id]
-        end
-
-        it "should infer the correct shard from an array of 1" do
-          relation = User.where(:id => [@user2])
-          # execute on @shard1, with id local to that shard
-          expect(relation.shard_value).to eq @shard1
-          expect(where_value(Array(predicates(relation).first.right))).to eq [@user2.local_id]
-        end
-
-        it "should do nothing when it's an array of 0" do
-          relation = User.where(:id => [])
-          # execute on @shard1, with id local to that shard
-          expect(relation.shard_value).to eq Shard.default
-          expect(where_value(predicates(relation).first.right)).to eq []
-        end
-
-        it "should order the shards preferring the shard it already had as primary" do
-          relation = User.where(:id => [@user1, @user2])
-          expect(relation.shard_value).to eq [Shard.default, @shard1]
-          expect(where_value(predicates(relation).first.right)).to eq [@user1.local_id, @user2.global_id]
-
-          @shard1.activate do
-            relation = User.where(:id => [@user1, @user2])
-            expect(relation.shard_value).to eq [@shard1, Shard.default]
-            expect(where_value(predicates(relation).first.right)).to eq [@user1.global_id, @user2.local_id]
-          end
-        end
-      end
-
-      describe "with foreign key conditions" do
-        it "should be changeable, and change conditions when it is changed" do
-          relation = Appendage.where(:user_id => @user1)
-          expect(relation.shard_value).to eq Shard.default
-          expect(relation.shard_source_value).to eq :implicit
-          expect(where_value(predicates(relation).first.right)).to eq @user1.local_id
-
-          relation = relation.shard(@shard1)
-          expect(relation.shard_value).to eq @shard1
-          expect(relation.shard_source_value).to eq :explicit
-          expect(where_value(predicates(relation).first.right)).to eq @user1.global_id
-        end
-
-        it "should translate ids based on current shard" do
-          relation = Appendage.where(:user_id => [@user1, @user2])
-          expect(where_value(predicates(relation).first.right)).to eq [@user1.local_id, @user2.global_id]
-
-          @shard1.activate do
-            relation = Appendage.where(:user_id => [@user1, @user2])
-            expect(where_value(predicates(relation).first.right)).to eq [@user1.global_id, @user2.local_id]
-          end
-        end
-
-        it "should translate ids in joins" do
-          relation = User.joins(:appendage).where(appendages: { user_id: [@user1, @user2]})
-          expect(where_value(predicates(relation).first.right)).to eq [@user1.local_id, @user2.global_id]
-        end
-
-        it "should translate ids according to the current shard of the foreign type" do
-          @shard1.activate(:mirror_universe) do
-            mirror_user = MirrorUser.create!
-            relation = User.where(mirror_user_id: mirror_user)
-            expect(where_value(predicates(relation).first.right)).to eq mirror_user.global_id
-          end
-        end
-      end
-
-      describe "with table aliases" do
-        it "should properly construct the query (at least in Rails 4)" do
-          child = @user1.children.create!
-          grandchild = child.children.create!
-          expect(child.reload.parent).to eq @user1
-
-          relation = @user1.association(:grandchildren).scope
-
-          attribute = predicates(relation).first.left
-          expect(attribute.name.to_s).to eq 'parent_id'
-          unless ::Rails.version >= '5'
-            # apparently rails 5 doesn't use table aliases here anymore
-            expect(attribute.relation.class).to eq ::Arel::Nodes::TableAlias
-
-            rel, column = relation.send(:relation_and_column, attribute)
-            expect(relation.send(:sharded_primary_key?, rel, column)).to eq false
-            expect(relation.send(:sharded_foreign_key?, rel, column)).to eq true
-          end
-
-          expect(@user1.grandchildren).to eq [grandchild]
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_record/relation_spec.rb

@@ -1,56 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe Relation do
-      include RSpecHelper
-
-      before do
-        @user1 = User.create!(:name => 'user1')
-        @user2 = @shard1.activate { User.create!(:name => 'user2') }
-      end
-
-      describe "#exec_queries" do
-        it "should activate the correct shard for the query" do
-          expect(User.shard(@shard1).where(:id => @user2.local_id).first).to eq @user2
-        end
-
-        it "should activate multiple shards if necessary" do
-          expect(User.where(:id => [@user1.id, @user2.id]).sort_by(&:id)).to eq [@user1, @user2].sort_by(&:id)
-        end
-      end
-
-      describe "#update_all" do
-        it "should activate the correct shard for the query" do
-          User.shard(@shard1).where(:id => @user2.local_id).update_all(:name => 'a')
-          expect(@user1.reload.name).to eq 'user1'
-          expect(@user2.reload.name).to eq 'a'
-        end
-
-        it "should activate multiple shards if necessary" do
-          expect(User.where(:id => [@user1.id, @user2.id]).update_all(:name => 'a')).to eq 2
-          expect(@user1.reload.name).to eq 'a'
-          expect(@user2.reload.name).to eq 'a'
-        end
-      end
-
-      describe "#new" do
-        it "should infer the scope's shard" do
-          scope = @shard1.activate { User.where(id: 1) }
-          u = scope.new
-          expect(u.shard).to eq @shard1
-          expect(u.local_id).to eq 1
-        end
-      end
-
-      describe "#clone" do
-        it "sets the shard_value that was previously nil" do
-          scope = User.all
-          scope.shard_value = nil
-          scope = scope.clone
-          expect(scope.shard_value).to eq Shard.current
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_record/spawn_methods_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe SpawnMethods do
-      include RSpecHelper
-
-      describe "#merge" do
-        it "should merge shard_value for multiple explicits" do
-          result = User.shard([@shard1, @shard2]).merge(User.shard([Shard.default, @shard1]))
-          expect(result.shard_value).to eq @shard1
-          expect(result.shard_source_value).to eq :explicit
-        end
-
-        it "should merge shard_value relations for multiple explicits" do
-          result = User.shard(Shard.where("id IN (?)", [@shard1, @shard2])).merge(User.shard(Shard.where(id: [Shard.default, @shard1])))
-          expect(::ActiveRecord::Relation === result.shard_value).to eq true
-          expect(result.shard_value.to_a).to eq [@shard1]
-          expect(result.shard_source_value).to eq :explicit
-        end
-
-        it "should ignore implicit shard value lhs" do
-          scope = User.all
-          result = scope.merge(User.shard(@shard1))
-          expect(result.shard_value).to eq @shard1
-          expect(result.shard_source_value).to eq :explicit
-        end
-
-        it "should ignore implicit shard value rhs" do
-          result = User.shard(@shard1).merge(User.all)
-          expect(result.shard_value).to eq @shard1
-          expect(result.shard_source_value).to eq :explicit
-        end
-
-        it "should take lhs shard_value for double implicit" do
-          scope1 = @shard2.activate { User.all }
-          result = scope1.merge(User.all)
-          expect(result.shard_value).to eq @shard2
-          expect(result.shard_source_value).to eq :implicit
-        end
-      end
-    end
-  end
-end

data/spec/lib/connection_pool_proxy_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  describe ConnectionPoolProxy do
-    include RSpecHelper
-
-    it "should not share connections for sqlite shards on the same db" do
-      @db = DatabaseServer.create(adapter: 'sqlite3', database: ':memory:')
-      @sqlite_shard1 = @db.shards.create!
-      @sqlite_shard2 = @db.shards.create!
-      expect(::ActiveRecord::Base.connection).not_to eq @sqlite_shard2.activate { ::ActiveRecord::Base.connection }
-      expect(@sqlite_shard1.activate { ::ActiveRecord::Base.connection }).not_to eq @sqlite_shard2.activate { ::ActiveRecord::Base.connection }
-    end
-
-    it "should forward clear_idle_connections! to each of its pools" do
-      proxy = User.connection_pool
-      @shard1.activate{ proxy.current_pool.expects(:clear_idle_connections!).once }
-      @shard2.activate{ proxy.current_pool.expects(:clear_idle_connections!).once }
-      proxy.clear_idle_connections!(Time.now)
-    end
-
-    it "should handle an array of slaves when creating a pool" do
-      spec = Object.new
-      spec.instance_variable_set(:@config, adapter: Shard.connection_pool.spec.config[:adapter], database: 'master', slave: [ { database: 'slave1' }, { database: 'slave2' }])
-      default_pool = stub(spec: spec)
-      cache = {}
-      proxy = ConnectionPoolProxy.new(:unsharded, default_pool, cache)
-      proxy.stubs(:active_shackles_environment).returns(:slave)
-      new_pool = proxy.send(:create_pool)
-      expect(new_pool.spec.config[:database]).to eq 'slave1'
-    end
-
-    it "should share schema caches between connections" do
-      conn1 = User.connection
-      conn2 = @shard2.activate { User.connection }
-      expect(conn1).to_not be conn2
-      expect(conn1.schema_cache).to be_a(Switchman::SchemaCache)
-      expect(conn1.schema_cache).to be conn2.schema_cache
-      expect(conn1.schema_cache.connection).to be conn1
-      @shard2.activate do
-        expect(conn1.schema_cache.connection).to be conn2
-      end
-    end
-  end
-end