mock_redis 0.36.0 → 0.37.0

data/spec/commands/hincrbyfloat_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe '#hincrbyfloat(key, field, increment)' do
-  before do
-    @key = 'mock-redis-test:hincrbyfloat'
-    @field = 'count'
-  end
-
-  it 'returns the value after the increment' do
-    @redises.hset(@key, @field, 2.0)
-    @redises.hincrbyfloat(@key, @field, 2.1).should be_within(0.0001).of(4.1)
-  end
-
-  it 'treats a missing key like 0' do
-    @redises.hincrbyfloat(@key, @field, 1.2).should be_within(0.0001).of(1.2)
-  end
-
-  it 'creates a hash if nothing is present' do
-    @redises.hincrbyfloat(@key, @field, 1.0)
-    @redises.hget(@key, @field).should == '1'
-  end
-
-  it 'increments negative numbers' do
-    @redises.hset(@key, @field, -10.4)
-    @redises.hincrbyfloat(@key, @field, 2.3).should be_within(0.0001).of(-8.1)
-  end
-
-  it 'works multiple times' do
-    @redises.hincrbyfloat(@key, @field, 2.1).should be_within(0.0001).of(2.1)
-    @redises.hincrbyfloat(@key, @field, 2.2).should be_within(0.0001).of(4.3)
-    @redises.hincrbyfloat(@key, @field, 2.3).should be_within(0.0001).of(6.6)
-  end
-
-  it 'accepts a float-ish string' do
-    @redises.hincrbyfloat(@key, @field, '2.2').should be_within(0.0001).of(2.2)
-  end
-
-  it 'treats the field as a string' do
-    field = 11
-    @redises.hset(@key, field, 2)
-    @redises.hincrbyfloat(@key, field, 2).should == 4.0
-  end
-
-  it 'raises an error if the value does not look like a float' do
-    @redises.hset(@key, @field, 'one.two')
-    lambda do
-      @redises.hincrbyfloat(@key, @field, 1)
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it 'raises an error if the delta does not look like a float' do
-    lambda do
-      @redises.hincrbyfloat(@key, @field, 'foobar.baz')
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hkeys_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe '#hkeys(key)' do
-  before do
-    @key = 'mock-redis-test:hkeys'
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k2', 'v2')
-  end
-
-  it 'returns the keys stored in the hash' do
-    @redises.hkeys(@key).sort.should == %w[k1 k2]
-  end
-
-  it 'returns [] when there is no such key' do
-    @redises.hkeys('mock-redis-test:nonesuch').should == []
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hlen_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe '#hlen(key)' do
-  before do
-    @key = 'mock-redis-test:hlen'
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k2', 'v2')
-  end
-
-  it 'returns the number of keys stored in the hash' do
-    @redises.hlen(@key).should == 2
-  end
-
-  it 'returns [] when there is no such key' do
-    @redises.hlen('mock-redis-test:nonesuch').should == 0
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hmget_spec.rb

@@ -1,46 +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 'raises an error if given an empty list of 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,69 +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
-
-  # The following tests address https://github.com/sds/mock_redis/issues/170
-  context 'keys are stored as strings' do
-    before do
-      @redises.hmset(1, :foo, :bar)
-      @redises.hmset(:a_sym, :boo, :bas)
-    end
-
-    it { expect(@redises.hgetall('1')).to eq @redises.hgetall(1) }
-    it { expect(@redises.hgetall('a_sym')).to eq @redises.hgetall(:a_sym) }
-    it { expect(@redises.del('1')).to eq 1 }
-    it { expect(@redises.del(1)).to eq 1 }
-    it { expect(@redises.del('a_sym')).to eq 1 }
-    it { expect(@redises.del(:a_sym)).to eq 1 }
-
-    after do
-      @redises.del(1)
-      @redises.del(:a_sym)
-    end
-  end
-
-  # The following tests address https://github.com/sds/mock_redis/issues/134
-  context 'hmset accepts an array as its only argument' do
-    it { expect(@redises.hmset([@key, :bar, :bas])).to eq 'OK' }
-    it { lambda { @redises.hmset([:foo, :bar]) }.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,42 +0,0 @@
-require 'spec_helper'
-
-describe '#hset(key, field)' do
-  before do
-    @key = 'mock-redis-test:hset'
-  end
-
-  it 'returns 1 if the key does not exist' do
-    @redises.hset(@key, 'k1', 'v1').should == 1
-  end
-
-  it 'returns 1 if the key exists but the field does not' do
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k2', 'v2').should == 1
-  end
-
-  it 'returns 0 if the field already exists' do
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k1', 'v1').should == 0
-  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 'stores fields sent in a hash' do
-    @redises.hset(@key, { 'k1' => 'v1', 'k2' => 'v2' }).should == 2
-  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