mock_redis 0.36.0 → 0.37.0

data/spec/commands/future_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe MockRedis::Future do
-  let(:command) { [:get, 'foo'] }
-  let(:result)  { 'bar' }
-  let(:block)   { ->(value) { value.upcase } }
-
-  before do
-    @future = MockRedis::Future.new(command)
-    @future2 = MockRedis::Future.new(command, block)
-  end
-
-  it 'remembers the command' do
-    @future.command.should eq(command)
-  end
-
-  it 'raises an error if the value is requested before the result is set' do
-    expect { @future.value }.to raise_error(MockRedis::FutureNotReady)
-  end
-
-  it 'returns the value after the result has been set' do
-    @future.store_result(result)
-    @future.value.should eq(result)
-  end
-
-  it 'executes the block on the value if block is passed in' do
-    @future2.store_result(result)
-    @future2.value.should eq('BAR')
-  end
-end

data/spec/commands/geoadd_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe '#geoadd' do
-  let(:key) { 'cities' }
-
-  context 'with valid points' do
-    let(:san_francisco) { [-122.5076404, 37.757815, 'SF'] }
-    let(:los_angeles) { [-118.6919259, 34.0207305, 'LA'] }
-    let(:expected_result) do
-      [['LA', 1.364461589564902e+15], ['SF', 1.367859319053696e+15]]
-    end
-
-    before { @redises.geoadd(key, *san_francisco, *los_angeles) }
-
-    after { @redises.zrem(key, %w[SF LA]) }
-
-    it 'adds members to ZSET' do
-      cities = @redises.zrange(key, 0, -1, with_scores: true)
-      expect(cities).to be == expected_result
-    end
-  end
-
-  context 'with invalud points' do
-    context 'when number of arguments wrong' do
-      let(:message) { "ERR wrong number of arguments for 'geoadd' command" }
-
-      it 'raises Redis::CommandError' do
-        expect { @redises.geoadd(key, 1, 1) }
-          .to raise_error(Redis::CommandError, message)
-      end
-    end
-
-    context 'when coordinates are not in allowed range' do
-      let(:coords) { [181, 86] }
-      let(:message) do
-        formatted_coords = coords.map { |c| format('%<coords>.6f', coords: c) }
-        "ERR invalid longitude,latitude pair #{formatted_coords.join(',')}"
-      end
-
-      after { @redises.zrem(key, 'SF') }
-
-      it 'raises Redis::CommandError' do
-        expect { @redises.geoadd(key, *coords, 'SF') }
-          .to raise_error(Redis::CommandError, message)
-      end
-    end
-
-    context 'when coordinates are not valid floats' do
-      let(:coords) { ['x', 35] }
-      let(:message) { 'ERR value is not a valid float' }
-
-      it 'raises Redis::CommandError' do
-        expect { @redises.geoadd key, *coords, 'SF' }
-          .to raise_error(Redis::CommandError, message)
-      end
-    end
-  end
-end

data/spec/commands/geodist_spec.rb

