mock_redis 0.36.0 → 0.37.0

data/spec/commands/pipelined_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-describe '#pipelined' do
-  it 'yields to its block' do
-    res = false
-    @redises.pipelined do
-      res = true
-    end
-    res.should == true
-  end
-
-  context 'with a few added data' do
-    let(:key1)   { 'hello' }
-    let(:key2)   { 'world' }
-    let(:value1) { 'foo' }
-    let(:value2) { 'bar' }
-
-    before do
-      @redises.set key1, value1
-      @redises.set key2, value2
-    end
-
-    it 'returns results of pipelined operations' do
-      results = @redises.pipelined do |redis|
-        redis.get key1
-        redis.get key2
-      end
-
-      results.should == [value1, value2]
-    end
-
-    it 'returns futures' do
-      future = nil
-
-      @redises.mock.pipelined do |redis|
-        future = redis.get key1
-      end
-
-      future.class.should be MockRedis::Future
-    end
-  end
-
-  context 'with pipelined operations returning array replies' do
-    let(:key1) { 'colors' }
-    let(:key2) { 'seasons' }
-    let(:value1) { %w[blue yellow] }
-    let(:value2) { %w[summer winter] }
-
-    before do
-      @redises.rpush(key1, value1)
-      @redises.rpush(key2, value2)
-    end
-
-    after do
-      @redises.del key1
-      @redises.del key2
-    end
-
-    it 'returns an array of the array replies' do
-      results = @redises.pipelined do |_redis|
-        @redises.lrange(key1, 0, -1)
-        @redises.lrange(key2, 0, -1)
-      end
-
-      results.should == [value1, value2]
-    end
-  end
-
-  context 'with redis time return value' do
-    let(:time_stub) { double 'Time', :now => Time.new(2019, 1, 2, 3, 4, 6, '+00:00') }
-    let(:options)   { { :time_class => time_stub } }
-
-    subject { MockRedis.new(options) }
-
-    it 'returns the time value' do
-      subject.set('foo', 'bar')
-
-      results = subject.pipelined do
-        subject.get('foo')
-        subject.host # defined on MockRedis, so not captured
-        subject.time
-        subject.echo('baz')
-      end
-
-      expect(results).to eq(['bar', [1_546_398_246, 0], 'baz'])
-    end
-  end
-
-  context 'with nested pipelines' do
-    let(:key1)   { 'hello' }
-    let(:key2)   { 'world' }
-    let(:value1) { 'foo' }
-    let(:value2) { 'bar' }
-
-    before do
-      @redises.set key1, value1
-      @redises.set key2, value2
-    end
-
-    it 'returns results of the nested pipelines' do
-      results = @redises.pipelined do |pr1|
-        pr1.pipelined do |pr2|
-          pr2.get key1
-        end
-
-        pr1.pipelined do |pr2|
-          pr2.get key2
-        end
-      end
-
-      results.should == [value1, value2]
-    end
-  end
-end

data/spec/commands/psetex_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe '#psetex(key, miliseconds, value)' do
-  before { @key = 'mock-redis-test:setex' }
-
-  it "responds with 'OK'" do
-    @redises.psetex(@key, 10, 'value').should == 'OK'
-  end
-
-  it 'sets the value' do
-    @redises.psetex(@key, 10_000, 'value')
-    @redises.get(@key).should == 'value'
-  end
-
-  it 'sets the expiration time' do
-    @redises.psetex(@key, 10_000, 'value')
-
-    # no guarantee these are the same
-    @redises.real.ttl(@key).should > 0
-    @redises.mock.ttl(@key).should > 0
-  end
-
-  it 'converts time correctly' do
-    @redises.psetex(@key, 10_000_000, 'value')
-
-    @redises.mock.ttl(@key).should > 9_000
-  end
-
-  context 'when expiration time is zero' do
-    it 'raises Redis::CommandError' do
-      expect do
-        @redises.psetex(@key, 0, 'value')
-      end.to raise_error(Redis::CommandError, 'ERR invalid expire time in psetex')
-    end
-  end
-
-  context 'when expiration time is negative' do
-    it 'raises Redis::CommandError' do
-      expect do
-        @redises.psetex(@key, -2, 'value')
-      end.to raise_error(Redis::CommandError, 'ERR invalid expire time in psetex')
-    end
-  end
-end

