redis-store 0.3.7 → 0.3.8

data/spec/config/master.conf

@@ -124,10 +124,10 @@ databases 16
 #
 # The name of the append only file is "appendonly.log"
 
-appendonly no
+#appendonly no
 
 # The fsync() call tells the Operating System to actually write data on disk
-# instead to wait for more data in the output buffer. Some OS will really flush 
+# instead to wait for more data in the output buffer. Some OS will really flush
 # data on disk, some other OS will just try to do it ASAP.
 #
 # Redis supports three different modes:
@@ -142,7 +142,7 @@ appendonly no
 # it want, for better performances (but if you can live with the idea of
 # some data loss consider the default persistence mode that's snapshotting).
 
-appendfsync always
+#appendfsync always
 # appendfsync everysec
 # appendfsync no
 
@@ -167,5 +167,5 @@ glueoutputbuf yes
 # WARNING: object sharing is experimental, don't enable this feature
 # in production before of Redis 1.0-stable. Still please try this feature in
 # your development environment so that we can test it better.
-shareobjects no
-shareobjectspoolsize 1024
+#shareobjects no
+#shareobjectspoolsize 1024

data/spec/config/single.conf

@@ -124,10 +124,10 @@ databases 16
 #
 # The name of the append only file is "appendonly.log"
 
-appendonly no
+#appendonly no
 
 # The fsync() call tells the Operating System to actually write data on disk
-# instead to wait for more data in the output buffer. Some OS will really flush 
+# instead to wait for more data in the output buffer. Some OS will really flush
 # data on disk, some other OS will just try to do it ASAP.
 #
 # Redis supports three different modes:
@@ -142,7 +142,7 @@ appendonly no
 # it want, for better performances (but if you can live with the idea of
 # some data loss consider the default persistence mode that's snapshotting).
 
-appendfsync always
+#appendfsync always
 # appendfsync everysec
 # appendfsync no
 
@@ -167,5 +167,5 @@ glueoutputbuf yes
 # WARNING: object sharing is experimental, don't enable this feature
 # in production before of Redis 1.0-stable. Still please try this feature in
 # your development environment so that we can test it better.
-shareobjects no
-shareobjectspoolsize 1024
+#shareobjects no
+#shareobjectspoolsize 1024

data/spec/config/slave.conf

@@ -65,7 +65,7 @@ databases 16
 # so for example it is possible to configure the slave to save the DB with a
 # different interval, or to listen to another port, and so on.
 
-slaveof localhost 6380 
+slaveof localhost 6380
 
 ################################## SECURITY ###################################
 
@@ -124,10 +124,10 @@ slaveof localhost 6380
 #
 # The name of the append only file is "appendonly.log"
 
-appendonly no
+#appendonly no
 
 # The fsync() call tells the Operating System to actually write data on disk
-# instead to wait for more data in the output buffer. Some OS will really flush 
+# instead to wait for more data in the output buffer. Some OS will really flush
 # data on disk, some other OS will just try to do it ASAP.
 #
 # Redis supports three different modes:
@@ -142,7 +142,7 @@ appendonly no
 # it want, for better performances (but if you can live with the idea of
 # some data loss consider the default persistence mode that's snapshotting).
 
-appendfsync always
+#appendfsync always
 # appendfsync everysec
 # appendfsync no
 
@@ -167,5 +167,5 @@ glueoutputbuf yes
 # WARNING: object sharing is experimental, don't enable this feature
 # in production before of Redis 1.0-stable. Still please try this feature in
 # your development environment so that we can test it better.
-shareobjects no
-shareobjectspoolsize 1024
+#shareobjects no
+#shareobjectspoolsize 1024

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

@@ -1,31 +1,40 @@
 require File.join(File.dirname(__FILE__), "/../../../spec_helper")
 
+class Object
+  def sha_like?
+    length == 40 && self =~ /^[0-9a-z]+$/
+  end
+end
+
 module Rack
   module Cache
     class EntityStore
+      # courtesy of http://github.com/rtomayko/rack-cache team
       describe "Rack::Cache::EntityStore::Redis" do
         before(:each) do
           @store = Rack::Cache::EntityStore::Redis.new :host => "localhost"
         end
 
+        # Redis store specific examples ===========================================
+
         it "should have the class referenced by homonym constant" do
           Rack::Cache::EntityStore::REDIS.should be(Rack::Cache::EntityStore::Redis)
         end
 
         it "should resolve the connection uri" do
           cache = Rack::Cache::EntityStore::Redis.resolve(uri("redis://127.0.0.1")).cache
