garner 0.4.5 → 0.5.0

data/spec/integration/rack_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'garner/mixins/rack'
+require 'securerandom'
+
+describe 'Rack integration' do
+  include Rack::Test::Methods
+
+  let(:app) do
+    class TestRackApp
+      include Garner::Mixins::Rack
+
+      attr_accessor :request
+
+      def call(env)
+        @request = Rack::Request.new(env)
+        random1 = garner { SecureRandom.hex }
+        random2 = garner { SecureRandom.hex }
+        [
+          200,
+          { 'Content-Type' => 'application/json' },
+          [random1, random2].to_json
+        ]
+      end
+    end
+
+    TestRackApp.new
+  end
+
+  context 'with the RequestGet strategy disabled' do
+    before(:each) do
+      Garner.configure do |config|
+        config.rack_context_key_strategies -= [Garner::Strategies::Context::Key::RequestGet]
+      end
+    end
+    it 'co-caches requests to the same path with different query strings' do
+      get '/foo?q=1'
+      response1 = JSON.parse(last_response.body)[0]
+      get '/foo?q=2'
+      response2 = JSON.parse(last_response.body)[0]
+      response1.should eq response2
+    end
+  end
+
+  context 'with default configuration' do
+    it 'bypasses cache if cache_enabled? returns false' do
+      TestRackApp.any_instance.stub(:cache_enabled?) { false }
+      get '/'
+      response1 = JSON.parse(last_response.body)[0]
+      get '/'
+      response2 = JSON.parse(last_response.body)[0]
+      response1.should_not == response2
+    end
+
+    it 'caches different results for different paths' do
+      get '/foo'
+      response1 = JSON.parse(last_response.body)[0]
+      get '/bar'
+      response2 = JSON.parse(last_response.body)[0]
+      response1.should_not == response2
+    end
+
+    it 'caches different results for different query strings' do
+      get '/foo?q=1'
+      response1 = JSON.parse(last_response.body)[0]
+      get '/foo?q=2'
+      response2 = JSON.parse(last_response.body)[0]
+      response1.should_not == response2
+    end
+
+    it 'caches multiple blocks separately within an endpoint' do
+      get '/'
+      random1 = JSON.parse(last_response.body)[0]
+      random2 = JSON.parse(last_response.body)[1]
+      random1.should_not == random2
+    end
+  end
+end

data/spec/integration/sinatra_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'garner/mixins/rack'
+require 'sinatra'
+
+describe 'Sinatra integration' do
+
+  let(:app) do
+    class TestSinatraApp < Sinatra::Base
+      helpers Garner::Mixins::Rack
+      use Rack::ConditionalGet
+      use Rack::ETag
+
+      before do
+        headers 'Expires' => Time.at(0).utc.to_s
+      end
+
+      get '/' do
+        garner do
+          { meaning_of_life: 42 }.to_json
+        end
+      end
+    end
+
+    TestSinatraApp.new
+  end
+
+  it_behaves_like 'Rack::ConditionalGet server'
+
+end

data/spec/performance/strategy_benchmark.rb

@@ -0,0 +1,59 @@
+require 'spec_support'
+require 'method_profiler'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'support/benchmark_context'
+require 'support/benchmark_context_wrapper'
+
+class StrategyBenchmark
+  attr_accessor :n, :d, :r
+
+  def initialize(options = {})
+    @n = options[:n] || 1000   # Number of iterations
+    @d = options[:d] || 1024   # Document payload size
+    @r = options[:r] || 4      # Recursive database calls per garner block
+  end
+
+  def run!
+    profiler = MethodProfiler.observe(BenchmarkContext)
+    self.class.strategy_pairs.each do |key_strategy, invalidation_strategy|
+      Garner.configure do |config|
+        config.mongoid_identity_fields = [:_id, :_slugs]
+        config.binding_key_strategy = key_strategy
+        config.binding_invalidation_strategy = invalidation_strategy
+      end
+
+      proxy = BenchmarkContextWrapper.new(d: d, r: r)
+
+      # Workaround for MethodProfiler bug
+      profiler.instance_variable_set(:@data, Hash.new { |h, k| h[k] = [] })
+      n.times do
+        # Randomize order of calls
+        [
+          :warm_virtual_fetch,
+          :cold_virtual_fetch,
+          :warm_class_fetch,
+          :cold_class_fetch,
+          :force_invalidate,
+          :soft_invalidate
+        ].shuffle.each { |method| proxy.send(method) }
+      end
+
+      puts "Key: #{key_strategy.to_s.split('::')[-1]}"
+      puts "Invalidation: #{invalidation_strategy.to_s.split('::')[-1]}"
+      puts profiler.report.sort_by(:method).order(:ascending)
+      puts "\n\n"
+    end
+  end
+
+  def self.strategy_pairs
+    {
+      Garner::Strategies::Binding::Key::Base =>
+        Garner::Strategies::Binding::Invalidation::Base,
+      Garner::Strategies::Binding::Key::SafeCacheKey =>
+        Garner::Strategies::Binding::Invalidation::Touch,
+      Garner::Strategies::Binding::Key::BindingIndex =>
+        Garner::Strategies::Binding::Invalidation::BindingIndex
+    }
+  end
+end

