mock_redis 0.36.0 → 0.37.0

data/spec/commands/smembers_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe '#smembers(key)' do
-  before { @key = 'mock-redis-test:smembers' }
-
-  it 'returns [] for an empty set' do
-    @redises.smembers(@key).should == []
-  end
-
-  it "returns the set's members" do
-    @redises.sadd(@key, 'Hello')
-    @redises.sadd(@key, 'World')
-    @redises.sadd(@key, 'Test')
-    @redises.smembers(@key).should == %w[Test World Hello]
-  end
-
-  it 'returns unfrozen copies of the input' do
-    input = 'a string'
-    @redises.sadd(@key, input)
-    output = @redises.smembers(@key).first
-
-    expect(output).to eq input
-    expect(output).to_not equal input
-    expect(output).to_not be_frozen
-  end
-
-  it_should_behave_like 'a set-only command'
-end

data/spec/commands/smismember_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe '#smismember(key, *members)' do
-  before do
-    @key = 'mock-redis-test:smismember'
-    @redises.sadd(@key, 'whiskey')
-    @redises.sadd(@key, 'beer')
-  end
-
-  it 'returns true if member is in set' do
-    @redises.smismember(@key, 'whiskey').should == [true]
-    @redises.smismember(@key, 'beer').should == [true]
-    @redises.smismember(@key, 'whiskey', 'beer').should == [true, true]
-    @redises.smismember(@key, %w[whiskey beer]).should == [true, true]
-  end
-
-  it 'returns false if member is not in set' do
-    @redises.smismember(@key, 'cola').should == [false]
-    @redises.smismember(@key, 'whiskey', 'cola').should == [true, false]
-    @redises.smismember(@key, %w[whiskey beer cola]).should == [true, true, false]
-  end
-
-  it 'stringifies member' do
-    @redises.sadd(@key, '1')
-    @redises.smismember(@key, 1).should == [true]
-    @redises.smismember(@key, [1]).should == [true]
-  end
-
-  it 'treats a nonexistent value as an empty set' do
-    @redises.smismember('mock-redis-test:nonesuch', 'beer').should == [false]
-  end
-
-  it_should_behave_like 'a set-only command'
-end

data/spec/commands/smove_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe '#smove(source, destination, member)' do
-  before do
-    @src  = 'mock-redis-test:smove-source'
-    @dest = 'mock-redis-test:smove-destination'
-
-    @redises.sadd(@src, 1)
-    @redises.sadd(@dest, 2)
-  end
-
-  it 'returns true if the member exists in src' do
-    @redises.smove(@src, @dest, 1).should == true
-  end
-
-  it 'returns false if the member exists in src' do
-    @redises.smove(@src, @dest, 'nope').should == false
-  end
-
-  it 'returns true if the member exists in src and dest' do
-    @redises.sadd(@dest, 1)
-    @redises.smove(@src, @dest, 1).should == true
-  end
-
-  it 'moves member from source to destination' do
-    @redises.smove(@src, @dest, 1)
-    @redises.sismember(@dest, 1).should == true
-    @redises.sismember(@src, 1).should == false
-  end
-
-  it 'cleans up empty sets' do
-    @redises.smove(@src, @dest, 1)
-    @redises.get(@src).should be_nil
-  end
-
-  it 'treats a nonexistent value as an empty set' do
-    @redises.smove('mock-redis-test:nonesuch', @dest, 1).should == false
-  end
-
-  it_should_behave_like 'a set-only command'
-end

data/spec/commands/sort_list_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe '#sort(key, options)' do
-  before do
-    @key = 'mock-redis-test:list_sort'
-
-    @redises.rpush(@key, '1')
-    @redises.rpush(@key, '2')
-
-    @redises.set('mock-redis-test:values_1', 'a')
-    @redises.set('mock-redis-test:values_2', 'b')
-
-    @redises.set('mock-redis-test:weight_1', '2')
-    @redises.set('mock-redis-test:weight_2', '1')
-
-    @redises.hset('mock-redis-test:hash_1', 'key', 'x')
-    @redises.hset('mock-redis-test:hash_2', 'key', 'y')
-  end
-
-  it_should_behave_like 'a sortable'
-end

data/spec/commands/sort_set_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe '#sort(key, options)' do
-  before do
-    @key = 'mock-redis-test:set_sort'
-
-    @redises.sadd(@key, '1')
-    @redises.sadd(@key, '2')
-
-    @redises.set('mock-redis-test:values_1', 'a')
-    @redises.set('mock-redis-test:values_2', 'b')
-
-    @redises.set('mock-redis-test:weight_1', '2')
-    @redises.set('mock-redis-test:weight_2', '1')
-
-    @redises.hset('mock-redis-test:hash_1', 'key', 'x')
-    @redises.hset('mock-redis-test:hash_2', 'key', 'y')
-  end
-
-  it_should_behave_like 'a sortable'
-end

