redis-store 1.0.0.1 → 1.1.0.rc

data/spec/cache/merb/redis_store_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-module Merb
-  module Cache
-    describe "Merb::Cache::RedisStore" do
-      before(:each) do
-        @store  = Merb::Cache::RedisStore.new
-        @dstore = Merb::Cache::RedisStore.new :servers => ["redis://127.0.0.1:6380/1", "redis://127.0.0.1:6381/1"]
-        @rabbit = OpenStruct.new :name => "bunny"
-        @white_rabbit = OpenStruct.new :color => "white"
-        with_store_management do |store|
-          store.write "rabbit", @rabbit
-          store.delete "rub-a-dub"
-        end
-      end
-
-      it "should accept connection params" do
-        redis = instantiate_store
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1:6380"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1:6380/13"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13"
-
-        redis = instantiate_store "redis://127.0.0.1:6380/13/theplaylist"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13 with namespace theplaylist"
-      end
-
-      it "should instantiate a ring" do
-        store = instantiate_store
-        store.should be_kind_of(Redis::Store)
-        store = instantiate_store ["redis://127.0.0.1:6379/0", "redis://127.0.0.1:6379/1"]
-        store.should be_kind_of(Redis::DistributedStore)
-      end
-
-      it "should verify if writable" do
-        with_store_management do |store|
-          store.writable?("rabbit").should be_true
-        end
-      end
-
-      it "should read the data" do
-        with_store_management do |store|
-          store.read("rabbit").should === @rabbit
-        end
-      end
-
-      it "should read raw data" do
-        with_store_management do |store|
-          store.read("rabbit", {}, :raw => true).should == Marshal.dump(@rabbit)
-        end
-      end
-
-      it "should write the data" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit
-          store.read("rabbit").should === @white_rabbit
-        end
-      end
-
-      it "should write raw data" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, {}, :raw => true
-          store.read("rabbit", {}, :raw => true).should == %(#<OpenStruct color="white">)
-        end
-      end
-
-      it "should write the data with expiration time" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, {}, :expires_in => 1.second
-          store.read("rabbit").should === @white_rabbit ; sleep 2
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should not write data if :unless_exist option is true" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, {}, :unless_exist => true
-          store.read("rabbit").should === @rabbit
-        end
-      end
-
-      it "should write all the data" do
-        with_store_management do |store|
-          store.write_all "rabbit", @white_rabbit
-          store.read("rabbit").should === @white_rabbit
-        end
-      end
-
-      it "should fetch data" do
-        with_store_management do |store|
-          store.fetch("rabbit").should == @rabbit
-          store.fetch("rub-a-dub").should be_nil
-          store.fetch("rub-a-dub") { "Flora de Cana" }.should == "Flora de Cana"
-          store.fetch("rub-a-dub").should === "Flora de Cana"
-        end
-      end
-
-      it "should verify existence" do
-        with_store_management do |store|
-          store.exists?("rabbit").should be_true
-          store.exists?("rab-a-dub").should be_false
-        end
-      end
-
-      it "should delete data" do
-        with_store_management do |store|
-          store.delete "rabbit"
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should delete all the data" do
-        with_store_management do |store|
-          store.delete_all
-          store.instance_variable_get(:@data).keys("*").flatten.should be_empty
-        end
-      end
-
-      it "should delete all the data with bang method" do
-        with_store_management do |store|
-          store.delete_all!
-          store.instance_variable_get(:@data).keys("*").flatten.should be_empty
-        end
-      end
-
-      private
-        def instantiate_store(addresses = nil)
-          Merb::Cache::RedisStore.new(:servers => [addresses].flatten).instance_variable_get(:@data)
-        end
-
-        def with_store_management
-          yield @store
-          yield @dstore
-        end
-    end
-  end
-end

data/spec/cache/sinatra/redis_store_spec.rb

@@ -1,192 +0,0 @@
-require 'spec_helper'
-
-class App
-  def initialize
-    @values = {}
-  end
-
-  def set(key, value)
-    @values[key] = value
-  end
-
-  def get(key)
-    @values[key]
-  end
-end
-
-module Sinatra
-  module Cache
-    describe "Sinatra::Cache::RedisStore" do
-      before(:each) do
-        @store  = Sinatra::Cache::RedisStore.new
-        @dstore = Sinatra::Cache::RedisStore.new "redis://127.0.0.1:6380/1", "redis://127.0.0.1:6381/1"
-        @rabbit = OpenStruct.new :name => "bunny"
-        @white_rabbit = OpenStruct.new :color => "white"
-        with_store_management do |store|
-          store.write  "rabbit", @rabbit
-          store.delete "counter"
-          store.delete "rub-a-dub"
-        end
-      end
-
-      it "should register as extension" do
-        app = App.new
-        Sinatra::Cache.register(app)
-        store = app.get(:cache)
-        store.should be_kind_of(RedisStore)
-      end
-
-      it "should accept connection params" do
-        redis = instantiate_store
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1:6380"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1:6380/13"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13"
-
-        redis = instantiate_store "redis://127.0.0.1:6380/13/theplaylist"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13 with namespace theplaylist"
-      end
-
-      it "should instantiate a ring" do
-        store = instantiate_store
-        store.should be_kind_of(Redis::Store)
-        store = instantiate_store ["redis://127.0.0.1:6379/0", "redis://127.0.0.1:6379/1"]
-        store.should be_kind_of(Redis::DistributedStore)
-      end
-
-      it "should read the data" do
-        with_store_management do |store|
-          store.read("rabbit").should === @rabbit
-        end
-      end
-
-      it "should write the data" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit
-          store.read("rabbit").should === @white_rabbit
-        end
-      end
-
-      it "should write the data with expiration time" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, :expires_in => 1.second
-          store.read("rabbit").should === @white_rabbit ; sleep 2
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should not write data if :unless_exist option is true" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, :unless_exist => true
-          store.read("rabbit").should === @rabbit
-        end
-      end
-
-      it "should read raw data" do
-        with_store_management do |store|
-          store.read("rabbit", :raw => true).should == Marshal.dump(@rabbit)
-        end
-      end
-
-      it "should write raw data" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, :raw => true
-          store.read("rabbit", :raw => true).should == %(#<OpenStruct color="white">)
-        end
-      end
-
-      it "should delete data" do
-        with_store_management do |store|
-          store.delete "rabbit"
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should delete matched data" do
-        with_store_management do |store|
-          store.delete_matched "rabb*"
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should verify existence of an object in the store" do
-        with_store_management do |store|
-          store.exist?("rabbit").should be_true
-          store.exist?("rab-a-dub").should be_false
-        end
-      end
-
-      it "should increment a key" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          store.read("counter", :raw => true).to_i.should == 3
-        end
-      end
-
-      it "should decrement a key" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          2.times { store.decrement "counter" }
-          store.read("counter", :raw => true).to_i.should == 1
-        end
-      end
-
-      it "should increment a key by given value" do
-        with_store_management do |store|
-          store.increment "counter", 3
-          store.read("counter", :raw => true).to_i.should == 3
-        end
-      end
-
-      it "should decrement a key by given value" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          store.decrement "counter", 2
-          store.read("counter", :raw => true).to_i.should == 1
-        end
-      end
-
-      it "should clear the store" do
-        with_store_management do |store|
-          store.clear
-          store.instance_variable_get(:@data).keys("*").flatten.should be_empty
-        end
-      end
-
-      it "should return store stats" do
-        with_store_management do |store|
-          store.stats.should_not be_empty
-        end
-      end
-
-      it "should fetch data" do
-        with_store_management do |store|
-          store.fetch("rabbit").should == @rabbit
-          store.fetch("rub-a-dub").should be_nil
-          store.fetch("rub-a-dub") { "Flora de Cana" }.should == "Flora de Cana"
-          store.fetch("rub-a-dub").should === "Flora de Cana"
-          store.fetch("rabbit", :force => true).should be_nil # force cache miss
-          store.fetch("rabbit", :force => true, :expires_in => 1.second) { @white_rabbit }
-          store.fetch("rabbit").should === @white_rabbit ; sleep 2
-          store.fetch("rabbit").should be_nil
-        end
-      end
-
-      private
-        def instantiate_store(addresses = nil)
-          Sinatra::Cache::RedisStore.new(addresses).instance_variable_get(:@data)
-        end
-
-        def with_store_management
-          yield @store
-          yield @dstore
-        end
-    end
-  end
-end

data/spec/i18n/backend/redis_spec.rb

@@ -1,72 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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