merb-cache 0.9.7 → 0.9.8

data/spec/merb-cache/stores/fundamental/abstract_store_spec.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe 'all stores', :shared => true do
+  describe "#writable?" do
+    it "should not raise a NotImplementedError error" do
+      lambda { @store.writable?(:foo) }.should_not raise_error(NotImplementedError)
+    end
+
+    it "should accept a conditions hash" do
+      @store.writable?('key', :conditions => :hash)
+    end
+  end
+
+  describe "#read" do
+    it "should not raise a NotImplementedError error" do
+      lambda { @store.read('foo') }.should_not raise_error(NotImplementedError)
+    end
+
+    it "should accept a string key" do
+      @store.read('foo')
+    end
+
+    it "should accept a symbol key" do
+      @store.read(:foo)
+    end
+
+    it "should accept a parameters hash" do
+      @store.read('foo', :params => :hash)
+    end
+  end
+
+  describe "#write" do
+    it "should not raise a NotImplementedError error" do
+      lambda { @store.write('foo', 'bar') }.should_not raise_error(NotImplementedError)
+    end
+
+    it "should accept a string key" do
+      @store.write('foo', 'bar')
+    end
+
+    it "should accept a symbol as a key" do
+      @store.write(:foo, :bar)
+    end
+
+    it "should accept parameters and conditions" do
+      @store.write('foo', 'bar', {:params => :hash}, :conditions => :hash)
+    end
+  end
+
+  describe "#fetch" do
+    it "should not raise a NotImplementedError error" do
+      lambda { @store.fetch('foo') {'bar'} }.should_not raise_error(NotImplementedError)
+    end
+
+    it "should accept a string key" do
+      @store.fetch('foo') { 'bar' }
+    end
+
+    it "should accept a symbol as a key" do
+      @store.fetch(:foo) { :bar }
+    end
+
+    it "should accept parameters and conditions" do
+      @store.fetch('foo', {:params => :hash}, :conditions => :hash) { 'bar' }
+    end
+
+    it "should accept a value generating block" do
+      @store.fetch('foo') {'bar'}
+    end
+
+    it "should return the value of the block if it is called" do
+      @store.fetch(:boo) { "bar" }.should == "bar" if @store.writable?(:boo)
+    end
+  end
+
+  describe "#exists?" do
+    it "should not raise a NotImplementedError error" do
+      lambda { @store.exists?('foo') }.should_not raise_error(NotImplementedError)
+    end
+
+    it "should accept a string key" do
+      @store.exists?('foo')
+    end
+
+    it "should accept a symbol as a key" do
+      @store.exists?(:foo)
+    end
+
+    it "should accept parameters" do
+      @store.exists?('foo', :params => :hash)
+    end
+  end
+
+  describe "#delete" do
+    it "should not raise a NotImplementedError error" do
+      lambda { @store.delete('foo') }.should_not raise_error(NotImplementedError)
+    end
+
+    it "should accept a string key" do
+      @store.delete('foo')
+    end
+
+    it "should accept a symbol as a key" do
+      @store.delete(:foo)
+    end
+
+    it "should accept a parameters hash" do
+      @store.delete('foo', :params => :hash)
+    end
+  end
+
+  describe "#delete_all!" do
+    it "should not raise a NotImplementedError error" do
+      lambda { @store.delete_all! }.should_not raise_error(NotImplementedError)
+    end
+  end
+end
+
+
+describe Merb::Cache::AbstractStore do
+  before(:each) do
+    @store = Merb::Cache::AbstractStore.new
+  end
+
+  describe "#writable?" do
+    it "should raise a NotImplementedError error" do
+      lambda { @store.writable?('foo') }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#read" do
+    it "should raise a NotImplementedError" do
+      lambda { @store.read('foo') }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#write" do
+    it "should raise a NotImplementedError" do
+      lambda { @store.write('foo', 'bar') }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#fetch" do
+    it "should raise a NotImplementedError" do
+      lambda { @store.fetch('foo') {'bar'} }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#exists?" do
+    it "should raise a NotImplementedError" do
+      lambda { @store.exists?('foo') }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#delete" do
+    it "should raise a NotImplementedError" do
+      lambda { @store.delete('foo') }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#delete_all!" do
+    it "should raise a NotImplementedError" do
+      lambda { @store.delete_all! }.should raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/merb-cache/stores/fundamental/file_store_spec.rb

