mock_redis 0.0.1

data/spec/commands/brpop_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe '#brpop(key [, key, ...,], timeout)' do
+  before do
+    @list1 = 'mock-redis-test:brpop1'
+    @list2 = 'mock-redis-test:brpop2'
+
+    @redises.rpush(@list1, 'one')
+    @redises.rpush(@list1, 'two')
+
+    @redises.rpush(@list2, 'ten')
+  end
+
+  it "returns [first-nonempty-list, popped-value]" do
+    @redises.brpop(@list1, @list2, 1).should == [@list1, 'two']
+  end
+
+  it "pops that value off the list" do
+    @redises.brpop(@list1, @list2, 1)
+    @redises.brpop(@list1, @list2, 1)
+    @redises.brpop(@list1, @list2, 1).should == [@list2, 'ten']
+  end
+
+  it "ignores empty keys" do
+    @redises.brpop('mock-redis-test:not-here', @list1, 1).should ==
+      [@list1, 'two']
+  end
+
+  it "raises an error on non-integer timeout" do
+    lambda do
+      @redises.brpop(@list1, @list2, 0.5)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "raises an error on negative timeout" do
+    lambda do
+      @redises.brpop(@list1, @list2, -1)
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a list-only command"
+
+  context "[mock only]" do
+    it "ignores positive timeouts and returns nil" do
+      @redises.mock.brpop('mock-redis-test:not-here', 1).should be_nil
+    end
+
+    it "raises WouldBlock on zero timeout (no blocking in the mock)" do
+      lambda do
+        @redises.mock.brpop('mock-redis-test:not-here', 0)
+      end.should raise_error(MockRedis::WouldBlock)
+    end
+  end
+end

data/spec/commands/brpoplpush_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+require 'spec_helper'
+
+describe '#brpoplpush(source, destination, timeout)' do
+  before do
+    @list1 = 'mock-redis-test:brpoplpush1'
+    @list2 = 'mock-redis-test:brpoplpush2'
+
+    @redises.rpush(@list1, 'A')
+    @redises.rpush(@list1, 'B')
+
+    @redises.rpush(@list2, 'alpha')
+    @redises.rpush(@list2, 'beta')
+  end
+
+  it "takes the last element of source and prepends it to destination" do
+    @redises.brpoplpush(@list1, @list2, 0)
+    @redises.lrange(@list1, 0, -1).should == %w[A]
+    @redises.lrange(@list2, 0, -1).should == %w[B alpha beta]
+  end
+
+  it "returns the moved element" do
+    @redises.brpoplpush(@list1, @list2, 0).should == "B"
+  end
+
+  it "raises an error on non-integer timeout" do
+    lambda do
+      @redises.brpoplpush(@list1, @list2, 0.5)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "raises an error on negative timeout" do
+    lambda do
+      @redises.brpoplpush(@list1, @list2, -1)
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a list-only command"
+
+  context "[mock only]" do
+    it "ignores positive timeouts and returns nil" do
+      @redises.mock.brpoplpush('mock-redis-test:not-here', @list1, 1).
+        should be_nil
+    end
+
+    it "raises WouldBlock on zero timeout (no blocking in the mock)" do
+      lambda do
+        @redises.mock.brpoplpush('mock-redis-test:not-here', @list1, 0)
+      end.should raise_error(MockRedis::WouldBlock)
+    end
+  end
+end

data/spec/commands/dbsize_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe "#dbsize [mock only]" do
+  # mock only since we can't guarantee that the real Redis is empty
+  before { @mock = @redises.mock }
+
+  it "returns 0 for an empty DB" do
+    @mock.dbsize.should == 0
+  end
+
+  it "returns the number of keys in the DB" do
+    @mock.set('foo', 1)
+    @mock.lpush('bar', 2)
+    @mock.hset('baz', 3, 4)
+
+    @mock.dbsize.should == 3
+  end
+end

data/spec/commands/decr_spec.rb

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

data/spec/commands/decrby_spec.rb

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