data/spec/commands/pttl_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe '#pttl(key)' do
-  before do
-    @key = 'mock-redis-test:persist'
-    @redises.set(@key, 'spork')
-  end
-
-  it 'returns -1 for a key with no expiration' do
-    @redises.pttl(@key).should == -1
-  end
-
-  it 'returns -2 for a key that does not exist' do
-    @redises.pttl('mock-redis-test:nonesuch').should == -2
-  end
-
-  it 'stringifies key' do
-    @redises.expire(@key, 8)
-    # Don't check against Redis since millisecond timing differences are likely
-    @redises.send_without_checking(:pttl, @key.to_sym).should > 0
-  end
-
-  context '[mock only]' do
-    # These are mock-only since we can't actually manipulate time in
-    # the real Redis.
-
-    before(:all) do
-      @mock = @redises.mock
-    end
-
-    before do
-      @now = Time.now.round
-      Time.stub(:now).and_return(@now)
-    end
-
-    it "gives you the key's remaining lifespan in milliseconds" do
-      @mock.expire(@key, 5)
-      @mock.pttl(@key).should == 5000
-    end
-  end
-end

data/spec/commands/quit_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe '#quit' do
-  it "responds with 'OK'" do
-    @redises.quit.should == 'OK'
-  end
-end

data/spec/commands/randomkey_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe '#randomkey [mock only]' do
-  before { @mock = @redises.mock }
-
-  it 'finds a random key' do
-    @keys = ['mock-redis-test:1', 'mock-redis-test:2', 'mock-redis-test:3']
-
-    @keys.each do |k|
-      @mock.set(k, 1)
-    end
-
-    @keys.should include(@mock.randomkey)
-  end
-
-  it 'returns nil when there are no keys' do
-    @mock.keys('*').each { |k| @mock.del(k) }
-    @mock.randomkey.should be_nil
-  end
-end

data/spec/commands/rename_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe '#rename(key, newkey)' do
-  before do
-    @key = 'mock-redis-test:rename:key'
-    @newkey = 'mock-redis-test:rename:newkey'
-
-    @redises.set(@key, 'oof')
-  end
-
-  it 'responds with "OK"' do
-    @redises.rename(@key, @newkey).should == 'OK'
-  end
-
-  it 'moves the data' do
-    @redises.rename(@key, @newkey)
-    @redises.get(@newkey).should == 'oof'
-  end
-
-  it 'raises an error when the source key is nonexistant' do
-    @redises.del(@key)
-    lambda do
-      @redises.rename(@key, @newkey)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'responds with "OK" when key == newkey' do
-    @redises.rename(@key, @key).should == 'OK'
-  end
-
-  it 'overwrites any existing value at newkey' do
-    @redises.set(@newkey, 'rab')
-    @redises.rename(@key, @newkey)
-    @redises.get(@newkey).should == 'oof'
-  end
-
-  it 'keeps expiration' do
-    @redises.expire(@key, 1000)
-    @redises.rename(@key, @newkey)
-    @redises.ttl(@newkey).should be > 0
-  end
-end

data/spec/commands/renamenx_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe '#renamenx(key, newkey)' do
-  before do
-    @key = 'mock-redis-test:renamenx:key'
-    @newkey = 'mock-redis-test:renamenx:newkey'
-
-    @redises.set(@key, 'oof')
-  end
-
-  it 'responds with true when newkey does not exist' do
-    @redises.renamenx(@key, @newkey).should == true
-  end
-
-  it 'responds with false when newkey exists' do
-    @redises.set(@newkey, 'monkey')
-    @redises.renamenx(@key, @newkey).should == false
-  end
-
-  it 'moves the data' do
-    @redises.renamenx(@key, @newkey)
-    @redises.get(@newkey).should == 'oof'
-  end
-
-  it 'raises an error when the source key is nonexistant' do
-    @redises.del(@key)
-    lambda do
-      @redises.rename(@key, @newkey)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'returns false when key == newkey' do
-    @redises.renamenx(@key, @key).should == false
-  end
-
-  it 'leaves any existing value at newkey alone' do
-    @redises.set(@newkey, 'rab')
-    @redises.renamenx(@key, @newkey)
-    @redises.get(@newkey).should == 'rab'
-  end
-end

