redis-file 0.4.2

data/redis-file.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis-file/version"
+
+Gem::Specification.new do |s|
+  s.name        = "redis-file"
+  s.version     = RedisFile::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Daniel Loureiro"]
+  s.email       = ["loureirorg@gmail.com"]
+  s.homepage    = "https://github.com/loureirorg/redis-file"
+  s.license     = "MIT"
+  s.summary     = %q{Fake (local file) driver for redis-rb.}
+  s.description = %q{Fake (local file) driver for redis-rb. Useful for development environment and machines without Redis.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency(%q<redis>, ["~> 3.0.0"])
+  s.add_development_dependency(%q<rspec>, [">= 2.0.0"])
+end

data/spec/compatibility_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module RedisFile
+  describe "Compatibility" do
+    it "should be accessible through RedisFile::Redis" do
+      lambda { RedisFile::Redis.new }.should_not raise_error
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module RedisFile
+  describe "ConnectionMethods" do
+
+    before(:each) do
+      @client = Redis.new
+    end
+
+  if redisfile?
+    it "should authenticate to the server" do
+      @client.auth("pass").should be == "OK"
+    end
+
+    it "should re-use the same instance with the same host & port" do
+      @client1 = Redis.new(:host => "localhost", :port => 1234)
+      @client2 = Redis.new(:host => "localhost", :port => 1234)
+      @client3 = Redis.new(:host => "localhost", :port => 5678)
+
+      @client1.set("key1", "1")
+      @client2.get("key1").should be == "1"
+      @client3.get("key1").should be_nil
+
+      @client2.set("key2", "2")
+      @client1.get("key2").should be == "2"
+      @client3.get("key2").should be_nil
+
+      @client3.set("key3", "3")
+      @client1.get("key3").should be_nil
+      @client2.get("key3").should be_nil
+
+      @client1.dbsize.should be == 2
+      @client2.dbsize.should be == 2
+      @client3.dbsize.should be == 1
+    end
+
+    it "should connect to a specific database" do
+      @client1 = Redis.new(:host => "localhost", :port => 1234, :db => 0)
+      @client1.set("key1", "1")
+      @client1.select(0)
+      @client1.get("key1").should be == "1"
+
+      @client2 = Redis.new(:host => "localhost", :port => 1234, :db => 1)
+      @client2.set("key1", "1")
+      @client2.select(1)
+      @client2.get("key1").should == "1"
+    end
+
+    it "should not error with shutdown" do
+      lambda { @client.shutdown }.should_not raise_error
+    end
+
+    it "should not error with quit" do
+      lambda { @client.quit }.should_not raise_error
+    end
+  end
+
+    it "should handle multiple clients using the same db instance" do
+      @client1 = Redis.new(:host => "localhost", :port => 6379, :db => 1)
+      @client2 = Redis.new(:host => "localhost", :port => 6379, :db => 2)
+
+      @client1.set("key1", "one")
+      @client1.get("key1").should be == "one"
+
+      @client2.set("key2", "two")
+      @client2.get("key2").should be == "two"
+
+      @client1.get("key1").should be == "one"
+    end
+
+    it "should not error with a disconnected client" do
+      @client1 = Redis.new
+      @client1.client.disconnect
+      @client1.get("key1").should be_nil
+    end
+
+    it "should echo the given string" do
+      @client.echo("something").should == "something"
+    end
+
+    it "should ping the server" do
+      @client.ping.should == "PONG"
+    end
+  end
+end

data/spec/hashes_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+module RedisFile
+  describe "HashesMethods" do
+    before(:each) do
+      @client = Redis.new
+    end
+
+    it "should delete a hash field" do
+      @client.hset("key1", "k1", "val1")
+      @client.hset("key1", "k2", "val2")
+      @client.hdel("key1", "k1")
+
+      @client.hget("key1", "k1").should be_nil
+      @client.hget("key1", "k2").should be == "val2"
+    end
+
+    it "should remove a hash with no keys left" do
+      @client.hset("key1", "k1", "val1")
+      @client.hset("key1", "k2", "val2")
+      @client.hdel("key1", "k1")
+      @client.hdel("key1", "k2")
+
+      @client.exists("key1").should be == false
+    end
+
+    it "should convert key to a string for hset" do
+      m = double("key")
+      m.stub(:to_s).and_return("foo")
+
+      @client.hset("key1", m, "bar")
+      @client.hget("key1", "foo").should be == "bar"
+    end
+
+    it "should convert key to a string for hget" do
+      m = double("key")
+      m.stub(:to_s).and_return("foo")
+
+      @client.hset("key1", "foo", "bar")
+      @client.hget("key1", m).should be == "bar"
+    end
+
+    it "should determine if a hash field exists" do
+      @client.hset("key1", "index", "value")
+
+      @client.hexists("key1", "index").should be_true
+      @client.hexists("key2", "i2").should be_false
+    end
+
+    it "should get the value of a hash field" do
+      @client.hset("key1", "index", "value")
+
+      @client.hget("key1", "index").should be == "value"
+    end
+
+    it "should get all the fields and values in a hash" do
+      @client.hset("key1", "i1", "val1")
+      @client.hset("key1", "i2", "val2")
+
+      @client.hgetall("key1").should be == {"i1" => "val1", "i2" => "val2"}
+    end
+
+    it "should increment the integer value of a hash field by the given number" do
+      @client.hset("key1", "cont1", "5")
+      @client.hincrby("key1", "cont1", "5").should be == 10
+      @client.hget("key1", "cont1").should be == "10"
+    end
+
+    it "should increment non existing hash keys" do
+      @client.hget("key1", "cont2").should be_nil
+      @client.hincrby("key1", "cont2", "5").should be == 5
+    end
+
+    it "should get all the fields in a hash" do
+      @client.hset("key1", "i1", "val1")
+      @client.hset("key1", "i2", "val2")
+
+      @client.hkeys("key1").should =~ ["i1", "i2"]
+      @client.hkeys("key2").should be == []
+    end
+
+    it "should get the number of fields in a hash" do
+      @client.hset("key1", "i1", "val1")
+      @client.hset("key1", "i2", "val2")
+
+      @client.hlen("key1").should be == 2
+    end
+
+    it "should get the values of all the given hash fields" do
+      @client.hset("key1", "i1", "val1")
+      @client.hset("key1", "i2", "val2")
+
+      @client.hmget("key1", "i1", "i2", "i3").should =~ ["val1", "val2", nil]
+      @client.hmget("key2", "i1", "i2").should be == [nil, nil]
+    end
+
+    it "should throw an argument error when you don't ask for any keys" do
+      lambda { @client.hmget("key1") }.should raise_error(Redis::CommandError)
+    end
+
+    it "should reject an empty list of values" do
+      lambda { @client.hmset("key") }.should raise_error(Redis::CommandError)
+      @client.exists("key").should be_false
+    end
+
+    it "rejects an insert with a key but no value" do
+      lambda { @client.hmset("key", 'foo') }.should raise_error(Redis::CommandError)
+      lambda { @client.hmset("key", 'foo', 3, 'bar') }.should raise_error(Redis::CommandError)
+      @client.exists("key").should be_false
+    end
+
+    it "should reject the wrong number of arguments" do
+      lambda { @client.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3") }.should raise_error(Redis::CommandError, "ERR wrong number of arguments for 'hmset' command")
+    end
+
+    it "should set multiple hash fields to multiple values" do
+      @client.hmset("key", "k1", "value1", "k2", "value2")
+
+      @client.hget("key", "k1").should be == "value1"
+      @client.hget("key", "k2").should be == "value2"
+    end
+
+    it "should set multiple hash fields from a ruby hash to multiple values" do
+      @client.mapped_hmset("foo", :k1 => "value1", :k2 => "value2")
+
+      @client.hget("foo", "k1").should be == "value1"
+      @client.hget("foo", "k2").should be == "value2"
+    end
+
+    it "should set the string value of a hash field" do
+      @client.hset("key1", "k1", "val1").should be == true
+      @client.hset("key1", "k1", "val1").should be == false
+
+      @client.hget("key1", "k1").should be == "val1"
+    end
+
+    it "should set the value of a hash field, only if the field does not exist" do
+      @client.hset("key1", "k1", "val1")
+      @client.hsetnx("key1", "k1", "value").should be == false
+      @client.hsetnx("key1", "k2", "val2").should be == true
+      @client.hsetnx("key1", :k1, "value").should be == false
+      @client.hsetnx("key1", :k3, "val3").should be == true
+
+      @client.hget("key1", "k1").should be == "val1"
+      @client.hget("key1", "k2").should be == "val2"
+      @client.hget("key1", "k3").should be == "val3"
+    end
+
+    it "should get all the values in a hash" do
+      @client.hset("key1", "k1", "val1")
+      @client.hset("key1", "k2", "val2")
+
+      @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' command")
+    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

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+module RedisFile
+  describe "KeysMethods" do
+
+    before(:each) do
+      @client = Redis.new
+    end
+
+    it "should delete a key" do
+      @client.set("key1", "1")
+      @client.set("key2", "2")
+      @client.del("key1", "key2")
+
+      @client.get("key1").should be == nil
+    end
+
+    it "should delete multiple keys" do
+      @client.set("key1", "1")
+      @client.set("key2", "2")
+      @client.del(["key1", "key2"])
+
+      @client.get("key1").should be == nil
+      @client.get("key2").should be == nil
+    end
+
+    it "should error deleting no keys" do
+      lambda { @client.del }.should raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
+      lambda { @client.del [] }.should raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
+    end
+
+    it "should determine if a key exists" do
+      @client.set("key1", "1")
+
+      @client.exists("key1").should be == true
+      @client.exists("key2").should be == false
+    end
+
+    it "should set a key's time to live in seconds" do
+      @client.set("key1", "1")
+      @client.expire("key1", 1)
+
+      @client.ttl("key1").should be == 1
+    end
+
+    it "should set the expiration for a key as a UNIX timestamp" do
+      @client.set("key1", "1")
+      @client.expireat("key1", Time.now.to_i + 2)
+
+      @client.ttl("key1").should be == 2
+    end
+
+    it "should not have an expiration after re-set" do
+      @client.set("key1", "1")
+      @client.expireat("key1", Time.now.to_i + 2)
+      @client.set("key1", "1")
+
+      @client.ttl("key1").should be == -1
+    end
+
+    it "should not have a ttl if expired" do
+      @client.set("key1", "1")
+      @client.expireat("key1", Time.now.to_i)
+
+      @client.ttl("key1").should be == -1
+    end
+
+    it "should not find a key if expired" do
+      @client.set("key1", "1")
+      @client.expireat("key1", Time.now.to_i)
+
+      @client.get("key1").should be_nil
+    end
+
+    it "should not find multiple keys if expired" do
+      @client.set("key1", "1")
+      @client.set("key2", "2")
+      @client.expireat("key1", Time.now.to_i)
+
+      @client.mget("key1", "key2").should be == [nil, "2"]
+    end
+
+    it "should only find keys that aren't expired" do
+      @client.set("key1", "1")
+      @client.set("key2", "2")
+      @client.expireat("key1", Time.now.to_i)
+
+      @client.keys.should be == ["key2"]
+    end
+
+    it "should not exist if expired" do
+      @client.set("key1", "1")
+      @client.expireat("key1", Time.now.to_i)
+
+      @client.exists("key1").should be_false
+    end
+
+    it "should find all keys matching the given pattern" do
+      @client.set("key:a", "1")
+      @client.set("key:b", "2")
+      @client.set("key:c", "3")
+      @client.set("akeyd", "4")
+      @client.set("key1", "5")
+
+      @client.keys("key:*").should =~ ["key:a", "key:b", "key:c"]
+    end
+
+    it "should remove the expiration from a key" do
+      @client.set("key1", "1")
+      @client.expireat("key1", Time.now.to_i + 1)
+      @client.persist("key1").should be == true
+      @client.persist("key1").should be == false
+
+      @client.ttl("key1").should be == -1
+    end
+
+    it "should return a random key from the keyspace" do
+      @client.set("key1", "1")
+      @client.set("key2", "2")
+
+      ["key1", "key2"].include?(@client.randomkey).should be == true
+    end
+
+    it "should rename a key" do
+      @client.set("key1", "2")
+      @client.rename("key1", "key2")
+
+      @client.get("key1").should be == nil
+      @client.get("key2").should be == "2"
+    end
+
+    it "should rename a key, only if new key does not exist" do
+      @client.set("key1", "1")
+      @client.set("key2", "2")
+      @client.set("key3", "3")
+      @client.renamenx("key1", "key2")
+      @client.renamenx("key3", "key4")
+
+      @client.get("key1").should be == "1"
+      @client.get("key2").should be == "2"
+      @client.get("key3").should be == nil
+      @client.get("key4").should be == "3"
+    end
+
+    it "should sort the elements in a list, set or sorted set" do
+      pending "SORT Command not implemented yet"
+    end
+
+    it "should determine the type stored at key" do
+      @client.set("key1", "1")
+
+      @client.type("key1").should be == "string"
+      @client.type("key0").should be == "none"
+    end
+
+    it "should convert the value into a string before storing" do
+      @client.set("key1", 1)
+      @client.get("key1").should be == "1"
+
+      @client.setex("key2", 30, 1)
+      @client.get("key2").should be == "1"
+
+      @client.getset("key3", 1)
+      @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")
+      @client.get("123").should be == "foo"
+
+      @client.setex(456, 30, "foo")
+      @client.keys.should include("456")
+      @client.get("456").should be == "foo"
+
+      @client.getset(789, "foo")
+      @client.keys.should include("789")
+      @client.get("789").should be == "foo"
+    end
+
+    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")
+
+      @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")
+    end
+
+    it "should move a key from one database to another successfully" do
+      @client.select(0)
+      @client.set("key1", "1")
+
+      @client.move("key1", 1).should be == true
+
+      @client.select(0)
+      @client.get("key1").should be_nil
+
+      @client.select(1)
+      @client.get("key1").should be == "1"
+    end
+
+    it "should fail to move a key that does not exist in the source database" do
+      @client.select(0)
+      @client.get("key1").should be_nil
+
+      @client.move("key1", 1).should be == false
+
+      @client.select(0)
+      @client.get("key1").should be_nil
+
+      @client.select(1)
+      @client.get("key1").should be_nil
+    end
+
+    it "should fail to move a key that exists in the destination database" do
+      @client.select(0)
+      @client.set("key1", "1")
+
+      @client.select(1)
+      @client.set("key1", "2")
+
+      @client.select(0)
+      @client.move("key1", 1).should be == false
+
+      @client.select(0)
+      @client.get("key1").should be == "1"
+
+      @client.select(1)
+      @client.get("key1").should be == "2"
+    end
+
+    it "should fail to move a key to the same database" do
+      @client.select(0)
+      @client.set("key1", "1")
+
+      lambda { @client.move("key1", 0) }.should raise_error(Redis::CommandError, "ERR source and destination objects are the same")
+
+      @client.select(0)
+      @client.get("key1").should be == "1"
+    end
+  end
+end