mock_redis 0.36.0 → 0.37.0

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,65 +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
-
-  context 'emulate param array' do
-    it 'returns an array of values' do
-      @redises.mget([@key1, @key2]).should == %w[1 2]
-    end
-
-    it 'returns an array of values' do
-      @redises.mget([@key1, @key2]).should == %w[1 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
-  end
-
-  context 'emulate params strings' do
-    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
-
-    it 'raises an error if you pass it empty array' do
-      lambda do
-        @redises.mget([])
-      end.should raise_error(Redis::CommandError)
-    end
-  end
-
-  context 'emulate block' do
-    it 'returns an array of values' do
-      @redises.mget(@key1, @key2) { |values| values.map(&:to_i) }.should == [1, 2]
-    end
-  end
-end

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,43 +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 "responds with 'OK' for passed Array with 1 item" do
-    @redises.mset([@key1, 1]).should == 'OK'
-  end
-
-  it "responds with 'OK' for passed Array with 2 items" do
-    @redises.mset([@key1, 1, @key2, 2]).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
-
-  it 'raises an error if given odd-sized array' do
-    lambda do
-      @redises.mset([@key1, 1, @key2])
-    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.pexpire(@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,11 +0,0 @@
-require 'spec_helper'
-
-describe '#ping' do
-  it 'returns "PONG" with no arguments' do
-    @redises.ping.should == 'PONG'
-  end
-
-  it 'returns the argument' do
-    @redises.ping('HELLO').should == 'HELLO'
-  end
-end