mock_redis 0.19.0 → 0.44.0

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/lpop_spec.rb

@@ -1,34 +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
-
-  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

data/spec/commands/ltrim_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe '#ltrim(key, start, stop)' do
-  before do
-    @key = 'mock-redis-test:22310'
-
-    %w[v0 v1 v2 v3 v4].reverse_each { |v| @redises.lpush(@key, v) }
-  end
-
-  it "returns 'OK'" do
-    @redises.ltrim(@key, 1, 3).should == 'OK'
-  end
-
-  it 'trims the list to include only the specified elements' do
-    @redises.ltrim(@key, 1, 3)
-    @redises.lrange(@key, 0, -1).should == %w[v1 v2 v3]
-  end
-
-  it 'trims the list when start and stop are strings' do
-    @redises.ltrim(@key, '1', '3')
-    @redises.lrange(@key, 0, -1).should == %w[v1 v2 v3]
-  end
-
-  it 'trims the list to include only the specified elements (negative indices)' do
-    @redises.ltrim(@key, -2, -1)
-    @redises.lrange(@key, 0, -1).should == %w[v3 v4]
-  end
-
-  it 'trims the list to include only the specified elements (out of range negative indices)' do
-    @redises.ltrim(@key, -10, -2)
-    @redises.lrange(@key, 0, -1).should == %w[v0 v1 v2 v3]
-  end
-
-  it 'does not crash on overly-large indices' do
-    @redises.ltrim(@key, 100, 200)
-    @redises.lrange(@key, 0, -1).should == %w[]
-  end
-
-  it 'removes empty lists' do
-    @redises.ltrim(@key, 1, 0)
-    @redises.get(@key).should be_nil
-  end
-
-  it_should_behave_like 'a list-only command'
-end

data/spec/commands/mapped_hmget_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe '#mapped_hmget(key, *fields)' do
-  before do
-    @key = 'mock-redis-test:mapped_hmget'
-    @redises.hmset(@key, 'k1', 'v1', 'k2', 'v2')
-  end
-
-  it 'returns values stored at key' do
-    @redises.mapped_hmget(@key, 'k1', 'k2').should == { 'k1' => 'v1', 'k2' => 'v2' }
-  end
-
-  it 'returns nils for missing fields' do
-    @redises.mapped_hmget(@key, 'k1', 'mock-redis-test:nonesuch').
-      should == { 'k1' => 'v1', 'mock-redis-test:nonesuch' => nil }
-  end
-
-  it 'treats an array as the first key' do
-    @redises.mapped_hmget(@key, %w[k1 k2]).should == { %w[k1 k2] => 'v1' }
-  end
-
-  it 'raises an error if given no fields' do
-    lambda do
-      @redises.mapped_hmget(@key)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/mapped_hmset_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe '#mapped_hmset(key, hash={})' do
-  before do
-    @key = 'mock-redis-test:mapped_hmset'
-  end
-
-  it "returns 'OK'" do
-    @redises.mapped_hmset(@key, 'k1' => 'v1', 'k2' => 'v2').should == 'OK'
-  end
-
-  it 'sets the values' do
-    @redises.mapped_hmset(@key, 'k1' => 'v1', 'k2' => 'v2')
-    @redises.hmget(@key, 'k1', 'k2').should == %w[v1 v2]
-  end
-
-  it 'updates an existing hash' do
-    @redises.hmset(@key, 'foo', 'bar')
-    @redises.mapped_hmset(@key, 'bert' => 'ernie', 'diet' => 'coke')
-
-    @redises.hmget(@key, 'foo', 'bert', 'diet').
-      should == %w[bar ernie coke]
-  end
-
-  it 'stores the values as strings' do
-    @redises.mapped_hmset(@key, 'one' => 1)
-    @redises.hget(@key, 'one').should == '1'
-  end
-
-  it 'raises an error if given no hash' do
-    lambda do
-      @redises.mapped_hmset(@key)
-    end.should raise_error(ArgumentError)
-  end
-
-  it 'raises an error if given a an odd length array' do
-    lambda do
-      @redises.mapped_hmset(@key, [1])
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an error if given a non-hash value' do
-    lambda do
-      @redises.mapped_hmset(@key, 1)
-    end.should raise_error(NoMethodError)
-  end
-end

data/spec/commands/mapped_mget_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe '#mapped_mget(*keys)' do
-  before do
-    @key1 = 'mock-redis-test:a'
-    @key2 = 'mock-redis-test:b'
-    @key3 = 'mock-redis-test:c'
-
-    @redises.set(@key1, '1')
-    @redises.set(@key2, '2')
-  end
-
-  it 'returns a hash' do
-    @redises.mapped_mget(@key1, @key2, @key3).should eq(@key1 => '1',
-                                                        @key2 => '2',
-                                                        @key3 => nil)
-  end
-
-  it 'returns a hash even when no matches' do
-    @redises.mapped_mget('qwer').should eq('qwer' => nil)
-  end
-end

data/spec/commands/mapped_mset_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe '#mapped_mset(hash)' do
-  before do
-    @key1 = 'mock-redis-test:a'
-    @key2 = 'mock-redis-test:b'
-    @key3 = 'mock-redis-test:c'
-
-    @redises.set(@key1, '1')
-    @redises.set(@key2, '2')
-  end
-
-  it 'sets the values properly' do
-    @redises.mapped_mset(@key1 => 'one', @key3 => 'three').should eq('OK')
-    @redises.get(@key1).should eq('one')
-    @redises.get(@key2).should eq('2') # left alone
-    @redises.get(@key3).should eq('three')
-  end
-end

data/spec/commands/mapped_msetnx_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe '#mapped_msetnx(hash)' do
-  before do
-    @key1 = 'mock-redis-test:a'
-    @key2 = 'mock-redis-test:b'
-    @key3 = 'mock-redis-test:c'
-
-    @redises.set(@key1, '1')
-    @redises.set(@key2, '2')
-  end
-
-  it 'sets properly when none collide' do
-    @redises.mapped_msetnx(@key3 => 'three').should eq(true)
-    @redises.get(@key1).should eq('1') # existed; untouched
-    @redises.get(@key2).should eq('2') # existed; untouched
-    @redises.get(@key3).should eq('three')
-  end
-
-  it 'does not set any when any collide' do
-    @redises.mapped_msetnx(@key1 => 'one', @key3 => 'three').should eq(false)
-    @redises.get(@key1).should eq('1') # existed; untouched
-    @redises.get(@key2).should eq('2') # existed; untouched
-    @redises.get(@key3).should be_nil
-  end
-end

data/spec/commands/mget_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe '#mget(key [, key, ...])' do
-  before do
-    @key1 = 'mock-redis-test:mget1'
-    @key2 = 'mock-redis-test:mget2'
-
-    @redises.set(@key1, 1)
-    @redises.set(@key2, 2)
-  end
-
-  it 'returns an array of values' do
-    @redises.mget(@key1, @key2).should == %w[1 2]
-  end
-
-  it 'returns nil for missing keys' do
-    @redises.mget(@key1, 'mock-redis-test:not-found', @key2).
-      should == ['1', nil, '2']
-  end
-
-  it 'returns nil for non-string keys' do
-    list = 'mock-redis-test:mget-list'
-
-    @redises.lpush(list, 'bork bork bork')
-
-    @redises.mget(@key1, @key2, list).should == ['1', '2', nil]
-  end
-
-  it 'raises an error if you pass it 0 arguments' do
-    lambda do
-      @redises.mget
-    end.should raise_error(Redis::CommandError)
-  end
-end