switchman 1.5.2 → 1.5.3

data/spec/lib/default_shard_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  describe DefaultShard do
-    context "sharding" do
-      include RSpecHelper
-
-      it "should be equivalent to a real default shard" do
-        expect(Shard.default).to be_is_a(Shard)
-        expect(DefaultShard.send(:new)).to eq Shard.default
-      end
-    end
-
-    it "all defaultshards should be equivalent to each other" do
-      expect(DefaultShard.send(:new)).to eq DefaultShard.send(:new)
-    end
-  end
-end

data/spec/lib/engine_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  describe Engine do
-    describe ".lookup_stores" do
-      it "should link strings to other entries" do
-        stores = Engine.lookup_stores('db1' => :memory_store, 'db2' =>  :memory_store, 'db3' => 'db1')
-        expect(stores['db1']).to be_a(::ActiveSupport::Cache::MemoryStore)
-        expect(stores['db1']).to equal stores['db3']
-        expect(stores['db1']).to_not equal stores['db2']
-      end
-    end
-  end
-end

data/spec/lib/environment_spec.rb

@@ -1,25 +0,0 @@
-require 'etc'
-require "spec_helper"
-
-module Switchman
-  describe Environment do
-    describe ".cpu_count" do
-      it "shells out for the cpu count" do
-        if Etc.respond_to?(:nprocessors)
-          expect(Environment.cpu_count).to eq(Etc.nprocessors)
-        else
-          expect(Environment.cpu_count("echo 42")).to eq(42)
-        end
-      end
-
-      it "return 0 if processor counter doesn't exist" do
-        if Etc.respond_to?(:nprocessors)
-          Etc.stubs(:nprocessors).returns(0)
-          expect(Environment.cpu_count).to eq(0)
-        else
-          expect(Environment.cpu_count("nonsense_nproc")).to eq(0)
-        end
-      end
-    end
-  end
-end

data/spec/lib/r_spec_helper_spec.rb

@@ -1,77 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  describe RSpecHelper do
-    context "unsharded" do
-      it "doesn't make shards accessible" do
-        # by virtue of including RSpecHelper somewhere, test shards will
-        # always already be set up by this point (though not accessible),
-        # but only if we are running a sharding spec
-        expect(Shard.count).to eq 0
-        expect(Shard.default).to be_a(DefaultShard)
-      end
-
-      it "doesn't set up sharding at all if no sharded specs are run" do
-        run_groups = RSpec.world.filtered_examples.select{ |k, v| v.present? }.map(&:first)
-        pending "run without other sharding specs" if run_groups.any?{ |group| RSpecHelper.included_in?(group) }
-
-        expect(RSpecHelper.class_variable_defined?(:@@default_shard)).to eq false
-        expect(RSpecHelper.class_variable_get(:@@shard1)).to be_nil
-      end
-
-      it "sets up sharding but hides it if other sharding specs are run" do
-        run_groups = RSpec.world.filtered_examples.select{ |k, v| v.present? }.map(&:first)
-        pending "run alongside sharding specs" unless run_groups.any?{ |group| RSpecHelper.included_in?(group) }
-
-        expect(RSpecHelper.class_variable_get(:@@default_shard)).to be_a(Shard)
-        expect(RSpecHelper.class_variable_get(:@@shard1)).to be_a(Shard)
-      end
-    end
-
-    context "sharding" do
-      # strategically place these before we include the module
-      before(:all) do
-        expect(Shard.default).to be_a(DefaultShard)
-      end
-
-      after(:all) do
-        expect(Shard.default).to be_a(DefaultShard)
-      end
-
-      include RSpecHelper
-
-      it "should make the default shard a real shard" do
-        expect(Shard.default).to be_a(Shard)
-      end
-    end
-
-    context "transactions" do
-      include RSpecHelper
-
-      before :all do
-        @shard2.activate do
-          ::ActiveRecord::Base.connection.begin_transaction(joinable: false)
-          User.create!
-        end
-      end
-
-      it "should support nested transactions" do
-        @shard2.activate do |shard|
-          expect(User.count).to eq 1 # we get the user from the before :all
-          User.create! # should only last for the duration of this spec
-          conn = ::ActiveRecord::Base.connection
-          expect(conn.open_transactions).to eql 2
-        end
-      end
-
-      prepend_after :all do
-        @shard2.activate do
-          expect(User.count).to eq 1
-          conn = ::ActiveRecord::Base.connection
-          expect(conn.open_transactions).to eql 1 # RSpecHelper shouldn't have rolled back the before :all one above
-          ::ActiveRecord::Base.connection.rollback_transaction
-        end
-      end
-    end
-  end
-end