@@ -0,0 +1,186 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+# has 'all stores' shared group
+require File.dirname(__FILE__) + '/abstract_store_spec'
+
+describe Merb::Cache::FileStore do
+  it_should_behave_like 'all stores'
+
+  before(:each) do
+    @store = Merb::Cache::FileStore.new(:dir => File.dirname(Tempfile.new("").path))
+  end
+
+  #
+  # ==== #writable
+  #
+
+  describe "#writable?" do
+    describe "when conditions hash is empty" do
+      it "returns true" do
+        @store.writable?('foo').should be_true
+      end
+    end
+
+    describe "when given expire_in option" do
+      it "returns false" do
+        @store.writable?('foo', {}, :expire_in => 10).should be_false
+      end
+    end
+  end
+
+  #
+  # ==== #read
+  #
+
+  describe "#read" do
+    describe "when cache file does not exist" do
+      it "should return nil" do
+        key = "body.txt"
+
+        FileUtils.rm(@store.pathify(key)) if File.exists?(@store.pathify(key))
+        @store.read(key).should be_nil
+      end
+    end
+
+    describe "when cache file exists" do
+      it "reads the contents of the file" do
+        key  = "tmp.txt"
+        body = "body of the file"
+
+        File.open(@store.pathify(key), "w+") do |file|
+          file << body
+        end
+
+        @store.read(key).should == body
+      end
+    end
+  end
+
+  #
+  # ==== #write
+  #
+
+  describe "#write" do
+    describe "if it does not exist" do
+      it "create the file" do
+        key = "body.txt"
+
+        FileUtils.rm(@store.pathify(key)) if File.exists?(@store.pathify(key))
+
+        File.should_not be_exist(@store.pathify(key))
+
+        @store.write(key, "")
+
+        File.should be_exist(@store.pathify(key))
+      end
+    end
+
+    describe "when file already exists" do
+      it "overwrites the file" do
+        key = "tmp.txt"
+        old_body, new_body = "old body", "new body"
+
+        File.open(@store.pathify(key), "w+") do |file|
+          file << old_body
+        end
+
+        File.open(@store.pathify(key), "r") do |file|
+          file.read.should == old_body
+        end
+
+        @store.write(key, new_body)
+
+        File.open(@store.pathify(key), "r") do |file|
+          file.read.should == new_body
+        end
+      end
+    end
+  end
+
+  #
+  # ==== #fetch
+  #
+
+  describe "#fetch" do
+    describe "when the entry can be read" do
+      it "does not call the block" do
+        key, body = "tmp.txt", "body"
+        called    = false
+        proc      = lambda { called = true }
+        
+        File.open(@store.pathify(key), "w+") do |file|
+          file << body
+        end
+        
+        @store.fetch(key, &proc)
+        called.should be_false
+      end
+    end
+
+    describe "when entry cannot be read" do
+      it "calls the block" do
+        key    = "tmp.txt"
+        called = false
+        proc   = lambda { called = true }
+
+        FileUtils.rm(@store.pathify(key)) if File.exists?(@store.pathify(key))
+        
+        @store.fetch(key, &proc)
+        called.should be_true
+      end      
+    end
+  end
+
+  #
+  # ==== #delete
+  #
+
+  describe "#delete" do
+    describe "when file exists" do
+      it "deletes the file" do
+        key, body = "tmp.txt", "body of the file"
+
+        File.open(@store.pathify(key), "w+") do |file|
+          file << body
+        end
+
+        File.exists?(@store.pathify(key)).should be_true
+        @store.delete(key)
+        File.exists?(@store.pathify(key)).should be_false
+      end
+    end
+    
+    describe "when file does not exist" do
+      it "does not raise" do
+        @store.delete("#{rand}-#{rand}-#{Time.now.to_i}.txt")
+      end      
+    end
+  end
+
+  #
+  # ==== #delete_all
+  #
+
+  describe "#delete_all" do
+    it "is not supported" do
+      lambda { @store.delete_all }.should raise_error(Merb::Cache::NotSupportedError)
+    end
+  end
+
+  #
+  # ==== #pathify
+  #
+
+  describe "#pathify" do
+    it "should begin with the cache dir" do
+      @store.pathify("tmp.txt").should include(@store.dir)
+    end
+
+    it "should add any parameters to the end of the filename" do
+      @store.pathify("index.html", :page => 3, :lang => :en).should =~ %r[--#{{:page => 3, :lang => :en}.to_sha2}$]
+    end
+
+    it "should separate the parameters from the key by a '?'" do
+      @store.pathify("index.html", :page => 3, :lang => :en).should =~ %r[--#{{:page => 3, :lang => :en}.to_sha2}$]
+    end
+  end
+end

data/spec/merb-cache/stores/fundamental/memcached_store_spec.rb

@@ -0,0 +1,243 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/abstract_store_spec'
+
+begin
+  require 'memcached'
+  servers = ['127.0.0.1:43042', '127.0.0.1:43043']
+  namespace = 'memcached_test_namespace'
+  
+  options = {      
+    :namespace    => @namespace,
+    :hash         => :default,
+    :distribution => :modula
+  }
+  cache = Memcached.new(servers, options)
+  key, value = Time.now.to_i.to_s, Time.now.to_s
+  cache.set(key, value)
+  raise Exception unless cache.get(key) == value
+rescue Exception => e
+  puts e.message
+  raise "Memcached connection failed.  Try starting memcached with the memcached:start rake task or installing memcached gem with sudo gem install memcached."
+end
+
+describe Merb::Cache::MemcachedStore do
+  it_should_behave_like 'all stores'
+
+  before(:each) do
+    @store = Merb::Cache::MemcachedStore.new(:namespace => "specs", :servers => ["127.0.0.1:43042", "127.0.0.1:43043"])
+    @memcached = @store.memcached
+    @memcached.flush
+  end
+
+  after(:each) do
+    @memcached.flush
+  end
+  
+
+  it "has accessor for namespace" do
+    @store.namespace.should == "specs"
+  end
+
+  it "has accessor for servers" do
+    @store.servers.should == ["127.0.0.1:43042", "127.0.0.1:43043"]
+  end
+  
+  it "has accessor for memcached connector" do
+    @store.memcached.should == @memcached
+  end
+
+
+  #
+  # ==== #writable?
+  #
+
+  describe "#writable?" do
+    describe "when conditions hash is empty" do
+      it "returns true" do
+        @store.writable?('foo').should be_true
+      end
+    end
+  end
+  
+  #
+  # ==== #read
+  #  
+
+  describe "#read" do
+    describe "when cache has NO entry matching key" do
+      it "returns nil" do
+        key = "foo"
+
+        @memcached.delete(key) rescue nil
+        @store.read(key).should be_nil
+      end
+    end
+    
+    describe "when cache has entry matching key" do
+      it "returns the entry matching the key" do
+        key, data = "foo", "bar"
+
+        @memcached.set(key, data)
+
+        @store.read(key).should == data
+      end      
+    end    
+  end
+
+  #
+  # ==== #write
+  #
+
+  describe "#write" do
+    describe "when entry with the same key does not exist" do
+      it "create a new entry" do
+        key, data = "foo", "bar"
+
+        @memcached.delete(key) rescue nil
+        lambda { @memcached.get(key) }.should raise_error(Memcached::NotFound)
+
+        @store.write(key, data)
+        @memcached.get(key).should == data
+      end      
+    end
+    
+    describe "when entry with the same key already exists" do
+      it "overwrites the entry in the cache" do
+        key, data = "foo", "bar"
+
+        @memcached.set(key, "baz")
+        @memcached.get(key).should == "baz"
+
+        @store.write(key, data)
+        @memcached.get(key).should == data
+      end      
+    end    
+  end
+
+  #
+  # ==== #fetch
+  #
+
+  describe "#fetch" do
+    describe "when the entry exists in the cache" do
+      it "does NOT call the block" do
+         key, data = "foo", "bar"
+         called = false
+         proc = lambda { called = true }
+
+         @memcached.set(key, data)
+         @store.fetch(key, &proc)
+
+         called.should be_false
+      end      
+    end
+    
+    describe "when the entry does not exist in the cache" do
+      it "calls the block" do
+        key, data = "foo", "bar"
+         called = false
+         proc = lambda { called = true }
+
+         @memcached.delete(key) rescue nil
+         @store.fetch(key, &proc)
+         
+         called.should be_true
+      end      
+    end    
+  end
+
+  #
+  # ==== #delete
+  #
+
+  describe "#delete" do
+    describe "when the entry exists in the cache" do
+      it "deletes the entry" do
+        key, data = "foo", "bar"
+
+        @memcached.set(key, data)
+        @memcached.get(key).should == data
+
+        @store.delete(key)
+        lambda { @memcached.get(key) }.should raise_error(Memcached::NotFound)
+      end      
+    end
+    
+    describe "when the entry does not exist in the cache" do
+      it "raises Memcached::NotFound" do
+        lambda { @memcached.delete("#{rand}-#{rand}-#{Time.now.to_i}") }.
+          should raise_error(Memcached::NotFound)
+      end      
+    end
+  end
+
+  #
+  # ==== #delete_all
+  #
+
+  describe "#delete_all" do
+    it "flushes Memcached object" do
+      @memcached.set("ruby", "rb")
+      @memcached.set("python", "py")
+      @memcached.set("perl", "pl")
+
+      @store.delete_all
+      
+      @store.exists?("ruby").should be_nil
+      @store.exists?("python").should be_nil
+      @store.exists?("perl").should be_nil           
+    end
+  end
+
+  #
+  # ==== #clone
+  #
+
+  describe "#clone" do
+    it "clones Memcached instance" do
+      clone = @store.clone
+      
+      clone.memcached.object_id.should_not == @store.memcached.object_id
+    end
+  end
+
+  #
+  # ==== #normalize
+  #
+
+  describe "#normalize" do
+    it "should begin with the key" do
+      @store.normalize("this/is/the/key").should =~ /^this\/is\/the\/key/
+    end
+
+    it "should not add the '?' if there are no parameters" do
+      @store.normalize("this/is/the/key").should_not =~ /\?/
+    end
+
+    it "should seperate the parameters from the key by a '?'" do
+      @store.normalize("this/is/the/key", :page => 3, :lang => :en).
+        should =~ %r!this\/is\/the\/key--#{{:page => 3, :lang => :en}.to_sha2}$!
+    end
+  end
+
+  #
+  # ==== #expire_time
+  #
+
+  describe "#expire_time" do
+    describe "when there is NO :expire_in parameter" do
+      it "returns 0" do
+        @store.expire_time.should == 0
+      end      
+    end
+    
+    describe "when there is :expire_in parameter" do
+      it "returns Time.now + the :expire_in parameter" do
+        now = Time.now
+        Time.should_receive(:now).and_return now
+
+        @store.expire_time(:expire_in => 100).should == now + 100
+      end      
+    end
+  end
+end

data/spec/merb-cache/stores/strategy/abstract_strategy_store_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/../fundamental/abstract_store_spec'
+
+
+describe Merb::Cache::AbstractStrategyStore do
+  describe 'all strategy stores', :shared => true do
+    it_should_behave_like 'all stores'
+
+    before(:each) do
+      Merb::Cache.stores.clear
+      Thread.current[:'merb-cache'] = nil
+    end
+
+    describe "contextualizing method", :shared => true do
+      it "should return a subclass of itself" do
+        subclass = @klass.contextualize(Class.new(Merb::Cache::AbstractStore))
+        subclass.superclass.should  == @klass
+      end
+
+      it "should set the contextualized_stores attributes" do
+        subclass = @klass.contextualize(context_class = Class.new(Merb::Cache::AbstractStore))
+        subclass.contextualized_stores.first.should == context_class
+      end
+    end
+    
+    describe ".contextualize" do
+      it_should_behave_like "contextualizing method"
+    end
+
+    describe ".[]" do
+      it_should_behave_like "contextualizing method"
+    end
+
+    describe "#initialize" do
+      it "should create an instance of the any context classes" do
+        subclass = @klass.contextualize(context_class = Class.new(Merb::Cache::AbstractStore))
+        instance = subclass.new({})
+        instance.stores.first.class.superclass.should == Merb::Cache::AbstractStore
+      end
+
+      it "should lookup the instance of any context names" do
+        Merb::Cache.register(:foo, Class.new(Merb::Cache::AbstractStore))
+        subclass = @klass.contextualize(:foo)
+        Merb::Cache.should_receive(:[]).with(:foo)
+        subclass.new({})
+      end
+    end
+
+    describe "#clone" do
+      it "should clone each context instance" do
+        subclass = @klass.contextualize(context_class = Class.new(Merb::Cache::AbstractStore))
+        instance = mock(:instance)
+        context_class.should_receive(:new).and_return(instance)
+        instance.should_receive(:clone)
+
+        subclass.new.clone
+      end
+    end
+
+    describe "#write_all" do
+      it "should not raise a NotImplementedError error" do
+        lambda { @store.write_all('foo', 'bar') }.should_not raise_error(NotImplementedError)
+      end
+
+      it "should accept a string key" do
+        @store.write_all('foo', 'bar')
+      end
+
+      it "should accept a symbol as a key" do
+        @store.write_all(:foo, :bar)
+      end
+
+      it "should accept parameters and conditions" do
+        @store.write_all('foo', 'bar', {:params => :hash}, :conditions => :hash)
+      end
+    end
+  end
+end