data/spec/commands/sort_zset_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe '#sort(key, options)' do
-  before do
-    @key = 'mock-redis-test:zset_sort'
-
-    @redises.zadd(@key, 100, '1')
-    @redises.zadd(@key, 99, '2')
-
-    @redises.set('mock-redis-test:values_1', 'a')
-    @redises.set('mock-redis-test:values_2', 'b')
-
-    @redises.set('mock-redis-test:weight_1', '2')
-    @redises.set('mock-redis-test:weight_2', '1')
-
-    @redises.hset('mock-redis-test:hash_1', 'key', 'x')
-    @redises.hset('mock-redis-test:hash_2', 'key', 'y')
-  end
-
-  it_should_behave_like 'a sortable'
-end

data/spec/commands/spop_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe '#spop(key)' do
-  before do
-    @key = 'mock-redis-test:spop'
-
-    @redises.sadd(@key, 'value')
-  end
-
-  it 'returns a member of the set' do
-    @redises.spop(@key).should == 'value'
-  end
-
-  it 'removes a member of the set' do
-    @redises.spop(@key)
-    @redises.smembers(@key).should == []
-  end
-
-  it 'returns nil if the set is empty' do
-    @redises.spop(@key)
-    @redises.spop(@key).should be_nil
-  end
-
-  it 'returns an array if count is not nil' do
-    @redises.sadd(@key, 'value2')
-    @redises.spop(@key, 2).should == %w[value value2]
-  end
-
-  it 'returns only whats in the set' do
-    @redises.spop(@key, 2).should == ['value']
-    @redises.smembers(@key).should == []
-  end
-
-  it 'returns an empty array if count is not nil and the set it empty' do
-    @redises.spop(@key)
-    @redises.spop(@key, 100).should == []
-  end
-
-  it_should_behave_like 'a set-only command'
-end

data/spec/commands/srandmember_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe '#srandmember(key)' do
-  before do
-    @key = 'mock-redis-test:srandmember'
-
-    @redises.sadd(@key, 'value')
-  end
-
-  it 'returns a member of the set' do
-    @redises.srandmember(@key).should == 'value'
-  end
-
-  it 'does not modify the set' do
-    @redises.srandmember(@key)
-    @redises.smembers(@key).should == ['value']
-  end
-
-  it 'returns nil if the set is empty' do
-    @redises.spop(@key)
-    @redises.srandmember(@key).should be_nil
-  end
-
-  context 'when count argument is specified' do
-    before do
-      @redises.sadd(@key, 'value2')
-      @redises.sadd(@key, 'value3')
-    end
-
-    # NOTE: We disable result checking since MockRedis and Redis will likely
-    # return a different random set (since the selection is, well, random)
-    it 'returns the whole set if count is greater than the set size' do
-      @redises.send_without_checking(:srandmember, @key, 5).should =~ %w[value value2 value3]
-    end
-
-    it 'returns random members up to count from the set when count is smaller than the set size' do
-      @redises.send_without_checking(:srandmember, @key, 2).size.should == 2
-    end
-
-    it 'returns random members up to count from the set when count is negative even if count.abs is greater than the set size' do # rubocop:disable Layout/LineLength
-      @redises.send_without_checking(:srandmember, @key, -5).size.should == 5
-    end
-
-    it 'returns nil if the set is empty' do
-      @redises.srem(@key, %w[value value2 value3])
-      @redises.srandmember(@key, 2).should be_empty
-    end
-  end
-end

data/spec/commands/srem_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe '#srem(key, member)' do
-  before do
-    @key = 'mock-redis-test:srem'
-
-    @redises.sadd(@key, 'bert')
-    @redises.sadd(@key, 'ernie')
-  end
-
-  it 'returns true if member is in the set' do
-    @redises.srem(@key, 'bert').should == true
-  end
-
-  it 'returns false if member is not in the set' do
-    @redises.srem(@key, 'cookiemonster').should == false
-  end
-
-  it 'removes member from the set' do
-    @redises.srem(@key, 'ernie')
-    @redises.smembers(@key).should == ['bert']
-  end
-
-  it 'stringifies member' do
-    @redises.sadd(@key, '1')
-    @redises.srem(@key, 1).should == true
-  end
-
-  it 'cleans up empty sets' do
-    @redises.smembers(@key).each { |m| @redises.srem(@key, m) }
-    @redises.get(@key).should be_nil
-  end
-
-  it 'supports a variable number of arguments' do
-    @redises.srem(@key, %w[bert ernie]).should == 2
-    @redises.get(@key).should be_nil
-  end
-
-  it 'allow passing an array of integers as argument' do
-    @redises.sadd(@key, %w[1 2])
-    @redises.srem(@key, [1, 2]).should == 2
-  end
-
-  it_should_behave_like 'a set-only command'
-end

