instructure-redis-store 1.0.0.1.instructure1

data/spec/i18n/backend/redis_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe "I18n::Backend::Redis" do
+  before :each do
+    @backend     = I18n::Backend::Redis.new
+    @store       = @backend.store
+    I18n.backend = @backend
+  end
+
+  it "should instantiate a store" do
+    @store.should be_kind_of(Redis::Store)
+  end
+
+  it "should instantiate a distributed store" do
+    store = I18n::Backend::Redis.new([ "redis://127.0.0.1:6379", "redis://127.0.0.1:6380" ]).store
+    store.should be_kind_of(Redis::DistributedStore)
+  end
+
+  it "should accept string uri" do
+    store = I18n::Backend::Redis.new("redis://127.0.0.1:6380/13/theplaylist").store
+    store.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13 with namespace theplaylist"
+  end
+
+  it "should accept hash params" do
+    store = I18n::Backend::Redis.new(:host => "127.0.0.1", :port => "6380", :db =>"13", :namespace => "theplaylist").store
+    store.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13 with namespace theplaylist"
+  end
+
+  it "should store translations" do
+    I18n.backend.store_translations :en, :foo => { :bar => :baz }
+    I18n.t(:"foo.bar").should == :baz
+
+    I18n.backend.store_translations :en, "foo" => { "bar" => "baz" }
+    I18n.t(:"foo.bar").should == "baz"
+  end
+
+  it "should get translations" do
+    I18n.backend.store_translations :en, :foo => { :bar => { :baz => :bang } }
+    I18n.t(:"foo.bar.baz").should == :bang
+    I18n.t(:"baz", :scope => :"foo.bar").should == :bang
+  end
+
+  it "should not store proc translations" do
+    lambda { I18n.backend.store_translations :en, :foo => lambda {|| } }.should raise_error("Key-value stores cannot handle procs")
+  end
+
+  describe "available locales" do
+    before :each do
+      @locales = [ :en, :it, :es, :fr, :de ]
+    end
+
+    it "should list" do
+      @locales.each { |locale| I18n.backend.store_translations locale, :foo => "bar" }
+      available_locales = I18n.backend.available_locales
+
+      @locales.each do |locale|
+        available_locales.should include(locale)
+      end
+    end
+
+    it "should list when namespaced" do
+      I18n.backend = I18n::Backend::Redis.new :namespace => 'foo'
+
+      @locales.each { |locale| I18n.backend.store_translations locale, :foo => "bar" }
+      available_locales = I18n.backend.available_locales
+
+      @locales.each do |locale|
+        available_locales.should include(locale)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+require '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.id.should == "redis://127.0.0.1:6379/0"
+
+          cache = Rack::Cache::EntityStore::Redis.resolve(uri("redis://127.0.0.1:6380")).cache
+          cache.id.should == "redis://127.0.0.1:6380/0"
+
+          cache = Rack::Cache::EntityStore::Redis.resolve(uri("redis://127.0.0.1/13")).cache
+          cache.id.should == "redis://127.0.0.1:6379/13"
+
+          cache = Rack::Cache::EntityStore::Redis.resolve(uri("redis://:secret@127.0.0.1")).cache
+          cache.id.should == "redis://127.0.0.1:6379/0"
+          cache.client.password.should == 'secret'
+        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)
+          end
+        end
+
+        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
+
+          data = @store.read(key)
+          data.should == 'My wild love went riding,'
+        end
+
+        it 'correctly determines whether cached body exists for key with #exist?' do
+          key, size = @store.write(['She rode to the devil,'])
+          @store.should be_exist(key)
+          @store.should_not be_exist('938jasddj83jasdh4438021ksdfjsdfjsdsf')
+        end
+
+        it 'can read data written with #write' do
+          key, size = @store.write(['And asked him to pay.'])
+          data = @store.read(key)
+          data.should == 'And asked him to pay.'
+        end
+
+        it 'gives a 40 character SHA1 hex digest from #write' do
+          key, size = @store.write(['she rode to the sea;'])
+          key.should_not be_nil
+          key.length.should == 40
+          key.should =~ /^[0-9a-z]+$/
+          key.should == '90a4c84d51a277f3dafc34693ca264531b9f51b6'
+        end
+
+        it 'returns the entire body as a String from #read' do
+          key, size = @store.write(['She gathered together'])
+          @store.read(key).should == 'She gathered together'
+        end
+
+        it 'returns nil from #read when key does not exist' do
+          @store.read('87fe0a1ae82a518592f6b12b0183e950b4541c62').should be_nil
+        end
+
+        it 'returns a Rack compatible body from #open' do
+          key, size = @store.write(['Some shells for her hair.'])
+          body = @store.open(key)
+          body.should respond_to(:each)
+          buf = ''
+          body.each { |part| buf << part }
+          buf.should == 'Some shells for her hair.'
+        end
+
+        it 'returns nil from #open when key does not exist' do
+          @store.open('87fe0a1ae82a518592f6b12b0183e950b4541c62').should be_nil
+        end
+
+        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
+          key, size = @store.write(['My wild love went riding,'])
+          @store.purge(key).should be_nil
+          @store.read(key).should be_nil
+        end
+
+        # Helper Methods =============================================================
+
+        define_method :uri do |uri|
+          URI.parse uri
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,259 @@
+require '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(::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
+          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.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 13"
+
+          cache = Rack::Cache::MetaStore::Redis.resolve(uri("redis://:secret@127.0.0.1")).cache
+          cache.id.should == "redis://127.0.0.1:6379/0"
+          cache.client.password.should == 'secret'
+        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