fakeredis 0.4.2 → 0.4.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 88195a8e3e41a553347ff30096fac78a8dcec153
+  data.tar.gz: 3ea4aa2ec9ec9857486a503ef8032b2f22562a60
+SHA512:
+  metadata.gz: 28fd4cbbe0ec660365112a7b7485c950771a4c8d75c933d0d55afdb3cfbdabdd1fdeba98d687e9050b01fdf2e52e07278b8497a8d0e03ac97f974c0211afaa72
+  data.tar.gz: 0c5c519761c03545a014d0822c3c4a32d63ea6ae3bd96f7c7b6e433dd5acf646dec8b195b5675838cd56e3ac6e5320164654318724e8c3e57ee8f53e32a408cd

data/.travis.yml

@@ -5,4 +5,4 @@ rvm:
   - 2.0.0
   - ree
   - jruby
-  - rbx-19mode
+  - rbx

data/Gemfile

@@ -3,5 +3,7 @@ source "http://rubygems.org"
 gem 'rake'
 gem 'rdoc'
 
+gem 'rubysl', :platforms => :rbx
+
 # Specify your gem's dependencies in fakeredis.gemspec
 gemspec

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.4.2"
+  VERSION = "0.4.3"
 end

data/lib/redis/connection/memory.rb

@@ -77,7 +77,7 @@ class Redis
       end
 
       def write(command)
-        meffod = command.shift
+        meffod = command.shift.to_s.downcase.to_sym
         if respond_to?(meffod)
           reply = send(meffod, *command)
         else
