DEV: Stablize DiscourseRedis tests.

spec/components/discourse_redis_spec.rb

@@ -97,6 +97,7 @@ describe DiscourseRedis do
         $redis.set('test', '1')
       ensure
         fallback_handler.master = true
+        $redis.del('test')
       end
     end
   end
@@ -104,6 +105,10 @@ describe DiscourseRedis do
   describe DiscourseRedis::Connector do
     let(:connector) { DiscourseRedis::Connector.new(config) }
 
+    after do
+      fallback_handler.master = true
+    end
+
     it 'should return the master config when master is up' do
       expect(connector.resolve).to eq(config)
     end
@@ -122,46 +127,44 @@ describe DiscourseRedis do
     end
 
     it 'should return the slave config when master is down' do
-      begin
-        error = Redis::CannotConnectError
-        expect { connector.resolve(BrokenRedis.new(error)) }.to raise_error(Redis::CannotConnectError)
+      error = Redis::CannotConnectError
 
-        config = connector.resolve
+      expect do
+        connector.resolve(BrokenRedis.new(error))
+      end.to raise_error(Redis::CannotConnectError)
 
-        expect(config[:host]).to eq(slave_host)
-        expect(config[:port]).to eq(slave_port)
-      ensure
-        fallback_handler.master = true
-      end
+      config = connector.resolve
+
+      expect(config[:host]).to eq(slave_host)
+      expect(config[:port]).to eq(slave_port)
     end
 
     it "should return the slave config when master's hostname cannot be resolved" do
-      begin
-        error = RuntimeError.new('Name or service not known')
+      error = RuntimeError.new('Name or service not known')
 
-        expect { connector.resolve(BrokenRedis.new(error)) }.to raise_error(error)
-        expect(fallback_handler.master).to eq(false)
+      expect do
+        connector.resolve(BrokenRedis.new(error))
+      end.to raise_error(error)
 
-        config = connector.resolve
+      expect(fallback_handler.master).to eq(false)
 
-        expect(config[:host]).to eq(slave_host)
-        expect(config[:port]).to eq(slave_port)
-        expect(fallback_handler.master).to eq(false)
-      ensure
-        fallback_handler.master = true
-      end
+      config = connector.resolve
+
+      expect(config[:host]).to eq(slave_host)
+      expect(config[:port]).to eq(slave_port)
+      expect(fallback_handler.master).to eq(false)
     end
 
     it "should return the slave config when master is still loading data" do
-      begin
-        Redis::Client.any_instance.expects(:call).with([:info]).returns("someconfig:haha\r\nloading:1")
-        config = connector.resolve
+      Redis::Client.any_instance
+        .expects(:call)
+        .with([:info])
+        .returns("someconfig:haha\r\nloading:1")
 
-        expect(config[:host]).to eq(slave_host)
-        expect(config[:port]).to eq(slave_port)
-      ensure
-        fallback_handler.master = true
-      end
+      config = connector.resolve
+
+      expect(config[:host]).to eq(slave_host)
+      expect(config[:port]).to eq(slave_port)
     end
 
     it "should raise the right error" do
@@ -172,9 +175,13 @@ describe DiscourseRedis do
   end
 
   describe DiscourseRedis::FallbackHandler do
+    before do
+      @original_keepalive_interval = MessageBus.keepalive_interval
+    end
+
     after do
       fallback_handler.master = true
-      MessageBus.keepalive_interval = -1
+      MessageBus.keepalive_interval = @original_keepalive_interval
     end
 
     describe '#initiate_fallback_to_master' do
@@ -188,7 +195,7 @@ describe DiscourseRedis do
 
       it 'should fallback to the master server once it is up' do
         fallback_handler.master = false
-        redis_connection = DiscourseRedis.raw_connection._client
+        redis_connection = mock('test')
         Redis::Client.expects(:new).with(DiscourseRedis.slave_config).returns(redis_connection)
 
         redis_connection.expects(:call).with([:info]).returns(DiscourseRedis::FallbackHandler::MASTER_LINK_STATUS)
@@ -197,6 +204,8 @@ describe DiscourseRedis do
           redis_connection.expects(:call).with([:client, [:kill, 'type', connection_type]])
         end
 
+        redis_connection.expects(:disconnect)
+
         expect(fallback_handler.initiate_fallback_to_master).to eq(true)
         expect(fallback_handler.master).to eq(true)
         expect(Discourse.recently_readonly?).to eq(false)