switchman 1.5.2 → 1.5.3

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

data/spec/lib/database_server_spec.rb

@@ -1,231 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  describe DatabaseServer do
-    describe "shareable?" do
-      it "should be false for sqlite" do
-        db = DatabaseServer.new(nil, adapter: 'sqlite3', database: '%{shard_name}')
-        expect(db.shareable?).to eq false
-      end
-
-      it "should be true for mysql" do
-        db = DatabaseServer.new(nil, adapter: 'mysql')
-        expect(db.shareable?).to eq true
-
-        db = DatabaseServer.new(nil, adapter: 'mysql2')
-        expect(db.shareable?).to eq true
-      end
-
-      it "should be true for postgres with a non-variable username" do
-        db = DatabaseServer.new(nil, adapter: 'postgresql')
-        expect(db.shareable?).to eq true
-      end
-
-      it "should be false for postgres with variable username" do
-        db = DatabaseServer.new(nil, adapter: 'postgresql', username: '%{schema_search_path}')
-        expect(db.shareable?).to eq false
-      end
-
-      it "should depend on the database environment" do
-        db = DatabaseServer.new(nil, adapter: 'postgresql', username: '%{schema_search_path}', deploy: { username: 'deploy' })
-        expect(db.shareable?).to eq false
-        expect(::Shackles.activate(:deploy) { db.shareable? }).to eq true
-      end
-
-      it "should handle string keys" do
-        db = DatabaseServer.new(nil, adapter: 'postgresql', username: '%{schema_search_path}', deploy: { 'username' => 'deploy' })
-        expect(db.shareable?).to eq false
-        expect(::Shackles.activate(:deploy) { db.shareable? }).to eq true
-      end
-    end
-
-    describe "#create_new_shard" do
-      include RSpecHelper
-
-      def maybe_activate(shard)
-        shard.activate { yield } if shard
-        yield unless shard
-      end
-
-      adapter = ::ActiveRecord::Base.connection.adapter_name
-      def create_shard(server)
-        new_shard = server.create_new_shard
-        expect(new_shard).not_to be_new_record
-        expect(new_shard.name).to match /shard_#{new_shard.id}/
-        # They should share a connection pool
-        if server == Shard.default.database_server
-          expect(User.connection_pool.current_pool).to eq new_shard.activate { User.connection_pool.current_pool }
-          expect(User.connection_pool.current_pool).to eq Shard.connection_pool.current_pool
-        else
-          expect(User.connection_pool.current_pool).not_to eq new_shard.activate { User.connection_pool.current_pool }
-        end
-        # The tables should be created, ready to use
-        new_shard.activate {
-          a = User.create!
-          expect(a).not_to be_new_record
-        }
-      ensure
-        if new_shard
-          new_shard.drop_database
-          new_shard.destroy
-        end
-      end
-
-      it "should be able to create a new sqlite shard from a given server" do
-        db = DatabaseServer.create(adapter: 'sqlite3', database: '%{shard_name}', shard_name: ':memory:')
-        begin
-          create_shard(db)
-        ensure
-          db.destroy
-        end
-      end
-
-      context "non-transactional" do
-        self.use_transactional_fixtures = ::ActiveRecord::Base.connection.supports_ddl_transactions?
-
-        it "should be able to create a new shard from the default db" do
-          create_shard(Shard.default.database_server)
-        end
-      end
-
-      it "should be able to create a new shard from a db server that doesn't have any shards" do
-        # otherwise it's a repeat of the sqlite spec above
-        skip 'A "real" database"' unless %w{MySQL Mysql2 PostgreSQL}.include?(adapter)
-
-        # So, it's really the same server, but we want separate connections
-        db = DatabaseServer.create(Shard.default.database_server.config)
-        begin
-          create_shard(db)
-        ensure
-          db.destroy
-        end
-      end
-
-      class MyException < Exception; end
-      it "should use the connection's db name as temp db name" do
-        db = DatabaseServer.new(nil, adapter: 'postgresql')
-        Shard.expects(:create!).with(:name => Shard.default.name, :database_server => db).raises(MyException.new)
-        expect { db.create_new_shard }.to raise_error(MyException)
-      end
-    end
-
-    describe "#config" do
-      it "should return subenvs" do
-        base_config = { database: 'db',
-                        slave: [nil, { database: 'slave' }],
-                        deploy: { username: 'deploy' }}
-        ds = DatabaseServer.new(nil, base_config)
-        expect(ds.config).to eq base_config
-        expect(ds.config(:slave)).to eq [{ database: 'db', deploy: base_config[:deploy] },
-                                     { database: 'slave', deploy: base_config[:deploy] }]
-        expect(ds.config(:deploy)).to eq({ database: 'db', username: 'deploy', slave: base_config[:slave], deploy: base_config[:deploy] })
-      end
-    end
-
-    describe "#shackles_environment" do
-      it "should inherit from Shackles.environment" do
-        ds = DatabaseServer.new
-        expect(ds.shackles_environment).to eq :master
-        ::Shackles.activate(:slave) do
-          expect(ds.shackles_environment).to eq :slave
-        end
-      end
-
-      it "should override Shackles.environment when explicitly set" do
-        ds = DatabaseServer.new
-        ds.shackle!
-        expect(ds.shackles_environment).to eq :slave
-        ds.unshackle do
-          expect(ds.shackles_environment).to eq :master
-        end
-        expect(ds.shackles_environment).to eq :slave
-        ::Shackles.activate(:slave) do
-          expect(ds.shackles_environment).to eq :slave
-          ds.unshackle do
-            expect(ds.shackles_environment).to eq :slave
-          end
-          expect(ds.shackles_environment).to eq :slave
-        end
-        expect(ds.shackles_environment).to eq :slave
-      end
-    end
-
-    describe "#cache_store" do
-      before do
-        @db = DatabaseServer.new
-        @default_store = ::ActiveSupport::Cache.lookup_store(:null_store)
-        @db_store = ::ActiveSupport::Cache.lookup_store(:memory_store)
-        @original_map = Switchman.config[:cache_map]
-        Switchman.config[:cache_map] = { ::Rails.env => @default_store, @db.id => @db_store }
-      end
-
-      after do
-        Switchman.config[:cache_map] = @original_map
-      end
-
-      it "should prefer the cache specific to the database" do
-        expect(@db.cache_store.object_id).to eq @db_store.object_id
-      end
-
-      it "should fallback to Rails.cache_without_sharding if no specific cache" do
-        Switchman.config[:cache_map].delete(@db.id)
-        expect(@db.cache_store.object_id).to eq @default_store.object_id
-      end
-    end
-
-    describe ".server_for_new_shard" do
-      before(:all) do
-        @db1 = DatabaseServer.find(nil)
-        @old_open = @db1.config.delete(:open)
-        @old_servers = DatabaseServer.all
-        @old_servers.delete(@db1)
-        @old_servers.each do |db|
-          db.destroy unless db == @db1
-        end
-      end
-
-      before do
-        @db1.config.delete(:open)
-      end
-
-      after do
-        @db2.try(:destroy)
-      end
-
-      after(:all) do
-        @db1.config[:open] = @old_open
-        @old_servers.each do |db|
-          DatabaseServer.create(db.config.merge(id: db.id))
-        end
-      end
-
-      it "should return the default server if that's the only one around" do
-        expect(DatabaseServer.server_for_new_shard).to eq @db1
-      end
-
-      it "should return on open server" do
-        @db1.config[:open] = true
-        expect(DatabaseServer.server_for_new_shard).to eq @db1
-      end
-
-      it "should return another server if it's the only one open" do
-        @db2 = DatabaseServer.create(open: true)
-        4.times { expect(DatabaseServer.server_for_new_shard).to eq @db2 }
-        @db2.config.delete(:open)
-        @db1.config[:open] = true
-        4.times { expect(DatabaseServer.server_for_new_shard).to eq @db1 }
-      end
-
-      it "should return multiple open servers" do
-        @db2 = DatabaseServer.create(open: true)
-        @db1.config[:open] = true
-        dbs = []
-        20.times do
-          dbs << DatabaseServer.server_for_new_shard
-        end
-        expect(dbs).to include(@db1)
-        expect(dbs).to include(@db2)
-      end
-    end
-  end
-end