redis-store 1.0.0.beta2 → 1.0.0.beta3

data/spec/rack/cache/entitystore/redis_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "/../../../spec_helper")
+require 'spec_helper'
 
 class Object
   def sha_like?
@@ -92,13 +92,15 @@ module Rack
           @store.open('87fe0a1ae82a518592f6b12b0183e950b4541c62').should be_nil
         end
 
-        it 'can store largish bodies with binary data' do
-          pony = ::File.open(::File.dirname(__FILE__) + '/pony.jpg', 'rb') { |f| f.read }
-          key, size = @store.write([pony])
-          key.should == 'd0f30d8659b4d268c5c64385d9790024c2d78deb'
-          data = @store.read(key)
-          data.length.should == pony.length
-          data.hash.should == pony.hash
+        if RUBY_VERSION < '1.9'
+          it 'can store largish bodies with binary data' do
+            pony = ::File.open(::File.dirname(__FILE__) + '/pony.jpg', 'rb') { |f| f.read }
+            key, size = @store.write([pony])
+            key.should == 'd0f30d8659b4d268c5c64385d9790024c2d78deb'
+            data = @store.read(key)
+            data.length.should == pony.length
+            data.hash.should == pony.hash
+          end
         end
 
         it 'deletes stored entries with #purge' do

data/spec/rack/cache/metastore/redis_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "/../../../spec_helper")
+require 'spec_helper'
 
 module Rack
   module Cache
@@ -23,7 +23,7 @@ module Rack
 
         it "should resolve the connection uri" do
           cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://127.0.0.1")).cache
-          cache.should be_kind_of(::Redis::MarshaledClient)
+          cache.should be_kind_of(::Redis::Store)
           cache.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
 
           cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://127.0.0.1:6380")).cache

data/spec/rack/session/redis_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "/../../spec_helper")
+require 'spec_helper'
 
 module Rack
   module Session
@@ -26,12 +26,12 @@ module Rack
       end
 
       it "should specify connection params" do
-        pool = Rack::Session::Redis.new(@incrementor, :redis_server => "localhost:6380/1").pool
-        pool.should be_kind_of(::Redis::MarshaledClient)
-        pool.to_s.should == "Redis Client connected to localhost:6380 against DB 1"
+        pool = Rack::Session::Redis.new(@incrementor, :redis_server => "redis://127.0.0.1:6380/1/theplaylist").pool
+        pool.should be_kind_of(::Redis::Store)
+        pool.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 1 with namespace theplaylist"
 
-        pool = Rack::Session::Redis.new(@incrementor, :redis_server => ["localhost:6379", "localhost:6380"]).pool
-        pool.should be_kind_of(::Redis::DistributedMarshaled)
+        pool = Rack::Session::Redis.new(@incrementor, :redis_server => ["redis://127.0.0.1:6379", "redis://127.0.0.1:6380"]).pool
+        pool.should be_kind_of(::Redis::DistributedStore)
       end
 
       it "creates a new cookie" do

data/spec/redis/distributed_store_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Redis::DistributedStore" do
+  before(:each) do
+    @dmr = Redis::DistributedStore.new [
+      {:host => "localhost", :port => "6380", :db => 0},
+      {:host => "localhost", :port => "6381", :db => 0}
+    ]
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    @dmr.set "rabbit", @rabbit
+  end
+
+  after(:all) do
+    @dmr.ring.nodes.each { |server| server.flushdb }
+  end
+
+  it "should accept connection params" do
+    dmr = Redis::DistributedStore.new [ :host => "localhost", :port => "6380", :db => "1" ]
+    dmr.ring.nodes.size == 1
+    mr = dmr.ring.nodes.first
+    mr.to_s.should == "Redis Client connected to localhost:6380 against DB 1"
+  end
+
+  it "should set an object" do
+    @dmr.set "rabbit", @white_rabbit
+    @dmr.get("rabbit").should == @white_rabbit
+  end
+
+  it "should get an object" do
+    @dmr.get("rabbit").should == @rabbit
+  end
+
+  describe "namespace" do
+    before :each do
+      @dmr = Redis::DistributedStore.new [
+        {:host => "localhost", :port => "6380", :db => 0},
+        {:host => "localhost", :port => "6381", :db => 0}
+      ], :namespace => "theplaylist"
+    end
+
+    it "should use namespaced key" do
+      @dmr.should_receive(:node_for).with("theplaylist:rabbit").and_return @dmr.nodes.first
+      @dmr.get "rabbit"
+    end
+  end
+end

