mock_redis 0.0.1

data/spec/commands/lrange_spec.rb

@@ -0,0 +1,35 @@
+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 an empty list when start > end" do
+    @redises.lrange(@key, 3, 2).should == []
+  end
+
+  it "works with negative indices" do
+    @redises.lrange(@key, 2, -1).should == %w[v2 v3 v4]
+  end
+
+  it "returns [] when run against a nonexistent value" do
+    @redises.lrange("mock-redis-test:bogus-key", 0, 1).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

@@ -0,0 +1,79 @@
+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 "treats non-integer count as 0" do
+    @redises.lrem(@key, 'foo', 'bottles').should == 3
+    @redises.lrange(@key, 0, -1).grep(/bottles/).should be_empty
+  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

@@ -0,0 +1,38 @@
+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 "stringifies value" do
+    @redises.lset(@key, 0, 12345)
+    @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(RuntimeError)
+  end
+
+  it "raises an exception for out-of-range indices" do
+    lambda do
+      @redises.lset(@key, 100, 'value')
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a list-only command"
+end

data/spec/commands/ltrim_spec.rb

@@ -0,0 +1,35 @@
+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 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 "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/mget_spec.rb

@@ -0,0 +1,34 @@
+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(RuntimeError)
+  end
+end

data/spec/commands/mset_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe '#mset(key, value [, key, value, ...])' do
+  before do
+    @key1 = 'mock-redis-test:mset1'
+    @key2 = 'mock-redis-test:mset2'
+  end
+
+  it "responds with 'OK'" do
+    @redises.mset(@key1, 1).should == 'OK'
+  end
+
+  it "sets the values" do
+    @redises.mset(@key1, 'value1', @key2, 'value2')
+    @redises.mget(@key1, @key2).should == %w[value1 value2]
+  end
+
+  it "raises an error if given an odd number of arguments" do
+    lambda do
+      @redises.mset(@key1, 'value1', @key2)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "raises an error if given 0 arguments" do
+    lambda do
+      @redises.mset()
+    end.should raise_error(RuntimeError)
+  end
+end

data/spec/commands/msetnx_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe '#msetnx(key, value [, key, value, ...])' do
+  before do
+    @key1 = 'mock-redis-test:msetnx1'
+    @key2 = 'mock-redis-test:msetnx2'
+  end
+
+  it "responds with 1 if any keys were set" do
+    @redises.msetnx(@key1, 1).should == 1
+  end
+
+  it "sets the values" do
+    @redises.msetnx(@key1, 'value1', @key2, 'value2')
+    @redises.mget(@key1, @key2).should == %w[value1 value2]
+  end
+
+  it "does nothing if any value is already set" do
+    @redises.set(@key1, "old1")
+    @redises.msetnx(@key1, 'value1', @key2, 'value2')
+    @redises.mget(@key1, @key2).should == ["old1", nil]
+  end
+
+  it "responds with 0 if any value is already set" do
+    @redises.set(@key1, "old1")
+    @redises.msetnx(@key1, 'value1', @key2, 'value2').should == 0
+  end
+
+  it "raises an error if given an odd number of arguments" do
+    lambda do
+      @redises.msetnx(@key1, 'value1', @key2)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "raises an error if given 0 arguments" do
+    lambda do
+      @redises.msetnx()
+    end.should raise_error(RuntimeError)
+  end
+end

data/spec/commands/persist_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "#persist(key)" do
+  before do
+    @key = 'mock-redis-test:persist'
+    @redises.set(@key, 'spork')
+  end
+
+  it "returns true for a key with a timeout" do
+    @redises.expire(@key, 10000)
+    @redises.persist(@key).should be_true
+  end
+
+  it "returns false for a key with no timeout" do
+    @redises.persist(@key).should be_false
+  end
+
+  it "returns false for a key that does not exist" do
+    @redises.persist('mock-redis-test:nonesuch').should be_false
+  end
+
+  it "removes the timeout" do
+    @redises.expire(@key, 10000)
+    @redises.persist(@key)
+    @redises.persist(@key).should be_false
+  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 "makes keys stay around" do
+      @mock.expire(@key, 5)
+      @mock.persist(@key)
+      Time.stub!(:now).and_return(@now + 5)
+      @mock.get(@key).should_not be_nil
+    end
+
+  end
+end

data/spec/commands/ping_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "#ping" do
+  it "returns 'PONG'" do
+    @redises.ping.should == 'PONG'
+  end
+end

data/spec/commands/quit_spec.rb

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

data/spec/commands/randomkey_spec.rb

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

@@ -0,0 +1,31 @@
+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 key == newkey" do
+    lambda do
+      @redises.rename(@key, @key)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "overwrites any existing value at newkey" do
+    @redises.set(@newkey, "rab")
+    @redises.rename(@key, @newkey)
+    @redises.get(@newkey).should == "oof"
+  end
+end

data/spec/commands/renamenx_spec.rb

@@ -0,0 +1,36 @@
+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 be_true
+  end
+
+  it "responds with false when newkey exists" do
+    @redises.set(@newkey, 'monkey')
+    @redises.renamenx(@key, @newkey).should be_false
+  end
+
+  it "moves the data" do
+    @redises.renamenx(@key, @newkey)
+    @redises.get(@newkey).should == "oof"
+  end
+
+  it "raises an error when key == newkey" do
+    lambda do
+      @redises.renamenx(@key, @key)
+    end.should raise_error(RuntimeError)
+  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/rpop_spec.rb

@@ -0,0 +1,34 @@
+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
+
+  it_should_behave_like "a list-only command"
+end

data/spec/commands/rpoplpush_spec.rb

@@ -0,0 +1,45 @@
+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 "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(RuntimeError)
+  end
+
+  it_should_behave_like "a list-only command"
+end

data/spec/commands/rpush_spec.rb

@@ -0,0 +1,30 @@
+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_should_behave_like "a list-only command"
+end

data/spec/commands/rpushx_spec.rb

@@ -0,0 +1,33 @@
+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_should_behave_like "a list-only command"
+end

data/spec/commands/sadd_spec.rb

@@ -0,0 +1,22 @@
+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 be_true
+  end
+
+  it "returns false if the set did already contain member" do
+    @redises.sadd(@key, 1)
+    @redises.sadd(@key, 1).should be_false
+  end
+
+  it "adds member to the set" do
+    @redises.sadd(@key, 1)
+    @redises.sadd(@key, 2)
+    @redises.smembers(@key).should == %w[1 2]
+  end
+
+  it_should_behave_like "a set-only command"
+end

data/spec/commands/save_spec.rb

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

data/spec/commands/scard_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe '#scard(key)' do
+  before { @key = 'mock-redis-test:scard' }
+
+  it "returns 0 for an empty set" do
+    @redises.scard(@key).should == 0
+  end
+
+  it "returns the number of elements in the set" do
+    @redises.sadd(@key, 'one')
+    @redises.sadd(@key, 'two')
+    @redises.sadd(@key, 'three')
+    @redises.scard(@key).should == 3
+  end
+
+  it_should_behave_like "a set-only command"
+end