libmemcached_store 0.6.2 → 0.7.0

data/.gitignore

@@ -1,3 +1,4 @@
 .DS_Store
 *.swp
 Gemfile.lock
+gemfiles/*.lock

data/.travis.yml

@@ -1,7 +1,10 @@
 language: ruby
 rvm:
   - 1.9.3
+  - 2.0.0
 gemfile:
   - gemfiles/rails30.gemfile
   - gemfiles/rails31.gemfile
-  - gemfiles/rails32.gemfile
+  - gemfiles/rails32.gemfile
+  - gemfiles/rails40.gemfile
+

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.7.0
+  * Add support for memcached 1.7 (grosser)
+  * Test with Rails 4 (grosser)
+  * Add race_condition_ttl option to #fetch (grosser)
+
 ## 0.6.2
   * Add :hit to the #fetch payload
 

data/gemfiles/rails40.gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gem 'activesupport', '~> 4.0.0'
+gem 'actionpack', '~> 4.0.0'
+gem 'mocha'
+
+gemspec :path => '../'

data/lib/action_dispatch/session/libmemcached_store.rb

@@ -9,7 +9,7 @@ module ActionDispatch
         options[:expire_after] ||= options[:expires]
         super
         client_options = { default_ttl: options.fetch(:expire_after, 0) }
-        client_options[:namespace] = options[:namespace] || 'rack:session'
+        client_options[:prefix_key] = options[:prefix_key] || options[:namespace] || 'rack:session'
         @mutex = Mutex.new
         @pool = options[:cache] || Memcached.new(@default_options[:memcache_server], client_options)
       end

data/lib/active_support/cache/libmemcached_store.rb

@@ -27,6 +27,23 @@ module ActiveSupport
         include GetWithFlags
       end
 
+      class FetchWithRaceConditionTTLEntry
+        attr_accessor :value, :extended
+
+        def initialize(value, expires_in)
+          @value, @extended = value, false
+          @expires_at = Time.now.to_i + expires_in
+        end
+
+        def expires_in
+          [@expires_at - Time.now.to_i, 1].max # never set to 0 -> never expires
+        end
+
+        def expired?
+          @expires_at <= Time.now.to_i
+        end
+      end
+
       attr_reader :addresses
 
       DEFAULT_CLIENT_OPTIONS = { distribution: :consistent_ketama, binary_protocol: true, default_ttl: 0 }
@@ -64,40 +81,69 @@ module ActiveSupport
         end
         client_options[:default_ttl] = options.delete(:expires_in).to_i if options[:expires_in]
 
-        @options = options.reverse_merge(compress_threshold: DEFAULT_COMPRESS_THRESHOLD)
+        @options = {compress_threshold: DEFAULT_COMPRESS_THRESHOLD}.merge(options)
         @addresses = addresses
-        @cache = MemcachedWithFlags.new(@addresses, client_options.reverse_merge(DEFAULT_CLIENT_OPTIONS))
+        @cache = MemcachedWithFlags.new(@addresses, DEFAULT_CLIENT_OPTIONS.merge(client_options))
       end
 
-      def fetch(key, options = nil)
+      def fetch(key, options = nil, &block)
         if block_given?
-          key = expanded_key(key)
-          unless options && options[:force]
-            entry = instrument(:read, key, options) do |payload|
-              read_entry(key, options).tap do |result|
-                if payload
-                  payload[:super_operation] = :fetch
-                  payload[:hit] = !!result
+          if options && options[:race_condition_ttl]
+            fetch_with_race_condition_ttl(key, options, &block)
+          else
+            key = expanded_key(key)
+            unless options && options[:force]
+              entry = instrument(:read, key, options) do |payload|
+                read_entry(key, options).tap do |result|
+                  if payload
+                    payload[:super_operation] = :fetch
+                    payload[:hit] = !!result
+                  end
                 end
               end
             end
-          end
 
-          if entry.nil?
-            result = instrument(:generate, key, options) do |payload|
-              yield
+            if entry.nil?
+              result = instrument(:generate, key, options) do |payload|
+                yield
+              end
+              write_entry(key, result, options)
+              result
+            else
+              instrument(:fetch_hit, key, options) { |payload| }
+              entry
             end
-            write_entry(key, result, options)
-            result
-          else
-            instrument(:fetch_hit, key, options) { |payload| }
-            entry
           end
         else
           read(key, options)
         end
       end
 
+      def fetch_with_race_condition_ttl(key, options={}, &block)
+        options = options.dup
+
+        race_ttl = options.delete(:race_condition_ttl) || raise("Use :race_condition_ttl option or normal fetch")
+        expires_in = options.fetch(:expires_in)
+        options[:expires_in] = expires_in + race_ttl
+        options[:preserve_race_condition_entry] = true
+
+        value = fetch(key, options) { FetchWithRaceConditionTTLEntry.new(yield, expires_in) }
+
+        return value unless value.is_a?(FetchWithRaceConditionTTLEntry)
+
+        if value.expired? && !value.extended
+          # we take care of refreshing the cache, all others should keep reading
+          value.extended = true
+          write(key, value, options.merge(:expires_in => value.expires_in + race_ttl))
+
+          # calculate new value and store it
+          value = FetchWithRaceConditionTTLEntry.new(yield, expires_in)
+          write(key, value, options)
+        end
+
+        value.value
+      end
+
       def read(key, options = nil)
         key = expanded_key(key)
         instrument(:read, key, options) do |payload|
@@ -191,7 +237,8 @@ module ActiveSupport
       def read_entry(key, options = nil)
         options ||= {}
         raw_value, flags = @cache.get(escape_and_normalize(key), false, true)
-        deserialize(raw_value, options[:raw], flags)
+        value = deserialize(raw_value, options[:raw], flags)
+        convert_race_condition_entry(value, options)
       rescue Memcached::NotFound
         nil
       rescue Memcached::Error => e
@@ -229,6 +276,14 @@ module ActiveSupport
 
       private
 
+      def convert_race_condition_entry(value, options)
+        if !options[:preserve_race_condition_entry] && value.is_a?(FetchWithRaceConditionTTLEntry)
+          value.value
+        else
+          value
+        end
+      end
+
       def deserialize(value, raw = false, flags = 0)
         value = Zlib::Inflate.inflate(value) if (flags & FLAG_COMPRESSED) != 0
         raw ? value : Marshal.load(value)

data/lib/version.rb

@@ -1,3 +1,3 @@
 module LibmemcachedStore
-  VERSION = "0.6.2"
+  VERSION = "0.7.0"
 end

data/libmemcached_store.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rack')
   s.add_development_dependency('rake')
   s.add_development_dependency('mocha')
+  s.add_development_dependency('minitest', '~> 4.7')
   s.add_development_dependency('activesupport', '>= 3')
   s.add_development_dependency('actionpack', '>= 3')
 end

data/test/action_dispatch/abstract_unit.rb

@@ -3,7 +3,11 @@ require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'action_controller'
 require 'action_dispatch/routing'
-require 'action_dispatch/middleware/head'
+if ActionPack::VERSION::MAJOR >= 4
+  require 'rack/head'
+else
+  require 'action_dispatch/middleware/head'
+end
 require 'action_dispatch/testing/assertions'
 require 'action_dispatch/testing/test_process'
 require 'action_dispatch/testing/integration'
@@ -36,8 +40,12 @@ class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
       middleware.use "ActionDispatch::ParamsParser"
       middleware.use "ActionDispatch::Cookies"
       middleware.use "ActionDispatch::Flash"
-      middleware.use "ActionDispatch::Head"
+      if ActionPack::VERSION::MAJOR >= 4
+        middleware.use "Rack::Head"
+      else
+        middleware.use "ActionDispatch::Head"
+      end
       yield(middleware) if block_given?
     end
   end
-end
+end

data/test/action_dispatch/libmemcached_store_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative '../test_helper'
 require File.expand_path('../abstract_unit', __FILE__)
 require 'action_dispatch/session/libmemcached_store'
 
@@ -38,7 +38,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_setting_and_getting_session_value
+  test "setting and getting session value" do
     with_test_route_set do
       get '/set_session_value'
       assert_response :success
@@ -50,7 +50,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_getting_nil_session_value
+  test "getting nil session value" do
     with_test_route_set do
       get '/get_session_value'
       assert_response :success
@@ -58,7 +58,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_getting_session_value_after_session_reset
+  test "getting session value after session reset" do
     with_test_route_set do
       get '/set_session_value'
       assert_response :success
@@ -77,7 +77,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_getting_from_nonexistent_session
+  test "getting from nonexistent session" do
     with_test_route_set do
       get '/get_session_value'
       assert_response :success
@@ -86,7 +86,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_setting_session_value_after_session_reset
+  test "setting session value after session reset" do
     with_test_route_set do
       get '/set_session_value'
       assert_response :success
@@ -107,7 +107,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_getting_session_id
+  test "getting session id" do
     with_test_route_set do
       get '/set_session_value'
       assert_response :success
@@ -120,7 +120,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_deserializes_unloaded_class
+  test "deserializes unloaded class" do
     with_test_route_set do
       with_autoload_path "session_autoload_test" do
         get '/set_serialized_session_value'
@@ -139,7 +139,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_doesnt_write_session_cookie_if_session_id_is_already_exists
+  test "doesnt write session cookie if session id is already exists" do
     with_test_route_set do
       get '/set_session_value'
       assert_response :success
@@ -151,7 +151,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_prevents_session_fixation
+  test "prevents session fixation" do
     with_test_route_set do
       get '/get_session_value'
       assert_response :success
@@ -171,7 +171,7 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
   def with_test_route_set
     with_routing do |set|
       set.draw do
-        match ':action', :to => TestController
+        get ':action', :to => TestController
       end
 
       @app = self.class.build_app(set) do |middleware|
@@ -197,4 +197,4 @@ class LibMemcachedStoreTest < ActionDispatch::IntegrationTest
       end
     end
   end
-end
+end

data/test/active_support/libmemcached_store_test.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require 'test_helper'
+require_relative '../test_helper'
 require 'memcached'
 require 'active_support'
 require 'active_support/core_ext/module/aliasing'
@@ -8,318 +8,319 @@ require 'active_support/core_ext/object/duplicable'
 require 'active_support/cache/libmemcached_store'
 
 # Make it easier to get at the underlying cache options during testing.
-class ActiveSupport::Cache::LibmemcachedStore
+ActiveSupport::Cache::LibmemcachedStore.class_eval do
   def client_options
     @cache.options
   end
 end
 
-class MockUser
-  def cache_key
-    'foo'
+describe ActiveSupport::Cache::LibmemcachedStore do
+  class MockUser
+    def cache_key
+      'foo'
+    end
   end
-end
 
-module CacheStoreBehavior
-  def test_fetch_without_cache_miss
-    @cache.write('foo', 'bar')
-    @cache.expects(:write_entry).never
-    assert_equal 'bar', @cache.fetch('foo') { 'baz' }
+  before do
+    @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, expires_in: 60)
+    @cache.clear
+    @cache.silence!
   end
 
-  def test_fetch_with_cache_miss
-    @cache.expects(:write_entry).with('foo', 'baz', nil)
-    assert_equal 'baz', @cache.fetch('foo') { 'baz' }
-  end
+  describe "cache store behavior" do
+    def really_long_keys_test
+      key = "a" * 251
+      assert @cache.write(key, "bar")
+      assert_equal "bar", @cache.read(key)
+      assert_equal "bar", @cache.fetch(key)
+      assert_nil @cache.read("#{key}x")
+      assert_equal({key => "bar"}, @cache.read_multi(key))
+      assert @cache.delete(key)
+      refute @cache.exist?(key)
+      assert @cache.write(key, '2', :raw => true)
+      assert_equal 3, @cache.increment(key)
+      assert_equal 2, @cache.decrement(key)
+    end
 
-  def test_fetch_with_forced_cache_miss
-    @cache.write('foo', 'bar')
-    @cache.expects(:read_entry).never
-    @cache.expects(:write_entry).with('foo', 'baz', force: true)
-    assert_equal 'baz', @cache.fetch('foo', force: true) { 'baz' }
-  end
+    it "fetch_without_cache_miss" do
+      @cache.write('foo', 'bar')
+      @cache.expects(:write_entry).never
+      assert_equal 'bar', @cache.fetch('foo') { 'baz' }
+    end
 
-  def test_fetch_with_cached_false
-    @cache.write('foo', false)
-    refute @cache.fetch('foo') { raise }
-  end
+    it "fetch_with_cache_miss" do
+      @cache.expects(:write_entry).with('foo', 'baz', nil)
+      assert_equal 'baz', @cache.fetch('foo') { 'baz' }
+    end
 
-  def test_fetch_with_raw_object
-    o = Object.new
-    o.instance_variable_set :@foo, 'bar'
-    assert_equal o, @cache.fetch('foo', raw: true) { o }
-  end
+    it "fetch_with_forced_cache_miss" do
+      @cache.write('foo', 'bar')
+      @cache.expects(:read_entry).never
+      @cache.expects(:write_entry).with('foo', 'baz', force: true)
+      assert_equal 'baz', @cache.fetch('foo', force: true) { 'baz' }
+    end
 
-  def test_fetch_with_cache_key
-    u = MockUser.new
-    @cache.write(u.cache_key, 'bar')
-    assert_equal 'bar', @cache.fetch(u) { raise }
-  end
+    it "fetch_with_cached_false" do
+      @cache.write('foo', false)
+      refute @cache.fetch('foo') { raise }
+    end
 
-  def test_should_read_and_write_strings
-    assert @cache.write('foo', 'bar')
-    assert_equal 'bar', @cache.read('foo')
-  end
+    it "fetch_with_raw_object" do
+      o = Object.new
+      o.instance_variable_set :@foo, 'bar'
+      assert_equal o, @cache.fetch('foo', raw: true) { o }
+    end
 
-  def test_should_read_and_write_hash
-    assert @cache.write('foo', { a: 'b' })
-    assert_equal({ a: 'b' }, @cache.read('foo'))
-  end
+    it "fetch_with_cache_key" do
+      u = MockUser.new
+      @cache.write(u.cache_key, 'bar')
+      assert_equal 'bar', @cache.fetch(u) { raise }
+    end
 
-  def test_should_read_and_write_integer
-    assert @cache.write('foo', 1)
-    assert_equal 1, @cache.read('foo')
-  end
+    it "should_read_and_write_strings" do
+      assert @cache.write('foo', 'bar')
+      assert_equal 'bar', @cache.read('foo')
+    end
 
-  def test_should_read_and_write_nil
-    assert @cache.write('foo', nil)
-    assert_equal nil, @cache.read('foo')
-  end
+    it "should_read_and_write_hash" do
+      assert @cache.write('foo', { a: 'b' })
+      assert_equal({ a: 'b' }, @cache.read('foo'))
+    end
 
-  def test_should_read_and_write_false
-    assert @cache.write('foo', false)
-    assert_equal false, @cache.read('foo')
-  end
+    it "should_read_and_write_integer" do
+      assert @cache.write('foo', 1)
+      assert_equal 1, @cache.read('foo')
+    end
 
-  def test_read_and_write_compressed_data
-    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1)
-    assert_equal 'bar', @cache.read('foo')
-  end
+    it "should_read_and_write_nil" do
+      assert @cache.write('foo', nil)
+      assert_equal nil, @cache.read('foo')
+    end
 
-  def test_write_should_overwrite
-    @cache.write('foo', 'bar')
-    @cache.write('foo', 'baz')
-    assert_equal 'baz', @cache.read('foo')
-  end
+    it "should_read_and_write_false" do
+      assert @cache.write('foo', false)
+      assert_equal false, @cache.read('foo')
+    end
 
-  def test_write_compressed_data
-    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1, :raw => true)
-    assert_equal Zlib::Deflate.deflate('bar'), @cache.instance_variable_get(:@cache).get('foo', false)
-  end
+    it "read_and_write_compressed_data" do
+      @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1)
+      assert_equal 'bar', @cache.read('foo')
+    end
 
-  def test_read_miss
-    assert_nil @cache.read('foo')
-  end
+    it "write_should_overwrite" do
+      @cache.write('foo', 'bar')
+      @cache.write('foo', 'baz')
+      assert_equal 'baz', @cache.read('foo')
+    end
 
-  def test_read_should_return_a_different_object_id_each_time_it_is_called
-    @cache.write('foo', 'bar')
-    refute_equal @cache.read('foo').object_id, @cache.read('foo').object_id
-  end
+    it "write_compressed_data" do
+      @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1, :raw => true)
+      assert_equal Zlib::Deflate.deflate('bar'), @cache.instance_variable_get(:@cache).get('foo', false)
+    end
 
-  def test_read_multi
-    @cache.write('foo', 'bar')
-    @cache.write('fu', 'baz')
-    @cache.write('fud', 'biz')
-    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
-  end
+    it "read_miss" do
+      assert_nil @cache.read('foo')
+    end
 
-  def test_read_multi_with_array
-    @cache.write('foo', 'bar')
-    @cache.write('fu', 'baz')
-    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi(['foo', 'fu']))
-  end
+    it "read_should_return_a_different_object_id_each_time_it_is_called" do
+      @cache.write('foo', 'bar')
+      refute_equal @cache.read('foo').object_id, @cache.read('foo').object_id
+    end
 
-  def test_read_multi_with_raw
-    @cache.write('foo', 'bar', :raw => true)
-    @cache.write('fu', 'baz', :raw => true)
-    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
-  end
+    it "read_multi" do
+      @cache.write('foo', 'bar')
+      @cache.write('fu', 'baz')
+      @cache.write('fud', 'biz')
+      assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+    end
 
-  def test_read_multi_with_compress
-    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1)
-    @cache.write('fu', 'baz', :compress => true, :compress_threshold => 1)
-    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
-  end
+    it "read_multi_with_array" do
+      @cache.write('foo', 'bar')
+      @cache.write('fu', 'baz')
+      assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi(['foo', 'fu']))
+    end
 
-  def test_cache_key
-    o = MockUser.new
-    @cache.write(o, 'bar')
-    assert_equal 'bar', @cache.read('foo')
-  end
+    it "read_multi_with_raw" do
+      @cache.write('foo', 'bar', :raw => true)
+      @cache.write('fu', 'baz', :raw => true)
+      assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+    end
 
-  def test_param_as_cache_key
-    obj = Object.new
-    def obj.to_param
-      'foo'
+    it "read_multi_with_compress" do
+      @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1)
+      @cache.write('fu', 'baz', :compress => true, :compress_threshold => 1)
+      assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
     end
-    @cache.write(obj, 'bar')
-    assert_equal 'bar', @cache.read('foo')
-  end
 
-  def test_array_as_cache_key
-    @cache.write([:fu, 'foo'], 'bar')
-    assert_equal 'bar', @cache.read('fu/foo')
-  end
+    it "cache_key" do
+      o = MockUser.new
+      @cache.write(o, 'bar')
+      assert_equal 'bar', @cache.read('foo')
+    end
 
-  def test_hash_as_cache_key
-    @cache.write({:foo => 1, :fu => 2}, 'bar')
-    assert_equal 'bar', @cache.read('foo=1/fu=2')
-  end
+    it "param_as_cache_key" do
+      obj = Object.new
+      def obj.to_param
+        'foo'
+      end
+      @cache.write(obj, 'bar')
+      assert_equal 'bar', @cache.read('foo')
+    end
 
-  def test_keys_are_case_sensitive
-    @cache.write('foo', 'bar')
-    assert_nil @cache.read('FOO')
-  end
+    it "array_as_cache_key" do
+      @cache.write([:fu, 'foo'], 'bar')
+      assert_equal 'bar', @cache.read('fu/foo')
+    end
 
-  def test_keys_with_spaces
-    assert_equal 'baz', @cache.fetch('foo bar') { 'baz' }
-  end
+    it "hash_as_cache_key" do
+      @cache.write({:foo => 1, :fu => 2}, 'bar')
+      assert_equal 'bar', @cache.read('foo=1/fu=2')
+    end
 
-  def test_exist
-    @cache.write('foo', 'bar')
-    assert @cache.exist?('foo')
-    refute @cache.exist?('bar')
-  end
+    it "keys_are_case_sensitive" do
+      @cache.write('foo', 'bar')
+      assert_nil @cache.read('FOO')
+    end
 
-  def test_delete
-    @cache.write('foo', 'bar')
-    assert @cache.exist?('foo')
-    assert @cache.delete('foo')
-    refute @cache.exist?('foo')
-  end
+    it "keys_with_spaces" do
+      assert_equal 'baz', @cache.fetch('foo bar') { 'baz' }
+    end
 
-  def test_delete_with_unexistent_key
-    @cache.expects(:log_error).never
-    refute @cache.exist?('foo')
-    refute @cache.delete('foo')
-  end
+    it "exist" do
+      @cache.write('foo', 'bar')
+      assert @cache.exist?('foo')
+      refute @cache.exist?('bar')
+    end
 
-  def test_store_objects_should_be_immutable
-    @cache.write('foo', 'bar')
-    @cache.read('foo').gsub!(/.*/, 'baz')
-    assert_equal 'bar', @cache.read('foo')
-  end
+    it "delete" do
+      @cache.write('foo', 'bar')
+      assert @cache.exist?('foo')
+      assert @cache.delete('foo')
+      refute @cache.exist?('foo')
+    end
 
