cryx-cacheability 0.1.0

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 0
+:major: 0

data/lib/cacheability/restclient.rb

@@ -0,0 +1,74 @@
+require 'restclient'
+require 'rack/cache'
+
+module RestClient
+  # A class that mocks the behaviour of a Net::HTTPResponse class.
+  # It is required since RestClient::Response must be initialized with a class that responds to :code and :to_hash.
+  class MockHTTPResponse
+    attr_reader :code, :headers, :body
+    def initialize(rack_response)
+      @code, @headers, @body = rack_response
+    end
+    def to_hash
+      @headers
+    end    
+  end
+  
+  class CacheableResource < Resource
+    attr_reader :cache
+    CACHE_DEFAULT_OPTIONS = {}.freeze
+    
+    def initialize(*args)
+      super(*args)
+      # rack-cache creates a singleton, so that there is only one instance of the cache at any time
+      @cache = Rack::Cache.new(self, options[:cache] || CACHE_DEFAULT_OPTIONS)
+    end
+  
+    def get(additional_headers = {}, pass_through_cache = true)
+      if pass_through_cache && cache
+        uri = URI.parse(url)
+        uri_path_split = uri.path.split("/")
+        path_info = (last_part = uri_path_split.pop) ? "/"+last_part : ""
+        script_name = uri_path_split.join("/")
+        # minimal rack spec
+        env = { 
+          "REQUEST_METHOD" => 'GET',
+          "SCRIPT_NAME" => script_name,
+          "PATH_INFO" => path_info,
+          "QUERY_STRING" => uri.query,
+          "SERVER_NAME" => uri.host,
+          "SERVER_PORT" => uri.port.to_s
+        }
+        debeautify_headers(additional_headers).each do |key, value|
+          env.merge!("HTTP_"+key.to_s.gsub("-", "_").upcase => value)
+        end
+        response = MockHTTPResponse.new(cache.call(env))
+        RestClient::Response.new(response.body.to_s, response)
+      else
+        super(additional_headers)
+      end
+    end
+  
+    def debeautify_headers(headers = {})
+      headers.inject({}) do |out, (key, value)|
+  			out[key.to_s.gsub(/_/, '-')] = value
+  			out
+  		end
+    end
+  
+    def call(env)
+      http_headers = env.inject({}) do |out, (header, value)| 
+        if header =~ /HTTP_/
+          out[header.gsub("HTTP_", '')] = value unless value.nil? || value.empty?
+        end
+        out
+      end
+      response = get(debeautify_headers(http_headers), pass_through_cache=false)
+      response.headers.delete(:x_content_digest) # don't know why, but it seems to make the validation fail if kept...
+      [response.code, debeautify_headers( response.headers ), response.to_s]
+    rescue RestClient::NotModified
+      # should be modified to include response headers when the rest-client gem is up to date
+      [304, {}, ""]
+    end
+  end
+end

data/spec/cacheability_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'restclient'
+
+describe RestClient::CacheableResource do
+  require File.dirname(__FILE__) + '/../lib/cacheability/restclient'
+  before do
+    @cache_options = {:metastore => 'file:/tmp/cache/meta', :entitystore => 'file:/tmp/cache/body'}
+  end
+  
+  it "should instantiate the cache at init" do
+    mock_cache = mock('rack-cache instance')    
+    Rack::Cache.should_receive(:new).with( 
+      RestClient::CacheableResource.new('http://domain.tld:8888/some/cacheable/resource', :cache => @cache_options), 
+      @cache_options
+    ).and_return(mock_cache)
+  end
+  
+  describe "correctly instantiated" do
+    before do
+      @mock_cache = mock('rack-cache singleton')
+      Rack::Cache.stub!(:new).and_return(@mock_cache)
+      @env = {
+        'REQUEST_METHOD' => 'GET',
+        "SCRIPT_NAME" => '/some/cacheable',
+        "PATH_INFO" => '/resource',
+        "QUERY_STRING" => 'q1=a&q2=b',
+        "SERVER_NAME" => 'domain.tld',
+        "SERVER_PORT" => '8888'
+      }
+      @resource = RestClient::CacheableResource.new('http://domain.tld:8888/some/cacheable/resource', :cache => @cache_options)
+    end
+    
+    it "should pass through the cache" do
+      @resource.cache.should_receive(:call).with( hash_including( @env.merge({'HTTP_ADDITIONAL_HEADER' => 'whatever'}) ) )
+      @resource['/?q1=a&q2=b'].get(:additional_header => 'whatever')
+    end
+  
+    it "should bypass the cache if pass_through_cache argument is false" do
+      @resource = RestClient::CacheableResource.new('http://domain.tld:8888/some/cacheable/resource', :cache => @cache_options)
+      @resource.cache.should_not_receive(:call)
+      @resource.get({:additional_header => 'whatever'}, false) rescue nil # don't know how to spec the call to super()
+    end
+  
+    it "should call the backend (bypassing the cache) if the requested resource is not in the cache" do
+      @resource.should_receive(:get).with({'ADDITIONAL-HEADER' => 'whatever'}, false).and_return(mock('rest-client response', :headers => {}, :code => 200, :to_s => 'body'))
+      response = @resource.call(@env.merge({'HTTP_ADDITIONAL_HEADER' => 'whatever'}))
+      response.should == [200, {}, "body"]
+    end
+    
+    it "should return a 304 not modified response if the call to the backend returned a 304 not modified response" do
+      @resource.should_receive(:get).with({'ADDITIONAL-HEADER' => 'whatever'}, false).and_raise(RestClient::NotModified)
+      response = @resource.call(@env.merge({'HTTP_ADDITIONAL_HEADER' => 'whatever'}))
+      response.should == [304, {}, ""]
+    end
+    
+    it "should render a RestClient::Response even when the data is coming from the cache" do
+      @resource.cache.should_receive(:call).and_return([200, {'ADDITIONAL_HEADER' => 'whatever'}, "body"])
+      response = @resource.get({'HTTP_ADDITIONAL_HEADER' => 'whatever'}, true)
+      response.should be_is_a(RestClient::Response)
+      response.code.should == 200
+      response.headers.should == {:ADDITIONAL_HEADER => 'whatever'}
+      response.to_s.should == "body"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require File.dirname(__FILE__) + '/../lib/cacheability'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: cryx-cacheability
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Cyril Rohr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-02 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack-cache
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: TODO
+email: cyril.rohr@irisa.fr
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- lib/cacheability
+- lib/cacheability/restclient.rb
+- lib/cacheability.rb
+- spec/cacheability_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/cryx/cacheability
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: []
+