fakeredis 0.3.3 → 0.4.0

data/spec/spec_helper.rb

@@ -2,8 +2,4 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
 require 'fakeredis'
-require "fakeredis/rspec"
 
-def fakeredis?
-  true
-end

data/spec/strings_spec.rb

@@ -11,121 +11,89 @@ module FakeRedis
       @client.set("key1", "Hello")
       @client.append("key1", " World")
 
-      @client.get("key1").should be == "Hello World"
+      @client.get("key1").should == "Hello World"
     end
 
     it "should decrement the integer value of a key by one" do
       @client.set("counter", "1")
       @client.decr("counter")
 
-      @client.get("counter").should be == "0"
+      @client.get("counter").should == "0"
     end
 
     it "should decrement the integer value of a key by the given number" do
       @client.set("counter", "10")
       @client.decrby("counter", "5")
 
-      @client.get("counter").should be == "5"
+      @client.get("counter").should == "5"
     end
 
     it "should get the value of a key" do
-      @client.get("key2").should be == nil
+      @client.get("key2").should == nil
     end
 
     it "should returns the bit value at offset in the string value stored at key" do
       @client.set("key1", "a")
 
-      @client.getbit("key1", 1).should be == 1
-      @client.getbit("key1", 2).should be == 1
-      @client.getbit("key1", 3).should be == 0
-      @client.getbit("key1", 4).should be == 0
-      @client.getbit("key1", 5).should be == 0
-      @client.getbit("key1", 6).should be == 0
-      @client.getbit("key1", 7).should be == 1
+      @client.getbit("key1", 1).should == 1
+      @client.getbit("key1", 2).should == 1
+      @client.getbit("key1", 3).should == 0
+      @client.getbit("key1", 4).should == 0
+      @client.getbit("key1", 5).should == 0
+      @client.getbit("key1", 6).should == 0
+      @client.getbit("key1", 7).should == 1
     end
 
     it "should allow direct bit manipulation even if the string isn't set" do
       @client.setbit("key1", 10, 1)
-      @client.getbit("key1", 10).should be == 1
+      @client.getbit("key1", 10).should == 1
     end
 
     it "should get a substring of the string stored at a key" do
       @client.set("key1", "This a message")
 
-      @client.getrange("key1", 0, 3).should be == "This"
-      @client.substr("key1", 0, 3).should be == "This"
+      @client.getrange("key1", 0, 3).should == "This"
+      @client.substr("key1", 0, 3).should == "This"
     end
 
     it "should set the string value of a key and return its old value" do
       @client.set("key1","value1")
 
-      @client.getset("key1", "value2").should be == "value1"
-      @client.get("key1").should be == "value2"
+      @client.getset("key1", "value2").should == "value1"
+      @client.get("key1").should == "value2"
     end
 
     it "should return nil for #getset if the key does not exist when setting" do
-      @client.getset("key1", "value1").should be_nil
-      @client.get("key1").should be == "value1"
+      @client.getset("key1", "value1").should == nil
+      @client.get("key1").should == "value1"
     end
 
     it "should increment the integer value of a key by one" do
       @client.set("counter", "1")
-      @client.incr("counter").should be == 2
+      @client.incr("counter").should == 2
 
-      @client.get("counter").should be == "2"
-    end
-
-    it "should not change the expire value of the key during incr" do
-      @client.set("counter", "1")
-      @client.expire("counter", 600).should be_true
-      @client.ttl("counter").should be == 600
-      @client.incr("counter").should be == 2
-      @client.ttl("counter").should be == 600
+      @client.get("counter").should == "2"
     end
 
     it "should decrement the integer value of a key by one" do
       @client.set("counter", "1")
-      @client.decr("counter").should be == 0
-
-      @client.get("counter").should be == "0"
-    end
+      @client.decr("counter").should == 0
 
-    it "should not change the expire value of the key during decr" do
-      @client.set("counter", "2")
-      @client.expire("counter", 600).should be_true
-      @client.ttl("counter").should be == 600
-      @client.decr("counter").should be == 1
-      @client.ttl("counter").should be == 600
+      @client.get("counter").should == "0"
     end
 
     it "should increment the integer value of a key by the given number" do
       @client.set("counter", "10")
-      @client.incrby("counter", "5").should be == 15
-      @client.incrby("counter", 2).should be == 17
-      @client.get("counter").should be == "17"
-    end
-
-    it "should not change the expire value of the key during incrby" do
-      @client.set("counter", "1")
-      @client.expire("counter", 600).should be_true
-      @client.ttl("counter").should be == 600
-      @client.incrby("counter", "5").should be == 6
-      @client.ttl("counter").should be == 600
+      @client.incrby("counter", "5").should == 15
+      @client.incrby("counter", 2).should == 17
+      @client.get("counter").should == "17"
     end
 
     it "should decrement the integer value of a key by the given number" do
       @client.set("counter", "10")
