switchman 1.5.0 → 1.5.3

data/spec/lib/active_record/calculations_spec.rb

@@ -1,282 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe Calculations do
-      include RSpecHelper
-
-      describe "#pluck" do
-        before do
-          @shard1.activate do
-            @user1 = User.create!(:name => "user1")
-            @appendage1 = @user1.appendages.create!
-          end
-          @shard2.activate do
-            @user2 = User.create!(:name => "user2")
-            @appendage2 = @user2.appendages.create!
-          end
-        end
-
-        it "should return non-id columns" do
-          expect(User.where(:id => [@user1.id, @user2.id]).pluck(:name).sort).to eq ["user1", "user2"]
-        end
-
-        it "should return primary ids relative to current shard" do
-          expect(Appendage.where(:id => @appendage1).pluck(:id)).to eq [@appendage1.global_id]
-          expect(Appendage.where(:id => @appendage2).pluck(:id)).to eq [@appendage2.global_id]
-          @shard1.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:id)).to eq [@appendage1.local_id]
-            expect(Appendage.where(:id => @appendage2).pluck(:id)).to eq [@appendage2.global_id]
-          end
-          @shard2.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:id)).to eq [@appendage1.global_id]
-            expect(Appendage.where(:id => @appendage2).pluck(:id)).to eq [@appendage2.local_id]
-          end
-        end
-
-        it "should return foreign ids relative to current shard" do
-          expect(Appendage.where(:id => @appendage1).pluck(:user_id)).to eq [@user1.global_id]
-          expect(Appendage.where(:id => @appendage2).pluck(:user_id)).to eq [@user2.global_id]
-          @shard1.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:user_id)).to eq [@user1.local_id]
-            expect(Appendage.where(:id => @appendage2).pluck(:user_id)).to eq [@user2.global_id]
-          end
-          @shard2.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:user_id)).to eq [@user1.global_id]
-            expect(Appendage.where(:id => @appendage2).pluck(:user_id)).to eq [@user2.local_id]
-          end
-        end
-
-        it "should post-uniq multi-shard" do
-          user3 = User.create!(name: 'user2')
-          expect(User.where(id: [@user1.id, @user2.id, user3.id]).distinct.pluck(:name).sort).to match_array ["user1", "user2"]
-        end
-
-        it "should work when setting an AR shard value" do
-          expect(Appendage.shard(@user1).pluck(:user_id)).to eq [@user1.global_id]
-        end
-
-        it "should work with multi-column plucking" do
-          expect(Appendage.where(:id => @appendage1).pluck(:id, :user_id)).to eq [[@appendage1.global_id, @user1.global_id]]
-          expect(Appendage.where(:id => @appendage2).pluck(:id, :user_id)).to eq [[@appendage2.global_id, @user2.global_id]]
-          @shard1.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:id, :user_id)).to eq [[@appendage1.local_id, @user1.local_id]]
-            expect(Appendage.where(:id => @appendage2).pluck(:id, :user_id)).to eq [[@appendage2.global_id, @user2.global_id]]
-          end
-          @shard2.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:id, :user_id)).to eq [[@appendage1.global_id, @user1.global_id]]
-            expect(Appendage.where(:id => @appendage2).pluck(:id, :user_id)).to eq [[@appendage2.local_id, @user2.local_id]]
-          end
-        end
-      end
-
-      describe "#execute_simple_calculation" do
-        before do
-          @appendages = []
-          @shard1.activate do
-            @user1 = User.create!(:name => "user1")
-            @appendages << @user1.appendages.create!(:value => 1)
-            @appendages << @user1.appendages.create!(:value => 2)
-          end
-          @shard2.activate do
-            @user2 = User.create!(:name => "user2")
-            @appendages << @user2.appendages.create!(:value => 3)
-            @appendages << @user2.appendages.create!(:value => 4)
-            @appendages << @user2.appendages.create!(:value => 5)
-          end
-        end
-
-        it "should calculate average across shards" do
-          expect(@user1.appendages.average(:value)).to eq 1.5
-          expect(@shard1.activate {Appendage.average(:value)}).to eq 1.5
-
-          expect(@user2.appendages.average(:value)).to eq 4
-          expect(@shard2.activate {Appendage.average(:value)}).to eq 4
-
-          expect(Appendage.where(:id => @appendages).average(:value)).to eq 3
-        end
-
-        it "should count across shards" do
-          expect(@user1.appendages.count).to eq 2
-          expect(@shard1.activate {Appendage.count}).to eq 2
-
-          expect(@user2.appendages.count).to eq 3
-          expect(@shard2.activate {Appendage.count}).to eq 3
-
-          expect(Appendage.where(:id => @appendages).count).to eq 5
-        end
-
-        it "should calculate minimum across shards" do
-          expect(@user1.appendages.minimum(:value)).to eq 1
-          expect(@shard1.activate {Appendage.minimum(:value)}).to eq 1
-
-          expect(@user2.appendages.minimum(:value)).to eq 3
-          expect(@shard2.activate {Appendage.minimum(:value)}).to eq 3
-
-          expect(Appendage.where(:id => @appendages).minimum(:value)).to eq 1
-        end
-
-        it "should calculate maximum across shards" do
-          expect(@user1.appendages.maximum(:value)).to eq 2
-          expect(@shard1.activate {Appendage.maximum(:value)}).to eq 2
-
-          expect(@user2.appendages.maximum(:value)).to eq 5
-          expect(@shard2.activate {Appendage.maximum(:value)}).to eq 5
-
-          expect(Appendage.where(:id => @appendages).maximum(:value)).to eq 5
-        end
-
-        it "should work with dates across shards" do
-          expect(Appendage.where(:id => @appendages).maximum(:created_at).to_i).to eq @appendages.map(&:created_at).map(&:to_i).max
-        end
-
-        it "should calculate sum across shards" do
-          expect(@user1.appendages.sum(:value)).to eq 3
-          expect(@shard1.activate {Appendage.sum(:value)}).to eq 3
-
-          expect(@user2.appendages.sum(:value)).to eq 12
-          expect(@shard2.activate {Appendage.sum(:value)}).to eq 12
-
-          expect(Appendage.where(:id => @appendages).sum(:value)).to eq 15
-        end
-      end
-
-      describe "#execute_grouped_calculation" do
-        before do
-          @appendages = []
-          @shard1.activate { @user1 = User.create!(:name => "user1") }
-          @shard2.activate { @user2 = User.create!(:name => "user2") }
-
-          @shard1.activate do
-            @appendages << Appendage.create!(:user_id => @user1.id, :value => 1)
-            @appendages << Appendage.create!(:user_id => @user2.id, :value => 3)
-          end
-          @shard2.activate do
-            @appendages << Appendage.create!(:user_id => @user1.id, :value => 2)
-            @appendages << Appendage.create!(:user_id => @user2.id, :value => 4)
-            @appendages << Appendage.create!(:user_id => @user2.id, :value => 5)
-          end
-        end
-
-        it "should calculate average across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value)).to eq(
-              {@user1.global_id => 1.5, @user2.global_id => 4}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value)).to eq(
-                {@user1.local_id => 1.5, @user2.global_id => 4}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value)).to eq(
-                {@user1.global_id => 1.5, @user2.local_id => 4}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).average(:value)).to eq(
-              {@user1 => 1.5, @user2 => 4}
-          )
-        end
-
-        it "should count across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
-              {@user1.global_id => 2, @user2.global_id => 3}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
-                {@user1.local_id => 2, @user2.global_id => 3}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
-                {@user1.global_id => 2, @user2.local_id => 3}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).count).to eq(
-              {@user1 => 2, @user2 => 3}
-          )
-        end
-
-        it "should calculate minimum across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value)).to eq(
-              {@user1.global_id => 1, @user2.global_id => 3}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value)).to eq(
-                {@user1.local_id => 1, @user2.global_id => 3}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value)).to eq(
-                {@user1.global_id => 1, @user2.local_id => 3}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).minimum(:value)).to eq(
-              {@user1 => 1, @user2 => 3}
-          )
-        end
-
-        it "should calculate maximum across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value)).to eq(
-              {@user1.global_id => 2, @user2.global_id => 5}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value)).to eq(
-                {@user1.local_id => 2, @user2.global_id => 5}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value)).to eq(
-                {@user1.global_id => 2, @user2.local_id => 5}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).maximum(:value)).to eq(
-              {@user1 => 2, @user2 => 5}
-          )
-        end
-
-        it "should calculate sum across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value)).to eq(
-              {@user1.global_id => 3, @user2.global_id => 12}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value)).to eq(
-                {@user1.local_id => 3, @user2.global_id => 12}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value)).to eq(
-                {@user1.global_id => 3, @user2.local_id => 12}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).sum(:value)).to eq(
-              {@user1 => 3, @user2 => 12}
-          )
-        end
-
-        it "should respect order for a single shard" do
-          @shard1.activate do
-            @user1.appendages.create!
-            user2 = User.create!
-            user2.appendages.create!
-            expect(Appendage.group(:user_id).order("COUNT(*) DESC").limit(1).count).to eq({ @user1.id => 2 })
-          end
-        end
-      end
-    end
-  end
-end

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