mock_redis 0.19.0 → 0.44.0

data/spec/commands/move_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-describe '#move(key, db)' do
-  before do
-    @srcdb = 0
-    @destdb = 1
-
-    @key = 'mock-redis-test:move'
-  end
-
-  context 'when key exists in destdb' do
-    before do
-      @redises.set(@key, 'srcvalue')
-      @redises.select(@destdb)
-      @redises.set(@key, 'destvalue')
-      @redises.select(@srcdb)
-    end
-
-    it 'returns false' do
-      @redises.move(@key, @destdb).should == false
-    end
-
-    it 'leaves destdb/key alone' do
-      @redises.select(@destdb)
-      @redises.get(@key).should == 'destvalue'
-    end
-
-    it 'leaves srcdb/key alone' do
-      @redises.get(@key).should == 'srcvalue'
-    end
-  end
-
-  context 'when key does not exist in srcdb' do
-    before do
-      @redises.select(@destdb)
-      @redises.set(@key, 'destvalue')
-      @redises.select(@srcdb)
-    end
-
-    it 'returns false' do
-      @redises.move(@key, @destdb).should == false
-    end
-
-    it 'leaves destdb/key alone' do
-      @redises.select(@destdb)
-      @redises.get(@key).should == 'destvalue'
-    end
-  end
-
-  context 'when key exists in the currently-selected DB and not in db' do
-    before do
-      @redises.set(@key, 'value')
-    end
-
-    it 'returns true' do
-      @redises.move(@key, @destdb).should == true
-    end
-  end
-
-  context 'on a string' do
-    before do
-      @redises.set(@key, 'value')
-      @redises.move(@key, @destdb)
-    end
-
-    it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
-    end
-
-    it 'copies key to destdb' do
-      @redises.select(@destdb)
-      @redises.get(@key).should == 'value'
-    end
-  end
-
-  context 'on a list' do
-    before do
-      @redises.rpush(@key, 'bert')
-      @redises.rpush(@key, 'ernie')
-      @redises.move(@key, @destdb)
-    end
-
-    it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
-    end
-
-    it 'copies key to destdb' do
-      @redises.select(@destdb)
-      @redises.lrange(@key, 0, -1).should == %w[bert ernie]
-    end
-  end
-
-  context 'on a hash' do
-    before do
-      @redises.hset(@key, 'a', 1)
-      @redises.hset(@key, 'b', 2)
-
-      @redises.move(@key, @destdb)
-    end
-
-    it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
-    end
-
-    it 'copies key to destdb' do
-      @redises.select(@destdb)
-      @redises.hgetall(@key).should == { 'a' => '1', 'b' => '2' }
-    end
-  end
-
-  context 'on a set' do
-    before do
-      @redises.sadd(@key, 'beer')
-      @redises.sadd(@key, 'wine')
-
-      @redises.move(@key, @destdb)
-    end
-
-    it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
-    end
-
-    it 'copies key to destdb' do
-      @redises.select(@destdb)
-      @redises.smembers(@key).should == %w[wine beer]
-    end
-  end
-
-  context 'on a zset' do
-    before do
-      @redises.zadd(@key, 1, 'beer')
-      @redises.zadd(@key, 2, 'wine')
-
-      @redises.move(@key, @destdb)
-    end
-
-    it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
-    end
-
-    it 'copies key to destdb' do
-      @redises.select(@destdb)
-      @redises.zrange(@key, 0, -1, :with_scores => true).should ==
-        [['beer', 1.0], ['wine', 2.0]]
-    end
-  end
-end

data/spec/commands/mset_spec.rb

@@ -1,29 +0,0 @@
-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(Redis::CommandError)
-  end
-
-  it 'raises an error if given 0 arguments' do
-    lambda do
-      @redises.mset
-    end.should raise_error(Redis::CommandError)
-  end
-end

data/spec/commands/msetnx_spec.rb

@@ -1,40 +0,0 @@
-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 == true
-  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 == false
-  end
-
-  it 'raises an error if given an odd number of arguments' do
-    lambda do
-      @redises.msetnx(@key1, 'value1', @key2)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an error if given 0 arguments' do
-    lambda do
-      @redises.msetnx
-    end.should raise_error(Redis::CommandError)
-  end
-end

data/spec/commands/persist_spec.rb

@@ -1,48 +0,0 @@
-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, 10_000)
-    @redises.persist(@key).should == true
-  end
-
-  it 'returns false for a key with no timeout' do
-    @redises.persist(@key).should == false
-  end
-
-  it 'returns false for a key that does not exist' do
-    @redises.persist('mock-redis-test:nonesuch').should == false
-  end
-
-  it 'removes the timeout' do
-    @redises.expire(@key, 10_000)
-    @redises.persist(@key)
-    @redises.persist(@key).should == 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/pexpire_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe '#pexpire(key, ms)' do
-  before do
-    @key = 'mock-redis-test:pexpire'
-    @redises.set(@key, 'spork')
-  end
-
-  it 'returns true for a key that exists' do
-    @redises.pexpire(@key, 1).should == true
-  end
-
-  it 'returns false for a key that does not exist' do
-    @redises.pexpire('mock-redis-test:nonesuch', 1).should == false
-  end
-
-  it 'removes a key immediately when ms==0' do
-    @redises.pexpire(@key, 0)
-    @redises.get(@key).should be_nil
-  end
-
-  it 'raises an error if ms is bogus' do
-    lambda do
-      @redises.pexpireat(@key, 'a couple minutes or so')
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'stringifies key' do
-    @redises.pexpire(@key.to_sym, 9).should == true
-  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.round
-      Time.stub(:now).and_return(@now)
-    end
-
-    it 'removes keys after enough time has passed' do
-      @mock.pexpire(@key, 5)
-      Time.stub(:now).and_return(@now + Rational(6, 1000))
-      @mock.get(@key).should be_nil
-    end
-
-    it 'updates an existing pexpire time' do
-      @mock.pexpire(@key, 5)
-      @mock.pexpire(@key, 6)
-
-      Time.stub(:now).and_return(@now + Rational(5, 1000))
-      @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.pexpire(@key, 2)
-        @mock.del(@key)
-        @mock.set(@key, 'string')
-
-        Time.stub(:now).and_return(@now + 0.003)
-
-        @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.pexpire(@key, 2)
-        @mock.rpop(@key)
-
-        @mock.rpush(@key, 'coconuts')
-
-        Time.stub(:now).and_return(@now + 0.003)
-
-        @mock.lindex(@key, 0).should_not be_nil
-      end
-    end
-  end
-end