data/spec/commands/del_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe '#del(key [, key, ...])' do
+  it "returns the number of keys deleted" do
+    @redises.set('mock-redis-test:1', 1)
+    @redises.set('mock-redis-test:2', 1)
+
+    @redises.del(
+      'mock-redis-test:1',
+      'mock-redis-test:2',
+      'mock-redis-test:other').should == 2
+  end
+
+  it "actually removes the key" do
+    @redises.set('mock-redis-test:1', 1)
+    @redises.del('mock-redis-test:1')
+
+    @redises.get('mock-redis-test:1').should be_nil
+  end
+end

data/spec/commands/echo_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe "#echo(str)" do
+  it "returns its argument" do
+    @redises.echo('foo').should == 'foo'
+  end
+
+  it "stringifies its argument" do
+    @redises.echo(1).should == "1"
+  end
+end

data/spec/commands/exists_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "#exists(key)" do
+  before { @key = 'mock-redis-test:45794' }
+
+  it "returns false for keys that do not exist" do
+    @redises.exists(@key).should be_false
+  end
+
+  it "returns true for keys that do exist" do
+    @redises.set(@key, 1)
+    @redises.exists(@key).should be_true
+  end
+end

data/spec/commands/expire_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe "#expire(key, seconds)" do
+  before do
+    @key = 'mock-redis-test:expire'
+    @redises.set(@key, 'spork')
+  end
+
+  it "returns true for a key that exists" do
+    @redises.expire(@key, 1).should be_true
+  end
+
+  it "returns false for a key that does not exist" do
+    @redises.expire('mock-redis-test:nonesuch', 1).should be_false
+  end
+
+  it "removes a key immediately when seconds==0" do
+    @redises.expire(@key, 0)
+    @redises.get(@key).should be_nil
+  end
+
+  it "raises an error if seconds is bogus" do
+    lambda do
+      @redises.expireat(@key, 'a couple minutes or so')
+    end.should raise_error(RuntimeError)
+  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 "removes keys after enough time has passed" do
+      @mock.expire(@key, 5)
+      Time.stub!(:now).and_return(@now + 5)
+      @mock.get(@key).should be_nil
+    end
+
+    it "updates an existing expire time" do
+      @mock.expire(@key, 5)
+      @mock.expire(@key, 6)
+
+      Time.stub!(:now).and_return(@now + 5) 
+      @mock.get(@key).should_not be_nil
+    end
+
+    context "expirations on a deleted key" do
+      before { @mock.del(@key) }
+
+      it "cleans up the expiration once the key is gone (string)" do
+        @mock.set(@key, 'string')
+        @mock.expire(@key, 2)
+        @mock.del(@key)
+        @mock.set(@key, 'string')
+
+        Time.stub!(:now).and_return(@now + 2)
+
+        @mock.get(@key).should_not be_nil
+      end
+
+      it "cleans up the expiration once the key is gone (list)" do
+        @mock.rpush(@key, 'coconuts')
+        @mock.expire(@key, 2)
+        @mock.rpop(@key)
+
+        @mock.rpush(@key, 'coconuts')
+
+        Time.stub!(:now).and_return(@now + 2)
+
+        @mock.lindex(@key, 0).should_not be_nil
+      end
+    end
+
+  end
+end

data/spec/commands/expireat_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "#expireat(key, timestamp)" do
+  before do
+    @key = 'mock-redis-test:expireat'
+    @redises.set(@key, 'spork')
+  end
+
+  it "returns true for a key that exists" do
+    @redises.expireat(@key, Time.now.to_i + 1).should be_true
+  end
+
+  it "returns false for a key that does not exist" do
+    @redises.expireat('mock-redis-test:nonesuch', Time.now.to_i + 1).should be_false
+  end
+
+  it "removes a key immediately when timestamp is now" do
+    @redises.expireat(@key, Time.now.to_i)
+    @redises.get(@key).should be_nil
+  end
+
+  it "raises an error if you don't give it a Unix timestamp" do
+    lambda do
+      @redises.expireat(@key, Time.now)   # oops, forgot .to_i
+    end.should raise_error(RuntimeError)
+  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 "removes keys after enough time has passed" do
+      @mock.expireat(@key, @now.to_i + 5)
+      Time.stub!(:now).and_return(@now + 5)
+      @mock.get(@key).should be_nil
+    end
+
+  end
+end