data/spec/commands/restore_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe '#restore(key, ttl, value)' do
-  before do
-    @key = 'mock-redis-test:45794'
-    @src = MockRedis.new
-    @src.set(@key, '123')
-    @dumped_value = @src.dump(@key)
-    @dst = MockRedis.new
-    @now = Time.now.round
-    Time.stub(:now).and_return(@now)
-  end
-
-  it 'allows dump/restoring values between two redis instances' do
-    expect(@dst.restore(@key, 0, @dumped_value)).to eq('OK')
-    expect(@dst.get(@key)).to eq('123')
-    expect(@dst.pttl(@key)).to eq(-1)
-  end
-
-  context 'when the key being restored to already exists' do
-    before do
-      @dst.set(@key, '456')
-    end
-
-    it 'raises an error by default' do
-      expect { @dst.restore(@key, 0, @dumped_value) }.to raise_error(Redis::CommandError)
-      expect(@dst.get(@key)).to eq('456')
-    end
-
-    it 'allows replacing the key if replace==true' do
-      expect(@dst.restore(@key, 0, @dumped_value, replace: true)).to eq('OK')
-      expect(@dst.get(@key)).to eq('123')
-    end
-  end
-
-  it 'sets ttl in ms' do
-    @dst.restore(@key, 500, @dumped_value)
-    expect(@dst.pttl(@key)).to eq(500)
-  end
-
-  it 'can dump/restore more complex data types' do
-    key = 'a_hash'
-    @src.mapped_hmset(key, foo: 'bar')
-    @dst.restore(key, 0, @src.dump(key))
-    expect(@dst.hgetall(key)).to eq('foo' => 'bar')
-  end
-end

data/spec/commands/rpop_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe '#rpop(key)' do
-  before { @key = 'mock-redis-test:43093' }
-
-  it 'returns and removes the first element of a list' do
-    @redises.lpush(@key, 1)
-    @redises.lpush(@key, 2)
-
-    @redises.rpop(@key).should == '1'
-
-    @redises.llen(@key).should == 1
-  end
-
-  it 'returns nil if the list is empty' do
-    @redises.lpush(@key, 'foo')
-    @redises.rpop(@key)
-
-    @redises.rpop(@key).should be_nil
-  end
-
-  it 'returns nil for nonexistent values' do
-    @redises.rpop(@key).should be_nil
-  end
-
-  it 'removes empty lists' do
-    @redises.lpush(@key, 'foo')
-    @redises.rpop(@key)
-
-    @redises.get(@key).should be_nil
-  end
-
-  let(:default_error) { RedisMultiplexer::MismatchedResponse }
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/rpoplpush_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe '#rpoplpush(source, destination)' do
-  before do
-    @list1 = 'mock-redis-test:rpoplpush-list1'
-    @list2 = 'mock-redis-test:rpoplpush-list2'
-
-    @redises.lpush(@list1, 'b')
-    @redises.lpush(@list1, 'a')
-
-    @redises.lpush(@list2, 'y')
-    @redises.lpush(@list2, 'x')
-  end
-
-  it 'returns the value moved' do
-    @redises.rpoplpush(@list1, @list2).should == 'b'
-  end
-
-  it "returns false and doesn't append if source empty" do
-    @redises.rpoplpush('empty', @list1).should be_nil
-    @redises.lrange(@list1, 0, -1).should == %w[a b]
-  end
-
-  it 'takes the last element of destination and prepends it to source' do
-    @redises.rpoplpush(@list1, @list2)
-
-    @redises.lrange(@list1, 0, -1).should == %w[a]
-    @redises.lrange(@list2, 0, -1).should == %w[b x y]
-  end
-
-  it 'rotates a list when source and destination are the same' do
-    @redises.rpoplpush(@list1, @list1)
-    @redises.lrange(@list1, 0, -1).should == %w[b a]
-  end
-
-  it 'removes empty lists' do
-    @redises.llen(@list1).times { @redises.rpoplpush(@list1, @list2) }
-    @redises.get(@list1).should be_nil
-  end
-
-  it 'raises an error for non-list source value' do
-    @redises.set(@list1, 'string value')
-
-    lambda do
-      @redises.rpoplpush(@list1, @list2)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/rpush_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe '#rpush(key)' do
-  before { @key = "mock-redis-test:#{__FILE__}" }
-
-  it 'returns the new size of the list' do
-    @redises.rpush(@key, 'X').should == 1
-    @redises.rpush(@key, 'X').should == 2
-  end
-
-  it 'creates a new list when run against a nonexistent key' do
-    @redises.rpush(@key, 'value')
-    @redises.llen(@key).should == 1
-  end
-
-  it 'appends items to the list' do
-    @redises.rpush(@key, 'bert')
-    @redises.rpush(@key, 'ernie')
-
-    @redises.lindex(@key, 0).should == 'bert'
-    @redises.lindex(@key, 1).should == 'ernie'
-  end
-
-  it 'stores values as strings' do
-    @redises.rpush(@key, 1)
-    @redises.lindex(@key, 0).should == '1'
-  end
-
-  it 'supports a variable number of arguments' do
-    @redises.rpush(@key, [1, 2, 3]).should == 3
-    @redises.lindex(@key, 0).should == '1'
-    @redises.lindex(@key, 1).should == '2'
-    @redises.lindex(@key, 2).should == '3'
-  end
-
-  it 'raises an error if an empty array is given' do
-    lambda do
-      @redises.rpush(@key, [])
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/rpushx_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe '#rpushx(key, value)' do
-  before { @key = 'mock-redis-test:92925' }
-
-  it 'returns the new size of the list' do
-    @redises.lpush(@key, 'X')
-
-    @redises.rpushx(@key, 'X').should == 2
-    @redises.rpushx(@key, 'X').should == 3
-  end
-
-  it 'does nothing when run against a nonexistent key' do
-    @redises.rpushx(@key, 'value')
-    @redises.get(@key).should be_nil
-  end
-
-  it 'appends items to the list' do
-    @redises.lpush(@key, 'bert')
-    @redises.rpushx(@key, 'ernie')
-
-    @redises.lindex(@key, 0).should == 'bert'
-    @redises.lindex(@key, 1).should == 'ernie'
-  end
-
-  it 'stores values as strings' do
-    @redises.rpush(@key, 1)
-    @redises.rpushx(@key, 2)
-    @redises.lindex(@key, 1).should == '2'
-  end
-
-  it 'raises an error if an empty array is given' do
-    @redises.lpush(@key, 'X')
-    lambda do
-      @redises.rpushx(@key, [])
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'stores multiple items if an array of more than one item is given' do
-    @redises.lpush(@key, 'X')
-    @redises.rpushx(@key, [1, 2]).should == 3
-    @redises.lrange(@key, 0, -1).should == %w[X 1 2]
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/sadd_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe '#sadd(key, member)' do
-  before { @key = 'mock-redis-test:sadd' }
-
-  it 'returns true if the set did not already contain member' do
-    @redises.sadd(@key, 1).should == true
-  end
-
-  it 'returns false if the set did already contain member' do
-    @redises.sadd(@key, 1)
-    @redises.sadd(@key, 1).should == false
-  end
-
-  it 'adds member to the set' do
-    @redises.sadd(@key, 1)
-    @redises.sadd(@key, 2)
-    @redises.smembers(@key).should == %w[2 1]
-  end
-
-  describe 'adding multiple members at once' do
-    it 'returns the amount of added members' do
-      @redises.sadd(@key, [1, 2, 3]).should == 3
-      @redises.sadd(@key, [1, 2, 3, 4]).should == 1
-    end
-
-    it 'returns 0 if the set did already contain all members' do
-      @redises.sadd(@key, [1, 2, 3])
-      @redises.sadd(@key, [1, 2, 3]).should == 0
-    end
-
-    it 'adds the members to the set' do
-      @redises.sadd(@key, [1, 2, 3])
-      @redises.smembers(@key).should == %w[1 2 3]
-    end
-
-    it 'raises an error if an empty array is given' do
-      lambda do
-        @redises.sadd(@key, [])
-      end.should raise_error(Redis::CommandError)
-    end
-  end
-
-  it_should_behave_like 'a set-only command'
-end

