mock_redis 0.19.0 → 0.44.0

data/spec/commands/geodist_spec.rb

@@ -1,114 +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|
-        let(:message) { "ERR wrong number of arguments for 'geodist' command" }
-
-        context "with #{count} arguments" do
-          it 'raises an error' do
-            args = list.slice(0, count)
-            expect { @redises.geodist(*args) }
-              .to raise_error(Redis::CommandError, message)
-          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(Redis::CommandError, message)
-      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, '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, '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, '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, '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, '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, '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, '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, 'SF', 'LA')
-      expect(coords).to be == [nil, nil]
-    end
-  end
-end

data/spec/commands/get_spec.rb

@@ -1,30 +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'
-  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/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/hash_operator_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe '#[](key)' do
-  before do
-    @key = 'mock-redis-test:hash_operator'
-  end
-
-  it 'returns nil for a nonexistent value' do
-    @redises['mock-redis-test:does-not-exist'].should be_nil
-  end
-
-  it 'returns a stored string value' do
-    @redises[@key] = 'forsooth'
-    @redises[@key].should == 'forsooth'
-  end
-
-  it 'treats integers as strings' do
-    @redises[@key] = 100
-    @redises[@key].should == '100'
-  end
-end

data/spec/commands/hdel_spec.rb

@@ -1,54 +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, %w[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_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

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