mock_redis 0.19.0 → 0.44.0

data/spec/commands/hmget_spec.rb

@@ -1,40 +0,0 @@
-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 'treats an array as multiple keys' do
-    @redises.hmget(@key, %w[k1 k2]).sort.should == %w[v1 v2]
-  end
-
-  it 'treats the fielsd as strings' do
-    @redises.hset(@key, 1, 'one')
-    @redises.hset(@key, 2, 'two')
-    @redises.hmget(@key, 1, 2).sort.should == %w[one two]
-  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(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hmset_spec.rb

@@ -1,43 +0,0 @@
-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(Redis::CommandError)
-  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(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hscan_each_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe '#hscan_each' do
-  subject { MockRedis::Database.new(self) }
-
-  let(:key) { 'mock-redis-test:hscan_each' }
-
-  before do
-    allow(subject).to receive(:hgetall).and_return(collection)
-  end
-
-  context 'when no keys are found' do
-    let(:collection) { [] }
-
-    it 'does not iterate over any elements' do
-      results = subject.hscan_each(key).map do |k, v|
-        [k, v]
-      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}", "v#{i}"] } }
-
-      it 'iterates over each item in the collection' do
-        results = subject.hscan_each(key).map do |k, v|
-          [k, v]
-        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}", "v#{i}"] } }
-      let(:expected) { [%w[k1 v1], %w[k10 v10], %w[k11 v11]] }
-
-      it 'iterates over each item in the filtered collection' do
-        results = subject.hscan_each(key, match: match).map do |k, v|
-          [k, v]
-        end
-        expect(results).to match_array(expected)
-      end
-    end
-  end
-end

data/spec/commands/hscan_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe '#hscan' do
-  let(:count) { 10 }
-  let(:match) { '*' }
-  let(:key) { 'mock-redis-test:hscan' }
-
-  context 'when the hash does not exist' do
-    it 'returns a 0 cursor and an empty collection' do
-      expect(@redises.hscan(key, 0, count: count, match: match)).to eq(['0', []])
-    end
-  end
-
-  context 'when the hash exists' do
-    before do
-      @redises.hset(key, 'k1', 'v1')
-      @redises.hset(key, 'k2', 'v2')
-      @redises.hset(key, 'k3', 'v3')
-    end
-
-    let(:expected) { ['0', [%w[k1 v1], %w[k2 v2], %w[k3 v3]]] }
-
-    it 'returns a 0 cursor and the collection' do
-      expect(@redises.hscan(key, 0, count: 10)).to eq(expected)
-    end
-  end
-end

data/spec/commands/hset_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe '#hset(key, field)' do
-  before do
-    @key = 'mock-redis-test:hset'
-  end
-
-  it 'returns true if the key does not exist' do
-    @redises.hset(@key, 'k1', 'v1').should == true
-  end
-
-  it 'returns true if the key exists but the field does not' do
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k2', 'v2').should == true
-  end
-
-  it 'returns false if the field already exists' do
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k1', 'v1').should == false
-  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 'stores fields as strings' do
-    @redises.hset(@key, 1, 'one')
-    @redises.hget(@key, '1').should == 'one'
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hsetnx_spec.rb

@@ -1,44 +0,0 @@
-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 == true
-  end
-
-  it 'returns 0 if the field is present' do
-    @redises.hset(@key, 'field', 'val')
-    @redises.hsetnx(@key, 'field', 'val').should == 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 'stores fields as strings' do
-    @redises.hsetnx(@key, 1, 'one')
-    @redises.hget(@key, '1').should == 'one'
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hvals_spec.rb

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