data/spec/commands/save_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe '#save' do
-  it "responds with 'OK'" do
-    @redises.save.should == 'OK'
-  end
-end

data/spec/commands/scan_each_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe '#scan_each' do
-  subject { MockRedis::Database.new(self) }
-
-  let(:match) { '*' }
-
-  before do
-    allow(subject).to receive_message_chain(:data, :keys).and_return(collection)
-  end
-
-  context 'when no keys are found' do
-    let(:collection) { [] }
-
-    it 'does not iterate over any elements' do
-      expect(subject.scan_each.to_a).to be_empty
-    end
-  end
-
-  context 'when keys are found' do
-    context 'when no match filter is supplied' do
-      let(:collection) { Array.new(20) { |i| "mock:key#{i}" } }
-
-      it 'iterates over each item in the collection' do
-        expect(subject.scan_each.to_a).to match_array(collection)
-      end
-    end
-
-    context 'when giving a custom match filter' do
-      let(:match) { 'mock:key*' }
-      let(:collection) { %w[mock:key mock:key2 mock:otherkey] }
-      let(:expected) { %w[mock:key mock:key2] }
-
-      it 'iterates over each item in the filtered collection' do
-        expect(subject.scan_each(match: match).to_a).to match_array(expected)
-      end
-    end
-  end
-end