switchman 1.5.2 → 1.5.3

data/spec/lib/active_record/connection_handler_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe ConnectionHandler do
-      include RSpecHelper
-
-      it "should use different proxies for different categories" do
-        expect(Shard.connection_pool).not_to eq User.connection_pool
-      end
-
-      it "should share underlying pools for different categories on the same shard" do
-        expect(Shard.connection_pool.current_pool).to eq User.connection_pool.current_pool
-      end
-
-      it "should insert sharding for connections established after initialization" do
-        expect(User.connection_pool).to eq ::ActiveRecord::Base.connection_pool
-        begin
-          config = { :adapter => 'sqlite3', :database => ':memory:', :something_unique_in_the_spec => true }
-          User.establish_connection(config)
-          expect(User.connection_pool).not_to eq ::ActiveRecord::Base.connection_pool
-          expect(User.connection_pool.spec.config).to eq config
-          expect(User.connection_pool).to be_is_a(ConnectionPoolProxy)
-          @shard2.activate do
-            expect(User.connection_pool.spec.config).to eq ::ActiveRecord::Base.connection_pool.spec.config
-            expect(User.connection_pool.spec.config).not_to eq config
-          end
-        ensure
-          User.remove_connection
-          expect(User.connection_pool).to eq ::ActiveRecord::Base.connection_pool
-          expect(User.connection_pool).to be_is_a(ConnectionPoolProxy)
-        end
-      end
-
-      it "should set up separate pools for different categories" do
-        expect(User.connection_pool).not_to eq MirrorUser.connection_pool
-        mu = MirrorUser.create!
-        expect(MirrorUser.find(mu.local_id)).to eq mu
-        # didn't activate the :mirror_universe category
-        @shard1.activate { expect(MirrorUser.find(mu.local_id)).to eq mu }
-        @shard1.activate(:mirror_universe) { expect(MirrorUser.where(id: mu.local_id).first).to eq nil }
-      end
-    end
-  end
-end

data/spec/lib/active_record/connection_pool_spec.rb

@@ -1,83 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe ConnectionPool do
-      it "should be able to access another shard on a db server after the 'primary' shard is gone" do
-        skip 'A "real" database"' unless Shard.default.database_server.shareable?
-        # separate connections
-        server = DatabaseServer.create(Shard.default.database_server.config)
-        s1 = server.shards.create!(:name => 'non_existent_shard') # don't actually create any schema
-        s2 = server.shards.create! # inherit's the default shard's config, which is functional
-        s1.activate do
-          expect { User.count }.to raise_error(::ActiveRecord::StatementInvalid)
-        end
-        # the config for s1 should not be the permanent default for all new
-        # connections now
-        s2.activate do
-          expect { User.count }.not_to raise_error
-        end
-      end
-
-      describe "clear_idle_connections!" do
-        before do
-          skip 'A "real" database"' unless Shard.default.database_server.shareable?
-          @server = DatabaseServer.create(Shard.default.database_server.config)
-          @shard = @server.shards.create!
-          @conn, @pool = @shard.activate{ [User.connection, User.connection_pool.current_pool] }
-        end
-
-        it "should disconnect idle connections" do
-          @pool.checkin(@conn)
-          @conn.expects(:disconnect!).once
-          @pool.clear_idle_connections!(@conn.last_query_at + 1)
-        end
-
-        it "should remove idle connections" do
-          @pool.checkin(@conn)
-          @pool.clear_idle_connections!(@conn.last_query_at + 1)
-          expect(@pool.connections).to be_empty
-          # fresh connection
-          expect(@pool.connection).to_not eq @conn
-        end
-
-        it "should not affect idle but checked out connections" do
-          @conn.expects(:disconnect!).never
-          @pool.clear_idle_connections!(@conn.last_query_at + 1)
-        end
-
-        it "should not affect checked in but recently active connections" do
-          @pool.checkin(@conn)
-          @conn.expects(:disconnect!).never
-          @pool.clear_idle_connections!(@conn.last_query_at - 1)
-        end
-      end
-
-      describe "release_connection" do
-        before do
-          skip 'A "real" database"' unless Shard.default.database_server.shareable?
-          @server = DatabaseServer.create(Shard.default.database_server.config)
-          @shard = @server.shards.create!
-          @pool = @shard.activate{ User.connection_pool.current_pool }
-          @timeout_was = @pool.spec.config[:idle_timeout]
-        end
-
-        after do
-          @pool.spec.config[:idle_timeout] = @timeout_was
-        end
-
-        it "should clear idle connections if idle timeout is configured" do
-          @pool.spec.config[:idle_timeout] = 1.minute
-          @pool.expects(:clear_idle_connections!).at_least_once
-          @pool.release_connection
-        end
-
-        it "should still work if idle timeout is not configured" do
-          @pool.spec.config[:idle_timeout] = nil
-          @pool.expects(:clear_idle_connections!).never
-          expect { @pool.release_connection }.not_to raise_exception
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_record/finder_methods_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe FinderMethods do
-      include RSpecHelper
-
-      before do
-        @user = @shard1.activate { User.create! }
-      end
-
-      describe "#find_one" do
-        it "should find with a global id" do
-          expect(User.find(@user.global_id)).to eq @user
-        end
-
-        it "should find with a global id and a current scope" do
-          User.where("id > 0").scoping do
-            # having a current scope skips the statement cache in rails 4.2
-            expect(User.find(@user.global_id)).to eq @user
-          end
-        end
-      end
-
-      describe "#find_by_attributes" do
-        it "should find with a global id" do
-          expect(User.find_by_id(@user.global_id)).to eq @user
-        end
-
-        it "should find with an array of global ids" do
-          expect(User.find_by_id([@user.global_id])).to eq @user
-        end
-      end
-
-      describe "#find_or_initialize" do
-        it "should initialize with the shard from the scope" do
-          @user.destroy
-          u = User.shard(@shard1).where(id: @user).first_or_initialize
-          expect(u).to be_new_record
-          expect(u.shard).to eq @shard1
-        end
-      end
-
-      describe "#exists?" do
-        it "should work for an out-of-shard scope" do
-          scope = @shard1.activate { User.where(id: @user) }
-          expect(scope.shard_value).to eq @shard1
-          expect(scope.exists?).to eq true
-        end
-
-        it "should work for a multi-shard scope" do
-          user2 = @shard2.activate { User.create!(name: "multi-shard exists") }
-          expect(User.where(name: "multi-shard exists").shard(Shard.all).exists?).to eq true
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_record/model_schema_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe ModelSchema do
-      include RSpecHelper
-
-      after do
-        User.reset_table_name
-      end
-
-      it "caches per-shard" do
-        User.reset_table_name
-        User.connection.expects(:quote_table_name).returns("1")
-        expect(User.quoted_table_name).to eq "1"
-        User.connection.expects(:quote_table_name).returns("2")
-        expect(User.quoted_table_name).to eq "1"
-        @shard1.activate do
-          expect(User.quoted_table_name).to eq "2"
-        end
-        expect(User.quoted_table_name).to eq "1"
-      end
-    end
-  end
-end