@@ -1,118 +0,0 @@
-require 'spec_helper'
-
-shared_examples 'a distance calculator' do
-  it 'returns distance between two points in specified unit' do
-    dist = @redises.geodist(key, 'SF', 'LA', unit)
-    expect(dist).to be == expected_result
-  end
-end
-
-describe '#geodist' do
-  let(:key) { 'cities' }
-
-  context 'with existing key' do
-    let(:san_francisco) { [-122.5076404, 37.757815, 'SF'] }
-    let(:los_angeles) { [-118.6919259, 34.0207305, 'LA'] }
-
-    before { @redises.geoadd(key, *san_francisco, *los_angeles) }
-
-    after { @redises.zrem(key, %w[SF LA]) }
-
-    context 'with existing points only' do
-      context 'using m as unit' do
-        let(:unit) { 'm' }
-        let(:expected_result) { '539327.9659' }
-
-        it 'returns distance between two points in meters' do
-          dist = @redises.geodist(key, 'SF', 'LA')
-          expect(dist).to be == expected_result
-        end
-
-        it_behaves_like 'a distance calculator'
-      end
-
-      context 'using km as unit' do
-        let(:unit) { 'km' }
-        let(:expected_result) { '539.3280' }
-
-        it_behaves_like 'a distance calculator'
-      end
-
-      context 'using ft as unit' do
-        let(:unit) { 'ft' }
-        let(:expected_result) { '1769448.7069' }
-
-        it_behaves_like 'a distance calculator'
-      end
-
-      context 'using mi as unit' do
-        let(:unit) { 'mi' }
-        let(:expected_result) { '335.1237' }
-
-        it_behaves_like 'a distance calculator'
-      end
-
-      context 'with non-existing points only' do
-        it 'returns nil' do
-          dist = @redises.geodist(key, 'FF', 'FA')
-          expect(dist).to be_nil
-        end
-      end
-
-      context 'with both existing and non-existing points' do
-        it 'returns nil' do
-          dist = @redises.geodist(key, 'SF', 'FA')
-          expect(dist).to be_nil
-        end
-      end
-    end
-  end
-
-  context 'with non-existing key' do
-    it 'returns empty string' do
-      dist = @redises.geodist(key, 'SF', 'LA')
-      expect(dist).to be_nil
-    end
-  end
-
-  context 'with wrong number of arguments' do
-    let(:list) { [key, 'SF', 'LA', 'm', 'smth'] }
-
-    context 'with less than 3 arguments' do
-      [1, 2].each do |count|
-        context "with #{count} arguments" do
-          it 'raises an error' do
-            args = list.slice(0, count)
-            expect { @redises.geodist(*args) }
-              .to raise_error(
-                ArgumentError,
-                /wrong number of arguments \((given\s)?#{count}(,\sexpected\s|\sfor\s)3?\.\.4\)$/
-              )
-          end
-        end
-      end
-    end
-
-    context 'with more than 3 arguments' do
-      let(:message) { 'ERR syntax error' }
-
-      it 'raises an error' do
-        args = list.slice(0, 5)
-        expect { @redises.geodist(*args) }
-          .to raise_error(
-            ArgumentError,
-            /wrong number of arguments \((given\s)?5(,\sexpected\s|\sfor\s)3?\.\.4\)$/
-          )
-      end
-    end
-  end
-
-  context 'with wrong unit' do
-    let(:message) { 'ERR unsupported unit provided. please use m, km, ft, mi' }
-
-    it 'raises an error' do
-      expect { @redises.geodist(key, 'SF', 'LA', 'a') }
-        .to raise_error(Redis::CommandError, message)
-    end
-  end
-end

data/spec/commands/geohash_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe '#geohash' do
-  let(:key) { 'cities' }
-
-  context 'with existing key' do
-    let(:san_francisco) { [-122.5076404, 37.757815, 'SF'] }
-    let(:los_angeles) { [-118.6919259, 34.0207305, 'LA'] }
-
-    before { @redises.geoadd(key, *san_francisco, *los_angeles) }
-
-    after { @redises.zrem(key, %w[SF LA]) }
-
-    context 'with existing points only' do
-      let(:expected_result) do
-        %w[9q8yu38ejp0 9q59e171je0]
-      end
-
-      it 'returns decoded coordinates pairs for each point' do
-        results = @redises.geohash(key, %w[SF LA])
-        expect(results).to be == expected_result
-      end
-
-      context 'with non-existing points only' do
-        it 'returns array filled with nils' do
-          results = @redises.geohash(key, %w[FF FA])
-          expect(results).to be == [nil, nil]
-        end
-      end
-
-      context 'with both existing and non-existing points' do
-        let(:expected_result) do
-          ['9q8yu38ejp0', nil]
-        end
-
-        it 'returns mixture of nil and coordinates pair' do
-          results = @redises.geohash(key, %w[SF FA])
-          expect(results).to be == expected_result
-        end
-      end
-    end
-  end
-
-  context 'with non-existing key' do
-    before { @redises.del(key) }
-
-    it 'returns empty array' do
-      results = @redises.geohash(key, %w[SF LA])
-      expect(results).to be == [nil, nil]
-    end
-  end
-end

data/spec/commands/geopos_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe '#geopos' do
-  let(:key) { 'cities' }
-
-  context 'with existing key' do
-    let(:san_francisco) { [-122.5076404, 37.757815, 'SF'] }
-    let(:los_angeles) { [-118.6919259, 34.0207305, 'LA'] }
-
-    before { @redises.geoadd(key, *san_francisco, *los_angeles) }
-
-    after { @redises.zrem(key, %w[SF LA]) }
-
-    context 'with existing points only' do
-      let(:expected_result) do
-        [
-          %w[-122.5076410174369812 37.75781598995183685],
-          %w[-118.69192510843276978 34.020729570911179]
-        ]
-      end
-
-      it 'returns decoded coordinates pairs for each point' do
-        coords = @redises.geopos(key, %w[SF LA])
-        expect(coords).to be == expected_result
-      end
-
-      context 'with non-existing points only' do
-        it 'returns array filled with nils' do
-          coords = @redises.geopos(key, %w[FF FA])
-          expect(coords).to be == [nil, nil]
-        end
-      end
-
-      context 'with both existing and non-existing points' do
-        let(:expected_result) do
-          [%w[-122.5076410174369812 37.75781598995183685], nil]
-        end
-
-        it 'returns mixture of nil and coordinates pair' do
-          coords = @redises.geopos(key, %w[SF FA])
-          expect(coords).to be == expected_result
-        end
-      end
-    end
-  end
-
-  context 'with non-existing key' do
-    before { @redises.del(key) }
-
-    it 'returns empty array' do
-      coords = @redises.geopos(key, %w[SF LA])
-      expect(coords).to be == [nil, nil]
-    end
-  end
-end

data/spec/commands/get_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe '#get(key)' do
-  before do
-    @key = 'mock-redis-test:73288'
-  end
-
-  it 'returns nil for a nonexistent value' do
-    @redises.get('mock-redis-test:does-not-exist').should be_nil
-  end
-
-  it 'returns a stored string value' do
-    @redises.set(@key, 'forsooth')
-    @redises.get(@key).should == 'forsooth'
-  end
-
-  it 'treats integers as strings' do
-    @redises.set(@key, 100)
-    @redises.get(@key).should == '100'
-  end
-
-  it 'stringifies key' do
-    key = :a_symbol
-
-    @redises.set(key, 'hello')
-    @redises.get(key.to_s).should == 'hello'
-    @redises.get(key).should == 'hello'
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/getbit_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe '#getbit(key, offset)' do
-  before do
-    @key = 'mock-redis-test:getbit'
-    @redises.set(@key, 'h') # ASCII 0x68
-  end
-
-  it 'gets the bits from the key' do
-    @redises.getbit(@key, 0).should == 0
-    @redises.getbit(@key, 1).should == 1
-    @redises.getbit(@key, 2).should == 1
-    @redises.getbit(@key, 3).should == 0
-    @redises.getbit(@key, 4).should == 1
-    @redises.getbit(@key, 5).should == 0
-    @redises.getbit(@key, 6).should == 0
-    @redises.getbit(@key, 7).should == 0
-  end
-
-  it 'returns 0 for out-of-range bits' do
-    @redises.getbit(@key, 100).should == 0
-  end
-
-  it 'does not modify the stored value for out-of-range bits' do
-    @redises.getbit(@key, 100)
-    @redises.get(@key).should == 'h'
-  end
-
-  it 'treats nonexistent keys as empty strings' do
-    @redises.getbit('mock-redis-test:not-found', 0).should == 0
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/getdel.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe '#getdel(key)' do
-  before do
-    @key = 'mock-redis-test:73288'
-  end
-
-  it 'returns nil for a nonexistent value' do
-    @redises.getdel('mock-redis-test:does-not-exist').should be_nil
-  end
-
-  it 'returns a stored string value' do
-    @redises.set(@key, 'forsooth')
-    @redises.getdel(@key).should == 'forsooth'
-  end
-
-  it 'deletes the key after returning it' do
-    @redises.set(@key, 'forsooth')
-    @redises.getdel(@key)
-    @redises.get(@key).should be_nil
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/getrange_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe '#getrange(key, start, stop)' do
-  before do
-    @key = 'mock-redis-test:getrange'
-    @redises.set(@key, 'This is a string')
-  end
-
-  it 'returns a substring' do
-    @redises.getrange(@key, 0, 3).should == 'This'
-  end
-
-  it 'works with negative indices' do
-    @redises.getrange(@key, -3, -1).should == 'ing'
-  end
-
-  it 'limits the result to the actual length of the string' do
-    @redises.getrange(@key, 10, 100).should == 'string'
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/getset_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe '#getrange(key, value)' do
-  before do
-    @key = 'mock-redis-test:getset'
-    @redises.set(@key, 'oldvalue')
-  end
-
-  it 'returns the old value' do
-    @redises.getset(@key, 'newvalue').should == 'oldvalue'
-  end
-
-  it 'sets the value to the new value' do
-    @redises.getset(@key, 'newvalue')
-    @redises.get(@key).should == 'newvalue'
-  end
-
-  it 'returns nil for nonexistent keys' do
-    @redises.getset('mock-redis-test:not-found', 1).should be_nil
-  end
-
-  it_should_behave_like 'a string-only command'
-end

data/spec/commands/hdel_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-describe '#hdel(key, field)' do
-  before do
-    @key = 'mock-redis-test:hdel'
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k2', 'v2')
-  end
-
-  it 'returns 1 when it removes a field' do
-    @redises.hdel(@key, 'k1').should == 1
-  end
-
-  it 'returns 0 when it does not remove a field' do
-    @redises.hdel(@key, 'nonesuch').should == 0
-  end
-
-  it 'actually removes the field' do
-    @redises.hdel(@key, 'k1')
-    @redises.hget(@key, 'k1').should be_nil
-  end
-
-  it 'treats the field as a string' do
-    field = 2
-    @redises.hset(@key, field, 'two')
-    @redises.hdel(@key, field)
-    @redises.hget(@key, field).should be_nil
-  end
-
-  it 'removes only the field specified' do
-    @redises.hdel(@key, 'k1')
-    @redises.hget(@key, 'k2').should == 'v2'
-  end
-
-  it 'cleans up empty hashes' do
-    @redises.hdel(@key, 'k1')
-    @redises.hdel(@key, 'k2')
-    @redises.get(@key).should be_nil
-  end
-
-  it 'supports a variable number of arguments' do
-    @redises.hdel(@key, 'k1', 'k2')
-    @redises.get(@key).should be_nil
-  end
-
-  it 'treats variable arguments as strings' do
-    field = 2
-    @redises.hset(@key, field, 'two')
-    @redises.hdel(@key, field)
-    @redises.hget(@key, field).should be_nil
-  end
-
-  it 'supports a variable number of fields as array' do
-    @redises.hdel(@key, %w[k1 k2]).should == 2
-
-    @redises.hget(@key, 'k1').should be_nil
-    @redises.hget(@key, 'k2').should be_nil
-    @redises.get(@key).should be_nil
-  end
-
-  it 'supports a list of fields in various way' do
-    @redises.hdel(@key, ['k1'], 'k2').should == 2
-
-    @redises.hget(@key, 'k1').should be_nil
-    @redises.hget(@key, 'k2').should be_nil
-    @redises.get(@key).should be_nil
-  end
-
-  it 'raises error if an empty array is passed' do
-    expect { @redises.hdel(@key, []) }.to raise_error(
-      Redis::CommandError,
-      "ERR wrong number of arguments for 'hdel' command"
-    )
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hexists_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe '#hexists(key, field)' do
-  before do
-    @key = 'mock-redis-test:hexists'
-    @redises.hset(@key, 'field', 'value')
-  end
-
-  it 'returns true if the hash has that field' do
-    @redises.hexists(@key, 'field').should == true
-  end
-
-  it 'returns false if the hash lacks that field' do
-    @redises.hexists(@key, 'nonesuch').should == false
-  end
-
-  it 'treats the field as a string' do
-    @redises.hset(@key, 1, 'one')
-    @redises.hexists(@key, 1).should == true
-  end
-
-  it 'returns nil when there is no such key' do
-    @redises.hexists('mock-redis-test:nonesuch', 'key').should == false
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hget_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe '#hget(key, field)' do
-  before do
-    @key = 'mock-redis-test:hget'
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k2', 'v2')
-  end
-
-  it 'returns the value stored at field' do
-    @redises.hget(@key, 'k1').should == 'v1'
-  end
-
-  it 'treats the field as a string' do
-    @redises.hset(@key, '3', 'v3')
-    @redises.hget(@key, 3).should == 'v3'
-  end
-
-  it 'returns nil when there is no such field' do
-    @redises.hget(@key, 'nonesuch').should be_nil
-  end
-
-  it 'returns nil when there is no such key' do
-    @redises.hget('mock-redis-test:nonesuch', 'k1').should be_nil
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hgetall_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe '#hgetall(key)' do
-  before do
-    @key = 'mock-redis-test:hgetall'
-    @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k2', 'v2')
-  end
-
-  it 'returns the (key, value) pairs stored in the hash' do
-    @redises.hgetall(@key).should == {
-      'k1' => 'v1',
-      'k2' => 'v2',
-    }
-  end
-
-  it 'returns [] when there is no such key' do
-    @redises.hgetall('mock-redis-test:nonesuch').should == {}
-  end
-
-  it "doesn't return a mutable reference to the returned data" do
-    mr = MockRedis.new
-    mr.hset(@key, 'k1', 'v1')
-    mr.hset(@key, 'k2', 'v2')
-    hash = mr.hgetall(@key)
-    hash['dont'] = 'mutate'
-    new_hash = mr.hgetall(@key)
-    new_hash.keys.sort.should == %w[k1 k2]
-  end
-
-  it_should_behave_like 'a hash-only command'
-end

data/spec/commands/hincrby_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe '#hincrby(key, field, increment)' do
-  before do
-    @key = 'mock-redis-test:hincrby'
-    @field = 'count'
-  end
-
-  it 'returns the value after the increment' do
-    @redises.hset(@key, @field, 2)
-    @redises.hincrby(@key, @field, 2).should == 4
-  end
-
-  it 'treats a missing key like 0' do
-    @redises.hincrby(@key, @field, 1).should == 1
-  end
-
-  it 'creates a hash if nothing is present' do
-    @redises.hincrby(@key, @field, 1)
-    @redises.hget(@key, @field).should == '1'
-  end
-
-  it 'increments negative numbers' do
-    @redises.hset(@key, @field, -10)
-    @redises.hincrby(@key, @field, 2).should == -8
-  end
-
-  it 'works multiple times' do
-    @redises.hincrby(@key, @field, 2).should == 2
-    @redises.hincrby(@key, @field, 2).should == 4
-    @redises.hincrby(@key, @field, 2).should == 6
-  end
-
-  it 'accepts an integer-ish string' do
-    @redises.hincrby(@key, @field, '2').should == 2
-  end
-
-  it 'treats the field as a string' do
-    field = 11
-    @redises.hset(@key, field, 2)
-    @redises.hincrby(@key, field, 2).should == 4
-  end
-
-  it 'raises an error if the value does not look like an integer' do
-    @redises.hset(@key, @field, 'one')
-    lambda do
-      @redises.hincrby(@key, @field, 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.hincrby(@key, @field, 'foo')
-    end.should raise_error(Redis::CommandError)
-  end
-
-  it_should_behave_like 'a hash-only command'
-end