-  def test_original_store_objects_should_not_be_immutable
-    bar = 'bar'
-    @cache.write('foo', bar)
-    assert_equal 'baz', bar.gsub!(/r/, 'z')
-  end
+    it "delete_with_unexistent_key" do
+      @cache.expects(:log_error).never
+      refute @cache.exist?('foo')
+      refute @cache.delete('foo')
+    end
 
-  def test_crazy_key_characters
-    crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
-    assert @cache.write(crazy_key, "1", :raw => true)
-    assert_equal "1", @cache.read(crazy_key)
-    assert_equal "1", @cache.fetch(crazy_key)
-    assert @cache.delete(crazy_key)
-    refute @cache.exist?(crazy_key)
-    assert_equal "2", @cache.fetch(crazy_key, :raw => true) { "2" }
-    assert_equal 3, @cache.increment(crazy_key)
-    assert_equal 2, @cache.decrement(crazy_key)
-  end
+    it "store_objects_should_be_immutable" do
+      @cache.write('foo', 'bar')
+      @cache.read('foo').gsub!(/.*/, 'baz')
+      assert_equal 'bar', @cache.read('foo')
+    end
 
-  def test_really_long_keys
-    key = "a" * 251
-    assert @cache.write(key, "bar")
-    assert_equal "bar", @cache.read(key)
-    assert_equal "bar", @cache.fetch(key)
-    assert_nil @cache.read("#{key}x")
-    assert_equal({key => "bar"}, @cache.read_multi(key))
-    assert @cache.delete(key)
-    refute @cache.exist?(key)
-    assert @cache.write(key, '2', :raw => true)
-    assert_equal 3, @cache.increment(key)
-    assert_equal 2, @cache.decrement(key)
-  end
+    it "original_store_objects_should_not_be_immutable" do
+      bar = 'bar'
+      @cache.write('foo', bar)
+      assert_equal 'baz', bar.gsub!(/r/, 'z')
+    end
 