data/spec/lib/rails_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  describe Rails do
-    it "should automatically isolate cache keys from different shards" do
-      cache = ::ActiveSupport::Cache.lookup_store(:memory_store)
-      ::Rails.stubs(:cache).returns(cache)
-      db = DatabaseServer.create(adapter: 'sqlite3')
-      s1 = db.shards.create!
-      s2 = db.shards.create!
-
-      expect(s1.activate { ::Rails.cache }).to eq s2.activate { ::Rails.cache }
-
-      from_1 = s1.activate { ::Rails.cache.fetch('key') { 1 } }
-      expect(from_1).to eq 1
-      from_2 = s2.activate do
-        ::Rails.cache.fetch('key') { 2 }
-      end
-      expect(from_2).to eq 2
-
-      from_1 = s1.activate { ::Rails.cache.fetch('key') }
-      expect(from_1).to eq 1
-      from_2 = s2.activate { ::Rails.cache.fetch('key') }
-      expect(from_2).to eq 2
-    end
-
-    it "should not be assignable" do
-      expect{ ::Rails.cache = :null_store }.to raise_exception(NoMethodError)
-    end
-  end
-end

data/spec/lib/rake_spec.rb

@@ -1,100 +0,0 @@
-require "spec_helper"
-
-require 'rake' if ::Rails.version < '4'
-Dummy::Application.load_tasks
-
-module Switchman
-  describe Rake do
-    include RSpecHelper
-
-    describe '.shard_scope' do
-      before do
-        @s1, @s2, @s3 = [Shard.default, @shard1, @shard2].sort
-      end
-
-      def shard_scope(shard_ids)
-        Rake.send(:shard_scope, Shard.all, shard_ids).order(:id)
-      end
-
-      it "should work for default shard" do
-        expect(shard_scope("default").to_a).to eq [Shard.default]
-      end
-
-      it "should exclude default shard" do
-        scope = shard_scope("-default")
-        # the query is negative
-        expect(scope.to_sql).to be_include(Shard.default.id.to_s)
-        shards = scope.to_a
-        expect(shards).to_not be_empty
-        expect(shards).to_not be_include(Shard.default)
-      end
-
-      it "should no-op exclude the default shard" do
-        scope = shard_scope("default,-default")
-        expect(scope.to_a).to be_empty
-      end
-
-      it "should work for a half-open range" do
-        expect(shard_scope("#{@s1.id}...#{@s2.id}").to_a).to eq [@s1]
-      end
-
-      it "should work for a half-closed range" do
-        expect(shard_scope("#{@s1.id}..#{@s2.id}").order(:id).to_a).to eq [@s1, @s2]
-      end
-
-      it "should remove from a range" do
-        expect(shard_scope("#{@s1.id}..#{@s2.id},-#{@s1.id}").to_a).to eq [@s2]
-      end
-
-      it "should work for multiple ranges" do
-        expect(shard_scope("#{@s1.id}...#{@s1.id + 1},#{@s3.id}...#{@s3.id + 1}").order(:id).to_a).to eq [@s1, @s3]
-      end
-
-      it "should work for beginning infinite range" do
-        expect(shard_scope("..#{@s2.id}").order(:id).to_a).to eq [@s1, @s2]
-      end
-
-      it "should work for ending infinite range" do
-        expect(shard_scope("#{@s2.id}..").order(:id).to_a).to eq [@s2, @s3]
-      end
-
-      it "should default include all if you're only excluding" do
-        scope = shard_scope("-#{@s1.id}").to_a
-        expect(scope.length).to eq (Shard.count - 1)
-        expect(scope).to_not be_include(@s1)
-      end
-
-      it "should not forget about ranges when specific ids cancel out" do
-        scope = shard_scope("#{@s1.id},#{@s2.id}..#{@s2.id},-#{@s1.id}").to_a
-        expect(scope).to eq [@s2]
-      end
-
-      it "supports fractions" do
-        s4 = Shard.default.database_server.shards.create!
-        hole = Shard.default.database_server.shards.create!
-        s5 = Shard.default.database_server.shards.create!
-        hole.destroy
-
-        expect(shard_scope("1/3").to_a).to eq [@s1, @s2]
-        expect(shard_scope("2/3").to_a).to eq [@s3, s4]
-        expect(shard_scope("3/3").to_a).to eq [s5]
-
-        expect(shard_scope("1/7").to_a).to eq [@s1]
-        expect(shard_scope("2/7").to_a).to eq [@s2]
-        expect(shard_scope("3/7").to_a).to eq [@s3]
-        expect(shard_scope("4/7").to_a).to eq [s4]
-        expect(shard_scope("5/7").to_a).to eq [s5]
-        expect(shard_scope("6/7").to_a).to eq []
-        expect(shard_scope("7/7").to_a).to eq []
-      end
-    end
-
-    describe '.scope' do
-      it "supports selecting open servers" do
-        db = DatabaseServer.create(open: true)
-        shard = db.shards.create!
-        expect(Rake.scope(database_server: 'open').to_a).to eq([shard])
-      end
-    end
-  end
-end