data/spec/commands/sscan_each_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe '#sscan_each' do
-  subject { MockRedis::Database.new(self) }
-
-  let(:key) { 'mock-redis-test:sscan_each' }
-
-  before do
-    allow(subject).to receive(:smembers).and_return(collection)
-  end
-
-  context 'when no keys are found' do
-    let(:collection) { [] }
-
-    it 'does not iterate over any elements' do
-      results = subject.sscan_each(key).map do |k|
-        k
-      end
-      expect(results).to match_array(collection)
-    end
-  end
-
-  context 'when keys are found' do
-    context 'when no match filter is supplied' do
-      let(:collection) { Array.new(20) { |i| "k#{i}" } }
-
-      it 'iterates over each item in the collection' do
-        results = subject.sscan_each(key).map do |k|
-          k
-        end
-        expect(results).to match_array(collection)
-      end
-    end
-
-    context 'when giving a custom match filter' do
-      let(:match) { 'k1*' }
-      let(:collection) { Array.new(12) { |i| "k#{i}" } }
-      let(:expected) { %w[k1 k10 k11] }
-
-      it 'iterates over each item in the filtered collection' do
-        results = subject.sscan_each(key, match: match).map do |k|
-          k
-        end
-        expect(results).to match_array(expected)
-      end
-    end
-  end
-end

data/spec/commands/sscan_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe '#sscan' do
-  let(:count) { 10 }
-  let(:match) { '*' }
-  let(:key) { 'mock-redis-test:sscan' }
-
-  before do
-    # The return order of the members is non-deterministic, so we sort them to compare
-    expect_any_instance_of(Redis).to receive(:sscan).and_wrap_original do |m, *args|
-      result = m.call(*args)
-      [result[0], result[1].sort]
-    end
-    expect_any_instance_of(MockRedis).to receive(:sscan).and_wrap_original do |m, *args|
-      result = m.call(*args)
-      [result[0], result[1].sort]
-    end
-  end
-
-  context 'when the set does not exist' do
-    it 'returns a 0 cursor and an empty collection' do
-      expect(@redises.sscan(key, 0, count: count, match: match)).to eq(['0', []])
-    end
-  end
-
-  context 'when the set exists' do
-    before do
-      @redises.sadd(key, 'Hello')
-      @redises.sadd(key, 'World')
-      @redises.sadd(key, 'Test')
-    end
-
-    let(:expected) { ['0', %w[Hello Test World]] }
-
-    it 'returns a 0 cursor and the collection' do
-      expect(@redises.sscan(key, 0, count: count)).to eq(expected)
-    end
-  end
-end

data/spec/commands/strlen_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe '#strlen(key)' do
-  before do
-    @key = 'mock-redis-test:73288'
-    @redises.set(@key, '5 ∈ (0..10)')
-  end
-
-  it "returns the string's length in bytes" do
-    @redises.strlen(@key).should == 13
-  end
-
-  it 'returns 0 for a nonexistent value' do
-    @redises.strlen('mock-redis-test:does-not-exist').should == 0
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/sunion_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe '#sunion(key [, key, ...])' do
-  before do
-    @evens   = 'mock-redis-test:sunion:evens'
-    @primes  = 'mock-redis-test:sunion:primes'
-
-    [2, 4, 6, 8, 10].each { |i| @redises.sadd(@evens, i) }
-    [2, 3, 5, 7].each { |i| @redises.sadd(@primes, i) }
-  end
-
-  it 'returns the elements in the resulting set' do
-    @redises.sunion(@evens, @primes).should == %w[2 4 6 8 10 3 5 7]
-  end
-
-  it 'treats missing keys as empty sets' do
-    @redises.sunion(@primes, 'mock-redis-test:nonesuch').
-      should == %w[2 3 5 7]
-  end
-
-  it 'allows Array as argument' do
-    @redises.sunion([@evens, @primes]).should == %w[2 4 6 8 10 3 5 7]
-  end
-
-  it 'raises an error if given 0 sets' do
-    lambda do
-      @redises.sunion
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an error if any argument is not a a set' do
-    @redises.set('mock-redis-test:notset', 1)
-
-    lambda do
-      @redises.sunion(@numbers, 'mock-redis-test:notset')
-    end.should raise_error(Redis::CommandError)
-
-    lambda do
-      @redises.sunion('mock-redis-test:notset', @numbers)
-    end.should raise_error(Redis::CommandError)
-  end
-end

