switchman 1.5.0 → 1.5.3

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

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