data/spec/commands/pexpireat_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe '#pexpireat(key, timestamp_ms)' do
-  before do
-    @key = 'mock-redis-test:pexpireat'
-    @redises.set(@key, 'spork')
-  end
-
-  it 'returns true for a key that exists' do
-    @redises.pexpireat(@key, (Time.now.to_f * 1000).to_i + 1).should == true
-  end
-
-  it 'returns false for a key that does not exist' do
-    @redises.pexpireat('mock-redis-test:nonesuch',
-                       (Time.now.to_f * 1000).to_i + 1).should == false
-  end
-
-  it 'removes a key immediately when timestamp is now' do
-    @redises.pexpireat(@key, (Time.now.to_f * 1000).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.pexpireat(@key, Time.now) # oops, forgot .to_i
-    end.should raise_error(Redis::CommandError)
-  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.pexpireat(@key, (@now.to_f * 1000).to_i + 5)
-      Time.stub(:now).and_return(@now + 0.006)
-      @mock.get(@key).should be_nil
-    end
-  end
-end

data/spec/commands/ping_spec.rb

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

data/spec/commands/pipelined_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe '#pipelined' do
-  it 'yields to its block' do
-    res = false
-    @redises.pipelined do
-      res = true
-    end
-    res.should == true
-  end
-
-  context 'with a few added data' do
-    let(:key1)   { 'hello' }
-    let(:key2)   { 'world' }
-    let(:value1) { 'foo' }
-    let(:value2) { 'bar' }
-
-    before do
-      @redises.set key1, value1
-      @redises.set key2, value2
-    end
-
-    it 'returns results of pipelined operations' do
-      results = @redises.pipelined do |redis|
-        redis.get key1
-        redis.get key2
-      end
-
-      results.should == [value1, value2]
-    end
-
-    it 'returns futures' do
-      future = nil
-
-      @redises.mock.pipelined do |redis|
-        future = redis.get key1
-      end
-
-      future.class.should be MockRedis::Future
-    end
-  end
-end

data/spec/commands/pttl_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe '#pttl(key)' do
-  before do
-    @key = 'mock-redis-test:persist'
-    @redises.set(@key, 'spork')
-  end
-
-  it 'returns -1 for a key with no expiration' do
-    @redises.pttl(@key).should == -1
-  end
-
-  it 'returns -2 for a key that does not exist' do
-    @redises.pttl('mock-redis-test:nonesuch').should == -2
-  end
-
-  it 'stringifies key' do
-    @redises.expire(@key, 8)
-    # Don't check against Redis since millisecond timing differences are likely
-    @redises.send_without_checking(:pttl, @key.to_sym).should > 0
-  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.round
-      Time.stub(:now).and_return(@now)
-    end
-
-    it "gives you the key's remaining lifespan in milliseconds" do
-      @mock.expire(@key, 5)
-      @mock.pttl(@key).should == 5000
-    end
-  end
-end

data/spec/commands/quit_spec.rb

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

data/spec/commands/randomkey_spec.rb

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

@@ -1,42 +0,0 @@
-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 the source key is nonexistant' do
-    @redises.del(@key)
-    lambda do
-      @redises.rename(@key, @newkey)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'responds with "OK" when key == newkey' do
-    @redises.rename(@key, @key).should == 'OK'
-  end
-
-  it 'overwrites any existing value at newkey' do
-    @redises.set(@newkey, 'rab')
-    @redises.rename(@key, @newkey)
-    @redises.get(@newkey).should == 'oof'
-  end
-
-  it 'keeps expiration' do
-    @redises.expire(@key, 1000)
-    @redises.rename(@key, @newkey)
-    @redises.ttl(@newkey).should be > 0
-  end
-end

data/spec/commands/renamenx_spec.rb

@@ -1,41 +0,0 @@
-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 == true
-  end
-
-  it 'responds with false when newkey exists' do
-    @redises.set(@newkey, 'monkey')
-    @redises.renamenx(@key, @newkey).should == false
-  end
-
-  it 'moves the data' do
-    @redises.renamenx(@key, @newkey)
-    @redises.get(@newkey).should == 'oof'
-  end
-
-  it 'raises an error when the source key is nonexistant' do
-    @redises.del(@key)
-    lambda do
-      @redises.rename(@key, @newkey)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'returns false when key == newkey' do
-    @redises.renamenx(@key, @key).should == false
-  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

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

@@ -1,50 +0,0 @@
-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 "returns false and doesn't append if source empty" do
-    @redises.rpoplpush('empty', @list1).should be_nil
-    @redises.lrange(@list1, 0, -1).should == %w[a 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(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a list-only command'
-end