-  def test_really_long_keys_with_namespace
-    @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, :expires_in => 60, :namespace => 'namespace')
-    @cache.silence!
-    test_really_long_keys
-  end
+    it "crazy_key_characters" do
+      crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
+      assert @cache.write(crazy_key, "1", :raw => true)
+      assert_equal "1", @cache.read(crazy_key)
+      assert_equal "1", @cache.fetch(crazy_key)
+      assert @cache.delete(crazy_key)
+      refute @cache.exist?(crazy_key)
+      assert_equal "2", @cache.fetch(crazy_key, :raw => true) { "2" }
+      assert_equal 3, @cache.increment(crazy_key)
+      assert_equal 2, @cache.decrement(crazy_key)
+    end
 
-  def test_clear
-    @cache.write("foo", "bar")
-    @cache.clear
-    assert_nil @cache.read("foo")
-  end
+    it "really_long_keys" do
+      really_long_keys_test
+    end
 
-  def test_clear_with_options
-    @cache.write("foo", "bar")
-    @cache.clear(:some_option => true)
-    assert_nil @cache.read("foo")
-  end
-end
+    it "really_long_keys_with_namespace" do
+      @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, :expires_in => 60, :namespace => 'namespace')
+      @cache.silence!
+      really_long_keys_test
+    end
 
