switchman 0.0.1 → 1.0.0

data/spec/lib/database_server_spec.rb

@@ -4,42 +4,38 @@ module Switchman
   describe DatabaseServer do
     describe "shareable?" do
       it "should be false for sqlite" do
-        db = DatabaseServer.new
-        db.config = { :adapter => 'sqlite3', :database => '%{shard_name}' }
+        db = DatabaseServer.new(config: { adapter: 'sqlite3', database: '%{shard_name}' })
         db.shareable?.should be_false
       end
 
       it "should be true for mysql" do
-        db = DatabaseServer.new
-        db.config = { :adapter => 'mysql' }
+        db = DatabaseServer.new(config: { adapter: 'mysql' })
         db.shareable?.should be_true
 
-        db = DatabaseServer.new
-        db.config = { :adapter => 'mysql2' }
+        db = DatabaseServer.new(config: { adapter: 'mysql2' })
         db.shareable?.should be_true
       end
 
       it "should be true for postgres with a non-variable username" do
-        db = DatabaseServer.new
-        db.config = { :adapter => 'postgresql' }
+        db = DatabaseServer.new(config: { adapter: 'postgresql' })
         db.shareable?.should be_true
       end
 
       it "should be false for postgres with variable username" do
-        db = DatabaseServer.new
-        db.config = { :adapter => 'postgresql', :username => '%{schema_search_path}' }
+        db = DatabaseServer.new(config: { adapter: 'postgresql', username: '%{schema_search_path}' })
         db.shareable?.should be_false
       end
 
       it "should depend on the database environment" do
-        db = DatabaseServer.new
-        db.config = { :adapter => 'postgresql', :username => '%{schema_search_path}', :deploy => { :username => 'deploy' } }
+        db = DatabaseServer.new(config: { adapter: 'postgresql', username: '%{schema_search_path}', deploy: { username: 'deploy' }})
         db.shareable?.should be_false
         ::Shackles.activate(:deploy) { db.shareable? }.should be_true
       end
     end
 
     describe "#create_new_shard" do
+      include RSpecHelper
+
       def maybe_activate(shard)
         shard.activate { yield } if shard
         yield unless shard
@@ -89,13 +85,76 @@ module Switchman
 
       class MyException < Exception; end
       it "should use the connection's db name as temp db name" do
-        db = DatabaseServer.new
-        db.config = { :adapter => 'postgresql' }
+        db = DatabaseServer.new(config: { adapter: 'postgresql' })
         Shard.expects(:create!).with(:name => Shard.default.name, :database_server => db).raises(MyException.new)
         lambda { db.create_new_shard }.should 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(config: base_config)
+        ds.config.should == base_config
+        ds.config(:slave).should == [{ database: 'db', deploy: base_config[:deploy] },
+                                     { database: 'slave', deploy: base_config[:deploy] }]
+        ds.config(:deploy).should == { 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
+        ds.shackles_environment.should == :master
+        ::Shackles.activate(:slave) do
+          ds.shackles_environment.should == :slave
+        end
+      end
+
+      it "should override Shackles.environment when explicitly set" do
+        ds = DatabaseServer.new
+        ds.shackle!
+        ds.shackles_environment.should == :slave
+        ds.unshackle do
+          ds.shackles_environment.should == :master
+        end
+        ds.shackles_environment.should == :slave
+        ::Shackles.activate(:slave) do
+          ds.shackles_environment.should == :slave
+          ds.unshackle do
+            ds.shackles_environment.should == :slave
+          end
+          ds.shackles_environment.should == :slave
+        end
+        ds.shackles_environment.should == :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
+        @db.cache_store.object_id.should == @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)
+        @db.cache_store.object_id.should == @default_store.object_id
+      end
+    end
+
     describe ".server_for_new_shard" do
       before(:all) do
         @db1 = DatabaseServer.find(nil)

data/spec/lib/default_shard_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+module Switchman
+  describe DefaultShard do
+    before(:all) do
+      @user = User.create!
+    end
+
+    after(:all) do
+      @user.destroy
+    end
+
+    context "sharding" do
+      include RSpecHelper
+
+      it "should be equivalent to a real default shard" do
+        Shard.default.should be_is_a(Shard)
+        @user.shard.should be_is_a(DefaultShard)
+        @user.shard.should == Shard.default
+        Shard.default.should == @user.shard
+      end
+    end
+  end
+end

data/spec/lib/r_spec_helper_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+module Switchman
+  describe RSpecHelper do
+    # strategically place these before we include the module
+    before(:all) do
+      Shard.default.should be_a(DefaultShard)
+    end
+
+    after(:all) do
+      Shard.default.should be_a(DefaultShard)
+    end
+
+    include RSpecHelper
+
+    it "should make the default shard a real shard" do
+      Shard.default.should be_a(Shard)
+    end
+  end
+end

data/spec/lib/rails_spec.rb

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