data/spec/redis/factory_spec.rb

@@ -1,11 +1,11 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
+require 'spec_helper'
 
 describe "Redis::Factory" do
   describe ".create" do
     context "when not given any arguments" do
-      it "should instantiate a Redis::MarshaledClient store" do
+      it "should instantiate a Redis::Store store" do
         store = Redis::Factory.create
-        store.should be_kind_of(Redis::MarshaledClient)
+        store.should be_kind_of(Redis::Store)
         store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
       end
     end
@@ -26,12 +26,32 @@ describe "Redis::Factory" do
         store.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
       end
 
-      it "should instantiate a Redis::DistributedMarshaled store" do
+      it "should allow to specify namespace" do
+        store = Redis::Factory.create :namespace => "theplaylist"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
+      end
+
+      it "should allow to specify key_prefix as namespace" do
+        store = Redis::Factory.create :key_prefix => "theplaylist"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
+      end
+
+      it "should allow to specify marshalling" do
+        store = Redis::Factory.create :marshalling => false
+        store.instance_variable_get(:@marshalling).should be_false
+      end
+
+      it "should allow to specify password" do
+        store = Redis::Factory.create :password => "secret"
+        store.instance_variable_get(:@client).password.should == "secret"
+      end
+
+      it "should instantiate a Redis::DistributedStore store" do
         store = Redis::Factory.create(
           {:host => "localhost", :port => 6379},
           {:host => "localhost", :port => 6380}
         )