-module CacheIncrementDecrementBehavior
-  def test_increment
-    @cache.write('foo', '1', :raw => true)
-    assert_equal 1, @cache.read('foo').to_i
-    assert_equal 2, @cache.increment('foo')
-    assert_equal 2, @cache.read('foo').to_i
-    assert_equal 3, @cache.increment('foo')
-    assert_equal 3, @cache.read('foo').to_i
-  end
+    it "clear" do
+      @cache.write("foo", "bar")
+      @cache.clear
+      assert_nil @cache.read("foo")
+    end
 
-  def test_decrement
-    @cache.write('foo', '3', :raw => true)
-    assert_equal 3, @cache.read('foo').to_i
-    assert_equal 2, @cache.decrement('foo')
-    assert_equal 2, @cache.read('foo').to_i
-    assert_equal 1, @cache.decrement('foo')
-    assert_equal 1, @cache.read('foo').to_i
+    it "clear_with_options" do
+      @cache.write("foo", "bar")
+      @cache.clear(:some_option => true)
+      assert_nil @cache.read("foo")
+    end
   end
 
-  def test_increment_decrement_non_existing_keys
-    @cache.expects(:log_error).never
-    assert_nil @cache.increment('foo')
-    assert_nil @cache.decrement('bar')
-  end
-end
+  describe "compression" do
+    it "read_and_write_compressed_small_data" do
+      @cache.write('foo', 'bar', :compress => true)
+      raw_value = @cache.send(:read_entry, 'foo', {})
+      assert_equal 'bar', @cache.read('foo')
+      value = Marshal.load(raw_value) rescue raw_value
+      assert_equal 'bar', value
+    end
 
