mock_redis 0.0.1

data/spec/commands/hincrby_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe '#hincrby(key, field, increment)' do
+  before do
+    @key = 'mock-redis-test:hincrby'
+    @field = 'count'
+  end
+
+  it "returns the value after the increment" do
+    @redises.hset(@key, @field, 2)
+    @redises.hincrby(@key, @field, 2).should == 4
+  end
+
+  it "treats a missing key like 0" do
+    @redises.hincrby(@key, @field, 1).should == 1
+  end
+
+  it "creates a hash if nothing is present" do
+    @redises.hincrby(@key, @field, 1)
+    @redises.hget(@key, @field).should == "1"
+  end
+
+  it "increments negative numbers" do
+    @redises.hset(@key, @field, -10)
+    @redises.hincrby(@key, @field, 2).should == -8
+  end
+
+  it "works multiple times" do
+    @redises.hincrby(@key, @field, 2).should == 2
+    @redises.hincrby(@key, @field, 2).should == 4
+    @redises.hincrby(@key, @field, 2).should == 6
+  end
+
+  it "accepts an integer-ish string" do
+    @redises.hincrby(@key, @field, "2").should == 2
+  end
+
+  it "raises an error if the value does not look like an integer" do
+    @redises.hset(@key, @field, "one")
+    lambda do
+      @redises.hincrby(@key, @field, 1)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "raises an error if the delta does not look like an integer" do
+    lambda do
+      @redises.hincrby(@key, @field, "foo")
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hkeys_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe "#hkeys(key)" do
+  before do
+    @key = "mock-redis-test:hkeys"
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k2', 'v2')
+  end
+
+  it "returns the keys stored in the hash" do
+    @redises.hkeys(@key).sort.should == %w[k1 k2]
+  end
+
+  it "returns [] when there is no such key" do
+    @redises.hkeys('mock-redis-test:nonesuch').should == []
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hlen_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe "#hlen(key)" do
+  before do
+    @key = "mock-redis-test:hlen"
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k2', 'v2')
+  end
+
+  it "returns the number of keys stored in the hash" do
+    @redises.hlen(@key).should == 2
+  end
+
+  it "returns [] when there is no such key" do
+    @redises.hlen('mock-redis-test:nonesuch').should == 0
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hmget_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "#hmget(key, field [, field, ...])" do
+  before do
+    @key = "mock-redis-test:hmget"
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k2', 'v2')
+  end
+
+  it "returns the values for those keys" do
+    @redises.hmget(@key, 'k1', 'k2').sort.should == %w[v1 v2]
+  end
+
+  it "returns nils when there are no such fields" do
+    @redises.hmget(@key, 'k1', 'mock-redis-test:nonesuch').
+      should == ['v1', nil]
+  end
+
+  it "returns nils when there is no such key" do
+    @redises.hmget(@key, 'mock-redis-test:nonesuch').should == [nil]
+  end
+
+  it "raises an error if given no fields" do
+    lambda do
+      @redises.hmget(@key)
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hmset_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "#hmset(key, field, value [, field, value ...])" do
+  before do
+    @key = "mock-redis-test:hmset"
+  end
+
+  it "returns 'OK'" do
+    @redises.hmset(@key, 'k1', 'v1', 'k2', 'v2').should == "OK"
+  end
+
+  it "sets the values" do
+    @redises.hmset(@key, 'k1', 'v1', 'k2', 'v2')
+    @redises.hmget(@key, 'k1', 'k2').should == %w[v1 v2]
+  end
+
+  it "updates an existing hash" do
+    @redises.hset(@key, 'foo', 'bar')
+    @redises.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.hmset(@key, 'one', 1)
+    @redises.hget(@key, 'one').should == "1"
+  end
+
+  it "raises an error if given no fields or values" do
+    lambda do
+      @redises.hmset(@key)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "raises an error if given an odd number of fields+values" do
+    lambda do
+      @redises.hmset(@key, 'k1', 1, 'k2')
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hset_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "#hset(key, field)" do
+  before do
+    @key = "mock-redis-test:hset"
+  end
+
+  it "returns true" do
+    @redises.hset(@key, 'k1', 'v1').should == true
+  end
+
+  it "creates a hash there is no such field" do
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hget(@key, 'k1').should == 'v1'
+  end
+
+  it "stores values as strings" do
+    @redises.hset(@key, "num", 1)
+    @redises.hget(@key, 'num').should == "1"
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hsetnx_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "#hsetnx(key, field)" do
+  before do
+    @key = "mock-redis-test:hsetnx"
+  end
+
+  it "returns true if the field is absent" do
+    @redises.hsetnx(@key, 'field', 'val').should be_true
+  end
+
+  it "returns 0 if the field is present" do
+    @redises.hset(@key, 'field', 'val')
+    @redises.hsetnx(@key, 'field', 'val').should be_false
+  end
+
+  it "leaves the field unchanged if the field is present" do
+    @redises.hset(@key, 'field', 'old')
+    @redises.hsetnx(@key, 'field', 'new')
+    @redises.hget(@key, 'field').should == 'old'
+  end
+
+  it "sets the field if the field is absent" do
+    @redises.hsetnx(@key, 'field', 'new')
+    @redises.hget(@key, 'field').should == 'new'
+  end
+
+  it "creates a hash if there is no such field" do
+    @redises.hsetnx(@key, 'field', 'val')
+    @redises.hget(@key, 'field').should == 'val'
+  end
+
+  it "stores values as strings" do
+    @redises.hsetnx(@key, "num", 1)
+    @redises.hget(@key, 'num').should == "1"
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hvals_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe "#hvals(key)" do
+  before do
+    @key = "mock-redis-test:hvals"
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k2', 'v2')
+  end
+
+  it "returns the values stored in the hash" do
+    @redises.hvals(@key).sort.should == %w[v1 v2]
+  end
+
+  it "returns [] when there is no such key" do
+    @redises.hvals('mock-redis-test:nonesuch').should == []
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/incr_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe '#incr(key)' do
+  before { @key = 'mock-redis-test:33888' }
+
+  it "returns the value after the increment" do
+    @redises.set(@key, 1)
+    @redises.incr(@key).should == 2
+  end
+
+  it "treats a missing key like 0" do
+    @redises.incr(@key).should == 1
+  end
+
+  it "increments negative numbers" do
+    @redises.set(@key, -10)
+    @redises.incr(@key).should == -9
+  end
+
+  it "works multiple times" do
+    @redises.incr(@key).should == 1
+    @redises.incr(@key).should == 2
+    @redises.incr(@key).should == 3
+  end
+
+  it "raises an error if the value does not look like an integer" do
+    @redises.set(@key, "one")
+    lambda do
+      @redises.incr(@key)
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a string-only command"
+end

