mock_redis 0.14.1 → 0.15.0

data/spec/commands/info_spec.rb

@@ -3,60 +3,60 @@ require 'spec_helper'
 describe '#info [mock only]' do
   let(:redis) { @redises.mock }
 
-  it "responds with a config hash" do
+  it 'responds with a config hash' do
     redis.info.should be_a(Hash)
   end
 
-  it "gets default set of info" do
+  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)
+    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
+  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)
+    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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  it 'gets commandstats info' do
+    redis.info(:commandstats)['sunionstore']['usec'].should be_a(String)
   end
 end

data/spec/commands/keys_spec.rb

@@ -1,48 +1,47 @@
 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: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: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 == [
+    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',
@@ -51,14 +50,14 @@ describe '#keys()' 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 "the * character" do
-      it "is treated as 0 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',
@@ -71,13 +70,13 @@ describe '#keys()' 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',
@@ -85,23 +84,23 @@ describe '#keys()' do
       end
     end
 
-    describe "the | character" 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)'
+          'mock-redis-test:regexp-key(1|22)',
         ]
       end
     end
 
-    describe "the + character" do
+    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+'
+          'mock-redis-test:regexp-key3+',
         ]
       end
     end
 
-    describe "character classes ([a-c])" do
+    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',
@@ -111,8 +110,8 @@ describe '#keys()' do
       end
     end
 
-    describe "combining metacharacters" do
-      it "works with different metacharacters simultaneously" do
+    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,47 +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 "gets an element from the list by its index when index is a string" 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"
+    @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
+  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
 
-  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