mock_redis 0.32.0 → 0.44.0

data/spec/commands/sscan_each_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe '#sscan_each' do
-  subject { MockRedis::Database.new(self) }
-
-  let(:key) { 'mock-redis-test:sscan_each' }
-
-  before do
-    allow(subject).to receive(:smembers).and_return(collection)
-  end
-
-  context 'when no keys are found' do
-    let(:collection) { [] }
-
-    it 'does not iterate over any elements' do
-      results = subject.sscan_each(key).map do |k|
-        k
-      end
-      expect(results).to match_array(collection)
-    end
-  end
-
-  context 'when keys are found' do
-    context 'when no match filter is supplied' do
-      let(:collection) { Array.new(20) { |i| "k#{i}" } }
-
-      it 'iterates over each item in the collection' do
-        results = subject.sscan_each(key).map do |k|
-          k
-        end
-        expect(results).to match_array(collection)
-      end
-    end
-
-    context 'when giving a custom match filter' do
-      let(:match) { 'k1*' }
-      let(:collection) { Array.new(12) { |i| "k#{i}" } }
-      let(:expected) { %w[k1 k10 k11] }
-
-      it 'iterates over each item in the filtered collection' do
-        results = subject.sscan_each(key, match: match).map do |k|
-          k
-        end
-        expect(results).to match_array(expected)
-      end
-    end
-  end
-end

data/spec/commands/sscan_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe '#sscan' do
-  let(:count) { 10 }
-  let(:match) { '*' }
-  let(:key) { 'mock-redis-test:sscan' }
-
-  before do
-    # The return order of the members is non-deterministic, so we sort them to compare
-    expect_any_instance_of(Redis).to receive(:sscan).and_wrap_original do |m, *args|
-      result = m.call(*args)
-      [result[0], result[1].sort]
-    end
-    expect_any_instance_of(MockRedis).to receive(:sscan).and_wrap_original do |m, *args|
-      result = m.call(*args)
-      [result[0], result[1].sort]
-    end
-  end
-
-  context 'when the set does not exist' do
-    it 'returns a 0 cursor and an empty collection' do
-      expect(@redises.sscan(key, 0, count: count, match: match)).to eq(['0', []])
-    end
-  end
-
-  context 'when the set exists' do
-    before do
-      @redises.sadd(key, 'Hello')
-      @redises.sadd(key, 'World')
-      @redises.sadd(key, 'Test')
-    end
-
-    let(:expected) { ['0', %w[Hello Test World]] }
-
-    it 'returns a 0 cursor and the collection' do
-      expect(@redises.sscan(key, 0, count: count)).to eq(expected)
-    end
-  end
-end

data/spec/commands/strlen_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe '#strlen(key)' do
-  before do
-    @key = 'mock-redis-test:73288'
-    @redises.set(@key, '5 ∈ (0..10)')
-  end
-
-  it "returns the string's length in bytes" do
-    @redises.strlen(@key).should == 13
-  end
-
-  it 'returns 0 for a nonexistent value' do
-    @redises.strlen('mock-redis-test:does-not-exist').should == 0
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/sunion_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe '#sunion(key [, key, ...])' do
-  before do
-    @evens   = 'mock-redis-test:sunion:evens'
-    @primes  = 'mock-redis-test:sunion:primes'
-
-    [2, 4, 6, 8, 10].each { |i| @redises.sadd(@evens, i) }
-    [2, 3, 5, 7].each { |i| @redises.sadd(@primes, i) }
-  end
-
-  it 'returns the elements in the resulting set' do
-    @redises.sunion(@evens, @primes).should == %w[2 4 6 8 10 3 5 7]
-  end
-
-  it 'treats missing keys as empty sets' do
-    @redises.sunion(@primes, 'mock-redis-test:nonesuch').
-      should == %w[2 3 5 7]
-  end
-
-  it 'allows Array as argument' do
-    @redises.sunion([@evens, @primes]).should == %w[2 4 6 8 10 3 5 7]
-  end
-
-  it 'raises an error if given 0 sets' do
-    lambda do
-      @redises.sunion
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an error if any argument is not a a set' do
-    @redises.set('mock-redis-test:notset', 1)
-
-    lambda do
-      @redises.sunion(@numbers, 'mock-redis-test:notset')
-    end.should raise_error(Redis::CommandError)
-
-    lambda do
-      @redises.sunion('mock-redis-test:notset', @numbers)
-    end.should raise_error(Redis::CommandError)
-  end
-end

