dsander-redis-store 0.3.8

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

@@ -0,0 +1,257 @@
+require File.join(File.dirname(__FILE__), "/../../../spec_helper")
+
+module Rack
+  module Cache
+    class MetaStore
+      # courtesy of http://github.com/rtomayko/rack-cache team
+      describe "Rack::Cache::MetaStore::Redis" do
+        before :each do
+          @store        = Rack::Cache::MetaStore::Redis.resolve uri("redis://127.0.0.1")
+          @entity_store = Rack::Cache::EntityStore::Redis.resolve uri("redis://127.0.0.1:6380")
+          @request  = mock_request('/', {})
+          @response = mock_response(200, {}, ['hello world'])
+        end
+
+        after :each do
+          @store.cache.flushall
+          @entity_store.cache.flushall
+        end
+
+        it "should have the class referenced by homonym constant" do
+          Rack::Cache::MetaStore::REDIS.should be(Rack::Cache::MetaStore::Redis)
+        end
+
+        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(::MarshaledRedis)
+          cache.host.should == "127.0.0.1"
+          cache.port.should == 6379
+          cache.db.should == 0
+
+          cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://127.0.0.1:6380")).cache
+          cache.port.should == 6380
+
+          cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://127.0.0.1/13")).cache
+          cache.db.should == 13
+        end
+
+        # Low-level implementation methods ===========================================
+
+        it 'writes a list of negotation tuples with #write' do
+          lambda { @store.write('/test', [[{}, {}]]) }.should_not raise_error
+        end
+
+        it 'reads a list of negotation tuples with #read' do
+          @store.write('/test', [[{},{}],[{},{}]])
+          tuples = @store.read('/test')
+          tuples.should == [ [{},{}], [{},{}] ]
+        end
+
+        it 'reads an empty list with #read when nothing cached at key' do
+          @store.read('/nothing').should be_empty
+        end
+
+        it 'removes entries for key with #purge' do
+          @store.write('/test', [[{},{}]])
+          @store.read('/test').should_not be_empty
+
+          @store.purge('/test')
+          @store.read('/test').should be_empty
+        end
+
+        it 'succeeds when purging non-existing entries' do
+          @store.read('/test').should be_empty
+          @store.purge('/test')
+        end
+
+        it 'returns nil from #purge' do
+          @store.write('/test', [[{},{}]])
+          @store.purge('/test').should be_nil
+          @store.read('/test').should == []
+        end
+
+        %w[/test http://example.com:8080/ /test?x=y /test?x=y&p=q].each do |key|
+          it "can read and write key: '#{key}'" do
+            lambda { @store.write(key, [[{},{}]]) }.should_not raise_error
+            @store.read(key).should == [[{},{}]]
+          end
+        end
+
+        it "can read and write fairly large keys" do
+          key = "b" * 4096
+          lambda { @store.write(key, [[{},{}]]) }.should_not raise_error
+          @store.read(key).should == [[{},{}]]
+        end
+
+        it "allows custom cache keys from block" do
+          request = mock_request('/test', {})
+          request.env['rack-cache.cache_key'] =
+            lambda { |request| request.path_info.reverse }
+          @store.cache_key(request).should == 'tset/'
+        end
+
+        it "allows custom cache keys from class" do
+          request = mock_request('/test', {})
+          request.env['rack-cache.cache_key'] = Class.new do
+            def self.call(request); request.path_info.reverse end
+          end
+          @store.cache_key(request).should == 'tset/'
+        end
+
+        # Abstract methods ===========================================================
+
+        # Stores an entry for the given request args, returns a url encoded cache key
+        # for the request.
+        define_method :store_simple_entry do |*request_args|
+          path, headers = request_args
+          @request = mock_request(path || '/test', headers || {})
+          @response = mock_response(200, {'Cache-Control' => 'max-age=420'}, ['test'])
+          body = @response.body
+          cache_key = @store.store(@request, @response, @entity_store)
+          @response.body.should_not equal(body)
+          cache_key
+        end
+
+        it 'stores a cache entry' do
+          cache_key = store_simple_entry
+          @store.read(cache_key).should_not be_empty
+        end
+
+        it 'sets the X-Content-Digest response header before storing' do
+          cache_key = store_simple_entry
+          req, res = @store.read(cache_key).first
+          res['X-Content-Digest'].should == 'a94a8fe5ccb19ba61c4c0873d391e987982fbbd3'
+        end
+
+        it 'finds a stored entry with #lookup' do
+          store_simple_entry
+          response = @store.lookup(@request, @entity_store)
+          response.should_not be_nil
+          response.should be_kind_of(Rack::Cache::Response)
+        end
+
+        it 'does not find an entry with #lookup when none exists' do
+          req = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
+          @store.lookup(req, @entity_store).should be_nil
+        end
+
+        it "canonizes urls for cache keys" do
+          store_simple_entry(path='/test?x=y&p=q')
+
+          hits_req = mock_request(path, {})
+          miss_req = mock_request('/test?p=x', {})
+
+          @store.lookup(hits_req, @entity_store).should_not be_nil
+          @store.lookup(miss_req, @entity_store).should be_nil
+        end
+
+        it 'does not find an entry with #lookup when the body does not exist' do
+          store_simple_entry
+          @response.headers['X-Content-Digest'].should_not be_nil
+          @entity_store.purge(@response.headers['X-Content-Digest'])
+          @store.lookup(@request, @entity_store).should be_nil
+        end
+
+        it 'restores response headers properly with #lookup' do
+          store_simple_entry
+          response = @store.lookup(@request, @entity_store)
+          response.headers.should == @response.headers.merge('Content-Length' => '4')
+        end
+
+        it 'restores response body from entity store with #lookup' do
+          store_simple_entry
+          response = @store.lookup(@request, @entity_store)
+          body = '' ; response.body.each {|p| body << p}
+          body.should == 'test'
+        end
+
+        it 'invalidates meta and entity store entries with #invalidate' do
+          store_simple_entry
+          @store.invalidate(@request, @entity_store)
+          response = @store.lookup(@request, @entity_store)
+          response.should be_kind_of(Rack::Cache::Response)
+          response.should_not be_fresh
+        end
+
+        it 'succeeds quietly when #invalidate called with no matching entries' do
+          req = mock_request('/test', {})
+          @store.invalidate(req, @entity_store)
+          @store.lookup(@request, @entity_store).should be_nil
+        end
+
+        # Vary =======================================================================
+
+        it 'does not return entries that Vary with #lookup' do
+          req1 = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
+          req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+          res = mock_response(200, {'Vary' => 'Foo Bar'}, ['test'])
+          @store.store(req1, res, @entity_store)
+
+          @store.lookup(req2, @entity_store).should be_nil
+        end
+
+        it 'stores multiple responses for each Vary combination' do
+          req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+          res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
+          key = @store.store(req1, res1, @entity_store)
+
+          req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+          res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
+          @store.store(req2, res2, @entity_store)
+
+          req3 = mock_request('/test', {'HTTP_FOO' => 'Baz',   'HTTP_BAR' => 'Boom'})
+          res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
+          @store.store(req3, res3, @entity_store)
+
+          slurp(@store.lookup(req3, @entity_store).body).should == 'test 3'
+          slurp(@store.lookup(req1, @entity_store).body).should == 'test 1'
+          slurp(@store.lookup(req2, @entity_store).body).should == 'test 2'
+
+          @store.read(key).length.should == 3
+        end
+
+        it 'overwrites non-varying responses with #store' do
+          req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+          res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
+          key = @store.store(req1, res1, @entity_store)
+          slurp(@store.lookup(req1, @entity_store).body).should == 'test 1'
+
+          req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+          res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
+          @store.store(req2, res2, @entity_store)
+          slurp(@store.lookup(req2, @entity_store).body).should == 'test 2'
+
+          req3 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+          res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
+          @store.store(req3, res3, @entity_store)
+          slurp(@store.lookup(req1, @entity_store).body).should == 'test 3'
+
+          @store.read(key).length.should == 2
+        end
+
+        # Helper Methods =============================================================
+
+        define_method :mock_request do |uri,opts|
+          env = Rack::MockRequest.env_for(uri, opts || {})
+          Rack::Cache::Request.new(env)
+        end
+
+        define_method :mock_response do |status,headers,body|
+          headers ||= {}
+          body = Array(body).compact
+          Rack::Cache::Response.new(status, headers, body)
+        end
+
+        define_method :slurp do |body|
+          buf = ''
+          body.each {|part| buf << part }
+          buf
+        end
+
+        define_method :uri do |uri|
+          URI.parse uri
+        end
+      end
+    end
+  end
+end

data/spec/rack/session/redis_spec.rb

@@ -0,0 +1,238 @@
+require File.join(File.dirname(__FILE__), "/../../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 => "localhost:6380/1").pool
+        pool.should be_kind_of(MarshaledRedis)
+        pool.host.should == "localhost"
+        pool.port.should == 6380
+        pool.db.should == 1
+
+        pool = Rack::Session::Redis.new(@incrementor, :redis_server => ["localhost:6379", "localhost:6380"]).pool
+        pool.should be_kind_of(DistributedMarshaledRedis)
+      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'].delete '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