data/spec/performance/support/benchmark_context.rb

@@ -0,0 +1,31 @@
+class BenchmarkContext
+  include Garner::Cache::Context
+
+  def virtual_fetch(klass, handle, r)
+    garner.bind(klass.identify(handle)).key(caller: nil) do
+      (r - 1).times { klass.find(handle).to_json }
+      klass.find(handle).to_json
+    end
+  end
+  alias_method :a_warm_virtual_fetch, :virtual_fetch
+  alias_method :b_cold_virtual_fetch, :virtual_fetch
+
+  def class_fetch(klass, handle, r)
+    garner.bind(klass).key(caller: nil) do
+      (r - 1).times { klass.find(handle).to_json }
+      klass.find(handle).to_json
+    end
+  end
+  alias_method :c_warm_class_fetch, :class_fetch
+  alias_method :d_cold_class_fetch, :class_fetch
+
+  def force_invalidate(binding)
+    binding.invalidate_garner_caches
+  end
+  alias_method :e_force_invalidate, :force_invalidate
+
+  def soft_invalidate(binding)
+    binding.send(:_garner_after_update)
+  end
+  alias_method :f_soft_invalidate, :soft_invalidate
+end

data/spec/performance/support/benchmark_context_wrapper.rb

@@ -0,0 +1,67 @@
+require 'securerandom'
+
+class BenchmarkContextWrapper
+  include Garner::Cache::Context
+  attr_accessor :binding, :context, :r
+
+  def initialize(options = {})
+    setup!(options)
+  end
+
+  def setup!(options)
+    Monger.destroy_all
+    Garner.config.cache.clear
+    @binding = Monger.create!(name: 'M1')
+    @binding.update_attributes!(
+      subdocument: SecureRandom.hex(options[:d])
+    ) if options[:d]
+    @r = options[:r]
+    @context = BenchmarkContext.new
+
+    # Prime MongoDB cache
+    Monger.find(@binding.slug)
+  end
+
+  def warm_virtual_fetch
+    warm_caches
+    context.a_warm_virtual_fetch(binding.class, binding.slug, r)
+  end
+
+  def cold_virtual_fetch
+    update_binding
+    context.b_cold_virtual_fetch(binding.class, binding.slug, r)
+  end
+
+  def warm_class_fetch
+    warm_caches
+    context.c_warm_class_fetch(binding.class, binding.slug, r)
+  end
+
+  def cold_class_fetch
+    update_binding
+    context.d_cold_class_fetch(binding.class, binding.slug, r)
+  end
+
+  def force_invalidate
+    context.e_force_invalidate(binding)
+  end
+
+  def soft_invalidate
+    context.f_soft_invalidate(binding)
+  end
+
+  private
+
+  def warm_caches
+    klass, handle = binding.class, binding.slug
+    json = binding.reload.to_json
+    garner.bind(klass.identify(handle)).key(caller: nil) { json }
+    garner.bind(klass).key(caller: nil) { json }
+  end
+
+  def update_binding
+    # Randomly shuffle name between M1, M2, M3
+    name = (%w(M1 M2 M3) - [binding.reload.name]).sample
+    binding.update_attributes!(name: name)
+  end
+end

data/spec/shared/binding_invalidation_strategy.rb

@@ -0,0 +1,17 @@
+# Shared examples for binding invalidation strategies. A valid strategy must
+# implement apply(binding) and force_apply(binding)
+shared_examples_for 'Garner::Strategies::Binding::Invalidation strategy' do
+  it 'inherits from Garner::Strategies::Binding::Invalidation::Base' do
+    subject.new.should be_a(Garner::Strategies::Binding::Invalidation::Base)
+  end
+
+  describe 'apply' do
+    it 'requires an argument' do
+      expect { subject.apply }.to raise_error
+    end
+
+    it 'operates on any binding' do
+      expect { subject.apply(double('foo')) }.not_to raise_error
+    end
+  end
+end

data/spec/shared/binding_key_strategy.rb