data/spec/commands/sunionstore_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe '#sunionstore(destination, key [, key, ...])' do
-  before do
-    @evens       = 'mock-redis-test:sunionstore:evens'
-    @primes      = 'mock-redis-test:sunionstore:primes'
-    @destination = 'mock-redis-test:sunionstore:destination'
-
-    [2, 4, 6, 8, 10].each { |i| @redises.sadd(@evens, i) }
-    [2, 3, 5, 7].each { |i| @redises.sadd(@primes, i) }
-  end
-
-  it 'returns the number of elements in the resulting set' do
-    @redises.sunionstore(@destination, @primes, @evens).should == 8
-  end
-
-  it 'stores the resulting set' do
-    @redises.sunionstore(@destination, @primes, @evens)
-    @redises.smembers(@destination).should == %w[10 8 6 4 7 5 3 2]
-  end
-
-  it 'does not store empty sets' do
-    @redises.sunionstore(@destination,
-      'mock-redis-test:nonesuch',
-      'mock-redis-test:nonesuch2').should == 0
-    @redises.get(@destination).should be_nil
-  end
-
-  it 'removes existing elements in destination' do
-    @redises.sadd(@destination, 42)
-
-    @redises.sunionstore(@destination, @primes)
-    @redises.smembers(@destination).should == %w[7 5 3 2]
-  end
-
-  it 'correctly unions and stores when the destination is empty and is one of the arguments' do
-    @redises.sunionstore(@destination, @destination, @primes)
-
-    @redises.smembers(@destination).should == %w[7 5 3 2]
-  end
-
-  it 'raises an error if given 0 sets' do
-    lambda do
-      @redises.sunionstore(@destination)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an error if any argument is not a a set' do
-    @redises.set('mock-redis-test:notset', 1)
-
-    lambda do
-      @redises.sunionstore(@destination, @primes, 'mock-redis-test:notset')
-    end.should raise_error(Redis::CommandError)
-
-    lambda do
-      @redises.sunionstore(@destination, 'mock-redis-test:notset', @primes)
-    end.should raise_error(Redis::CommandError)
-  end
-end