data/spec/commands/incrby_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe '#incrby(key, increment)' do
+  before { @key = 'mock-redis-test:65374' }
+
+  it "returns the value after the increment" do
+    @redises.set(@key, 2)
+    @redises.incrby(@key, 2).should == 4
+  end
+
+  it "treats a missing key like 0" do
+    @redises.incrby(@key, 1).should == 1
+  end
+
+  it "increments negative numbers" do
+    @redises.set(@key, -10)
+    @redises.incrby(@key, 2).should == -8
+  end
+
+  it "works multiple times" do
+    @redises.incrby(@key, 2).should == 2
+    @redises.incrby(@key, 2).should == 4
+    @redises.incrby(@key, 2).should == 6
+  end
+
+  it "accepts an integer-ish string" do
+    @redises.incrby(@key, "2").should == 2
+  end
+
+  it "raises an error if the value does not look like an integer" do
+    @redises.set(@key, "one")
+    lambda do
+      @redises.incrby(@key, 1)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "raises an error if the delta does not look like an integer" do
+    lambda do
+      @redises.incrby(@key, "foo")
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a string-only command"
+end

data/spec/commands/info_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe '#info [mock only]' do
+  before { @info = @redises.mock.info }
+
+  it "responds with a config hash" do
+    @info.should be_a(Hash)
+  end
+
+  it "has some data in it" do
+    @info.keys.length.should > 0
+  end
+end

data/spec/commands/keys_spec.rb

@@ -0,0 +1,87 @@
+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: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: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
+    end
+
+    describe "the * character" do
+      it "is treated as 1 or more characters" do
+        @redises.keys("mock-redis-test:key*").sort.should == [
+          '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 "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

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

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

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

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

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

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

data/spec/commands/lpushx_spec.rb

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