data/spec/lib/active_record/persistence_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe FinderMethods do
-      include RSpecHelper
-
-      describe "#touch" do
-        it "should touch on the correct shard" do
-          user = @shard1.activate { User.create! }
-
-          User.connection.expects(:update).never
-
-          # expects an update
-          @shard1.activate do
-            User.connection.expects(:update).once.with do |arel, name, binds|
-              # does not match the global id
-              # but does match the local_id
-              if ::Rails.version < '4.2'
-                arel.to_sql.match(/#{user.local_id}/) && !arel.to_sql.match(/#{user.global_id}/)
-              elsif ::Rails.version < '5'
-                binds.first.last == user.local_id
-              else
-                binds.first.value == user.local_id
-              end
-            end
-          end
-
-          user.touch
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_record/postgresql_adapter_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe PostgreSQLAdapter do
-      before do
-        skip "requires PostgreSQL" unless ::ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-      end
-
-      describe '#quote_table_name' do
-        before do
-          shard = mock()
-          shard.stubs(:name).returns('bob')
-          ::ActiveRecord::Base.connection.stubs(:use_qualified_names?).returns(true)
-          ::ActiveRecord::Base.connection.stubs(:shard).returns(shard)
-        end
-
-        it 'should add schema if not included' do
-          expect(::ActiveRecord::Base.connection.quote_table_name('table')).to eq '"bob"."table"'
-        end
-
-        it 'should not add schema if already included' do
-          expect(::ActiveRecord::Base.connection.quote_table_name('schema.table')).to eq '"schema"."table"'
-        end
-      end
-
-      context "table aliases" do
-        it "qualifies tables, but not aliases or columns" do
-          shard = mock()
-          shard.stubs(:name).returns('bob')
-          ::ActiveRecord::Base.connection.stubs(:use_qualified_names?).returns(true)
-          ::ActiveRecord::Base.connection.stubs(:shard).returns(shard)
-          ::ActiveRecord::Base.connection.stubs(:columns).returns([])
-
-          expect(User.joins(:parent).where(id: 1).to_sql).to be_include %{* FROM "bob"."users" INNER JOIN "bob"."users" "parents_users" ON "parents_users"."id" = "users"."parent_id" WHERE "users"."id" = 1}
-        end
-      end
-    end
-  end
-end

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