data/spec/commands/ttl_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe '#ttl(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.ttl(@key).should == -1
-  end
-
-  it 'returns -2 for a key that does not exist' do
-    @redises.ttl('mock-redis-test:nonesuch').should == -2
-  end
-
-  it 'stringifies key' do
-    @redises.expire(@key, 9)
-    @redises.ttl(@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
-      Time.stub(:now).and_return(@now)
-    end
-
-    it "gives you the key's remaining lifespan in seconds" do
-      @mock.expire(@key, 5)
-      @mock.ttl(@key).should == 5
-    end
-  end
-end

data/spec/commands/type_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe '#type(key)' do
-  before do
-    @key = 'mock-redis-test:type'
-  end
-
-  it "returns 'none' for no key" do
-    @redises.type(@key).should == 'none'
-  end
-
-  it "returns 'string' for a string" do
-    @redises.set(@key, 'stringlish')
-    @redises.type(@key).should == 'string'
-  end
-
-  it "returns 'list' for a list" do
-    @redises.lpush(@key, 100)
-    @redises.type(@key).should == 'list'
-  end
-
-  it "returns 'hash' for a hash" do
-    @redises.hset(@key, 100, 200)
-    @redises.type(@key).should == 'hash'
-  end
-
-  it "returns 'set' for a set" do
-    @redises.sadd(@key, 100)
-    @redises.type(@key).should == 'set'
-  end
-
-  it "returns 'zset' for a zset" do
-    @redises.zadd(@key, 1, 2)
-    @redises.type(@key).should == 'zset'
-  end
-end

data/spec/commands/unwatch_spec.rb

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

data/spec/commands/watch_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe '#watch(key [, key, ...)' do
-  before do
-    @key1 = 'mock-redis-test-watch1'
-    @key2 = 'mock-redis-test-watch2'
-  end
-
-  it "returns 'OK'" do
-    @redises.watch(@key1, @key2).should == 'OK'
-  end
-
-  it 'EXECs its MULTI on successes' do
-    @redises.watch @key1, @key2 do
-      @redises.multi do |multi|
-        multi.set 'bar', 'baz'
-      end
-    end
-    @redises.get('bar').should eq('baz')
-  end
-end

data/spec/commands/xadd_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-describe '#xadd("mystream", { f1: "v1", f2: "v2" }, id: "0-0", maxlen: 1000, approximate: true)' do
-  before :all do
-    sleep 1 - (Time.now.to_f % 1)
-    @key = 'mock-redis-test:xadd'
-  end
-
-  before :each do
-    # TODO: Redis appears to be returning a timestamp a few seconds in the future
-    # so we're ignoring the last 5 digits (time in milliseconds)
-    @redises._gsub(/\d{5}-\d/, '....-.')
-  end
-
-  it 'returns an id based on the timestamp' do
-    t = Time.now.to_i
-    id = @redises.xadd(@key, { key: 'value' })
-    expect(id).to match(/#{t}\d{3}-0/)
-  end
-
-  it 'adds data with symbols' do
-    @redises.xadd(@key, { symbol_key: :symbol_value })
-    expect(@redises.xrange(@key, '-', '+').last[1])
-      .to eq('symbol_key' => 'symbol_value')
-  end
-
-  it 'increments the sequence number with the same timestamp' do
-    Timecop.freeze do
-      @redises.xadd(@key, { key: 'value' })
-      expect(@redises.xadd(@key, { key: 'value' })).to match(/\d+-1/)
-    end
-  end
-
-  it 'sets the id if it is given' do
-    expect(@redises.xadd(@key, { key: 'value' }, id: '1234567891234-2'))
-      .to eq '1234567891234-2'
-  end
-
-  it 'accepts is as an integer' do
-    expect(@redises.xadd(@key, { key: 'value' }, id: 1_234_567_891_234))
-      .to eq '1234567891234-0'
-  end
-
-  it 'raises exception if id is less that stream top item' do
-    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-0')
-    expect { @redises.xadd(@key, { key: 'value' }, id: '1234567891233-0') }
-      .to raise_error(
-        Redis::CommandError,
-        'ERR The ID specified in XADD is equal or smaller than the target ' \
-        'stream top item'
-      )
-  end
-
-  it 'raises exception if id of 0 is added to an empty stream' do
-    expect { @redises.xadd('mock-redis-test:unknown-stream', { key: 'value' }, id: '0') }
-      .to raise_error(
-        Redis::CommandError,
-        'ERR The ID specified in XADD must be greater than 0-0'
-      )
-  end
-
-  it 'does not raise exception on empty stream with id of 0 and positive sequence number' do
-    expect { @redises.xadd('mock-redis-test:unknown-stream', { key: 'value' }, id: '0-1') }
-      .to_not raise_error
-  end
-
-  it 'caters for the current time being before the last time' do
-    t = (Time.now.to_f * 1000).to_i + 2000
-    @redises.xadd(@key, { key: 'value' }, id: "#{t}-0")
-    expect(@redises.xadd(@key, { key: 'value' })).to match(/#{t}-1/)
-  end
-
-  it 'appends a sequence number if it is missing' do
-    expect(@redises.xadd(@key, { key: 'value' }, id: '1234567891234'))
-      .to eq '1234567891234-0'
-  end
-
-  it 'raises an invalid stream id error' do
-    expect { @redises.xadd(@key, { key: 'value' }, id: 'X') }
-      .to raise_error(
-        Redis::CommandError,
-        'ERR Invalid stream ID specified as stream command argument'
-      )
-  end
-
-  it 'caps the stream to 5 elements' 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')
-    @redises.xadd(@key, { key7: 'value7' }, id: '1234567891300-0', maxlen: 5)
-    expect(@redises.xrange(@key, '-', '+')).to eq(
-      [
-        ['1234567891245-1', { 'key3' => 'value3' }],
-        ['1234567891278-0', { 'key4' => 'value4' }],
-        ['1234567891278-1', { 'key5' => 'value5' }],
-        ['1234567891299-0', { 'key6' => 'value6' }],
-        ['1234567891300-0', { 'key7' => 'value7' }]
-      ]
-    )
-  end
-
-  it 'supports a maxlen greater than the current size' do
-    @redises.xadd(@key, { key1: 'value1' }, id: '1234567891234-0')
-    @redises.xadd(@key, { key2: 'value2' }, id: '1234567891245-0', maxlen: 1000)
-    expect(@redises.xrange(@key, '-', '+')).to eq(
-      [
-        ['1234567891234-0', { 'key1' => 'value1' }],
-        ['1234567891245-0', { 'key2' => 'value2' }],
-      ]
-    )
-  end
-
-  it 'creates an empty stream with maxlen of 0' do
-    @redises.xadd(@key, { key: 'value' }, maxlen: 0)
-    expect(@redises.xlen(@key)).to eq 0
-    expect(@redises.xrange(@key, '-', '+')).to eq([])
-    expect(@redises.exists?(@key)).to eq true
-  end
-end

data/spec/commands/xlen_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe '#xlen(key)' do
-  before :all do
-    sleep 1 - (Time.now.to_f % 1)
-    @key = 'mock-redis-test:xlen'
-  end
-
-  before :each do
-    # TODO: Redis appears to be returning a timestamp a few seconds in the future
-    # so we're ignoring the last 5 digits (time in milliseconds)
-    @redises._gsub(/\d{5}-\d/, '...-.')
-  end
-
-  it 'returns the number of items in the stream' do
-    expect(@redises.xlen(@key)).to eq 0
-    @redises.xadd(@key, { key: 'value' })
-    expect(@redises.xlen(@key)).to eq 1
-    3.times { @redises.xadd(@key, { key: 'value' }) }
-    expect(@redises.xlen(@key)).to eq 4
-  end
-end

data/spec/commands/xrange_spec.rb

@@ -1,164 +0,0 @@
-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 all entries with a lower limit of 0-0' do
-      expect(@redises.xrange(@key, '0-0', '+')).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 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 inclusive' do
-      expect(@redises.xrange(@key, '1234567891245-0', '1234567891278-0')).to eq(
-        [
-          ['1234567891245-0', { 'key2' => 'value2' }],
-          ['1234567891245-1', { 'key3' => 'value3' }],
-          ['1234567891278-0', { 'key4' => 'value4' }]
-        ]
-      )
-    end
-
-    it 'returns entries with both a lower and an upper limit exclusive' do
-      expect(@redises.xrange(@key, '(1234567891245-0', '1234567891285-1')).to eq(
-        [
-          # We no longer get '1234567891245-0'
-          ['1234567891245-1', { 'key3' => 'value3' }],
-          ['1234567891278-0', { 'key4' => 'value4' }],
-          ['1234567891278-1', { 'key5' => 'value5' }] # Note sequence -1
-        ]
-      )
-    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