-        store.should be_kind_of(Redis::DistributedMarshaled)
+        store.should be_kind_of(Redis::DistributedStore)
         store.nodes.map {|node| node.to_s}.should == [
           "Redis Client connected to localhost:6379 against DB 0",
           "Redis Client connected to localhost:6380 against DB 0",
@@ -41,26 +61,48 @@ describe "Redis::Factory" do
 
     context "when given a String" do
       it "should allow to specify host" do
-        store = Redis::Factory.create "localhost"
-        store.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
+        store = Redis::Factory.create "redis://127.0.0.1"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
       end
 
       it "should allow to specify port" do
-        store = Redis::Factory.create "localhost:6380"
-        store.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
+        store = Redis::Factory.create "redis://127.0.0.1:6380"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
       end
 
       it "should allow to specify db" do
-        store = Redis::Factory.create "localhost:6380/13"
-        store.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
+        store = Redis::Factory.create "redis://127.0.0.1:6380/13"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13"
+      end
+
+      it "should allow to specify namespace" do
+        store = Redis::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
       end
 
-      it "should instantiate a Redis::DistributedMarshaled store" do
-        store = Redis::Factory.create "localhost:6379", "localhost:6380"
-        store.should be_kind_of(Redis::DistributedMarshaled)
+      it "should allow to specify scheme" do
+        store = Redis::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
+      end
+
+      it "should allow to specify password" do
+        store = Redis::Factory.create "redis://:secret@127.0.0.1:6379/0/theplaylist"
+        store.instance_variable_get(:@client).password.should == "secret"
+      end
+
+      it "should allow to specify password without scheme" do
+        suppress_warnings do
+          store = Redis::Factory.create ":secret@127.0.0.1:6379/0/theplaylist"
+          store.instance_variable_get(:@client).password.should == "secret"
+        end
+      end
+
+      it "should instantiate a Redis::DistributedStore store" do
+        store = Redis::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380"
+        store.should be_kind_of(Redis::DistributedStore)
         store.nodes.map {|node| node.to_s}.should == [
-          "Redis Client connected to localhost:6379 against DB 0",
-          "Redis Client connected to localhost:6380 against DB 0",
+          "Redis Client connected to 127.0.0.1:6379 against DB 0",
+          "Redis Client connected to 127.0.0.1:6380 against DB 0",
         ]
       end
     end

data/spec/redis/store/interface_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+class InterfacedRedis < Redis
+  include Redis::Store::Interface
+end
+
+describe "Redis::Store::Interface" do
+  before :each do
+    @r = InterfacedRedis.new
+  end
+
+  it "should get an element" do
+    lambda { @r.get("key", :option => true) }.should_not raise_error
+  end
+
+  it "should set an element" do
+    lambda { @r.set("key", "value", :option => true) }.should_not raise_error
+  end
+
+  it "should setnx an element" do
+    lambda { @r.setnx("key", "value", :option => true) }.should_not raise_error
+  end
+end

data/spec/redis/store/marshalling_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe "Redis::Marshalling" do
+  before(:each) do
+    @store = Redis::Store.new :marshalling => true
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    @store.set "rabbit", @rabbit
+    @store.del "rabbit2"
+  end
+
+  after :each do
+    @store.quit
+  end
+
+  it "should unmarshal an object on get" do
+    @store.get("rabbit").should === @rabbit
+  end
+
+  it "should marshal object on set" do
+    @store.set "rabbit", @white_rabbit
+    @store.get("rabbit").should === @white_rabbit
+  end
+
+  if RUBY_VERSION.match /1\.9/
+    it "should not unmarshal object on get if raw option is true" do
+      @store.get("rabbit", :raw => true).should == "\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF"
+    end
+  else
+    it "should not unmarshal object on get if raw option is true" do
+      @store.get("rabbit", :raw => true).should == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
+    end
+  end
+
+  it "should not marshal object on set if raw option is true" do
+    @store.set "rabbit", @white_rabbit, :raw => true
+    @store.get("rabbit", :raw => true).should == %(#<OpenStruct color="white">)
+  end
+
+  it "should not unmarshal object if getting an empty string" do
+    @store.set "empty_string", ""
+    lambda { @store.get("empty_string").should == "" }.should_not raise_error
+  end
+
+  it "should not set an object if already exist" do
+    @store.setnx "rabbit", @white_rabbit
+    @store.get("rabbit").should === @rabbit
+  end
+
+  it "should marshal object on set_unless_exists" do
+    @store.setnx "rabbit2", @white_rabbit
+    @store.get("rabbit2").should === @white_rabbit
+  end
+
+  it "should not marshal object on set_unless_exists if raw option is true" do
+    @store.setnx "rabbit2", @white_rabbit, :raw => true
+    @store.get("rabbit2", :raw => true).should == %(#<OpenStruct color="white">)
+  end
+
+  it "should unmarshal object(s) on multi get" do
+    @store.set "rabbit2", @white_rabbit
+    rabbit, rabbit2 = @store.mget "rabbit", "rabbit2"
+    rabbit.should  == @rabbit
+    rabbit2.should == @white_rabbit
+  end
+
+  if RUBY_VERSION.match /1\.9/
+    it "should not unmarshal object(s) on multi get if raw option is true" do
+      @store.set "rabbit2", @white_rabbit
+      rabbit, rabbit2 = @store.mget "rabbit", "rabbit2", :raw => true
+      rabbit.should  == "\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF"
+      rabbit2.should == "\x04\bU:\x0FOpenStruct{\x06:\ncolorI\"\nwhite\x06:\x06EF"
+    end
+  else
+    it "should not unmarshal object(s) on multi get if raw option is true" do
+      @store.set "rabbit2", @white_rabbit
+      rabbit, rabbit2 = @store.mget "rabbit", "rabbit2", :raw => true
+      rabbit.should  == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
+      rabbit2.should == "\004\bU:\017OpenStruct{\006:\ncolor\"\nwhite"
+    end
+  end
+end
+

data/spec/redis/store/namespace_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe "Redis::Store::Namespace" do
+  before :each do
+    @namespace = "theplaylist"
+    @store  = Redis::Store.new :namespace => @namespace, :marshalling => false # TODO remove mashalling option
+    @client = @store.instance_variable_get(:@client)
+    @rabbit = "bunny"
+  end
+
+  after :each do
+    @store.should_receive(:quit) # stupid rspec, meh!
+    @store.quit
+  end
+
+  it "should only decorate instances that needs to be namespaced" do
+    @store = Redis::Store.new
+    client = @store.instance_variable_get(:@client)
+    client.should_receive(:call).with(:get, "rabbit")
+    @store.get("rabbit")
+  end
+
+  it "should not namespace a key which is already namespaced" do
+    @store.send(:interpolate, "#{@namespace}:rabbit").should == "#{@namespace}:rabbit"
+  end
+
+  it "should namespace get" do
+    @client.should_receive(:call).with(:get, "#{@namespace}:rabbit")
+    @store.get("rabbit")
+  end
+
+  it "should namespace set" do
+    @client.should_receive(:call).with(:set, "#{@namespace}:rabbit", @rabbit)
+    @store.set "rabbit", @rabbit
+  end
+
+  it "should namespace setnx" do
+    @client.should_receive(:call).with(:setnx, "#{@namespace}:rabbit", @rabbit)
+    @store.setnx "rabbit", @rabbit
+  end
+
+  it "should namespace del with single key" do
+    @client.should_receive(:call).with(:del, "#{@namespace}:rabbit")
+    @store.del "rabbit"
+  end
+
+  it "should namespace del with multiple keys" do
+    @client.should_receive(:call).with(:del, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit")
+    @store.del "rabbit", "white_rabbit"
+  end
+
+  it "should namespace keys" do
+    @client.should_receive(:call).with(:keys, "#{@namespace}:rabb*").and_return [ "#{@namespace}:rabbit" ]
+    @store.keys "rabb*"
+  end
+
+  it "should namespace exists" do
+    @client.should_receive(:call).with(:exists, "#{@namespace}:rabbit")
+    @store.exists "rabbit"
+  end
+
+  it "should namespace incrby" do
+    @client.should_receive(:call).with(:incrby, "#{@namespace}:counter", 1)
+    @store.incrby "counter", 1
+  end
+
+  it "should namespace decrby" do
+    @client.should_receive(:call).with(:decrby, "#{@namespace}:counter", 1)
+    @store.decrby "counter", 1
+  end
+
+  it "should namespace mget" do
+    @client.should_receive(:call).with(:mget, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit")
+    @store.mget "rabbit", "white_rabbit"
+  end
+end

data/spec/redis/store/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Redis::Store::VERSION do
+  it "should describe Redis::Store version" do
+    Redis::Store::VERSION::STRING.should == "1.0.0.beta3"
+  end
+end

data/spec/spec_helper.rb

@@ -3,13 +3,13 @@ ARGV << "-b"
 require "rubygems"
 require "bundler"
 Bundler.setup
-
-#require "vendor/gems/environment"
+require "methopara" if RUBY_VERSION.match /1\.9/
 require "ostruct"
 require "spec"
 require "spec/autorun"
 require "redis"
 require "merb"
+require "i18n"
 require "rack/cache"
 require "rack/cache/metastore"
 require "rack/cache/entitystore"
@@ -19,10 +19,21 @@ begin
   require "action_controller/session/abstract_store" # Rails 2.3.x
 rescue LoadError
   require "action_dispatch/middleware/session/abstract_store" # Rails 3.x
-  module Rails; def self.version; "3.0.0.beta4" end end unless defined?(Rails)
+  module Rails; def self.version; "3.0.0" end end unless defined?(Rails)
 end
-require "cache/rails/redis_store"
-require "rack/session/rails"
+require "active_support/cache/redis_store"
+require "action_controller/session/redis_session_store"
 require "cache/sinatra/redis_store"
 
 $DEBUG = ENV["DEBUG"] === "true"
+
+# http://mentalized.net/journal/2010/04/02/suppress_warnings_from_ruby/
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end
+end