@@ -1,34 +0,0 @@
-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(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/incrby_spec.rb

@@ -1,44 +0,0 @@
-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(Redis::CommandError)
-  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(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/incrbyfloat_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe '#incrbyfloat(key, increment)' do
-  before { @key = 'mock-redis-test:65374' }
-
-  it 'returns the value after the increment' do
-    @redises.set(@key, 2.0)
-    @redises.incrbyfloat(@key, 2.1).should be_within(0.0001).of(4.1)
-  end
-
-  it 'treats a missing key like 0' do
-    @redises.incrbyfloat(@key, 1.2).should be_within(0.0001).of(1.2)
-  end
-
-  it 'increments negative numbers' do
-    @redises.set(@key, -10.4)
-    @redises.incrbyfloat(@key, 2.3).should be_within(0.0001).of(-8.1)
-  end
-
-  it 'works multiple times' do
-    @redises.incrbyfloat(@key, 2.1).should be_within(0.0001).of(2.1)
-    @redises.incrbyfloat(@key, 2.2).should be_within(0.0001).of(4.3)
-    @redises.incrbyfloat(@key, 2.3).should be_within(0.0001).of(6.6)
-  end
-
-  it 'accepts an float-ish string' do
-    @redises.incrbyfloat(@key, '2.2').should be_within(0.0001).of(2.2)
-  end
-
-  it 'raises an error if the value does not look like an float' do
-    @redises.set(@key, 'one.two')
-    lambda do
-      @redises.incrbyfloat(@key, 1)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an error if the delta does not look like an float' do
-    lambda do
-      @redises.incrbyfloat(@key, 'foobar.baz')
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/info_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe '#info [mock only]' do
-  let(:redis) { @redises.mock }
-
-  it 'responds with a config hash' do
-    redis.info.should be_a(Hash)
-  end
-
-  it 'gets default set of info' do
-    info = redis.info
-    info['arch_bits'].should be_a(String)
-    info['connected_clients'].should be_a(String)
-    info['aof_rewrite_scheduled'].should be_a(String)
-    info['used_cpu_sys'].should be_a(String)
-  end
-
-  it 'gets all info' do
-    info = redis.info(:all)
-    info['arch_bits'].should be_a(String)
-    info['connected_clients'].should be_a(String)
-    info['aof_rewrite_scheduled'].should be_a(String)
-    info['used_cpu_sys'].should be_a(String)
-    info['cmdstat_slowlog'].should be_a(String)
-  end
-
-  it 'gets server info' do
-    redis.info(:server)['arch_bits'].should be_a(String)
-  end
-
-  it 'gets clients info' do
-    redis.info(:clients)['connected_clients'].should be_a(String)
-  end
-
-  it 'gets memory info' do
-    redis.info(:memory)['used_memory'].should be_a(String)
-  end
-
-  it 'gets persistence info' do
-    redis.info(:persistence)['aof_rewrite_scheduled'].should be_a(String)
-  end
-
-  it 'gets stats info' do
-    redis.info(:stats)['keyspace_hits'].should be_a(String)
-  end
-
-  it 'gets replication info' do
-    redis.info(:replication)['role'].should be_a(String)
-  end
-
-  it 'gets cpu info' do
-    redis.info(:cpu)['used_cpu_sys'].should be_a(String)
-  end
-
-  it 'gets keyspace info' do
-    redis.info(:keyspace)['db0'].should be_a(String)
-  end
-
-  it 'gets commandstats info' do
-    redis.info(:commandstats)['sunionstore']['usec'].should be_a(String)
-  end
-end

data/spec/commands/keys_spec.rb

@@ -1,122 +0,0 @@
-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:key',   0)
-      @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:regexp-key(1|22)', 40)
-      @redises.set('mock-redis-test:regexp-key3+', 40)
-      @redises.set('mock-redis-test:regexp-key33', 40)
-      @redises.set('mock-redis-test:regexp-key4a', 40)
-      @redises.set('mock-redis-test:regexp-key4-', 40)
-      @redises.set('mock-redis-test:regexp-key4b', 40)
-      @redises.set('mock-redis-test:regexp-key4c', 40)
-
-      @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 0 or more characters' do
-        @redises.keys('mock-redis-test:key*').sort.should == [
-          'mock-redis-test:key',
-          '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 'the | character' do
-      it "is treated as literal (not 'or')" do
-        @redises.keys('mock-redis-test:regexp-key(1|22)').sort.should == [
-          'mock-redis-test:regexp-key(1|22)',
-        ]
-      end
-    end
-
-    describe 'the + character' do
-      it "is treated as literal (not 'one or more' quantifier)" do
-        @redises.keys('mock-redis-test:regexp-key3+').sort.should == [
-          'mock-redis-test:regexp-key3+',
-        ]
-      end
-    end
-
-    describe 'character classes ([a-c])' do
-      it 'specifies a range which matches any lowercase letter from "a" to "c"' do
-        @redises.keys('mock-redis-test:regexp-key4[a-c]').sort.should == [
-          'mock-redis-test:regexp-key4a',
-          'mock-redis-test:regexp-key4b',
-          'mock-redis-test:regexp-key4c',
-        ]
-      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

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

@@ -1,49 +0,0 @@
-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 'gets an element from the list by its index when index is a string' do
-    @redises.lpush(@key, 20)
-    @redises.lpush(@key, 10)
-
-    @redises.lindex(@key, '0').should == '10'
-    @redises.lindex(@key, '1').should == '20'
-    @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