data/spec/lib/shackles_spec.rb

@@ -6,18 +6,12 @@ module Switchman
 
     before do
       #!!! trick Shackles in to actually switching envs
-      Rails.env.stubs(:test?).returns(false)
+      ::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 call ensure_handler when switching envs" do
-      old_handler = ::ActiveRecord::Base.connection_handler
-      ::Shackles.expects(:ensure_handler).returns(old_handler).twice
-      ::Shackles.activate(:slave) {}
-    end
-
     it "should capture the correct current_pool" do
       # use @shard2 cause it has its own DatabaseServer
       @shard2.activate do
@@ -29,15 +23,75 @@ module Switchman
     end
 
     it "should correctly set up pools for sharding categories" do
-      @default_pools = ::ActiveRecord::Base.connection_handler.connection_pools
+      models = ::ActiveRecord::Base.connection_handler.connection_pools
+      default_pools = Hash[models.map { |k, v| [k, v.current_pool] }]
       ::Shackles.activate(:slave_that_no_one_else_uses) do
-        pools = ::ActiveRecord::Base.connection_handler.connection_pools
-        @default_pools.keys.sort.should == pools.keys.sort
-        @default_pools.keys.each do |model|
-          @default_pools[model].should_not == pools[model]
+        models = ::ActiveRecord::Base.connection_handler.connection_pools
+        pools = Hash[models.map { |k, v| [k, v.current_pool] }]
+        default_pools.keys.sort.should == pools.keys.sort
+        default_pools.keys.each do |model|
+          default_pools[model].should_not == 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(config: 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
+        User.connection_pool.spec.config[:host].should_not == '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
+          Shard.default.database_server.shackles_environment.should == :slave
+          ::Shackles.environment.should == :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!
+        Shard.default.database_server.shackles_environment.should == :slave
+
+        u = User.create!
+        Shard.default.database_server.expects(:unshackle).once.returns([])
+        User.scoped(lock: true).first
+        Shard.default.database_server.expects(:unshackle).once.returns([])
+        lambda { u.lock! }.should 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(config: { adapter: 'postgresql', host: 'notshackled', slave: { host: 'shackled' }})
+        ::Rails.env.stubs(:test?).returns(false)
+        s = ds.shards.create!
+        s.activate do
+          User.connection_pool.spec.config[:host].should == 'notshackled'
         end
-        # should have the same number of distinct default_pools
-        pools.values.map(&:default_pool).uniq.length.should == @default_pools.values.map(&:default_pool).uniq.length
+      ensure
+        Shard.default.database_server.unshackle!
       end
     end
 

data/spec/models/shard_spec.rb

@@ -103,6 +103,30 @@ module Switchman
     end
 
     describe ".with_each_shard" do
+      describe ":exception" do
+        it "should default to :raise" do
+          lambda { Shard.with_each_shard { raise "error" } }.should raise_error
+        end
+
+        it "should :ignore" do
+          Shard.with_each_shard(exception: :ignore) { raise "error" }.should == []
+        end
+
+        it "should :defer" do
+          counter = 0
+          lambda { Shard.with_each_shard(exception: :defer) { counter += 1; raise "error" } }.should raise_error
+          # called more than once
+          counter.should > 1
+        end
+
+        it "should call a proc" do
+          counter = 0
+          Shard.with_each_shard(exception: -> { counter += 1 }) { raise "error" }.should == []
+          # called more than once
+          counter.should > 1
+        end
+      end
+
       context "non-transactional" do
         self.use_transactional_fixtures = false
 
@@ -202,23 +226,20 @@ module Switchman
       end
 
       it "should fall back to shard_name in the config if nil" do
-        db = DatabaseServer.new
-        db.config = { :adapter => 'mysql', :database => 'canvas', :shard_name => 'yoyoyo' }
-        shard = Shard.new(:database_server => db)
+        db = DatabaseServer.new(config: { adapter: 'mysql', database: 'canvas', shard_name: 'yoyoyo' })
+        shard = Shard.new(database_server: db)
         shard.name.should == 'yoyoyo'
       end
 
       it "should fall back to the database_server if nil" do
-        db = DatabaseServer.new
-        db.config = { :adapter => 'mysql', :database => 'canvas' }
-        shard = Shard.new(:database_server => db)
+        db = DatabaseServer.new(config: { adapter: 'mysql', database: 'canvas' })
+        shard = Shard.new(database_server: db)
         shard.name.should == 'canvas'
       end
 
       it "should get it from the postgres connection if not otherwise specified" do
-        db = DatabaseServer.create
-        db.config = { :adapter => 'postgresql', :database => 'notme' }
-        shard = Shard.new(:database_server => db)
+        db = DatabaseServer.create(config: { adapter: 'postgresql', database: 'notme' })
+        shard = Shard.new(database_server: db)
         shard.database_server = db
         connection = mock()
         connection.stubs(:open_transactions).returns(0)