data/spec/commands/flushall_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe "#flushall [mock only]" do
+  # don't want to hurt things in the real redis that are outside our
+  # namespace.
+  before { @mock = @redises.mock }
+  before { @key = 'mock-redis-test:select' }
+
+  it "returns 'OK'" do
+    @mock.flushall.should == 'OK'
+  end
+
+  it "removes all keys in the current DB" do
+    @mock.set('k1', 'v1')
+    @mock.lpush('k2', 'v2')
+
+    @mock.flushall
+    @mock.keys('*').should == []
+  end
+
+  it "removes all keys in other DBs, too" do
+    @mock.set('k1', 'v1')
+
+    @mock.select(1)
+    @mock.flushall
+    @mock.select(0)
+
+    @mock.get('k1').should be_nil
+  end
+
+  it "removes expiration times" do
+    @mock.set('k1', 'v1')
+    @mock.expire('k1', 360000)
+    @mock.flushall
+    @mock.set('k1', 'v1')
+    @mock.ttl('k1').should == -1
+  end
+end

data/spec/commands/flushdb_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe "#flushdb [mock only]" do
+  # don't want to hurt things in the real redis that are outside our
+  # namespace.
+  before { @mock = @redises.mock }
+  before { @key = 'mock-redis-test:select' }
+
+  it "returns 'OK'" do
+    @mock.flushdb.should == 'OK'
+  end
+
+  it "removes all keys in the current DB" do
+    @mock.set('k1', 'v1')
+    @mock.lpush('k2', 'v2')
+
+    @mock.flushdb
+    @mock.keys('*').should == []
+  end
+
+  it "leaves other databases alone" do
+    @mock.set('k1', 'v1')
+
+    @mock.select(1)
+    @mock.flushdb
+    @mock.select(0)
+
+    @mock.get('k1').should == 'v1'
+  end
+
+  it "removes expiration times" do
+    @mock.set('k1', 'v1')
+    @mock.expire('k1', 360000)
+    @mock.flushdb
+    @mock.set('k1', 'v1')
+    @mock.ttl('k1').should == -1
+  end
+end

data/spec/commands/get_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "#get(key)" do
+  before do
+    @key = 'mock-redis-test:73288'
+  end
+
+  it "returns nil for a nonexistent value" do
+    @redises.get('mock-redis-test:does-not-exist').should be_nil
+  end
+
+  it "returns a stored string value" do
+    @redises.set(@key, 'forsooth')
+    @redises.get(@key).should == 'forsooth'
+  end
+
+  it "treats integers as strings" do
+    @redises.set(@key, 100)
+    @redises.get(@key).should == "100"
+  end
+
+  it_should_behave_like "a string-only command"
+end

data/spec/commands/getbit_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "#getbit(key, offset)" do
+  before do
+    @key = 'mock-redis-test:getbit'
+    @redises.set(@key, 'h')    # ASCII 0x68
+  end
+
+  it "gets the bits from the key" do
+    @redises.getbit(@key, 0).should == 0
+    @redises.getbit(@key, 1).should == 1
+    @redises.getbit(@key, 2).should == 1
+    @redises.getbit(@key, 3).should == 0
+    @redises.getbit(@key, 4).should == 1
+    @redises.getbit(@key, 5).should == 0
+    @redises.getbit(@key, 6).should == 0
+    @redises.getbit(@key, 7).should == 0
+  end
+
+  it "returns 0 for out-of-range bits" do
+    @redises.getbit(@key, 100).should == 0
+  end
+
+  it "does not modify the stored value for out-of-range bits" do
+    @redises.getbit(@key, 100)
+    @redises.get(@key).should == 'h'
+  end
+
+  it "treats nonexistent keys as empty strings" do
+    @redises.getbit('mock-redis-test:not-found', 0).should == 0
+  end
+
+  it_should_behave_like "a string-only command"
+end