-      @client.decrby("counter", "5").should be == 5
-      @client.decrby("counter", 2).should be == 3
-      @client.get("counter").should be == "3"
-    end
-
-    it "should not change the expire value of the key during decrby" do
-      @client.set("counter", "8")
-      @client.expire("counter", 600).should be_true
-      @client.ttl("counter").should be == 600
-      @client.decrby("counter", "3").should be == 5
-      @client.ttl("counter").should be == 600
+      @client.decrby("counter", "5").should == 5
+      @client.decrby("counter", 2).should == 3
+      @client.get("counter").should == "3"
     end
 
     it "should get the values of all the given keys" do
@@ -133,63 +101,48 @@ module FakeRedis
       @client.set("key2", "value2")
       @client.set("key3", "value3")
 
-      @client.mget("key1", "key2", "key3").should be == ["value1", "value2", "value3"]
+      @client.mget("key1", "key2", "key3").should == ["value1", "value2", "value3"]
     end
 
-    it "raises an argument error when not passed any fields" do
+    it 'raises an argument error when not passed any fields' do
       @client.set("key3", "value3")
 
-      lambda { @client.mget }.should raise_error(RuntimeError, "ERR wrong number of arguments for 'mget' command")
+      lambda { @client.mget }.should raise_error(ArgumentError)
     end
 
     it "should set multiple keys to multiple values" do
       @client.mset(:key1, "value1", :key2, "value2")
 
-      @client.get("key1").should be == "value1"
-      @client.get("key2").should be == "value2"
+      @client.get("key1").should == "value1"
+      @client.get("key2").should == "value2"
     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 == 1
-      @client.msetnx(:key1, "value3", :key2, "value4").should be == 0
-
-      @client.get("key1").should be == "value1"
-      @client.get("key2").should be == "value2"
-    end
-
-    it "should set multiple keys to multiple values with a hash" do
-      @client.mapped_mset(:key1 => "value1", :key2 => "value2")
-
-      @client.get("key1").should be == "value1"
-      @client.get("key2").should be == "value2"
-    end
-
-    it "should set multiple keys to multiple values with a hash, only if none of the keys exist" do
-      @client.mapped_msetnx(:key1 => "value1", :key2 => "value2").should be == 1
-      @client.mapped_msetnx(:key1 => "value3", :key2 => "value4").should be == 0
+      @client.msetnx(:key1, "value1", :key2, "value2")
+      @client.msetnx(:key1, "value3", :key2, "value4")
 
-      @client.get("key1").should be == "value1"
-      @client.get("key2").should be == "value2"
+      @client.get("key1").should == "value1"
+      @client.get("key2").should == "value2"
     end
 
     it "should set the string value of a key" do
       @client.set("key1", "1")
 
-      @client.get("key1").should be == "1"
+      @client.get("key1").should == "1"
     end
 
     it "should sets or clears the bit at offset in the string value stored at key" do
       @client.set("key1", "abc")
       @client.setbit("key1", 11, 1)
 
-      @client.get("key1").should be == "arc"
+      @client.get("key1").should == "arc"
     end
 
     it "should set the value and expiration of a key" do
       @client.setex("key1", 30, "value1")
 
-      @client.get("key1").should be == "value1"
-      @client.ttl("key1").should be == 30
+      @client.get("key1").should == "value1"
+      @client.ttl("key1").should == 30
     end
 
     it "should set the value of a key, only if the key does not exist" do
@@ -197,21 +150,21 @@ module FakeRedis
       @client.setnx("key1", "new value")
       @client.setnx("key2", "another value")
 
-      @client.get("key1").should be == "test value"
-      @client.get("key2").should be == "another value"
+      @client.get("key1").should == "test value"
+      @client.get("key2").should == "another value"
     end
 
     it "should overwrite part of a string at key starting at the specified offset" do
       @client.set("key1", "Hello World")
       @client.setrange("key1", 6, "Redis")
 
-      @client.get("key1").should be == "Hello Redis"
+      @client.get("key1").should == "Hello Redis"
     end
 
     it "should get the length of the value stored in a key" do
       @client.set("key1", "abc")
 
-      @client.strlen("key1").should be == 3
+      @client.strlen("key1").should == 3
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fakeredis
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-28 00:00:00.000000000 Z
+date: 2012-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -59,14 +59,9 @@ files:
 - README.md
 - Rakefile
 - fakeredis.gemspec
-- lib/fake_redis.rb
 - lib/fakeredis.rb
-- lib/fakeredis/expiring_hash.rb
 - lib/fakeredis/rspec.rb
-- lib/fakeredis/sorted_set_argument_handler.rb
-- lib/fakeredis/sorted_set_store.rb
 - lib/fakeredis/version.rb