-module CacheCompressBehavior
-  def test_read_and_write_compressed_small_data
-    @cache.write('foo', 'bar', :compress => true)
-    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
-    assert_equal 'bar', @cache.read('foo')
-    value = Marshal.load(raw_value) rescue raw_value
-    assert_equal 'bar', value
+    it "read_and_write_compressed_large_data" do
+      @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
+      raw_value = @cache.send(:read_entry, 'foo', :raw => true)
+      assert_equal 'bar', @cache.read('foo')
+      assert_equal 'bar', Marshal.load(raw_value)
+    end
   end
 
-  def test_read_and_write_compressed_large_data
-    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
-    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
-    assert_equal 'bar', @cache.read('foo')
-    assert_equal 'bar', Marshal.load(Zlib::Inflate.inflate(raw_value))
-  end
-end
+  describe "increment / decrement" do
+    it "increment" do
+      @cache.write('foo', '1', :raw => true)
+      assert_equal 1, @cache.read('foo').to_i
+      assert_equal 2, @cache.increment('foo')
+      assert_equal 2, @cache.read('foo').to_i
+      assert_equal 3, @cache.increment('foo')
+      assert_equal 3, @cache.read('foo').to_i
+    end
 
-class LibmemcachedStoreTest < MiniTest::Unit::TestCase
-  include CacheStoreBehavior
-  include CacheIncrementDecrementBehavior
+    it "decrement" do
+      @cache.write('foo', '3', :raw => true)
+      assert_equal 3, @cache.read('foo').to_i
+      assert_equal 2, @cache.decrement('foo')
+      assert_equal 2, @cache.read('foo').to_i
+      assert_equal 1, @cache.decrement('foo')
+      assert_equal 1, @cache.read('foo').to_i
+    end
 