data/spec/commands/getrange_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "#getrange(key, start, stop)" do
+  before do
+    @key = 'mock-redis-test:getrange'
+    @redises.set(@key, "This is a string")
+  end
+
+  it "returns a substring" do
+    @redises.getrange(@key, 0, 3).should == "This"
+  end
+
+  it "works with negative indices" do
+    @redises.getrange(@key, -3, -1).should == "ing"
+  end
+
+  it "limits the result to the actual length of the string" do
+    @redises.getrange(@key, 10, 100).should == "string"
+  end
+
+  it_should_behave_like "a string-only command"
+end

data/spec/commands/getset_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "#getrange(key, value)" do
+  before do
+    @key = 'mock-redis-test:getset'
+    @redises.set(@key, "oldvalue")
+  end
+
+  it "returns the old value" do
+    @redises.getset(@key, 'newvalue').should == "oldvalue"
+  end
+
+  it "sets the value to the new value" do
+    @redises.getset(@key, 'newvalue')
+    @redises.get(@key).should == 'newvalue'
+  end
+
+  it "returns nil for nonexistent keys" do
+    @redises.getset('mock-redis-test:not-found', 1).should be_nil
+  end
+
+  it_should_behave_like "a string-only command"
+end

data/spec/commands/hdel_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "#hdel(key, field)" do
+  before do
+    @key = "mock-redis-test:hdel"
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k2', 'v2')
+  end
+
+  it "returns 1 when it removes a field" do
+    @redises.hdel(@key, 'k1').should == 1
+  end
+
+  it "returns 0 when it does not remove a field" do
+    @redises.hdel(@key, 'nonesuch').should == 0
+  end
+
+  it "actually removes the field" do
+    @redises.hdel(@key, 'k1')
+    @redises.hget(@key, 'k1').should be_nil
+  end
+
+  it "removes only the field specified" do
+    @redises.hdel(@key, 'k1')
+    @redises.hget(@key, 'k2').should == 'v2'
+  end
+
+  it "cleans up empty hashes" do
+    @redises.hdel(@key, 'k1')
+    @redises.hdel(@key, 'k2')
+    @redises.get(@key).should be_nil
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hexists_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "#hexists(key, field)" do
+  before do
+    @key = "mock-redis-test:hexists"
+    @redises.hset(@key, 'field', 'value')
+  end
+
+  it "returns true if the hash has that field" do
+    @redises.hexists(@key, 'field').should be_true
+  end
+
+  it "returns false if the hash lacks that field" do
+    @redises.hexists(@key, 'nonesuch').should be_false
+  end
+
+  it "returns nil when there is no such key" do
+    @redises.hexists('mock-redis-test:nonesuch', 'key').should be_false
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hget_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "#hget(key, field)" do
+  before do
+    @key = "mock-redis-test:hget"
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k2', 'v2')
+  end
+
+  it "returns the value stored at field" do
+    @redises.hget(@key, 'k1').should == 'v1'
+  end
+
+  it "returns nil when there is no such field" do
+    @redises.hget(@key, 'nonesuch').should be_nil
+  end
+
+  it "returns nil when there is no such key" do
+    @redises.hget('mock-redis-test:nonesuch', 'k1').should be_nil
+  end
+
+  it_should_behave_like "a hash-only command"
+end

data/spec/commands/hgetall_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "#hgetall(key)" do
+  before do
+    @key = "mock-redis-test:hgetall"
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k2', 'v2')
+  end
+
+  it "returns the (key, value) pairs stored in the hash" do
+    @redises.hgetall(@key).should == {
+      'k1' => 'v1',
+      'k2' => 'v2',
+    }
+  end
+
+  it "returns [] when there is no such key" do
+    @redises.hgetall('mock-redis-test:nonesuch').should == {}
+  end
+
+  it_should_behave_like "a hash-only command"
+end