mock_redis 0.36.0 → 0.37.0

data/spec/commands/keys_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-describe '#keys()' do
-  it 'returns [] when no keys are found (no regex characters)' do
-    @redises.keys('mock-redis-test:29016').should == []
-  end
-
-  it 'returns [] when no keys are found (some regex characters)' do
-    @redises.keys('mock-redis-test:29016*').should == []
-  end
-
-  describe 'with pattern matching' do
-    before do
-      @redises.set('mock-redis-test:key',   0)
-      @redises.set('mock-redis-test:key1',  1)
-      @redises.set('mock-redis-test:key2',  2)
-      @redises.set('mock-redis-test:key3',  3)
-      @redises.set('mock-redis-test:key10', 10)
-      @redises.set('mock-redis-test:key20', 20)
-      @redises.set('mock-redis-test:key30', 30)
-
-      @redises.set('mock-redis-test:regexp-key(1|22)', 40)
-      @redises.set('mock-redis-test:regexp-key3+', 40)
-      @redises.set('mock-redis-test:regexp-key33', 40)
-      @redises.set('mock-redis-test:regexp-key4a', 40)
-      @redises.set('mock-redis-test:regexp-key4-', 40)
-      @redises.set('mock-redis-test:regexp-key4b', 40)
-      @redises.set('mock-redis-test:regexp-key4c', 40)
-
-      @redises.set('mock-redis-test:special-key?', 'true')
-      @redises.set('mock-redis-test:special-key*', 'true')
-      @redises.set('mock-redis-test:special-key-!?*', 'true')
-    end
-
-    describe 'the ? character' do
-      it 'is treated as a single character (at the end of the pattern)' do
-        @redises.keys('mock-redis-test:key?').sort.should == [
-          'mock-redis-test:key1',
-          'mock-redis-test:key2',
-          'mock-redis-test:key3',
-        ]
-      end
-
-      it 'is treated as a single character (in the middle of the pattern)' do
-        @redises.keys('mock-redis-test:key?0').sort.should == [
-          'mock-redis-test:key10',
-          'mock-redis-test:key20',
-          'mock-redis-test:key30',
-        ]
-      end
-
-      it 'treats \\? as a literal ?' do
-        @redises.keys('mock-redis-test:special-key\?').sort.should == [
-          'mock-redis-test:special-key?',
-        ]
-      end
-
-      context 'multiple ? characters' do
-        it "properly handles multiple consequtive '?' characters" do
-          @redises.keys('mock-redis-test:special-key-???').sort.should == [
-            'mock-redis-test:special-key-!?*',
-          ]
-        end
-
-        context '\\? as a literal ' do
-          it 'handles multiple ? as both literal and special character' do
-            @redises.keys('mock-redis-test:special-key-?\??').sort.should == [
-              'mock-redis-test:special-key-!?*',
-            ]
-          end
-        end
-      end
-    end
-
-    describe 'the * character' do
-      it 'is treated as 0 or more characters' do
-        @redises.keys('mock-redis-test:key*').sort.should == [
-          'mock-redis-test:key',
-          'mock-redis-test:key1',
-          'mock-redis-test:key10',
-          'mock-redis-test:key2',
-          'mock-redis-test:key20',
-          'mock-redis-test:key3',
-          'mock-redis-test:key30',
-        ]
-      end
-
-      it 'treats \\* as a literal *' do
-        @redises.keys('mock-redis-test:special-key\*').sort.should == [
-          'mock-redis-test:special-key*',
-        ]
-      end
-    end
-
-    describe 'character classes ([abcde])' do
-      it 'matches any one of those characters' do
-        @redises.keys('mock-redis-test:key[12]').sort.should == [
-          'mock-redis-test:key1',
-          'mock-redis-test:key2',
-        ]
-      end
-    end
-
-    describe 'the | character' do
-      it "is treated as literal (not 'or')" do
-        @redises.keys('mock-redis-test:regexp-key(1|22)').sort.should == [
-          'mock-redis-test:regexp-key(1|22)',
-        ]
-      end
-    end
-
-    describe 'the + character' do
-      it "is treated as literal (not 'one or more' quantifier)" do
-        @redises.keys('mock-redis-test:regexp-key3+').sort.should == [
-          'mock-redis-test:regexp-key3+',
-        ]
-      end
-    end
-
-    describe 'character classes ([a-c])' do
-      it 'specifies a range which matches any lowercase letter from "a" to "c"' do
-        @redises.keys('mock-redis-test:regexp-key4[a-c]').sort.should == [
-          'mock-redis-test:regexp-key4a',
-          'mock-redis-test:regexp-key4b',
-          'mock-redis-test:regexp-key4c',
-        ]
-      end
-    end
-
-    describe 'combining metacharacters' do
-      it 'works with different metacharacters simultaneously' do
-        @redises.keys('mock-redis-test:k*[12]?').sort.should == [
-          'mock-redis-test:key10',
-          'mock-redis-test:key20',
-        ]
-      end
-    end
-  end
-end