data/spec/commands/sunionstore_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe '#sunionstore(destination, key [, key, ...])' do
-  before do
-    @evens       = 'mock-redis-test:sunionstore:evens'
-    @primes      = 'mock-redis-test:sunionstore:primes'
-    @destination = 'mock-redis-test:sunionstore:destination'
-
-    [2, 4, 6, 8, 10].each { |i| @redises.sadd(@evens, i) }
-    [2, 3, 5, 7].each { |i| @redises.sadd(@primes, i) }
-  end
-
-  it 'returns the number of elements in the resulting set' do
-    @redises.sunionstore(@destination, @primes, @evens).should == 8
-  end
-
-  it 'stores the resulting set' do
-    @redises.sunionstore(@destination, @primes, @evens)
-    @redises.smembers(@destination).should == %w[10 8 6 4 7 5 3 2]
-  end
-
-  it 'does not store empty sets' do
-    @redises.sunionstore(@destination,
-      'mock-redis-test:nonesuch',
-      'mock-redis-test:nonesuch2').should == 0
-    @redises.get(@destination).should be_nil
-  end
-
-  it 'removes existing elements in destination' do
-    @redises.sadd(@destination, 42)
-
-    @redises.sunionstore(@destination, @primes)
-    @redises.smembers(@destination).should == %w[7 5 3 2]
-  end
-
-  it 'correctly unions and stores when the destination is empty and is one of the arguments' do
-    @redises.sunionstore(@destination, @destination, @primes)
-
-    @redises.smembers(@destination).should == %w[7 5 3 2]
-  end
-
-  it 'raises an error if given 0 sets' do
-    lambda do
-      @redises.sunionstore(@destination)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an error if any argument is not a a set' do
-    @redises.set('mock-redis-test:notset', 1)
-
-    lambda do
-      @redises.sunionstore(@destination, @primes, 'mock-redis-test:notset')
-    end.should raise_error(Redis::CommandError)
-
-    lambda do
-      @redises.sunionstore(@destination, 'mock-redis-test:notset', @primes)
-    end.should raise_error(Redis::CommandError)
-  end
-end

data/spec/commands/ttl_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe '#ttl(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.ttl(@key).should == -1
-  end
-
-  it 'returns -2 for a key that does not exist' do
-    @redises.ttl('mock-redis-test:nonesuch').should == -2
-  end
-
-  it 'stringifies key' do
-    @redises.expire(@key, 9)
-    @redises.ttl(@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
-      Time.stub(:now).and_return(@now)
-    end
-
-    it "gives you the key's remaining lifespan in seconds" do
-      @mock.expire(@key, 5)
-      @mock.ttl(@key).should == 5
-    end
-  end
-end

data/spec/commands/type_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe '#type(key)' do
-  before do
-    @key = 'mock-redis-test:type'
-  end
-
-  it "returns 'none' for no key" do
-    @redises.type(@key).should == 'none'
-  end
-
-  it "returns 'string' for a string" do
-    @redises.set(@key, 'stringlish')
-    @redises.type(@key).should == 'string'
-  end
-
-  it "returns 'list' for a list" do
-    @redises.lpush(@key, 100)
-    @redises.type(@key).should == 'list'
-  end
-
-  it "returns 'hash' for a hash" do
-    @redises.hset(@key, 100, 200)
-    @redises.type(@key).should == 'hash'
-  end
-
-  it "returns 'set' for a set" do
-    @redises.sadd(@key, 100)
-    @redises.type(@key).should == 'set'
-  end
-
-  it "returns 'zset' for a zset" do
-    @redises.zadd(@key, 1, 2)
-    @redises.type(@key).should == 'zset'
-  end
-end

data/spec/commands/unwatch_spec.rb

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

data/spec/commands/watch_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe '#watch(key [, key, ...)' do
-  before do
-    @key1 = 'mock-redis-test-watch1'
-    @key2 = 'mock-redis-test-watch2'
-  end
-
-  it "returns 'OK'" do
-    @redises.watch(@key1, @key2).should == 'OK'
-  end
-
-  it 'EXECs its MULTI on successes' do
-    @redises.watch @key1, @key2 do
-      @redises.multi do |multi|
-        multi.set 'bar', 'baz'
-      end
-    end
-    @redises.get('bar').should eq('baz')
-  end
-end