benschwarz-merb-cache 1.0.0

data/spec/merb-cache/core_ext/hash_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Hash do
+  
+  describe "to_sha1" do
+    before(:each) do
+      @params = {:id => 1, :string => "string", :symbol => :symbol}
+    end
+    
+    it{@params.should respond_to(:to_sha2)}
+    
+    # This sec only has meaning in ruby 1.9 that uses an ordered hash
+    it "should encode the hash by alphabetic key" do
+      x = @params.to_sha2
+      y = {:id => 1, :symbol => :symbol, :string => "string"}.to_sha2
+      x.should == y
+    end
+    
+    it "should not have any collisions between different values (using arrays)" do
+      x = {'test' => ['at','vc'], 'test2' => 'b'}.to_sha2
+      y = {'test' => ['atv', 'c'], 'test2' => 'b'}.to_sha2
+      puts x != y
+      x.should_not == y
+    end
+    
+    it "should encode the keys" do
+      x = {'key' => [1,2,3]}.to_sha2
+      y = {'test' => [1,2,3]}.to_sha2
+      x.should_not == y
+    end
+    
+    it "should not make a distinction between symbol and strings for keys" do
+      x = {:key => 1}.to_sha2
+      y = {'key' => 1}.to_sha2
+      x.should == y
+    end
+    
+    it "should not have any collisions between keys and values" do
+      x = {'key' => 'ab'}.to_sha2
+      y = {'keya' => 'b'}.to_sha2
+      x.should_not == y
+    end
+    
+    it "should not have any collisions between the values of two different keys" do
+      x = {'a' => 'abc', 'b' => 'def'}.to_sha2
+      y = {'a' => 'abcd', 'b' => 'ef'}.to_sha2
+      x.should_not == y
+    end
+  end
+  
+end

data/spec/merb-cache/merb_ext/controller_spec.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Merb::Cache::Controller do
+  # Oh this hurts
+end

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

@@ -0,0 +1,118 @@
+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 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
+  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 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
+  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 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,205 @@
+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
+    
+    it "should return a boolean" do
+      @store.writable?(:foo, {}).should be_true
+    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
+    it "should write" do
+      @store.write('foo', 'bar', {:params => :hash}, :conditions => :hash).should be_true
+    end
+    
+    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
+
+  #
+  # ==== # exists?
+  #
+  
+  describe "#exists?" do
+    it "should return a boolean" do
+      @store.write('foo', 'bar')
+      @store.exists?('foo').should be_true
+    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,258 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/abstract_store_spec'
+
+begin
+  require 'memcached'
+  servers = '127.0.0.1:11211'
+  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
+  puts "Memcached connection failed.  Try starting memcached on the default port (11211)"
+else
+
+  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:11211"])
+      @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:11211"]
+    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
+      it "should write" do
+        @store.write('foo', 'bar', {:params => :hash}, :conditions => :hash).should be_true
+      end
+      
+      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
+    
+    #
+    # ==== #exists?
+    #
+    describe "#exists?" do
+      it "should return a boolean" do
+        @store.write('foo', 'bar')
+        @store.exists?('foo').should be_true
+      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_false
+        @store.exists?("python").should be_false
+        @store.exists?("perl").should be_false
+      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
+end