data/spec/commands/lastsave_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-describe '#lastsave [mock only]' do
-  # can't test against both since it's timing-dependent
-  it 'returns a Unix time' do
-    @redises.mock.lastsave.to_s.should =~ /^\d+$/
-  end
-end

data/spec/commands/lindex_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe '#lindex(key, index)' do
-  before { @key = 'mock-redis-test:69312' }
-
-  it 'gets an element from the list by its index' do
-    @redises.lpush(@key, 20)
-    @redises.lpush(@key, 10)
-
-    @redises.lindex(@key, 0).should == '10'
-    @redises.lindex(@key, 1).should == '20'
-  end
-
-  it 'treats negative indices as coming from the right' do
-    @redises.lpush(@key, 20)
-    @redises.lpush(@key, 10)
-
-    @redises.lindex(@key, -1).should == '20'
-    @redises.lindex(@key, -2).should == '10'
-  end
-
-  it 'gets an element from the list by its index when index is a string' do
-    @redises.lpush(@key, 20)
-    @redises.lpush(@key, 10)
-
-    @redises.lindex(@key, '0').should == '10'
-    @redises.lindex(@key, '1').should == '20'
-    @redises.lindex(@key, '-1').should == '20'
-    @redises.lindex(@key, '-2').should == '10'
-  end
-
-  it 'returns nil if the index is too large (and positive)' do
-    @redises.lpush(@key, 20)
-
-    @redises.lindex(@key, 100).should be_nil
-  end
-
-  it 'returns nil if the index is too large (and negative)' do
-    @redises.lpush(@key, 20)
-
-    @redises.lindex(@key, -100).should be_nil
-  end
-
-  it 'returns nil for nonexistent values' do
-    @redises.lindex(@key, 0).should be_nil
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/linsert_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe '#linsert(key, :before|:after, pivot, value)' do
-  before { @key = 'mock-redis-test:48733' }
-
-  it 'returns the new size of the list when the pivot is found' do
-    @redises.lpush(@key, 'X')
-
-    @redises.linsert(@key, :before, 'X', 'Y').should == 2
-    @redises.lpushx(@key, 'X').should == 3
-  end
-
-  it 'does nothing when run against a nonexistent key' do
-    @redises.linsert(@key, :before, 1, 2).should == 0
-    @redises.get(@key).should be_nil
-  end
-
-  it 'returns -1 if the pivot is not found' do
-    @redises.lpush(@key, 1)
-    @redises.linsert(@key, :after, 'X', 'Y').should == -1
-  end
-
-  it 'inserts elements before the pivot when given :before as position' do
-    @redises.lpush(@key, 'bert')
-    @redises.linsert(@key, :before, 'bert', 'ernie')
-
-    @redises.lindex(@key, 0).should == 'ernie'
-    @redises.lindex(@key, 1).should == 'bert'
-  end
-
-  it "inserts elements before the pivot when given 'before' as position" do
-    @redises.lpush(@key, 'bert')
-    @redises.linsert(@key, 'before', 'bert', 'ernie')
-
-    @redises.lindex(@key, 0).should == 'ernie'
-    @redises.lindex(@key, 1).should == 'bert'
-  end
-
-  it 'inserts elements after the pivot when given :after as position' do
-    @redises.lpush(@key, 'bert')
-    @redises.linsert(@key, :after, 'bert', 'ernie')
-
-    @redises.lindex(@key, 0).should == 'bert'
-    @redises.lindex(@key, 1).should == 'ernie'
-  end
-
-  it "inserts elements after the pivot when given 'after' as position" do
-    @redises.lpush(@key, 'bert')
-    @redises.linsert(@key, 'after', 'bert', 'ernie')
-
-    @redises.lindex(@key, 0).should == 'bert'
-    @redises.lindex(@key, 1).should == 'ernie'
-  end
-
-  it 'raises an error when given a position that is neither before nor after' do
-    lambda do
-      @redises.linsert(@key, :near, 1, 2)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'stores values as strings' do
-    @redises.lpush(@key, 1)
-    @redises.linsert(@key, :before, 1, 2)
-    @redises.lindex(@key, 0).should == '2'
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/llen_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe '#llen(key)' do
-  before { @key = 'mock-redis-test:78407' }
-
-  it 'returns 0 for a nonexistent key' do
-    @redises.llen(@key).should == 0
-  end
-
-  it 'returns the length of the list' do
-    5.times { @redises.lpush(@key, 'X') }
-    @redises.llen(@key).should == 5
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/lmove_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-describe '#lmove(source, destination, wherefrom, whereto)' do
-  before do
-    @list1 = 'mock-redis-test:lmove-list1'
-    @list2 = 'mock-redis-test:lmove-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.lmove(@list1, @list2, 'left', 'right').should == 'a'
-  end
-
-  it "returns nil and doesn't append if source empty" do
-    @redises.lmove('empty', @list1, 'left', 'right').should be_nil
-    @redises.lrange(@list1, 0, -1).should == %w[a b]
-  end
-
-  it 'takes the first element of source and prepends it to destination' do
-    @redises.lmove(@list1, @list2, 'left', 'left')
-
-    @redises.lrange(@list1, 0, -1).should == %w[b]
-    @redises.lrange(@list2, 0, -1).should == %w[a x y]
-  end
-
-  it 'takes the first element of source and appends it to destination' do
-    @redises.lmove(@list1, @list2, 'left', 'right')
-
-    @redises.lrange(@list1, 0, -1).should == %w[b]
-    @redises.lrange(@list2, 0, -1).should == %w[x y a]
-  end
-
-  it 'takes the last element of source and prepends it to destination' do
-    @redises.lmove(@list1, @list2, 'right', 'left')
-
-    @redises.lrange(@list1, 0, -1).should == %w[a]
-    @redises.lrange(@list2, 0, -1).should == %w[b x y]
-  end
-
-  it 'takes the last element of source and appends it to destination' do
-    @redises.lmove(@list1, @list2, 'right', 'right')
-
-    @redises.lrange(@list1, 0, -1).should == %w[a]
-    @redises.lrange(@list2, 0, -1).should == %w[x y b]
-  end
-
-  it 'rotates a list when source and destination are the same' do
-    @redises.lmove(@list1, @list1, 'left', 'right')
-    @redises.lrange(@list1, 0, -1).should == %w[b a]
-  end
-
-  it 'removes empty lists' do
-    @redises.llen(@list1).times { @redises.lmove(@list1, @list2, 'left', 'right') }
-    @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.lmove(@list1, @list2, 'left', 'right')
-    end.should raise_error(Redis::CommandError)
-  end
-
-  let(:default_error) { RedisMultiplexer::MismatchedResponse }
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/lpop_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe '#lpop(key)' do
-  before { @key = 'mock-redis-test:65374' }
-
-  it 'returns and removes the first element of a list' do
-    @redises.lpush(@key, 1)
-    @redises.lpush(@key, 2)
-
-    @redises.lpop(@key).should == '2'
-
-    @redises.llen(@key).should == 1
-  end
-
-  it 'returns nil if the list is empty' do
-    @redises.lpush(@key, 'foo')
-    @redises.lpop(@key)
-
-    @redises.lpop(@key).should be_nil
-  end
-
-  it 'returns nil for nonexistent values' do
-    @redises.lpop(@key).should be_nil
-  end
-
-  it 'removes empty lists' do
-    @redises.lpush(@key, 'foo')
-    @redises.lpop(@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/lpush_spec.rb

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

data/spec/commands/lpushx_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe '#lpushx(key, value)' do
-  before { @key = 'mock-redis-test:81267' }
-
-  it 'returns the new size of the list' do
-    @redises.lpush(@key, 'X')
-
-    @redises.lpushx(@key, 'X').should == 2
-    @redises.lpushx(@key, 'X').should == 3
-  end
-
-  it 'does nothing when run against a nonexistent key' do
-    @redises.lpushx(@key, 'value')
-    @redises.get(@key).should be_nil
-  end
-
-  it 'prepends items to the list' do
-    @redises.lpush(@key, 'bert')
-    @redises.lpushx(@key, 'ernie')
-
-    @redises.lindex(@key, 0).should == 'ernie'
-    @redises.lindex(@key, 1).should == 'bert'
-  end
-
-  it 'stores values as strings' do
-    @redises.lpush(@key, 1)
-    @redises.lpushx(@key, 2)
-    @redises.lindex(@key, 0).should == '2'
-  end
-
-  it 'raises an error if an empty array is given' do
-    @redises.lpush(@key, 'X')
-    lambda do
-      @redises.lpushx(@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.lpushx(@key, [1, 2]).should == 3
-    @redises.lrange(@key, 0, -1).should == %w[2 1 X]
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/lrange_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe '#lrange(key, start, stop)' do
-  before do
-    @key = 'mock-redis-test:68036'
-
-    @redises.lpush(@key, 'v4')
-    @redises.lpush(@key, 'v3')
-    @redises.lpush(@key, 'v2')
-    @redises.lpush(@key, 'v1')
-    @redises.lpush(@key, 'v0')
-  end
-
-  it 'returns a subset of the list inclusive of the right end' do
-    @redises.lrange(@key, 0, 2).should == %w[v0 v1 v2]
-  end
-
-  it 'returns a subset of the list when start and end are strings' do
-    @redises.lrange(@key, '0', '2').should == %w[v0 v1 v2]
-  end
-
-  it 'returns an empty list when start > end' do
-    @redises.lrange(@key, 3, 2).should == []
-  end
-
-  it 'works with a negative stop index' do
-    @redises.lrange(@key, 2, -1).should == %w[v2 v3 v4]
-  end
-
-  it 'works with negative start and stop indices' do
-    @redises.lrange(@key, -2, -1).should == %w[v3 v4]
-  end
-
-  it 'works with negative start indices less than list length' do
-    @redises.lrange(@key, -10, -2).should == %w[v0 v1 v2 v3]
-  end
-
-  it 'returns [] when run against a nonexistent value' do
-    @redises.lrange('mock-redis-test:bogus-key', 0, 1).should == []
-  end
-
-  it 'returns [] when start is too large' do
-    @redises.lrange(@key, 100, 100).should == []
-  end
-
-  it 'finds the end of the list correctly when end is too large' do
-    @redises.lrange(@key, 4, 10).should == %w[v4]
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/lrem_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-describe '#lrem(key, count, value)' do
-  before do
-    @key = 'mock-redis-test:66767'
-
-    %w[99 bottles of beer on the wall
-       99 bottles of beer
-       take one down
-       pass it around
-       98 bottles of beer on the wall].reverse_each do |x|
-      @redises.lpush(@key, x)
-    end
-  end
-
-  it 'deletes the first count instances of key when count > 0' do
-    @redises.lrem(@key, 2, 'bottles')
-
-    @redises.lrange(@key, 0, 8).should == %w[
-      99 of beer on the wall
-      99 of beer
-    ]
-
-    @redises.lrange(@key, -7, -1).should == %w[98 bottles of beer on the wall]
-  end
-
-  it 'deletes the last count instances of key when count < 0' do
-    @redises.lrem(@key, -2, 'bottles')
-
-    @redises.lrange(@key, 0, 9).should == %w[
-      99 bottles of beer on the wall
-      99 of beer
-    ]
-
-    @redises.lrange(@key, -6, -1).should == %w[98 of beer on the wall]
-  end
-
-  it 'deletes all instances of key when count == 0' do
-    @redises.lrem(@key, 0, 'bottles')
-    @redises.lrange(@key, 0, -1).grep(/bottles/).should be_empty
-  end
-
-  it 'returns the number of elements deleted' do
-    @redises.lrem(@key, 2, 'bottles').should == 2
-  end
-
-  it 'returns the number of elements deleted even if you ask for more' do
-    @redises.lrem(@key, 10, 'bottles').should == 3
-  end
-
-  it 'stringifies value' do
-    @redises.lrem(@key, 0, 99).should == 2
-  end
-
-  it 'returns 0 when run against a nonexistent value' do
-    @redises.lrem('mock-redis-test:bogus-key', 0, 1).should == 0
-  end
-
-  it 'returns 0 when run against an empty list' do
-    @redises.llen(@key).times { @redises.lpop(@key) } # empty the list
-    @redises.lrem(@key, 0, 'beer').should == 0
-  end
-
-  it 'raises an error if the value does not look like an integer' do
-    lambda do
-      @redises.lrem(@key, 'foo', 'bottles')
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'removes empty lists' do
-    other_key = "mock-redis-test:lrem-#{__LINE__}"
-
-    @redises.lpush(other_key, 'foo')
-    @redises.lrem(other_key, 0, 'foo')
-
-    @redises.get(other_key).should be_nil
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/lset_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe '#lset(key, index, value)' do
-  before do
-    @key = 'mock-redis-test:21522'
-
-    @redises.lpush(@key, 'v1')
-    @redises.lpush(@key, 'v0')
-  end
-
-  it "returns 'OK'" do
-    @redises.lset(@key, 0, 'newthing').should == 'OK'
-  end
-
-  it "sets the list's value at index to value" do
-    @redises.lset(@key, 0, 'newthing')
-    @redises.lindex(@key, 0).should == 'newthing'
-  end
-
-  it "sets the list's value at index to value when the index is a string" do
-    @redises.lset(@key, '0', 'newthing')
-    @redises.lindex(@key, 0).should == 'newthing'
-  end
-
-  it 'stringifies value' do
-    @redises.lset(@key, 0, 12_345)
-    @redises.lindex(@key, 0).should == '12345'
-  end
-
-  it 'raises an exception for nonexistent keys' do
-    lambda do
-      @redises.lset('mock-redis-test:bogus-key', 100, 'value')
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an exception for out-of-range indices' do
-    lambda do
-      @redises.lset(@key, 100, 'value')
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a list-only command'
-end