@@ -131,7 +131,7 @@ class Redis
 
       def info
         {
-          "redis_version" => "0.07",
+          "redis_version" => "2.6.16",
           "connected_clients" => "1",
           "connected_slaves" => "0",
           "used_memory" => "3187",
@@ -185,7 +185,7 @@ class Redis
       end
 
       def mget(*keys)
-        raise Redis::CommandError, "wrong number of arguments for 'mget' command" if keys.empty?
+        raise_argument_error('mget') if keys.empty?
         # We work with either an array, or list of arguments
         keys = keys.first if keys.size == 1
         data.values_at(*keys)
@@ -212,6 +212,7 @@ class Redis
       end
 
       def hdel(key, field)
+        field = field.to_s
         data_type_check(key, Hash)
         data[key] && data[key].delete(field)
         remove_key_for_empty_collection(key)
@@ -224,8 +225,7 @@ class Redis
       end
 
       def keys(pattern = "*")
-        regexp = Regexp.new(pattern.split("*").map { |r| Regexp.escape(r) }.join(".*"))
-        data.keys.select { |key| key =~ regexp }
+        data.keys.select { |key| File.fnmatch(pattern, key) }
       end
 
       def randomkey
@@ -266,7 +266,18 @@ class Redis
       def ltrim(key, start, stop)
         data_type_check(key, Array)
         return unless data[key]
-        data[key] = data[key][start..stop]
+
+        if start < 0 && data[key].count < start.abs
+          # Example: we have a list of 3 elements and
+          # we give it a ltrim list, -5, -1. This means
+          # it should trim to a max of 5. Since 3 < 5
+          # we should not touch the list. This is consistent
+          # with behavior of real Redis's ltrim with a negative
+          # start argument.
+          data[key]
+        else
+          data[key] = data[key][start..stop]
+        end
       end
 
       def lindex(key, index)
@@ -281,14 +292,14 @@ class Redis
         case where
           when :before then data[key].insert(index, value)
           when :after  then data[key].insert(index + 1, value)
-          else raise Redis::CommandError, "ERR syntax error"
+          else raise_syntax_error
         end
       end
 
       def lset(key, index, value)
         data_type_check(key, Array)
         return unless data[key]
-        raise(Redis::CommandError, "ERR index out of range") if index >= data[key].size
+        raise Redis::CommandError, "ERR index out of range" if index >= data[key].size
         data[key][index] = value
       end
 
@@ -374,6 +385,7 @@ class Redis
       def sadd(key, value)
         data_type_check(key, ::Set)
         value = Array(value)
+        raise_argument_error('sadd') if value.empty?
 
         result = if data[key]
           old_set = data[key].dup
@@ -417,6 +429,8 @@ class Redis
       end
 
       def sinter(*keys)
+        raise_argument_error('sinter') if keys.empty?
+
         keys.each { |k| data_type_check(k, ::Set) }
         return ::Set.new if keys.any? { |k| data[k].nil? }
         keys = keys.map { |k| data[k] || ::Set.new }
@@ -448,7 +462,7 @@ class Redis
       def sdiff(key1, *keys)
         [key1, *keys].each { |k| data_type_check(k, ::Set) }
         keys = keys.map { |k| data[k] || ::Set.new }
-        keys.inject(data[key1]) do |memo, set|
+        keys.inject(data[key1] || Set.new) do |memo, set|
           memo - set
         end.to_a
       end
@@ -467,7 +481,8 @@ class Redis
 
       def del(*keys)
         keys = keys.flatten(1)
-        raise Redis::CommandError, "ERR wrong number of arguments for 'del' command" if keys.empty?
+        raise_argument_error('del') if keys.empty?
+
         old_count = data.keys.size
         keys.each do |key|
           data.delete(key)
@@ -510,7 +525,7 @@ class Redis
         if data.expires.include?(key) && (ttl = data.expires[key].to_i - Time.now.to_i) > 0
           ttl
         else
-          -1
+          exists(key) ? -1 : -2
         end
       end
 
@@ -546,16 +561,30 @@ class Redis
       def hmset(key, *fields)
         # mapped_hmset gives us [[:k1, "v1", :k2, "v2"]] for `fields`. Fix that.
         fields = fields[0] if mapped_param?(fields)
-        raise Redis::CommandError, "ERR wrong number of arguments for HMSET" if fields.empty? || fields.size.odd?
+        raise_argument_error('hmset') if fields.empty?
+
+        is_list_of_arrays = fields.all?{|field| field.instance_of?(Array)}
+
+        raise_argument_error('hmset') if fields.size.odd? and !is_list_of_arrays
+        raise_argument_error('hmset') if is_list_of_arrays and !fields.all?{|field| field.length == 2}
+
         data_type_check(key, Hash)
         data[key] ||= {}
-        fields.each_slice(2) do |field|
-          data[key][field[0].to_s] = field[1].to_s
+
+        if is_list_of_arrays
+          fields.each do |pair|
+            data[key][pair[0].to_s] = pair[1].to_s
+          end
+        else
+          fields.each_slice(2) do |field|
+            data[key][field[0].to_s] = field[1].to_s
+          end
         end
       end
 
       def hmget(key, *fields)
-        raise Redis::CommandError, "wrong number of arguments for 'hmget' command" if fields.empty?
+        raise_argument_error('hmget')  if fields.empty?
+
         data_type_check(key, Hash)
         fields.map do |field|
           field = field.to_s
@@ -581,8 +610,9 @@ class Redis
 
       def hincrby(key, field, increment)
         data_type_check(key, Hash)
+        field = field.to_s
         if data[key]
-          data[key][field] = (data[key][field.to_s].to_i + increment.to_i).to_s
+          data[key][field] = (data[key][field].to_i + increment.to_i).to_s
         else
           data[key] = { field => increment.to_s }
         end
@@ -592,7 +622,7 @@ class Redis
       def hexists(key, field)
         data_type_check(key, Hash)
         return false unless data[key]
-        data[key].key?(field)
+        data[key].key?(field.to_s)
       end
 
       def sync ; end
@@ -625,6 +655,7 @@ class Redis
       def setex(key, seconds, value)
         data[key] = value.to_s
         expire(key, seconds)
+        "OK"
       end
 
       def setrange(key, offset, value)
@@ -636,6 +667,10 @@ class Redis
       def mset(*pairs)
         # Handle pairs for mapped_mset command
         pairs = pairs[0] if mapped_param?(pairs)
+        raise_argument_error('mset') if pairs.empty? || pairs.size == 1
+        # We have to reply with a different error message here to be consistent with redis-rb 3.0.6 / redis-server 2.8.1
+        raise_argument_error("mset", "mset_odd") if pairs.size.odd?
+
         pairs.each_slice(2) do |pair|
           data[pair[0].to_s] = pair[1].to_s
         end
@@ -680,6 +715,7 @@ class Redis
         case data[key]
           when nil then "none"
           when String then "string"
+          when ZSet then "zset"
           when Hash then "hash"
           when Array then "list"
           when ::Set then "set"
@@ -713,20 +749,20 @@ class Redis
       def zadd(key, *args)
         if !args.first.is_a?(Array)
           if args.size < 2
-            raise Redis::CommandError, "ERR wrong number of arguments for 'zadd' command"
+            raise_argument_error('zadd')
           elsif args.size.odd?
-            raise Redis::CommandError, "ERR syntax error"
+            raise_syntax_error
           end
         else
           unless args.all? {|pair| pair.size == 2 }
-            raise(Redis::CommandError, "ERR syntax error")
+            raise_syntax_error
           end
         end
 
         data_type_check(key, ZSet)
         data[key] ||= ZSet.new
 
-        if args.size == 2
+        if args.size == 2 && !(Array === args.first)
           score, value = args
           exists = !data[key].key?(value.to_s)
           data[key][value.to_s] = score
@@ -746,7 +782,7 @@ class Redis
         return 0 unless data[key]
 
         response = values.map do |v|
-          data[key].delete(v) if data[key].has_key?(v)
+          data[key].delete(v.to_s) if data[key].has_key?(v.to_s)
         end.compact.size
 
         remove_key_for_empty_collection(key)
@@ -780,12 +816,16 @@ class Redis
 
       def zrank(key, value)
         data_type_check(key, ZSet)
-        data[key].keys.sort_by {|k| data[key][k] }.index(value.to_s)
+        z = data[key]
+        return unless z
+        z.keys.sort_by {|k| z[k] }.index(value.to_s)
       end
 
       def zrevrank(key, value)
         data_type_check(key, ZSet)
-        data[key].keys.sort_by {|k| -data[key][k] }.index(value.to_s)
+        z = data[key]
+        return unless z
+        z.keys.sort_by {|k| -z[k] }.index(value.to_s)
       end
 
       def zrange(key, start, stop, with_scores = nil)
@@ -834,6 +874,7 @@ class Redis
       end
 
       def zrevrangebyscore(key, max, min, *opts)
+        opts = opts.flatten
         data_type_check(key, ZSet)
         return [] unless data[key]
 
@@ -882,6 +923,19 @@ class Redis
       end
 
       private
+        def raise_argument_error(command, match_string=command)
+          error_message = if %w(hmset mset_odd).include?(match_string.downcase)
+            "ERR wrong number of arguments for #{command.upcase}"
+          else
+            "ERR wrong number of arguments for '#{command}' command"
+          end
+
+          raise Redis::CommandError, error_message
+        end
+
+        def raise_syntax_error
+          raise Redis::CommandError, "ERR syntax error"
+        end
 
         def remove_key_for_empty_collection(key)
           del(key) if data[key] && data[key].empty?
@@ -890,7 +944,7 @@ class Redis
         def data_type_check(key, klass)
           if data[key] && !data[key].is_a?(klass)
             warn "Operation against a key holding the wrong kind of value: Expected #{klass} at #{key}."
-            raise Redis::CommandError.new("ERR Operation against a key holding the wrong kind of value")
+            raise Redis::CommandError.new("WRONGTYPE Operation against a key holding the wrong kind of value")
           end
         end
 

data/spec/hashes_spec.rb

@@ -153,5 +153,30 @@ module FakeRedis
       @client.hvals("key1").should =~ ["val1", "val2"]
     end
 
+    it "should accept a list of array pairs as arguments and not throw an invalid argument number error" do
+      @client.hmset("key1", [:k1, "val1"], [:k2, "val2"], [:k3, "val3"])
+      @client.hget("key1", :k1).should be == "val1"
+      @client.hget("key1", :k2).should be == "val2"
+      @client.hget("key1", :k3).should be == "val3"
+    end
+
+    it "should reject a list of arrays that contain an invalid number of arguments" do
+      expect { @client.hmset("key1", [:k1, "val1"], [:k2, "val2", "bogus val"]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for HMSET")
+    end
+
+    it "should convert a integer field name to string for hdel" do
+      @client.hset("key1", "1", 1)
+      @client.hdel("key1", 1).should be(1)
+    end
+
+    it "should convert a integer field name to string for hexists" do
+      @client.hset("key1", "1", 1)
+      @client.hexists("key1", 1).should be_true
+    end
+
+    it "should convert a integer field name to string for hincrby" do
+      @client.hset("key1", 1, 0)
+      @client.hincrby("key1", 1, 1).should be(1)
+    end
   end
 end

data/spec/keys_spec.rb

@@ -58,11 +58,11 @@ module FakeRedis
       @client.ttl("key1").should be == -1
     end
 
-    it "should not have a ttl if expired" do
+    it "should not have a ttl if expired (and thus key does not exist)" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.ttl("key1").should be == -1
+      @client.ttl("key1").should be == -2
     end
 
     it "should not find a key if expired" do
@@ -102,7 +102,10 @@ module FakeRedis
       @client.set("akeyd", "4")
       @client.set("key1", "5")
 
+      @client.mset("database", 1, "above", 2, "suitability", 3, "able", 4)
+
       @client.keys("key:*").should =~ ["key:a", "key:b", "key:c"]
+      @client.keys("ab*").should =~ ["above", "able"]
     end
 
     it "should remove the expiration from a key" do
@@ -147,10 +150,28 @@ module FakeRedis
     end
 
     it "should determine the type stored at key" do
-      @client.set("key1", "1")
+      # Non-existing key
+      @client.type("key0").should be == "none"
 
+      # String
+      @client.set("key1", "1")
       @client.type("key1").should be == "string"
-      @client.type("key0").should be == "none"
+
+      # List
+      @client.lpush("key2", "1")
+      @client.type("key2").should be == "list"
+
+      # Set
+      @client.sadd("key3", "1")
+      @client.type("key3").should be == "set"
+
+      # Sorted Set
+      @client.zadd("key4", 1.0, "1")
+      @client.type("key4").should be == "zset"
+
+      # Hash
+      @client.hset("key5", "a", "1")
+      @client.type("key5").should be == "hash"
     end
 
     it "should convert the value into a string before storing" do
@@ -164,6 +185,10 @@ module FakeRedis
       @client.get("key3").should be == "1"
     end
 
+    it "should return 'OK' for the setex command" do
+      @client.setex("key4", 30, 1).should be == "OK"
+    end
+
     it "should convert the key into a string before storing" do
       @client.set(123, "foo")
       @client.keys.should include("123")
@@ -180,12 +205,12 @@ module FakeRedis
 
     it "should only operate against keys containing string values" do
       @client.sadd("key1", "one")
-      lambda { @client.get("key1") }.should raise_error(Redis::CommandError, "ERR Operation against a key holding the wrong kind of value")
-      lambda { @client.getset("key1", 1) }.should raise_error(Redis::CommandError, "ERR Operation against a key holding the wrong kind of value")
+      lambda { @client.get("key1") }.should raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
+      lambda { @client.getset("key1", 1) }.should raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
 
       @client.hset("key2", "one", "two")
-      lambda { @client.get("key2") }.should raise_error(Redis::CommandError, "ERR Operation against a key holding the wrong kind of value")
-      lambda { @client.getset("key2", 1) }.should raise_error(Redis::CommandError, "ERR Operation against a key holding the wrong kind of value")
+      lambda { @client.get("key2") }.should raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
+      lambda { @client.getset("key2", 1) }.should raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
     end
 
     it "should move a key from one database to another successfully" do

data/spec/lists_spec.rb

@@ -123,6 +123,39 @@ module FakeRedis
       @client.lrange("key1", 0, -1).should be == ["two", "three"]
     end
 
+
+    context "when the list is smaller than the requested trim" do
+      before { @client.rpush("listOfOne", "one") }
+
+      context "trimming with a negative start (specifying a max)" do
+        before { @client.ltrim("listOfOne", -5, -1) }
+
+        it "returns the unmodified list" do
+          @client.lrange("listOfOne", 0, -1).should be == ["one"]
+        end
+      end
+    end
+
+    context "when the list is larger than the requested trim" do
+      before do
+        @client.rpush("maxTest", "one")
+        @client.rpush("maxTest", "two")
+        @client.rpush("maxTest", "three")
+        @client.rpush("maxTest", "four")
+        @client.rpush("maxTest", "five")
+        @client.rpush("maxTest", "six")
+      end
+
+      context "trimming with a negative start (specifying a max)" do
+        before { @client.ltrim("maxTest", -5, -1) }
+
+        it "should trim a list to the specified maximum size" do
+          @client.lrange("maxTest", 0, -1).should be == ["two","three", "four", "five", "six"]
+        end
+      end
+    end
+
+
     it "should remove and return the last element in a list" do
       @client.rpush("key1", "one")
       @client.rpush("key1", "two")

data/spec/sets_spec.rb

@@ -13,6 +13,13 @@ module FakeRedis
       @client.smembers("key").should be == ["value"]
     end
 
+    it "should raise error if command arguments count is not enough" do
+      expect { @client.sadd("key", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sadd' command")
+      expect { @client.sinter(*[]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sinter' command")
+
+      @client.smembers("key").should be_empty
+    end
+
     it "should add multiple members to a set" do
       @client.sadd("key", %w(value other something more)).should be == 4
       @client.sadd("key", %w(and additional values)).should be == 3
@@ -39,6 +46,13 @@ module FakeRedis
       @client.sdiff("key1", "key2", "key3").should =~ ["b", "d"]
     end
 
+    it "should subtract from a nonexistent set" do
+      @client.sadd("key2", "a")
+      @client.sadd("key2", "b")
+
+      @client.sdiff("key1", "key2").should == []
+    end
+
     it "should subtract multiple sets and store the resulting set in a key" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")

data/spec/sorted_sets_spec.rb

@@ -44,6 +44,10 @@ module FakeRedis
       @client.zscore("key", "val2").should be == 2
       @client.zscore("key", "val3").should be == 3
       @client.zscore("key", "val4").should be == 4
+
+      @client.zadd("key", [[5, "val5"], [3, "val6"]]).should be == 2
+      @client.zscore("key", "val5").should be == 5
+      @client.zscore("key", "val6").should be == 3
     end
 
     it "should error with wrong number of arguments when adding members" do
@@ -178,10 +182,10 @@ module FakeRedis
       @client.zrevrangebyscore("key", 100, 0).should be == ["three", "two", "one"]
       @client.zrevrangebyscore("key", 2, 1).should be == ["two", "one"]
       @client.zrevrangebyscore("key", 1, 2).should be == []
-      @client.zrevrangebyscore("key", 2, 1, :with_scores => true).should be == [["two", 2], ["one", 1]]
+      @client.zrevrangebyscore("key", 2, 1, :with_scores => true).should be == [["two", 2.0], ["one", 1.0]]
       @client.zrevrangebyscore("key", 100, 0, :limit => [0, 1]).should be == ["three"]
       @client.zrevrangebyscore("key", 100, 0, :limit => [0, -1]).should be == ["three", "two", "one"]
-      @client.zrevrangebyscore("key", 100, 0, :limit => [1, -1], :with_scores => true).should be == [["two", 2], ["one", 1]]
+      @client.zrevrangebyscore("key", 100, 0, :limit => [1, -1], :with_scores => true).should be == [["two", 2.0], ["one", 1.0]]
     end
 
     it "should determine the index of a member in a sorted set" do
@@ -202,6 +206,14 @@ module FakeRedis
       @client.zrevrank("key", "four").should be_nil
     end
 
+    it "should not raise errors for zrank() on accessing a non-existing key in a sorted set" do
+      @client.zrank("no_such_key", "no_suck_id").should be_nil
+    end
+
+    it "should not raise errors for zrevrank() on accessing a non-existing key in a sorted set" do
+      @client.zrevrank("no_such_key", "no_suck_id").should be_nil
+    end
+
     describe "#zinterstore" do
       before do
         @client.zadd("key1", 1, "one")
@@ -409,5 +421,11 @@ module FakeRedis
     #it "should get the score associated with the given member in a sorted set"
 
     #it "should add multiple sorted sets and store the resulting sorted set in a new key"
+
+    it "zrem should remove members add by zadd" do
+      @client.zadd("key1", 1, 3)
+      @client.zrem("key1", 3)
+      @client.zscore("key1", 3).should be_nil
+    end
   end
 end

data/spec/strings_spec.rb

@@ -158,6 +158,15 @@ module FakeRedis
       @client.get("key2").should be == "value2"
     end
 
+    it "should raise error if command arguments count is wrong" do
+      expect { @client.mset }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'mset' command")
+      expect { @client.mset(:key1) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'mset' command")
+      expect { @client.mset(:key1, "value", :key2) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for MSET")
+
+      @client.get("key1").should be_nil
+      @client.get("key2").should be_nil
+    end
+
     it "should set multiple keys to multiple values, only if none of the keys exist" do
       @client.msetnx(:key1, "value1", :key2, "value2").should be == true
       @client.msetnx(:key1, "value3", :key2, "value4").should be == false

data/spec/upcase_method_name_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe "UPCASE method name will call downcase method" do
+
+    before do
+      @client = Redis.new
+    end
+
+    it "#ZCOUNT" do
+      @client.ZCOUNT("key", 2, 3).should == @client.zcount("key", 2, 3)
+    end
+
+    it "#ZSCORE" do
+      @client.ZSCORE("key", 2).should == @client.zscore("key", 2)
+    end
+  end
+end

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: fakeredis
 version: !ruby/object:Gem::Version
-  version: 0.4.2
-  prerelease: 
+  version: 0.4.3
 platform: ruby
 authors:
 - Guillermo Iguaran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-28 00:00:00.000000000 Z
+date: 2013-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,17 +27,15 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.0.0
 description: Fake (In-memory) driver for redis-rb. Useful for testing environment
@@ -80,30 +75,30 @@ files:
 - spec/spec_helper_live_redis.rb
 - spec/strings_spec.rb
 - spec/transactions_spec.rb
+- spec/upcase_method_name_spec.rb
 homepage: https://guilleiguaran.github.com/fakeredis
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Fake (In-memory) driver for redis-rb.
 test_files:
 - spec/compatibility_spec.rb
@@ -118,3 +113,4 @@ test_files:
 - spec/spec_helper_live_redis.rb
 - spec/strings_spec.rb
 - spec/transactions_spec.rb
+- spec/upcase_method_name_spec.rb