-  def setup
-    @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, expires_in: 60)
-    @cache.clear
-    @cache.silence!
+    it "increment_decrement_non_existing_keys" do
+      @cache.expects(:log_error).never
+      assert_nil @cache.increment('foo')
+      assert_nil @cache.decrement('bar')
+    end
   end
 
-  def test_should_identify_cache_store
+  it "should_identify_cache_store" do
     assert_kind_of ActiveSupport::Cache::LibmemcachedStore, @cache
   end
 
-  def test_should_set_server_addresses_to_nil_if_none_are_given
+  it "should_set_server_addresses_to_nil_if_none_are_given" do
     assert_equal [], @cache.addresses
   end
 
-  def test_should_set_custom_server_addresses
+  it "should_set_custom_server_addresses" do
     store = ActiveSupport::Cache.lookup_store :libmemcached_store, 'localhost', '192.168.1.1'
     assert_equal %w(localhost 192.168.1.1), store.addresses
   end
 
-  def test_should_enable_consistent_ketema_hashing_by_default
+  it "should_enable_consistent_ketema_hashing_by_default" do
     assert_equal :consistent_ketama, @cache.client_options[:distribution]
   end
 
-  def test_should_not_enable_non_blocking_io_by_default
+  it "should_not_enable_non_blocking_io_by_default" do
     assert_equal false, @cache.client_options[:no_block]
   end
 