-          cache.should be_kind_of(::Redis)
-          cache.host.should == "127.0.0.1"
-          cache.port.should == 6379
-          cache.db.should == 0
+          cache.should be_kind_of(::Redis::Client)
+          cache.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
 
           cache = Rack::Cache::EntityStore::Redis.resolve(uri("redis://127.0.0.1:6380")).cache
-          cache.port.should == 6380
+          cache.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
 
           cache = Rack::Cache::EntityStore::Redis.resolve(uri("redis://127.0.0.1/13")).cache
-          cache.db.should == 13
+          cache.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 13"
         end
 
+        # Entity store shared examples ===========================================
+
         it 'responds to all required messages' do
           %w[read open write exist?].each do |message|
             @store.should respond_to(message)
@@ -35,7 +44,7 @@ module Rack
         it 'stores bodies with #write' do
           key, size = @store.write(['My wild love went riding,'])
           key.should_not be_nil
-          # key.should be_sha_like TODO re-enable
+          key.should be_sha_like
 
           data = @store.read(key)
           data.should == 'My wild love went riding,'
@@ -98,10 +107,11 @@ module Rack
           @store.read(key).should be_nil
         end
 
-        private
-          def uri(uri)
-            URI.parse uri
-          end
+        # Helper Methods =============================================================
+
+        define_method :uri do |uri|
+          URI.parse uri
+        end
       end
     end
   end

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

@@ -3,9 +3,18 @@ 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")
+        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
@@ -14,18 +23,18 @@ 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(::MarshaledRedis)
-          cache.host.should == "127.0.0.1"
-          cache.port.should == 6379
-          cache.db.should == 0
+          cache.should be_kind_of(::Redis::MarshaledClient)
+          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
-          cache.port.should == 6380
+          cache.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
 
           cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://127.0.0.1/13")).cache
-          cache.db.should == 13
+          cache.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 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
@@ -87,15 +96,159 @@ module Rack
           @store.cache_key(request).should == 'tset/'
         end
 
-        private
-          def mock_request(uri, opts)
-            env = Rack::MockRequest.env_for(uri, opts || {})
-            Rack::Cache::Request.new(env)
-          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
 
-          def uri(uri)
-            URI.parse uri
-          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

data/spec/rack/session/redis_spec.rb

@@ -27,13 +27,11 @@ module Rack
 
       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.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 => ["localhost:6379", "localhost:6380"]).pool
-        pool.should be_kind_of(DistributedMarshaledRedis)
+        pool.should be_kind_of(::Redis::DistributedMarshaled)
       end
 
       it "creates a new cookie" do
@@ -48,12 +46,10 @@ module Rack
         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}'
+        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)
@@ -211,7 +207,7 @@ module Rack
         session['counter'].should == 3
 
         drop_counter = proc do |env|
-          env['rack.session'].delete 'counter'
+          env['rack.session'].del 'counter'
           env['rack.session']['foo'] = 'bar'
           [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
         end

data/spec/redis/distributed_marshaled_redis_spec.rb

@@ -1,35 +1,33 @@
 require File.join(File.dirname(__FILE__), "/../spec_helper")
 
-describe "DistributedMarshaledRedis" do
+describe "Redis::DistributedMarshaled" do
   before(:each) do
-    @dmr = DistributedMarshaledRedis.new [
+    @dmr = Redis::DistributedMarshaled.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
+    @dmr.marshalled_set "rabbit", @rabbit
   end
 
   after(:all) do
-    @dmr.ring.nodes.each { |server| server.flush_db }
+    @dmr.ring.nodes.each { |server| server.flushdb }
   end
 
   it "should accept connection params" do
-    dmr = DistributedMarshaledRedis.new [ :host => "localhost", :port => "6380", :db => "1" ]
+    dmr = Redis::DistributedMarshaled.new [ :host => "localhost", :port => "6380", :db => "1" ]
     dmr.ring.should have(1).node
     mr = dmr.ring.nodes.first
-    mr.host.should == "localhost"
-    mr.port.should == 6380
-    mr.db.should == 1
+    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
+    @dmr.marshalled_set "rabbit", @white_rabbit
+    @dmr.marshalled_get("rabbit").should == @white_rabbit
   end
 
   it "should get an object" do
-    @dmr.get("rabbit").should == @rabbit
+    @dmr.marshalled_get("rabbit").should == @rabbit
   end
 end