diff --git a/spec/components/discourse_redis_spec.rb b/spec/components/discourse_redis_spec.rb
index 900e20ac981..abc9a5917a8 100644
--- a/spec/components/discourse_redis_spec.rb
+++ b/spec/components/discourse_redis_spec.rb
@@ -3,246 +3,244 @@
require 'rails_helper'
describe DiscourseRedis do
- skip "these tests are broken" do
- let(:slave_host) { 'testhost' }
- let(:slave_port) { 1234 }
+ let(:slave_host) { 'testhost' }
+ let(:slave_port) { 1234 }
- let(:config) do
- DiscourseRedis.config.dup.merge(slave_host: 'testhost', slave_port: 1234, connector: DiscourseRedis::Connector)
+ let(:config) do
+ DiscourseRedis.config.dup.merge(slave_host: 'testhost', slave_port: 1234, connector: DiscourseRedis::Connector)
+ end
+
+ let(:fallback_handler) { DiscourseRedis::FallbackHandler.instance }
+
+ it "ignore_readonly returns nil from a pure exception" do
+ result = DiscourseRedis.ignore_readonly { raise Redis::CommandError.new("READONLY") }
+ expect(result).to eq(nil)
+ end
+
+ describe 'redis commands' do
+ let(:raw_redis) { Redis.new(DiscourseRedis.config) }
+
+ before do
+ raw_redis.flushdb
end
- let(:fallback_handler) { DiscourseRedis::FallbackHandler.instance }
-
- it "ignore_readonly returns nil from a pure exception" do
- result = DiscourseRedis.ignore_readonly { raise Redis::CommandError.new("READONLY") }
- expect(result).to eq(nil)
+ after do
+ raw_redis.flushdb
end
- describe 'redis commands' do
- let(:raw_redis) { Redis.new(DiscourseRedis.config) }
+ describe 'when namespace is enabled' do
+ let(:redis) { DiscourseRedis.new }
- before do
- raw_redis.flushdb
- end
+ it 'should append namespace to the keys' do
+ raw_redis.set('default:key', 1)
+ raw_redis.set('test:key2', 1)
- after do
- raw_redis.flushdb
- end
+ expect(redis.keys).to include('key')
+ expect(redis.keys).to_not include('key2')
+ expect(redis.scan_each.to_a).to eq(['key'])
- describe 'when namespace is enabled' do
- let(:redis) { DiscourseRedis.new }
-
- it 'should append namespace to the keys' do
- raw_redis.set('default:key', 1)
- raw_redis.set('test:key2', 1)
-
- expect(redis.keys).to include('key')
- expect(redis.keys).to_not include('key2')
- expect(redis.scan_each.to_a).to eq(['key'])
-
- redis.scan_each.each do |key|
- expect(key).to eq('key')
- end
-
- redis.del('key')
-
- expect(raw_redis.get('default:key')).to eq(nil)
- expect(redis.scan_each.to_a).to eq([])
-
- raw_redis.set('default:key1', '1')
- raw_redis.set('default:key2', '2')
-
- expect(redis.mget('key1', 'key2')).to eq(['1', '2'])
- expect(redis.scan_each.to_a).to contain_exactly('key1', 'key2')
- end
- end
-
- describe 'when namespace is disabled' do
- let(:redis) { DiscourseRedis.new(nil, namespace: false) }
-
- it 'should not append any namespace to the keys' do
- raw_redis.set('default:key', 1)
- raw_redis.set('test:key2', 1)
-
- expect(redis.keys).to include('default:key', 'test:key2')
-
- redis.del('key')
-
- expect(raw_redis.get('key')).to eq(nil)
-
- raw_redis.set('key1', '1')
- raw_redis.set('key2', '2')
-
- expect(redis.mget('key1', 'key2')).to eq(['1', '2'])
+ redis.scan_each.each do |key|
+ expect(key).to eq('key')
end
- it 'should noop a readonly redis' do
- expect(Discourse.recently_readonly?).to eq(false)
+ redis.del('key')
- redis.without_namespace
- .expects(:set)
- .raises(Redis::CommandError.new("READONLY"))
+ expect(raw_redis.get('default:key')).to eq(nil)
+ expect(redis.scan_each.to_a).to eq([])
- redis.set('key', 1)
+ raw_redis.set('default:key1', '1')
+ raw_redis.set('default:key2', '2')
- expect(Discourse.recently_readonly?).to eq(true)
- end
+ expect(redis.mget('key1', 'key2')).to eq(['1', '2'])
+ expect(redis.scan_each.to_a).to contain_exactly('key1', 'key2')
end
end
- context '.slave_host' do
- it 'should return the right config' do
- slave_config = DiscourseRedis.slave_config(config)
- expect(slave_config[:host]).to eq(slave_host)
- expect(slave_config[:port]).to eq(slave_port)
+ describe 'when namespace is disabled' do
+ let(:redis) { DiscourseRedis.new(nil, namespace: false) }
+
+ it 'should not append any namespace to the keys' do
+ raw_redis.set('default:key', 1)
+ raw_redis.set('test:key2', 1)
+
+ expect(redis.keys).to include('default:key', 'test:key2')
+
+ redis.del('key')
+
+ expect(raw_redis.get('key')).to eq(nil)
+
+ raw_redis.set('key1', '1')
+ raw_redis.set('key2', '2')
+
+ expect(redis.mget('key1', 'key2')).to eq(['1', '2'])
+ end
+
+ it 'should noop a readonly redis' do
+ expect(Discourse.recently_readonly?).to eq(false)
+
+ redis.without_namespace
+ .expects(:set)
+ .raises(Redis::CommandError.new("READONLY"))
+
+ redis.set('key', 1)
+
+ expect(Discourse.recently_readonly?).to eq(true)
end
end
+ end
- context 'when redis connection is to a slave redis server' do
- it 'should check the status of the master server' do
- begin
- fallback_handler.master = false
- Discourse.redis.without_namespace.expects(:set).raises(Redis::CommandError.new("READONLY"))
- fallback_handler.expects(:verify_master).once
- Discourse.redis.set('test', '1')
- ensure
- fallback_handler.master = true
- Discourse.redis.del('test')
- end
- end
+ context '.slave_host' do
+ it 'should return the right config' do
+ slave_config = DiscourseRedis.slave_config(config)
+ expect(slave_config[:host]).to eq(slave_host)
+ expect(slave_config[:port]).to eq(slave_port)
end
+ end
- describe DiscourseRedis::Connector do
- let(:connector) { DiscourseRedis::Connector.new(config) }
-
- after do
+ context 'when redis connection is to a slave redis server' do
+ it 'should check the status of the master server' do
+ begin
+ fallback_handler.master = false
+ Discourse.redis.without_namespace.expects(:set).raises(Redis::CommandError.new("READONLY"))
+ fallback_handler.expects(:verify_master).once
+ Discourse.redis.set('test', '1')
+ ensure
fallback_handler.master = true
+ Discourse.redis.del('test')
+ end
+ end
+ end
+
+ 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
+
+ class BrokenRedis
+ def initialize(error)
+ @error = error
end
- it 'should return the master config when master is up' do
- expect(connector.resolve).to eq(config)
+ def call(*args)
+ raise @error
end
- class BrokenRedis
- def initialize(error)
- @error = error
- end
+ def disconnect
+ end
+ end
- def call(*args)
- raise @error
- end
+ it 'should return the slave config when master is down' do
+ error = Redis::CannotConnectError
- def disconnect
- end
+ expect do
+ connector.resolve(BrokenRedis.new(error))
+ end.to raise_error(Redis::CannotConnectError)
+
+ 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
+ error = RuntimeError.new('Name or service not known')
+
+ expect do
+ connector.resolve(BrokenRedis.new(error))
+ end.to raise_error(error)
+
+ expect(fallback_handler.master).to eq(false)
+
+ 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
+ Redis::Client.any_instance
+ .expects(:call)
+ .with([:info, :persistence])
+ .returns("
+ someconfig:haha\r
+ #{DiscourseRedis::FallbackHandler::MASTER_LOADING_STATUS}
+ ")
+
+ 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
+ error = RuntimeError.new('test')
+
+ 2.times do
+ expect { connector.resolve(BrokenRedis.new(error)) }
+ .to raise_error(error)
+ end
+ end
+ end
+
+ describe DiscourseRedis::FallbackHandler do
+ before do
+ @original_keepalive_interval = MessageBus.keepalive_interval
+ end
+
+ after do
+ fallback_handler.master = true
+ MessageBus.keepalive_interval = @original_keepalive_interval
+ end
+
+ describe '#initiate_fallback_to_master' do
+ it 'should return the right value if the master server is still down' do
+ fallback_handler.master = false
+ Redis::Client.any_instance.expects(:call).with([:info]).returns("Some other stuff")
+
+ expect(fallback_handler.initiate_fallback_to_master).to eq(false)
+ expect(MessageBus.keepalive_interval).to eq(0)
end
- it 'should return the slave config when master is down' do
- error = Redis::CannotConnectError
+ it 'should fallback to the master server once it is up' do
+ fallback_handler.master = false
+ master_conn = mock('master')
+ slave_conn = mock('slave')
- expect do
- connector.resolve(BrokenRedis.new(error))
- end.to raise_error(Redis::CannotConnectError)
+ Redis::Client.expects(:new)
+ .with(DiscourseRedis.config)
+ .returns(master_conn)
- config = connector.resolve
+ Redis::Client.expects(:new)
+ .with(DiscourseRedis.slave_config)
+ .returns(slave_conn)
- 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
- error = RuntimeError.new('Name or service not known')
-
- expect do
- connector.resolve(BrokenRedis.new(error))
- end.to raise_error(error)
-
- expect(fallback_handler.master).to eq(false)
-
- 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
- Redis::Client.any_instance
- .expects(:call)
- .with([:info, :persistence])
+ master_conn.expects(:call)
+ .with([:info])
.returns("
- someconfig:haha\r
- #{DiscourseRedis::FallbackHandler::MASTER_LOADING_STATUS}
+ #{DiscourseRedis::FallbackHandler::MASTER_ROLE_STATUS}\r\n
+ #{DiscourseRedis::FallbackHandler::MASTER_LOADED_STATUS}
")
- 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
- error = RuntimeError.new('test')
-
- 2.times do
- expect { connector.resolve(BrokenRedis.new(error)) }
- .to raise_error(error)
- end
- end
- end
-
- describe DiscourseRedis::FallbackHandler do
- before do
- @original_keepalive_interval = MessageBus.keepalive_interval
- end
-
- after do
- fallback_handler.master = true
- MessageBus.keepalive_interval = @original_keepalive_interval
- end
-
- describe '#initiate_fallback_to_master' do
- it 'should return the right value if the master server is still down' do
- fallback_handler.master = false
- Redis::Client.any_instance.expects(:call).with([:info]).returns("Some other stuff")
-
- expect(fallback_handler.initiate_fallback_to_master).to eq(false)
- expect(MessageBus.keepalive_interval).to eq(0)
+ DiscourseRedis::FallbackHandler::CONNECTION_TYPES.each do |connection_type|
+ slave_conn.expects(:call).with(
+ [:client, [:kill, 'type', connection_type]]
+ )
end
- it 'should fallback to the master server once it is up' do
- fallback_handler.master = false
- master_conn = mock('master')
- slave_conn = mock('slave')
+ master_conn.expects(:disconnect)
+ slave_conn.expects(:disconnect)
- Redis::Client.expects(:new)
- .with(DiscourseRedis.config)
- .returns(master_conn)
-
- Redis::Client.expects(:new)
- .with(DiscourseRedis.slave_config)
- .returns(slave_conn)
-
- master_conn.expects(:call)
- .with([:info])
- .returns("
- #{DiscourseRedis::FallbackHandler::MASTER_ROLE_STATUS}\r\n
- #{DiscourseRedis::FallbackHandler::MASTER_LOADED_STATUS}
- ")
-
- DiscourseRedis::FallbackHandler::CONNECTION_TYPES.each do |connection_type|
- slave_conn.expects(:call).with(
- [:client, [:kill, 'type', connection_type]]
- )
- end
-
- master_conn.expects(:disconnect)
- slave_conn.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)
- expect(MessageBus.keepalive_interval).to eq(-1)
- end
+ expect(fallback_handler.initiate_fallback_to_master).to eq(true)
+ expect(fallback_handler.master).to eq(true)
+ expect(Discourse.recently_readonly?).to eq(false)
+ expect(MessageBus.keepalive_interval).to eq(-1)
end
end
end