@@ -0,0 +1,35 @@
+# Shared examples for binding strategies. A valid binding strategy must implement
+# apply(binding).
+shared_examples_for 'Garner::Strategies::Binding::Key strategy' do
+  it 'requires an argument' do
+    expect { subject.apply }.to raise_error
+  end
+
+  it 'inherits from Garner::Strategies::Binding::Key::Base' do
+    subject.new.should be_a(Garner::Strategies::Binding::Key::Base)
+  end
+
+  describe 'given a known binding' do
+    it 'returns a valid cache key' do
+      known_bindings.each do |binding|
+        subject.apply(binding).should be_a(String)
+      end
+    end
+
+    it 'returns the same cache key for an unchanged object' do
+      known_bindings.each do |binding|
+        key1 = subject.apply(binding)
+        key2 = subject.apply(binding)
+        key1.should eq key2
+      end
+    end
+  end
+
+  describe 'given an unknown binding' do
+    it 'returns a nil cache key' do
+      unknown_bindings.each do |binding|
+        subject.apply(binding).should be_nil
+      end
+    end
+  end
+end

data/spec/shared/conditional_get.rb

@@ -0,0 +1,48 @@
+# Shared examples for a proper Conditional GET server.
+#   To test a new Rack framework, define an app returned by app, with a
+#   single endpoint, "/".
+shared_examples_for 'Rack::ConditionalGet server' do
+  include Rack::Test::Methods
+
+  def etag_for(body_str)
+    Rack::ETag.new(nil).send(:digest_body, [body_str]).first
+  end
+
+  before(:each) do
+    Garner.config.cache.clear
+  end
+
+  it "writes the cached object's ETag from binding" do
+    get '/'
+    last_response.headers['ETag'].length.should eq 32 + 2
+  end
+
+  it 'sends a 304 response if content has not changed (If-None-Match)' do
+    get '/'
+    last_response.status.should eq 200
+    last_response.headers['ETag'].should eq %Q("#{etag_for(last_response.body)}")
+    get '/', {},  'HTTP_IF_NONE_MATCH' => last_response.headers['ETag']
+    last_response.status.should eq 304
+  end
+
+  it 'sends a 200 response if content has changed (If-None-Match)' do
+    get '/'
+    last_response.status.should eq 200
+    get '/', {},  'HTTP_IF_NONE_MATCH' => %Q("#{etag_for('foobar')}")
+    last_response.status.should eq 200
+  end
+
+  it 'sends a 200 response if content has changed (valid If-Modified-Since but invalid If-None-Match)' do
+    get '/'
+    last_response.status.should eq 200
+    get '/', {},  'HTTP_IF_MODIFIED_SINCE' => (Time.now + 1).httpdate, 'HTTP_IF_NONE_MATCH' => %Q("#{etag_for(last_response.body)}")
+    last_response.status.should eq 200
+  end
+
+  it 'adds Cache-Control, Pragma and Expires headers' do
+    get '/'
+    last_response.headers['Cache-Control'].split(', ').sort.should eq %w(max-age=0 must-revalidate private)
+    last_response.headers['Pragma'].should be_nil
+    Time.parse(last_response.headers['Expires']).should be < Time.now
+  end
+end

data/spec/shared/context_key_strategy.rb

@@ -0,0 +1,24 @@
+# Shared examples for key strategies. A valid key strategy must implement
+# apply(identity, ruby_context = self).
+shared_examples_for 'Garner::Strategies::Context::Key strategy' do
+  before(:each) do
+    @cache_identity = Garner::Cache::Identity.new
+  end
+
+  it 'inherits from Garner::Strategies::Context::Key::Base' do
+    subject.new.should be_a(Garner::Strategies::Context::Key::Base)
+  end
+
+  it 'requires a Garner::Cache::Identity' do
+    expect { subject.apply }.to raise_error
+  end
+
+  it 'does not require an explicit context, defaulting to self' do
+    expect { subject.apply(@cache_identity) }.to_not raise_error
+  end
+
+  it 'returns a Garner::Cache::Identity' do
+    modified_identity = subject.apply(@cache_identity, self)
+    modified_identity.should eq @cache_identity
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'coveralls'
+Coveralls.wear!('test_frameworks') if ENV['CI']
+
+require 'rspec'
+require 'rack/test'
+
+require 'garner'
+
+# Load support files
+require 'spec_support'
+
+# Load shared examples
+Dir["#{File.dirname(__FILE__)}/shared/*.rb"].each do |file|
+  require file
+end
+
+RSpec.configure do |rspec|
+  rspec.mock_with :rspec do |mocks|
+    mocks.patch_marshal_to_support_partial_doubles = true
+  end
+end

data/spec/spec_support.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].each do |file|
+  require file
+end

data/spec/support/active_record.rb

@@ -0,0 +1,36 @@
+require 'active_record'
+require 'garner/mixins/active_record'
+
+# Set up in-memory SQLite connection for ActiveRecord
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+# Include mixin
+module ActiveRecord
+  class Base
+    include Garner::Mixins::ActiveRecord::Base
+  end
+end
+
+# Stub classes
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Migration.create_table :activists do |t|
+  t.string :name
+  t.timestamps
+end
+
+class Activist < ActiveRecord::Base
+end
+
+# Wrap each test example in a failing transaction to ensure a clean
+# database for each run.
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      fail ActiveRecord::Rollback
+    end
+  end
+end