mock_redis 0.19.0 → 0.24.0

data/spec/commands/xrange_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe '#xrange("mystream", first: "0-1", last: "0-3", count: 10)' do
+  before { @key = 'mock-redis-test:xrange' }
+
+  it 'finds an empty range' do
+    expect(@redises.xrange(@key, '-', '+')).to eq []
+  end
+
+  it 'finds a single entry with a full range' do
+    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-0')
+    expect(@redises.xrange(@key, '-', '+'))
+      .to eq [['1234567891234-0', { 'key' => 'value' }]]
+  end
+
+  it 'finds multiple key/value pairs with a full range' do
+    @redises.xadd(@key, { key1: 'value1', key2: 'value2', key3: 'value3' }, id: '1234567891234-0')
+    expect(@redises.xrange(@key, '-', '+'))
+      .to eq [['1234567891234-0', { 'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3' }]]
+  end
+
+  context 'six items on the list' do
+    before :each do
+      @redises.xadd(@key, { key1: 'value1' }, id: '1234567891234-0')
+      @redises.xadd(@key, { key2: 'value2' }, id: '1234567891245-0')
+      @redises.xadd(@key, { key3: 'value3' }, id: '1234567891245-1')
+      @redises.xadd(@key, { key4: 'value4' }, id: '1234567891278-0')
+      @redises.xadd(@key, { key5: 'value5' }, id: '1234567891278-1')
+      @redises.xadd(@key, { key6: 'value6' }, id: '1234567891299-0')
+    end
+
+    it 'returns entries in sequential order' do
+      expect(@redises.xrange(@key, '-', '+')).to eq(
+        [
+          ['1234567891234-0', { 'key1' => 'value1' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891299-0', { 'key6' => 'value6' }]
+        ]
+      )
+    end
+
+    it 'returns entries with a lower limit' do
+      expect(@redises.xrange(@key, '1234567891239-0', '+')).to eq(
+        [
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891299-0', { 'key6' => 'value6' }]
+        ]
+      )
+    end
+
+    it 'returns entries with an upper limit' do
+      expect(@redises.xrange(@key, '-', '1234567891285-0')).to eq(
+        [
+          ['1234567891234-0', { 'key1' => 'value1' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891278-1', { 'key5' => 'value5' }]
+        ]
+      )
+    end
+
+    it 'returns entries with both a lower and an upper limit' do
+      expect(@redises.xrange(@key, '1234567891239-0', '1234567891285-0')).to eq(
+        [
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891278-1', { 'key5' => 'value5' }]
+        ]
+      )
+    end
+
+    it 'finds the list with sequence numbers' do
+      expect(@redises.xrange(@key, '1234567891245-1', '1234567891278-0')).to eq(
+        [
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }]
+        ]
+      )
+    end
+
+    it 'finds the list with lower bound without sequence numbers' do
+      expect(@redises.xrange(@key, '1234567891245', '+')).to eq(
+        [
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891299-0', { 'key6' => 'value6' }]
+        ]
+      )
+    end
+
+    it 'finds the list with upper bound without sequence numbers' do
+      expect(@redises.xrange(@key, '-', '1234567891278')).to eq(
+        [
+          ['1234567891234-0', { 'key1' => 'value1' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891278-1', { 'key5' => 'value5' }]
+        ]
+      )
+    end
+
+    it 'accepts limits as integers' do
+      expect(@redises.xrange(@key, 1_234_567_891_245, 1_234_567_891_278)).to eq(
+        [
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891278-1', { 'key5' => 'value5' }]
+        ]
+      )
+    end
+
+    it 'returns a limited number of items' do
+      expect(@redises.xrange(@key, '-', '+', count: 2)).to eq(
+        [
+          ['1234567891234-0', { 'key1' => 'value1' }],
+          ['1234567891245-0', { 'key2' => 'value2' }]
+        ]
+      )
+    end
+  end
+
+  it 'raises an invalid stream id error' do
+    expect { @redises.xrange(@key, 'X', '+') }
+      .to raise_error(
+        Redis::CommandError,
+        'ERR Invalid stream ID specified as stream command argument'
+      )
+  end
+end

data/spec/commands/xrevrange_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe '#xrevrange(key, start, end)' do
+  before { @key = 'mock-redis-test:xrevrange' }
+
+  it 'finds an empty range' do
+    expect(@redises.xrevrange(@key, '-', '+')).to eq []
+  end
+
+  it 'finds a single entry with a full range' do
+    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-0')
+    expect(@redises.xrevrange(@key, '+', '-'))
+      .to eq [['1234567891234-0', { 'key' => 'value' }]]
+  end
+
+  it 'finds multiple key/value pairs with a full range' do
+    @redises.xadd(@key, { key1: 'value1', key2: 'value2', key3: 'value3' }, id: '1234567891234-0')
+    expect(@redises.xrevrange(@key, '+', '-'))
+      .to eq [['1234567891234-0', { 'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3' }]]
+  end
+
+  context 'six items on the list' do
+    before :each do
+      @redises.xadd(@key, { key1: 'value1' }, id: '1234567891234-0')
+      @redises.xadd(@key, { key2: 'value2' }, id: '1234567891245-0')
+      @redises.xadd(@key, { key3: 'value3' }, id: '1234567891245-1')
+      @redises.xadd(@key, { key4: 'value4' }, id: '1234567891278-0')
+      @redises.xadd(@key, { key5: 'value5' }, id: '1234567891278-1')
+      @redises.xadd(@key, { key6: 'value6' }, id: '1234567891299-0')
+    end
+
+    it 'returns entries in sequential order' do
+      expect(@redises.xrevrange(@key, '+', '-')).to eq(
+        [
+          ['1234567891299-0', { 'key6' => 'value6' }],
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891234-0', { 'key1' => 'value1' }],
+        ]
+      )
+    end
+
+    it 'returns entries with a lower limit' do
+      expect(@redises.xrevrange(@key, '+', '1234567891239-0')).to eq(
+        [
+          ['1234567891299-0', { 'key6' => 'value6' }],
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+        ]
+      )
+    end
+
+    it 'returns entries with an upper limit' do
+      expect(@redises.xrevrange(@key, '1234567891285-0', '-')).to eq(
+        [
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891234-0', { 'key1' => 'value1' }],
+        ]
+      )
+    end
+
+    it 'returns entries with both a lower and an upper limit' do
+      expect(@redises.xrevrange(@key, '1234567891285-0', '1234567891239-0')).to eq(
+        [
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+        ]
+      )
+    end
+
+    it 'finds the list with sequence numbers' do
+      expect(@redises.xrevrange(@key, '1234567891278-0', '1234567891245-1')).to eq(
+        [
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+        ]
+      )
+    end
+
+    it 'finds the list with lower bound without sequence numbers' do
+      expect(@redises.xrevrange(@key, '+', '1234567891245')).to eq(
+        [
+          ['1234567891299-0', { 'key6' => 'value6' }],
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+        ]
+      )
+    end
+
+    it 'finds the list with upper bound without sequence numbers' do
+      expect(@redises.xrevrange(@key, '1234567891278', '-')).to eq(
+        [
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891234-0', { 'key1' => 'value1' }],
+        ]
+      )
+    end
+
+    it 'returns a limited number of items' do
+      expect(@redises.xrevrange(@key, count: 2)).to eq(
+        [
+          ['1234567891299-0', { 'key6' => 'value6' }],
+          ['1234567891278-1', { 'key5' => 'value5' }],
+        ]
+      )
+    end
+  end
+
+  it 'raises an invalid stream id error' do
+    expect { @redises.xrevrange(@key, 'X', '-') }
+      .to raise_error(
+        Redis::CommandError,
+        'ERR Invalid stream ID specified as stream command argument'
+      )
+  end
+end

data/spec/commands/xtrim_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe '#xtrim("mystream", 1000, approximate: true)' do
+  before { @key = 'mock-redis-test:xtrim' }
+
+  before :each do
+    @redises.xadd(@key, { key1: 'value1' }, id: '1234567891234-0')
+    @redises.xadd(@key, { key2: 'value2' }, id: '1234567891245-0')
+    @redises.xadd(@key, { key3: 'value3' }, id: '1234567891245-1')
+    @redises.xadd(@key, { key4: 'value4' }, id: '1234567891278-0')
+    @redises.xadd(@key, { key5: 'value5' }, id: '1234567891278-1')
+    @redises.xadd(@key, { key6: 'value6' }, id: '1234567891299-0')
+  end
+
+  it 'returns the number of elements deleted' do
+    expect(@redises.xtrim(@key, 4)).to eq 2
+  end
+
+  it 'deletes the oldes elements' do
+    @redises.xtrim(@key, 4)
+    expect(@redises.xrange(@key, '-', '+')).to eq(
+      [
+        ['1234567891245-1', { 'key3' => 'value3' }],
+        ['1234567891278-0', { 'key4' => 'value4' }],
+        ['1234567891278-1', { 'key5' => 'value5' }],
+        ['1234567891299-0', { 'key6' => 'value6' }]
+      ]
+    )
+  end
+end

data/spec/commands/zinterstore_spec.rb

@@ -42,6 +42,40 @@ describe '#zinterstore(destination, keys, [:weights => [w,w,], [:aggregate => :s
     end.should raise_error(Redis::CommandError)
   end
 
+  context 'when used with a set' do
+    before do
+      @primes_text = 'mock-redis-test:zinterstore:primes-text'
+
+      @redises.sadd(@primes_text, 'two')
+      @redises.sadd(@primes_text, 'three')
+      @redises.sadd(@primes_text, 'five')
+      @redises.sadd(@primes_text, 'seven')
+    end
+
+    it 'returns the number of elements in the new set' do
+      @redises.zinterstore(@dest, [@odds, @primes_text]).should == 3
+    end
+
+    it 'sums the scores, substituting 1.0 for set values' do
+      @redises.zinterstore(@dest, [@odds, @primes_text])
+      @redises.zrange(@dest, 0, -1, :with_scores => true).should ==
+        [['three', 4.0], ['five', 6.0], ['seven', 8.0]]
+    end
+  end
+
+  context 'when used with a non-coercible structure' do
+    before do
+      @non_set = 'mock-redis-test:zinterstore:non-set'
+
+      @redises.set(@non_set, 'one')
+    end
+    it 'raises an error for wrong value type' do
+      lambda do
+        @redises.zinterstore(@dest, [@odds, @non_set])
+      end.should raise_error(Redis::CommandError)
+    end
+  end
+
   context 'the :weights argument' do
     it 'multiplies the scores by the weights while aggregating' do
       @redises.zinterstore(@dest, [@odds, @primes], :weights => [2, 3])

data/spec/commands/zpopmax_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe '#zpopmax(key, count)' do
+  before(:each) do
+    @key = 'mock-redis-test:zpopmax'
+    @redises.del(@key)
+    @redises.zadd(@key, 1, 'one')
+    @redises.zadd(@key, 2, 'two')
+    @redises.zadd(@key, 3, 'three')
+  end
+
+  context 'when count is unspecified' do
+    it 'returns nil if the set does not exist' do
+      @redises.zpopmax('does-not-exist').should nil
+    end
+
+    it 'returns the highest ranked element' do
+      @redises.zpopmax(@key).should == ['three', 3]
+      @redises.zcard(@key).should == 2
+    end
+  end
+
+  context 'when count is 1' do
+    let(:count) { 1 }
+
+    it 'returns nil if the set does not exist' do
+      @redises.zpopmax('does-not-exist', count).should nil
+    end
+
+    it 'returns the highest ranked element' do
+      @redises.zpopmax(@key, count).should == ['three', 3]
+      @redises.zcard(@key).should == 2
+    end
+  end
+
+  context 'when count is greater than 1' do
+    let(:count) { 2 }
+
+    it 'returns empty array if the set does not exist' do
+      @redises.zpopmax('does-not-exist', count).should == []
+    end
+
+    it 'returns the highest ranked elements' do
+      @redises.zpopmax(@key, count).should == [['three', 3], ['two', 2]]
+      @redises.zcard(@key).should == 1
+    end
+  end
+
+  context 'when count is greater than the size of the set' do
+    let(:count) { 4 }
+
+    it 'returns the entire set' do
+      before = @redises.zrange(@key, 0, count, with_scores: true).reverse
+      @redises.zpopmax(@key, count).should == before
+      @redises.zcard(@key).should == 0
+    end
+  end
+
+  it_should_behave_like 'a zset-only command'
+end

data/spec/commands/zpopmin_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe '#zpopmin(key, count)' do
+  before(:each) do
+    @key = 'mock-redis-test:zpopmin'
+    @redises.del(@key)
+    @redises.zadd(@key, 1, 'one')
+    @redises.zadd(@key, 2, 'two')
+    @redises.zadd(@key, 3, 'three')
+  end
+
+  context 'when count is unspecified' do
+    it 'returns nil if the set does not exist' do
+      @redises.zpopmin('does-not-exist').should nil
+    end
+
+    it 'returns the lowest ranked element' do
+      @redises.zpopmin(@key).should == ['one', 1]
+      @redises.zcard(@key).should == 2
+    end
+  end
+
+  context 'when count is 1' do
+    let(:count) { 1 }
+
+    it 'returns nil if the set does not exist' do
+      @redises.zpopmin('does-not-exist', count).should nil
+    end
+
+    it 'returns the lowest ranked element' do
+      @redises.zpopmin(@key, count).should == ['one', 1]
+      @redises.zcard(@key).should == 2
+    end
+  end
+
+  context 'when count is greater than 1' do
+    let(:count) { 2 }
+
+    it 'returns empty array if the set does not exist' do
+      @redises.zpopmin('does-not-exist', count).should == []
+    end
+
+    it 'returns the lowest ranked elements' do
+      @redises.zpopmin(@key, count).should == [['one', 1], ['two', 2]]
+      @redises.zcard(@key).should == 1
+    end
+  end
+
+  context 'when count is greater than the size of the set' do
+    let(:count) { 4 }
+
+    it 'returns the entire set' do
+      before = @redises.zrange(@key, 0, count, with_scores: true)
+      @redises.zpopmin(@key, count).should == before
+      @redises.zcard(@key).should == 0
+    end
+  end
+
+  it_should_behave_like 'a zset-only command'
+end