data/spec/lib/shackles_spec.rb

@@ -1,210 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  describe Shackles do
-    include RSpecHelper
-
-    before do
-      #!!! trick Shackles in to actually switching envs
-      ::Rails.env.stubs(:test?).returns(false)
-
-      # be sure to test bugs where the current env isn't yet included in this hash
-      ::Shackles.connection_handlers.clear
-    end
-
-    it "should capture the correct current_pool" do
-      # use @shard2 cause it has its own DatabaseServer
-      @shard2.activate do
-        @current_pool = ::Shackles.activate(:slave) { ::ActiveRecord::Base.connection_pool.current_pool }
-      end
-      ::Shackles.activate(:slave) do
-        expect(::ActiveRecord::Base.connection_pool.default_pool).not_to eq @current_pool
-      end
-    end
-
-    it "should correctly set up pools for sharding categories" do
-      models = ::ActiveRecord::Base.connection_handler.send(:class_to_pool)
-      default_pools = {}
-      models.each_pair { |k, v| default_pools[k] = v.current_pool }
-      ::Shackles.activate(:slave_that_no_one_else_uses) do
-        models = ::ActiveRecord::Base.connection_handler.send(:class_to_pool)
-        pools = {}
-        models.each_pair { |k, v| pools[k] = v.current_pool }
-        expect(default_pools.keys.sort).to eq pools.keys.sort
-        default_pools.keys.each do |model|
-          expect(default_pools[model]).not_to eq pools[model]
-        end
-      end
-    end
-
-    it "should connect to the first working slave" do
-      # have to unstub long enough to create this
-      ::Rails.env.unstub(:test?)
-      ds = DatabaseServer.create(Shard.default.database_server.config.merge(
-        :slave => [{ host: 'some.postgres.server' }, nil]))
-      ::Rails.env.stubs(:test?).returns(false)
-      ds.shackle!
-      s = ds.shards.create!
-      s.activate do
-        User.connection
-        expect(User.connection_pool.spec.config[:host]).not_to eq 'some.postgres.server'
-      end
-    end
-
-    it "should deshackle the appropriate connection when the scope changes connections" do
-      begin
-        Shard.default.database_server.shackle!
-        @shard2.activate do
-          expect(Shard.default.database_server.shackles_environment).to eq :slave
-          expect(::Shackles.environment).to eq :master
-
-          Shard.default.database_server.expects(:unshackle).once
-          User.shard(Shard.default).update_all(updated_at: nil)
-        end
-      ensure
-        Shard.default.database_server.unshackle!
-      end
-    end
-
-    it "should deshackle for FOR UPDATE queries" do
-      begin
-        Shard.default.database_server.shackle!
-        expect(Shard.default.database_server.shackles_environment).to eq :slave
-
-        u = User.create!
-        Shard.default.database_server.expects(:unshackle).once.returns([])
-        User.lock.first
-        Shard.default.database_server.expects(:unshackle).once.returns([])
-        expect { u.lock! }.to raise_error(::ActiveRecord::RecordNotFound)
-      ensure
-        Shard.default.database_server.unshackle!
-      end
-    end
-
-    it "should not get confused about a single shackled server" do
-      begin
-        Shard.default.database_server.shackle!
-        # have to unstub long enough to create this
-        ::Rails.env.unstub(:test?)
-        ds = DatabaseServer.create(adapter: 'postgresql', host: 'notshackled', slave: { host: 'shackled' })
-        ::Rails.env.stubs(:test?).returns(false)
-        s = ds.shards.create!
-        s.activate do
-          expect(User.connection_pool.spec.config[:host]).to eq 'notshackled'
-        end
-      ensure
-        Shard.default.database_server.unshackle!
-      end
-    end
-
-    it "should track all activated environments" do
-      ::Shackles.activate(:slave) {}
-      ::Shackles.activate(:custom) {}
-      expected = Set.new([:master, :slave, :custom])
-      expect(::Shackles.activated_environments & expected).to eq expected
-    end
-
-    context "non-transactional" do
-      self.use_transactional_fixtures = false
-
-      it "should really disconnect all envs" do
-        ::ActiveRecord::Base.connection
-        expect(::ActiveRecord::Base.connection_pool).to be_connected
-        @shard1.activate do
-          ::ActiveRecord::Base.connection
-          expect(::ActiveRecord::Base.connection_pool).to be_connected
-        end
-        @shard2.activate do
-          ::ActiveRecord::Base.connection
-          expect(::ActiveRecord::Base.connection_pool).to be_connected
-        end
-
-        ::Shackles.activate(:slave) do
-          ::ActiveRecord::Base.connection
-          expect(::ActiveRecord::Base.connection_pool).to be_connected
-          @shard1.activate do
-            ::ActiveRecord::Base.connection
-            expect(::ActiveRecord::Base.connection_pool).to be_connected
-          end
-          @shard2.activate do
-            ::ActiveRecord::Base.connection
-            expect(::ActiveRecord::Base.connection_pool).to be_connected
-          end
-        end
-
-        ::ActiveRecord::Base.clear_all_connections!
-        expect(::ActiveRecord::Base.connection_pool).not_to be_connected
-        @shard1.activate do
-          expect(::ActiveRecord::Base.connection_pool).not_to be_connected
-        end
-        @shard2.activate do
-          expect(::ActiveRecord::Base.connection_pool).not_to be_connected
-        end
-        ::Shackles.activate(:slave) do
-          expect(::ActiveRecord::Base.connection_pool).not_to be_connected
-          @shard1.activate do
-            expect(::ActiveRecord::Base.connection_pool).not_to be_connected
-          end
-          @shard2.activate do
-            expect(::ActiveRecord::Base.connection_pool).not_to be_connected
-          end
-        end
-      end
-
-      def actual_connection_count
-        ::ActiveRecord::Base.connection_pool.current_pool.instance_variable_get(::Rails.version >= '5' ? :@thread_cached_conns : :@reserved_connections).size
-      end
-
-      it "should really return active connections to the pool in all envs" do
-        ::ActiveRecord::Base.connection
-        expect(actual_connection_count).not_to eq 0
-        @shard1.activate do
-          ::ActiveRecord::Base.connection
-          expect(actual_connection_count).not_to eq 0
-        end
-        @shard2.activate do
-          ::ActiveRecord::Base.connection
-          expect(actual_connection_count).not_to eq 0
-        end
-
-        ::Shackles.activate(:slave) do
-          ::ActiveRecord::Base.connection
-          expect(actual_connection_count).not_to eq 0
-          @shard1.activate do
-            ::ActiveRecord::Base.connection
-            expect(actual_connection_count).not_to eq 0
-          end
-          @shard2.activate do
-            ::ActiveRecord::Base.connection
-            expect(actual_connection_count).not_to eq 0
-          end
-        end
-
-        ::ActiveRecord::Base.clear_active_connections!
-        expect(actual_connection_count).to eq 0
-        @shard1.activate do
-          expect(actual_connection_count).to eq 0
-        end
-        @shard2.activate do
-          expect(actual_connection_count).to eq 0
-        end
-        ::Shackles.activate(:slave) do
-          expect(actual_connection_count).to eq 0
-          @shard1.activate do
-            expect(actual_connection_count).to eq 0
-          end
-          @shard2.activate do
-            expect(actual_connection_count).to eq 0
-          end
-        end
-      end
-
-      it "should not establish connections when switching environments" do
-        ::ActiveRecord::Base.clear_all_connections!
-        expect(::ActiveRecord::Base.connection_pool).not_to be_connected
-        ::Shackles.activate(:slave) {}
-        expect(::ActiveRecord::Base.connection_pool).not_to be_connected
-      end
-    end
-  end
-end