-  def test_should_not_enable_server_failover_by_default
+  it "should_not_enable_server_failover_by_default" do
     assert_nil @cache.client_options[:failover]
   end
 
-  def test_should_allow_configuration_of_custom_options
+  it "should_allow_configuration_of_custom_options" do
     options = { client: { tcp_nodelay: true, distribution: :modula } }
 
     store = ActiveSupport::Cache.lookup_store :libmemcached_store, 'localhost', options
@@ -328,7 +329,7 @@ class LibmemcachedStoreTest < MiniTest::Unit::TestCase
     assert_equal true, store.client_options[:tcp_nodelay]
   end
 
-  def test_should_allow_mute_and_silence
+  it "should_allow_mute_and_silence" do
     cache = ActiveSupport::Cache.lookup_store :libmemcached_store, 'localhost'
     cache.mute do
       assert cache.write('foo', 'bar')
@@ -338,4 +339,50 @@ class LibmemcachedStoreTest < MiniTest::Unit::TestCase
     cache.silence!
     assert cache.silence?
   end
+
+  describe "#fetch with :race_condition_ttl" do
+    let(:options) { {:expires_in => 1, :race_condition_ttl => 5} }
+
+    def fetch(&block)
+      @cache.fetch("unknown", options, &block)
+    end
+
+    after do
+      Thread.list.each { |t| t.exit unless t == Thread.current }
+    end
+
+    it "works like a normal fetch" do
+      fetch { 1 }.must_equal 1
+    end
+
+    it "keeps a cached value even if the cache expires" do
+      fetch { 1 } # fill it
+
+      future = Time.now + 3 * 60
+      Time.stubs(:now).returns future
+
+      Thread.new do
+        sleep 0.1
+        fetch { raise }.must_equal 1 # 3rd fetch -> read expired value
+      end
+      fetch { sleep 0.2; 2 }.must_equal 2 # 2nd fetch -> takes time to generate but returns correct value
+      fetch { 3 }.must_equal 2 # 4th fetch still correct value
+    end
+
+    it "can be read by a normal read" do
+      fetch { 1 }
+      @cache.read("unknown").must_equal 1
+    end
+
+    it "can be read by a normal fetch" do
+      fetch { 1 }
+      @cache.fetch("unknown") { 2 }.must_equal 1
+    end
+
+    it "can write to things that get fetched" do
+      fetch { 1 }
+      @cache.write "unknown", 2
+      fetch { 1 }.must_equal 2
+    end
+  end
 end

data/test/test_helper.rb

@@ -1,5 +1,6 @@
 ENV["RAILS_ENV"] = "test"
-$:.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
 require 'minitest/autorun'
-require 'mocha/setup'
+require 'minitest/spec'
+require 'mocha/setup'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libmemcached_store
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-11 00:00:00.000000000 Z
+date: 2013-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: memcached
@@ -77,6 +77,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.7'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -129,6 +145,7 @@ files:
 - gemfiles/rails30.gemfile
 - gemfiles/rails31.gemfile
 - gemfiles/rails32.gemfile
+- gemfiles/rails40.gemfile
 - lib/action_dispatch/session/libmemcached_store.rb
 - lib/active_support/cache/libmemcached_store.rb
 - lib/libmemcached_store.rb