mock_redis 0.5.4 → 0.31.0

data/spec/commands/incr_spec.rb

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe '#incr(key)' do
   before { @key = 'mock-redis-test:33888' }
 
-  it "returns the value after the increment" do
+  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
+  it 'treats a missing key like 0' do
     @redises.incr(@key).should == 1
   end
 
-  it "increments negative numbers" do
+  it 'increments negative numbers' do
     @redises.set(@key, -10)
     @redises.incr(@key).should == -9
   end
 
-  it "works multiple times" do
+  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")
+  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(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a string-only command"
+  it_should_behave_like 'a string-only command'
 end

data/spec/commands/incrby_spec.rb

@@ -3,42 +3,42 @@ require 'spec_helper'
 describe '#incrby(key, increment)' do
   before { @key = 'mock-redis-test:65374' }
 
-  it "returns the value after the increment" do
+  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
+  it 'treats a missing key like 0' do
     @redises.incrby(@key, 1).should == 1
   end
 
-  it "increments negative numbers" do
+  it 'increments negative numbers' do
     @redises.set(@key, -10)
     @redises.incrby(@key, 2).should == -8
   end
 
-  it "works multiple times" do
+  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
+  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")
+  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(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if the delta does not look like an integer" do
+  it 'raises an error if the delta does not look like an integer' do
     lambda do
-      @redises.incrby(@key, "foo")
-    end.should raise_error(RuntimeError)
+      @redises.incrby(@key, 'foo')
+    end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a string-only command"
+  it_should_behave_like 'a string-only command'
 end

data/spec/commands/incrbyfloat_spec.rb

@@ -3,42 +3,42 @@ require 'spec_helper'
 describe '#incrbyfloat(key, increment)' do
   before { @key = 'mock-redis-test:65374' }
 
-  it "returns the value after the increment" do
+  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
+  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
+  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
+  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)
+  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")
+  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(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if the delta does not look like an float" do
+  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(RuntimeError)
+      @redises.incrbyfloat(@key, 'foobar.baz')
+    end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a string-only command"
+  it_should_behave_like 'a string-only command'
 end

data/spec/commands/info_spec.rb

@@ -1,13 +1,62 @@
 require 'spec_helper'
 
 describe '#info [mock only]' do
-  before { @info = @redises.mock.info }
+  let(:redis) { @redises.mock }
 
-  it "responds with a config hash" do
-    @info.should be_a(Hash)
+  it 'responds with a config hash' do
+    redis.info.should be_a(Hash)
   end
 
-  it "has some data in it" do
-    @info.keys.length.should > 0
+  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,55 +1,81 @@
 require 'spec_helper'
 
 describe '#keys()' do
-
-  it "returns [] when no keys are found (no regex characters)" do
-    @redises.keys("mock-redis-test:29016").should == []
+  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 == []
+  it 'returns [] when no keys are found (some regex characters)' do
+    @redises.keys('mock-redis-test:29016*').should == []
   end
 
-  describe "with pattern matching" do
+  describe 'with pattern matching' do
     before do
-      @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:special-key?", 'true')
-      @redises.set("mock-redis-test:special-key*", 'true')
+      @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')
+      @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 == [
+    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 == [
+      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
+      it 'treats \\? as a literal ?' do
         @redises.keys('mock-redis-test:special-key\?').sort.should == [
-          'mock-redis-test:special-key?'
+          'mock-redis-test:special-key?',
         ]
       end
+
+      context 'multiple ? characters' do
+        it "properly handles multiple consequtive '?' characters" do
+          @redises.keys('mock-redis-test:special-key-???').sort.should == [
+            'mock-redis-test:special-key-!?*',
+          ]
+        end
+
+        context '\\? as a literal ' do
+          it 'handles multiple ? as both literal and special character' do
+            @redises.keys('mock-redis-test:special-key-?\??').sort.should == [
+              'mock-redis-test:special-key-!?*',
+            ]
+          end
+        end
+      end
     end
 
-    describe "the * character" do
-      it "is treated as 1 or more characters" do
-        @redises.keys("mock-redis-test:key*").sort.should == [
+    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',
@@ -59,15 +85,15 @@ describe '#keys()' do
         ]
       end
 
-      it "treats \* as a literal *" do
+      it 'treats \\* as a literal *' do
         @redises.keys('mock-redis-test:special-key\*').sort.should == [
-          'mock-redis-test:special-key*'
+          'mock-redis-test:special-key*',
         ]
       end
     end
 
-    describe "character classes ([abcde])" do
-      it "matches any one of those characters" do
+    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',
@@ -75,8 +101,34 @@ describe '#keys()' do
       end
     end
 
-    describe "combining metacharacters" do
-      it "works with different metacharacters simultaneously" do
+    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',

data/spec/commands/lastsave_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe "#lastsave [mock only]" do
+describe '#lastsave [mock only]' do
   # can't test against both since it's timing-dependent
-  it "returns a Unix time" do
+  it 'returns a Unix time' do
     @redises.mock.lastsave.to_s.should =~ /^\d+$/
   end
 end

data/spec/commands/lindex_spec.rb

@@ -3,37 +3,47 @@ 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
+  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"
+    @redises.lindex(@key, 0).should == '10'
+    @redises.lindex(@key, 1).should == '20'
   end
 
-  it "treats negative indices as coming from the right" do
+  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"
+    @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
+  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
+  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
+  it 'returns nil for nonexistent values' do
     @redises.lindex(@key, 0).should be_nil
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/linsert_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
-describe "#linsert(key, :before|:after, pivot, value)" do
+describe '#linsert(key, :before|:after, pivot, value)' do
   before { @key = 'mock-redis-test:48733' }
 
-  it "returns the new size of the list when the pivot is found" do
+  it 'returns the new size of the list when the pivot is found' do
     @redises.lpush(@key, 'X')
 
     @redises.linsert(@key, :before, 'X', 'Y').should == 2
     @redises.lpushx(@key, 'X').should == 3
   end
 
-  it "does nothing when run against a nonexistent key" do
+  it 'does nothing when run against a nonexistent key' do
     @redises.linsert(@key, :before, 1, 2).should == 0
     @redises.get(@key).should be_nil
   end
 
-  it "returns -1 if the pivot is not found" do
+  it 'returns -1 if the pivot is not found' do
     @redises.lpush(@key, 1)
     @redises.linsert(@key, :after, 'X', 'Y').should == -1
   end
 
-  it "inserts elements before the pivot when given :before as position" do
+  it 'inserts elements before the pivot when given :before as position' do
     @redises.lpush(@key, 'bert')
     @redises.linsert(@key, :before, 'bert', 'ernie')
 
@@ -36,33 +36,33 @@ describe "#linsert(key, :before|:after, pivot, value)" do
     @redises.lindex(@key, 1).should == 'bert'
   end
 
-  it "inserts elements after the pivot when given :after as position" do
+  it 'inserts elements after the pivot when given :after as position' do
     @redises.lpush(@key, 'bert')
     @redises.linsert(@key, :after, 'bert', 'ernie')
-    
+
     @redises.lindex(@key, 0).should == 'bert'
     @redises.lindex(@key, 1).should == 'ernie'
   end
-    
+
   it "inserts elements after the pivot when given 'after' as position" do
     @redises.lpush(@key, 'bert')
     @redises.linsert(@key, 'after', 'bert', 'ernie')
-    
+
     @redises.lindex(@key, 0).should == 'bert'
     @redises.lindex(@key, 1).should == 'ernie'
   end
 
-  it "raises an error when given a position that is neither before nor after" do
+  it 'raises an error when given a position that is neither before nor after' do
     lambda do
       @redises.linsert(@key, :near, 1, 2)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it "stores values as strings" do
+  it 'stores values as strings' do
     @redises.lpush(@key, 1)
     @redises.linsert(@key, :before, 1, 2)
-    @redises.lindex(@key, 0).should == "2"
+    @redises.lindex(@key, 0).should == '2'
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/llen_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
-describe "#llen(key)" do
+describe '#llen(key)' do
   before { @key = 'mock-redis-test:78407' }
 
-  it "returns 0 for a nonexistent key" do
+  it 'returns 0 for a nonexistent key' do
     @redises.llen(@key).should == 0
   end
 
-  it "returns the length of the list" do
+  it 'returns the length of the list' do
     5.times { @redises.lpush(@key, 'X') }
     @redises.llen(@key).should == 5
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/lpop_spec.rb

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe '#lpop(key)' do
   before { @key = 'mock-redis-test:65374' }
 
-  it "returns and removes the first element of a list" do
+  it 'returns and removes the first element of a list' do
     @redises.lpush(@key, 1)
     @redises.lpush(@key, 2)
 
-    @redises.lpop(@key).should == "2"
+    @redises.lpop(@key).should == '2'
 
     @redises.llen(@key).should == 1
   end
 
-  it "returns nil if the list is empty" do
+  it 'returns nil if the list is empty' do
     @redises.lpush(@key, 'foo')
     @redises.lpop(@key)
 
     @redises.lpop(@key).should be_nil
   end
 
-  it "returns nil for nonexistent values" do
+  it 'returns nil for nonexistent values' do
     @redises.lpop(@key).should be_nil
   end
 
-  it "removes empty lists" do
+  it 'removes empty lists' do
     @redises.lpush(@key, 'foo')
     @redises.lpop(@key)
 
     @redises.get(@key).should be_nil
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/lpush_spec.rb

@@ -1,37 +1,43 @@
 require 'spec_helper'
 
-describe "#lpush(key, value)" do
+describe '#lpush(key, value)' do
   before { @key = 'mock-redis-test:57367' }
 
-  it "returns the new size of the list" do
+  it 'returns the new size of the list' do
     @redises.lpush(@key, 'X').should == 1
     @redises.lpush(@key, 'X').should == 2
   end
 
-  it "creates a new list when run against a nonexistent key" do
+  it 'creates a new list when run against a nonexistent key' do
     @redises.lpush(@key, 'value')
     @redises.llen(@key).should == 1
   end
 
-  it "prepends items to the list" do
-    @redises.lpush(@key, "bert")
-    @redises.lpush(@key, "ernie")
+  it 'prepends items to the list' do
+    @redises.lpush(@key, 'bert')
+    @redises.lpush(@key, 'ernie')
 
-    @redises.lindex(@key, 0).should == "ernie"
-    @redises.lindex(@key, 1).should == "bert"
+    @redises.lindex(@key, 0).should == 'ernie'
+    @redises.lindex(@key, 1).should == 'bert'
   end
 
-  it "stores values as strings" do
+  it 'stores values as strings' do
     @redises.lpush(@key, 1)
-    @redises.lindex(@key, 0).should == "1"
+    @redises.lindex(@key, 0).should == '1'
   end
 
-  it "supports a variable number of arguments" do
+  it 'supports a variable number of arguments' do
     @redises.lpush(@key, [1, 2, 3]).should == 3
-    @redises.lindex(@key, 0).should == "3"
-    @redises.lindex(@key, 1).should == "2"
-    @redises.lindex(@key, 2).should == "1"
+    @redises.lindex(@key, 0).should == '3'
+    @redises.lindex(@key, 1).should == '2'
+    @redises.lindex(@key, 2).should == '1'
   end
 
-  it_should_behave_like "a list-only command"
+  it 'raises an error if an empty array is given' do
+    lambda do
+      @redises.lpush(@key, [])
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it_should_behave_like 'a list-only command'
 end