instructure-redis-store 1.0.0.1.instructure1

data/spec/rack/session/redis_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+module Rack
+  module Session
+    describe "Rack::Session::Redis" do
+      before(:each) do
+        @session_key = Rack::Session::Redis::DEFAULT_OPTIONS[:key]
+        @session_match = /#{@session_key}=[0-9a-fA-F]+;/
+        @incrementor = lambda do |env|
+          env["rack.session"]["counter"] ||= 0
+          env["rack.session"]["counter"] += 1
+          Rack::Response.new(env["rack.session"].inspect).to_a
+        end
+        @drop_session = proc do |env|
+          env['rack.session.options'][:drop] = true
+          @incrementor.call(env)
+        end
+        @renew_session = proc do |env|
+          env['rack.session.options'][:renew] = true
+          @incrementor.call(env)
+        end
+        @defer_session = proc do |env|
+          env['rack.session.options'][:defer] = true
+          @incrementor.call(env)
+        end
+      end
+
+      it "should specify connection params" do
+        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 => ["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
+        pool = Rack::Session::Redis.new(@incrementor)
+        res = Rack::MockRequest.new(pool).get("/")
+        res["Set-Cookie"].should match(/#{@session_key}=/)
+        res.body.should == '{"counter"=>1}'
+      end
+
+      it "determines session from a cookie" do
+        pool = Rack::Session::Redis.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+        res = req.get("/")
+        cookie = res["Set-Cookie"]
+        req.get("/", "HTTP_COOKIE" => cookie).body.should == '{"counter"=>2}'
+        req.get("/", "HTTP_COOKIE" => cookie).body.should == '{"counter"=>3}'
+      end
+
+      it "survives nonexistant cookies" do
+        bad_cookie = "rack.session=blarghfasel"
+        pool = Rack::Session::Redis.new(@incrementor)
+        res = Rack::MockRequest.new(pool).
+          get("/", "HTTP_COOKIE" => bad_cookie)
+        res.body.should == '{"counter"=>1}'
+        cookie = res["Set-Cookie"][@session_match]
+        cookie.should_not match(/#{bad_cookie}/)
+      end
+
+      it "should maintain freshness" do
+        pool = Rack::Session::Redis.new(@incrementor, :expire_after => 3)
+        res = Rack::MockRequest.new(pool).get('/')
+        res.body.should include('"counter"=>1')
+        cookie = res["Set-Cookie"]
+        res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+        res["Set-Cookie"].should == cookie
+        res.body.should include('"counter"=>2')
+        puts 'Sleeping to expire session' if $DEBUG
+        sleep 4
+        res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+        res["Set-Cookie"].should_not == cookie
+        res.body.should include('"counter"=>1')
+      end
+
+      it "deletes cookies with :drop option" do
+        pool = Rack::Session::Redis.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+        drop = Rack::Utils::Context.new(pool, @drop_session)
+        dreq = Rack::MockRequest.new(drop)
+
+        res0 = req.get("/")
+        session = (cookie = res0["Set-Cookie"])[@session_match]
+        res0.body.should == '{"counter"=>1}'
+
+        res1 = req.get("/", "HTTP_COOKIE" => cookie)
+        res1["Set-Cookie"][@session_match].should == session
+        res1.body.should == '{"counter"=>2}'
+
+        res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+        res2["Set-Cookie"].should be_nil
+        res2.body.should == '{"counter"=>3}'
+
+        res3 = req.get("/", "HTTP_COOKIE" => cookie)
+        res3["Set-Cookie"][@session_match].should_not == session
+        res3.body.should == '{"counter"=>1}'
+      end
+
+      it "provides new session id with :renew option" do
+        pool = Rack::Session::Redis.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+        renew = Rack::Utils::Context.new(pool, @renew_session)
+        rreq = Rack::MockRequest.new(renew)
+
+        res0 = req.get("/")
+        session = (cookie = res0["Set-Cookie"])[@session_match]
+        res0.body.should == '{"counter"=>1}'
+
+        res1 = req.get("/", "HTTP_COOKIE" => cookie)
+        res1["Set-Cookie"][@session_match].should == session
+        res1.body.should == '{"counter"=>2}'
+
+        res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
+        new_cookie = res2["Set-Cookie"]
+        new_session = new_cookie[@session_match]
+        new_session.should_not == session
+        res2.body.should == '{"counter"=>3}'
+
+        res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+        res3["Set-Cookie"][@session_match].should == new_session
+        res3.body.should == '{"counter"=>4}'
+      end
+
+      specify "omits cookie with :defer option" do
+        pool = Rack::Session::Redis.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+        defer = Rack::Utils::Context.new(pool, @defer_session)
+        dreq = Rack::MockRequest.new(defer)
+
+        res0 = req.get("/")
+        session = (cookie = res0["Set-Cookie"])[@session_match]
+        res0.body.should == '{"counter"=>1}'
+
+        res1 = req.get("/", "HTTP_COOKIE" => cookie)
+        res1["Set-Cookie"][@session_match].should == session
+        res1.body.should == '{"counter"=>2}'
+
+        res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+        res2["Set-Cookie"].should be_nil
+        res2.body.should == '{"counter"=>3}'
+
+        res3 = req.get("/", "HTTP_COOKIE" => cookie)
+        res3["Set-Cookie"][@session_match].should == session
+        res3.body.should == '{"counter"=>4}'
+      end
+
+      # anyone know how to do this better?
+      specify "multithread: should cleanly merge sessions" do
+        next unless $DEBUG
+        warn 'Running multithread test for Session::Redis'
+        pool = Rack::Session::Redis.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+
+        res = req.get('/')
+        res.body.should == '{"counter"=>1}'
+        cookie = res["Set-Cookie"]
+        sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
+
+        delta_incrementor = lambda do |env|
+          # emulate disconjoinment of threading
+          env['rack.session'] = env['rack.session'].dup
+          Thread.stop
+          env['rack.session'][(Time.now.usec*rand).to_i] = true
+          @incrementor.call(env)
+        end
+        tses = Rack::Utils::Context.new pool, delta_incrementor
+        treq = Rack::MockRequest.new(tses)
+        tnum = rand(7).to_i+5
+        r = Array.new(tnum) do
+          Thread.new(treq) do |run|
+            run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+          end
+        end.reverse.map{|t| t.run.join.value }
+        r.each do |res|
+          res['Set-Cookie'].should == cookie
+          res.body.should include('"counter"=>2')
+        end
+
+        session = pool.pool.get(sess_id)
+        session.size.should == tnum+1 # counter
+        session['counter'].should == 2 # meeeh
+
+        tnum = rand(7).to_i+5
+        r = Array.new(tnum) do |i|
+          delta_time = proc do |env|
+            env['rack.session'][i]  = Time.now
+            Thread.stop
+            env['rack.session']     = env['rack.session'].dup
+            env['rack.session'][i] -= Time.now
+            @incrementor.call(env)
+          end
+          app = Rack::Utils::Context.new pool, time_delta
+          req = Rack::MockRequest.new app
+          Thread.new(req) do |run|
+            run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+          end
+        end.reverse.map{|t| t.run.join.value }
+        r.each do |res|
+          res['Set-Cookie'].should == cookie
+          res.body.should include('"counter"=>3')
+        end
+
+        session = pool.pool.get(sess_id)
+        session.size.should == tnum+1
+        session['counter'].should == 3
+
+        drop_counter = proc do |env|
+          env['rack.session'].del 'counter'
+          env['rack.session']['foo'] = 'bar'
+          [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+        end
+        tses = Rack::Utils::Context.new pool, drop_counter
+        treq = Rack::MockRequest.new(tses)
+        tnum = rand(7).to_i+5
+        r = Array.new(tnum) do
+          Thread.new(treq) do |run|
+            run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+          end
+        end.reverse.map{|t| t.run.join.value }
+        r.each do |res|
+          res['Set-Cookie'].should == cookie
+          res.body.should include('"foo"=>"bar"')
+        end
+
+        session = pool.pool.get(sess_id)
+        session.size.should == r.size+1
+        session['counter'].should be_nil
+        session['foo'].should == 'bar'
+      end
+    end
+  end
+end

data/spec/redis/distributed_store_spec.rb

@@ -0,0 +1,55 @@
+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 force reconnection" do
+    @dmr.nodes.each do |node|
+      node.should_receive(:reconnect)
+    end
+
+    @dmr.reconnect
+  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

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe "Redis::Factory" do
+  describe ".create" do
+    context "when not given any arguments" do
+      it "should instantiate a Redis::Store store" do
+        store = Redis::Factory.create
+        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
+
+    context "when given a Hash" do
+      it "should allow to specify host" do
+        store = Redis::Factory.create :host => "localhost"
+        store.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
+      end
+
+      it "should allow to specify port" do
+        store = Redis::Factory.create :host => "localhost", :port => 6380
+        store.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
+      end
+
+      it "should allow to specify db" do
+        store = Redis::Factory.create :host => "localhost", :port => 6380, :db => 13
+        store.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
+      end
+
+      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::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",
+        ]
+      end
+    end
+
+    context "when given a String" do
+      it "should allow to specify host" do
+        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 "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 "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 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 127.0.0.1:6379 against DB 0",
+          "Redis Client connected to 127.0.0.1:6380 against DB 0",
+        ]
+      end
+    end
+  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,119 @@
+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
+
+  describe "binary safety" do
+    it "should marshal objects" do
+      utf8_key = [51339].pack("U*")
+      ascii_rabbit = OpenStruct.new(:name => [128].pack("C*"))
+
+      @store.set(utf8_key, ascii_rabbit)
+      @store.get(utf8_key).should === ascii_rabbit
+    end
+
+    it "should get and set raw values" do
+      utf8_key = [51339].pack("U*")
+      ascii_string = [128].pack("C*")
+
+      @store.set(utf8_key, ascii_string, :raw => true)
+      @store.get(utf8_key, :raw => true).bytes.to_a === ascii_string.bytes.to_a
+    end
+
+    it "should marshal objects on setnx" do
+      utf8_key = [51339].pack("U*")
+      ascii_rabbit = OpenStruct.new(:name => [128].pack("C*"))
+
+      @store.del(utf8_key)
+      @store.setnx(utf8_key, ascii_rabbit)
+      @store.get(utf8_key).should === ascii_rabbit
+    end
+
+    it "should get and set raw values on setnx" do
+      utf8_key = [51339].pack("U*")
+      ascii_string = [128].pack("C*")
+
+      @store.del(utf8_key)
+      @store.setnx(utf8_key, ascii_string, :raw => true)
+      @store.get(utf8_key, :raw => true).bytes.to_a === ascii_string.bytes.to_a
+    end
+  end if defined?(Encoding)
+end
+