-- lib/fakeredis/zset.rb
 - lib/redis/connection/memory.rb
 - spec/compatibility_spec.rb
 - spec/connection_spec.rb
@@ -77,12 +72,10 @@ files:
 - spec/sets_spec.rb
 - spec/sorted_sets_spec.rb
 - spec/spec_helper.rb
-- spec/spec_helper_live_redis.rb
 - spec/strings_spec.rb
 - spec/transactions_spec.rb
-homepage: https://guilleiguaran.github.com/fakeredis
-licenses:
-- MIT
+homepage: https://github.com/guilleiguaran/fakeredis
+licenses: []
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -100,8 +93,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.23
+rubyforge_project: fakeredis
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Fake (In-memory) driver for redis-rb.
@@ -115,6 +108,6 @@ test_files:
 - spec/sets_spec.rb
 - spec/sorted_sets_spec.rb
 - spec/spec_helper.rb
-- spec/spec_helper_live_redis.rb
 - spec/strings_spec.rb
 - spec/transactions_spec.rb
+has_rdoc: 

data/lib/fake_redis.rb

@@ -1 +0,0 @@
-require "fakeredis"

data/lib/fakeredis/expiring_hash.rb

@@ -1,56 +0,0 @@
-module FakeRedis
-  # Represents a normal hash with some additional expiration information
-  # associated with each key
-  class ExpiringHash < Hash
-    attr_reader :expires
-
-    def initialize(*)
-      super
-      @expires = {}
-    end
-
-    def [](key)
-      delete(key) if expired?(key)
-      super
-    end
-
-    def []=(key, val)
-      expire(key)
-      super
-    end
-
-    def delete(key)
-      expire(key)
-      super
-    end
-
-    def expire(key)
-      expires.delete(key)
-    end
-
-    def expired?(key)
-      expires.include?(key) && expires[key] < Time.now
-    end
-
-    def key?(key)
-      delete(key) if expired?(key)
-      super
-    end
-
-    def values_at(*keys)
-      keys.each {|key| delete(key) if expired?(key)}
-      super
-    end
-
-    def keys
-      super.select do |key|
-        if expired?(key)
-          delete(key)
-          false
-        else
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fakeredis/sorted_set_argument_handler.rb

@@ -1,74 +0,0 @@
-module FakeRedis
-  # Takes in the variable length array of arguments for a zinterstore/zunionstore method
-  # and parses them into a few attributes for the method to access.
-  #
-  # Handles throwing errors for various scenarios (matches redis):
-  #   * Custom weights specified, but not enough or too many given
-  #   * Invalid aggregate value given
-  #   * Multiple aggregate values given
-  class SortedSetArgumentHandler
-    # [Symbol] The aggregate method to use for the output values. One of %w(sum min max) expected
-    attr_reader :aggregate
-    # [Integer] Number of keys in the argument list
-    attr_accessor :number_of_keys
-    # [Array] The actual keys in the argument list
-    attr_accessor :keys
-    # [Array] integers for weighting the values of each key - one number per key expected
-    attr_accessor :weights
-
-    # Used internally
-    attr_accessor :type
-
-    # Expects all the argments for the method to be passed as an array
-    def initialize args
-      # Pull out known lengths of data
-      self.number_of_keys = args.shift
-      self.keys = args.shift(number_of_keys)
-      # Handle the variable lengths of data (WEIGHTS/AGGREGATE)
-      args.inject(self) {|handler, item| handler.handle(item) }
-
-      # Defaults for unspecified things
-      self.weights ||= Array.new(number_of_keys) { 1 }
-      self.aggregate ||= :sum
-
-      # Validate values
-      raise(RuntimeError, "ERR syntax error") unless weights.size == number_of_keys
-      raise(RuntimeError, "ERR syntax error") unless [:min, :max, :sum].include?(aggregate)
-    end
-
-    # Only allows assigning a value *once* - raises Redis::CommandError if a second is given
-    def aggregate=(str)
-      raise(RuntimeError, "ERR syntax error") if (defined?(@aggregate) && @aggregate)
-      @aggregate = str.to_s.downcase.to_sym
-    end
-
-    # Decides how to handle an item, depending on where we are in the arguments
-    def handle(item)
-      case item
-      when "WEIGHTS"
-        self.type = :weights
-        self.weights = []
-      when "AGGREGATE"
-        self.type = :aggregate
-      when nil
-        # This should never be called, raise a syntax error if we manage to hit it
-        raise(RuntimeError, "ERR syntax error")
-      else
-        send "handle_#{type}", item
-      end
-      self
-    end
-
-    def handle_weights(item)
-      self.weights << item
-    end
-
-    def handle_aggregate(item)
-      self.aggregate = item
-    end
-
-    def inject_block
-      lambda { |handler, item| handler.handle(item) }
-    end
-  end
-end