spymemcached_store 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 594001153c291de7b7060e24e9bb9ee0a84f00a7
+  data.tar.gz: fe9f4e4d15186eaa6d25aef478330d81ccc62542
+SHA512:
+  metadata.gz: 6288b45b59a236d638c1b3102caf9ebfbfa6b230eadc61a8ab958b0715a1722bfff6252081bb19002d247eb3d9a0dd2f087a8d2fd0f0ea52ce85a40d6e626029
+  data.tar.gz: cf5fc673f81471b351d697fd286349c1a4c3cbaf605cf63296f4eb65e76b22fe2f7593b4c9a267dd68b7c7b403192f3270f48cd75ceeb9d7c0519f3271fac564

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.ruby-version

@@ -0,0 +1 @@
+jruby-1.7.16

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spymemcached_store.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Xiao Li swing1979@gmail.com
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# SpymemcachedStore
+
+This is Rails 4 compatible cache store for [spymemcached.jruby](https://github.com/ThoughtWorksStudios/spymemcached.jruby)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'spymemcached_store'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spymemcached_store
+
+## Usage
+
+    ActiveSupport::Cache.lookup_store(:spymemcached_store, :expires_in => 60, :namespace => 'app-namespace')
+
+Supports all Rails cache store options, see [spymemcached.jruby](https://github.com/ThoughtWorksStudios/spymemcached.jruby) for additional options.
+
+It is not recommended to use :compress and :compress_threshold options, as spymemcached.jruby does it by default.
+
+## Contributing
+
+1. Fork it ( https://github.com/ThoughtWorksStudios/spymemcached_store/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/*_test.rb']
+  t.warning = true
+  t.verbose = false
+end
+
+task :default => [:test]

data/lib/active_support/cache/spymemcached_store.rb

@@ -0,0 +1,166 @@
+require 'active_support/cache'
+require 'spymemcached'
+
+module ActiveSupport
+  module Cache
+    class SpymemcachedStore < ActiveSupport::Cache::Store
+
+      # namespace
+      def initialize(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        super(options)
+
+        unless [String, Spymemcached, NilClass].include?(addresses.first.class)
+          raise ArgumentError, "First argument must be an empty array, an array of hosts or a Spymemcached instance."
+        end
+        @client = if addresses.first.is_a?(Spymemcached)
+          addresses.first
+        else
+          mem_cache_options = options.dup
+          UNIVERSAL_OPTIONS.each{|name| mem_cache_options.delete(name)}
+          Spymemcached.new(addresses, mem_cache_options)
+        end
+
+        extend Strategy::LocalCache
+        extend LocalCacheWithRaw
+      end
+
+      # Read multiple values at once from the cache. Options can be passed
+      # in the last argument.
+      #
+      # Some cache implementation may optimize this method.
+      #
+      # Returns a hash mapping the names provided to the values found.
+      def read_multi(*names)
+        options = names.extract_options!
+        options = merged_options(options)
+        keys_to_names = Hash[names.map{|name| [namespaced_key(name, options), name]}]
+        raw_values = @client.get_multi(keys_to_names.keys)
+        values = {}
+        raw_values.each do |key, value|
+          entry = deserialize_entry(value)
+          values[keys_to_names[key]] = entry.value unless entry.expired?
+        end
+        values
+      end
+
+      # Increment an integer value in the cache.
+      #
+      # Options are passed to the underlying cache implementation.
+      #
+      # All implementations may not support this method.
+      def increment(name, amount = 1, options = nil)
+        options = merged_options(options)
+
+        instrument(:increment, name, :amount => amount) do
+          @client.incr(name, amount)
+        end
+      rescue Spymemcached::Error => e
+        logger.error("Spymemcached::Error (#{e}): #{e.message}") if logger
+        nil
+      end
+
+      # Decrement an integer value in the cache.
+      #
+      # Options are passed to the underlying cache implementation.
+      #
+      # All implementations may not support this method.
+      def decrement(name, amount = 1, options = nil)
+        options = merged_options(options)
+
+        instrument(:decrement, name, :amount => amount) do
+          @client.decr(name, amount)
+        end
+      rescue Spymemcached::Error => e
+        logger.error("Spymemcached::Error (#{e}): #{e.message}") if logger
+        nil
+      end
+
+      # Clear the entire cache. Be careful with this method since it could
+      # affect other processes if shared cache is being used.
+      #
+      # The options hash is passed to the underlying cache implementation.
+      #
+      # All implementations may not support this method.
+      def clear(options = nil)
+        @client.flush_all
+      rescue Spymemcached::Error => e
+        logger.error("Spymemcached::Error (#{e}): #{e.message}") if logger
+        nil
+      end
+
+      # Get the statistics from the memcached servers.
+      def stats
+        @client.stats
+      end
+
+      protected
+      # Read an entry from the cache implementation. Subclasses must implement
+      # this method.
+      def read_entry(key, options) # :nodoc:
+        deserialize_entry(@client.get(key))
+      rescue Spymemcached::Error => e
+        logger.error("Spymemcached::Error (#{e}): #{e.message}") if logger
+        nil
+      end
+
+      # Write an entry to the cache implementation. Subclasses must implement
+      # this method.
+      def write_entry(key, entry, options) # :nodoc:
+        method = options && options[:unless_exist] ? :add : :set
+        value = options[:raw] ? entry.value.to_s : entry
+        expires_in = options[:expires_in].to_i
+        if expires_in > 0 && !options[:raw]
+          # Set the memcache expire a few minutes in the future to support race condition ttls on read
+          expires_in += 5.minutes
+        end
+        @client.send(method, key, value, expires_in)
+      rescue Spymemcached::Error => e
+        logger.error("Spymemcached::Error (#{e}): #{e.message}") if logger
+        false
+      end
+
+      # Delete an entry from the cache implementation. Subclasses must
+      # implement this method.
+      def delete_entry(key, options) # :nodoc:
+        @client.delete(key)
+      rescue Spymemcached::Error => e
+        logger.error("Spymemcached::Error (#{e}): #{e.message}") if logger
+        false
+      end
+
+      protected
+      def deserialize_entry(raw_value)
+        if raw_value
+          entry = Marshal.load(raw_value) rescue raw_value
+          entry.is_a?(Entry) ? entry : Entry.new(entry)
+        else
+          nil
+        end
+      end
+
+      # Provide support for raw values in the local cache strategy.
+      module LocalCacheWithRaw # :nodoc:
+        protected
+        def read_entry(key, options)
+          entry = super
+          if options[:raw] && local_cache && entry
+             entry = deserialize_entry(entry.value)
+          end
+          entry
+        end
+
+        def write_entry(key, entry, options) # :nodoc:
+          retval = super
+          if options[:raw] && local_cache && retval
+            raw_entry = Entry.new(entry.value.to_s)
+            raw_entry.expires_at = entry.expires_at
+            local_cache.write_entry(key, raw_entry, options)
+          end
+          retval
+        end
+      end
+    end
+  end
+end

data/lib/spymemcached_store.rb

@@ -0,0 +1,5 @@
+require "spymemcached_store/version"
+
+module SpymemcachedStore
+  # Your code goes here...
+end

data/lib/spymemcached_store/version.rb

@@ -0,0 +1,3 @@
+module SpymemcachedStore
+  VERSION = "1.0.0"
+end

data/spymemcached_store.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'spymemcached_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "spymemcached_store"
+  spec.version       = SpymemcachedStore::VERSION
+  spec.authors       = ["Xiao Li"]
+  spec.email         = ["swing1979@gmail.com"]
+  spec.summary       = %q{Rails 3 & 4 cache store for spymemcached.jruby.}
+  spec.description   = %q{Rails 3 & 4 cache store for spymemcached.jruby.}
+  spec.homepage      = "https://github.com/ThoughtWorksStudios/spymemcached_store"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "spymemcached.jruby"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rack"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "activesupport"
+  spec.add_development_dependency 'minitest', '~> 5.1'
+
+end

data/test/autoloading_cache_behavior.rb

@@ -0,0 +1,50 @@
+require 'dependencies_test_helpers'
+
+module AutoloadingCacheBehavior
+  class E
+  end
+  class ClassFolder
+    class NestedClass
+    end
+
+    class SiblingClass
+    end
+  end
+
+  include DependenciesTestHelpers
+  def test_simple_autoloading
+    with_autoloading_fixtures do
+      @cache.write('foo', E.new)
+    end
+
+    remove_constants(:E)
+    ActiveSupport::Dependencies.clear
+
+    with_autoloading_fixtures do
+      assert_kind_of E, @cache.read('foo')
+    end
+
+    remove_constants(:E)
+    ActiveSupport::Dependencies.clear
+  end
+
+  def test_two_classes_autoloading
+    with_autoloading_fixtures do
+      @cache.write('foo', [E.new, ClassFolder.new])
+    end
+
+    remove_constants(:E, :ClassFolder)
+    ActiveSupport::Dependencies.clear
+
+    with_autoloading_fixtures do
+      loaded = @cache.read('foo')
+      assert_kind_of Array, loaded
+      assert_equal 2, loaded.size
+      assert_kind_of E, loaded[0]
+      assert_kind_of ClassFolder, loaded[1]
+    end
+
+    remove_constants(:E, :ClassFolder)
+    ActiveSupport::Dependencies.clear
+  end
+end

data/test/cache_increment_decrement_behavior.rb

@@ -0,0 +1,24 @@
+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
+    # spymemcached will set zero as default value
+    assert_equal 0, @cache.increment('bar')
+  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
+
+    # spymemcached will set zero as default value
+    assert_equal 0, @cache.decrement('bar')
+  end
+end

data/test/cache_store_behavior.rb

@@ -0,0 +1,248 @@
+module CacheStoreBehavior
+  def test_should_read_and_write_strings
+    assert @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_should_overwrite
+    @cache.write('foo', 'bar')
+    @cache.write('foo', 'baz')
+    assert_equal 'baz', @cache.read('foo')
+  end
+
+  def test_fetch_without_cache_miss
+    @cache.write('foo', 'bar')
+    @cache.expects(:write).never
+    assert_equal 'bar', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_cache_miss
+    @cache.expects(:write).with('foo', 'baz', @cache.options)
+    assert_equal 'baz', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_cache_miss_passes_key_to_block
+    cache_miss = false
+    assert_equal 3, @cache.fetch('foo') { |key| cache_miss = true; key.length }
+    assert cache_miss
+
+    cache_miss = false
+    assert_equal 3, @cache.fetch('foo') { |key| cache_miss = true; key.length }
+    assert !cache_miss
+  end
+
+  def test_fetch_with_forced_cache_miss
+    @cache.write('foo', 'bar')
+    @cache.expects(:read).never
+    @cache.expects(:write).with('foo', 'bar', @cache.options.merge(:force => true))
+    @cache.fetch('foo', :force => true) { 'bar' }
+  end
+
+  def test_fetch_with_cached_nil
+    @cache.write('foo', nil)
+    @cache.expects(:write).never
+    assert_nil @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_should_read_and_write_hash
+    assert @cache.write('foo', {:a => "b"})
+    assert_equal({:a => "b"}, @cache.read('foo'))
+  end
+
+  def test_should_read_and_write_integer
+    assert @cache.write('foo', 1)
+    assert_equal 1, @cache.read('foo')
+  end
+
+  def test_should_read_and_write_nil
+    assert @cache.write('foo', nil)
+    assert_equal nil, @cache.read('foo')
+  end
+
+  def test_should_read_and_write_false
+    assert @cache.write('foo', false)
+    assert_equal false, @cache.read('foo')
+  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
+
+  def test_read_multi_with_expires
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 10)
+    @cache.write('fu', 'baz')
+    @cache.write('fud', 'biz')
+    Time.stubs(:now).returns(time + 11)
+    assert_equal({"fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  def test_fetch_multi
+    @cache.write('foo', 'bar')
+    @cache.write('fud', 'biz')
+
+    values = @cache.fetch_multi('foo', 'fu', 'fud') {|value| value * 2 }
+
+    assert_equal(["bar", "fufu", "biz"], values)
+    assert_equal("fufu", @cache.read('fu'))
+  end
+
+  def test_multi_with_objects
+    foo = stub(:title => "FOO!", :cache_key => "foo")
+    bar = stub(:cache_key => "bar")
+
+    @cache.write('bar', "BAM!")
+
+    values = @cache.fetch_multi(foo, bar) {|object| object.title }
+    assert_equal(["FOO!", "BAM!"], values)
+  end
+
+  def test_read_and_write_compressed_small_data
+    @cache.write('foo', 'bar', :compress => true)
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_read_and_write_compressed_large_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_read_and_write_compressed_nil
+    @cache.write('foo', nil, :compress => true)
+    assert_nil @cache.read('foo')
+  end
+
+  def test_cache_key
+    obj = Object.new
+    def obj.cache_key
+      :foo
+    end
+    @cache.write(obj, "bar")
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_param_as_cache_key
+    obj = Object.new
+    def obj.to_param
+      "foo"
+    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
+
+  def test_hash_as_cache_key
+    @cache.write({:foo => 1, :fu => 2}, "bar")
+    assert_equal "bar", @cache.read("foo=1/fu=2")
+  end
+
+  def test_keys_are_case_sensitive
+    @cache.write("foo", "bar")
+    assert_nil @cache.read("FOO")
+  end
+
+  def test_exist
+    @cache.write('foo', 'bar')
+    assert_equal true, @cache.exist?('foo')
+    assert_equal false, @cache.exist?('bar')
+  end
+
+  def test_nil_exist
+    @cache.write('foo', nil)
+    assert @cache.exist?('foo')
+  end
+
+  def test_delete
+    @cache.write('foo', 'bar')
+    assert @cache.exist?('foo')
+    assert @cache.delete('foo')
+    assert !@cache.exist?('foo')
+  end
+
+  def test_original_store_objects_should_not_be_immutable
+    bar = 'bar'
+    @cache.write('foo', bar)
+    assert_nothing_raised { bar.gsub!(/.*/, 'baz') }
+  end
+
+  def test_expires_in
+    time = Time.local(2008, 4, 24)
+    Time.stubs(:now).returns(time)
+
+    @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+
+    Time.stubs(:now).returns(time + 30)
+    assert_equal 'bar', @cache.read('foo')
+
+    Time.stubs(:now).returns(time + 61)
+    assert_nil @cache.read('foo')
+  end
+
+  def test_race_condition_protection
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 61)
+    result = @cache.fetch('foo', :race_condition_ttl => 10) do
+      assert_equal 'bar', @cache.read('foo')
+      "baz"
+    end
+    assert_equal "baz", result
+  end
+
+  def test_race_condition_protection_is_limited
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 71)
+    result = @cache.fetch('foo', :race_condition_ttl => 10) do
+      assert_equal nil, @cache.read('foo')
+      "baz"
+    end
+    assert_equal "baz", result
+  end
+
+  def test_race_condition_protection_is_safe
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 61)
+    begin
+      @cache.fetch('foo', :race_condition_ttl => 10) do
+        assert_equal 'bar', @cache.read('foo')
+        raise ArgumentError.new
+      end
+    rescue ArgumentError
+    end
+    assert_equal "bar", @cache.read('foo')
+    Time.stubs(:now).returns(time + 91)
+    assert_nil @cache.read('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)
+    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_really_long_keys
+    key = ""
+    900.times{key << "x"}
+    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)
+  end
+end

data/test/dependencies_test_helpers.rb

@@ -0,0 +1,28 @@
+module DependenciesTestHelpers
+  def with_loading(*from)
+    old_mechanism, ActiveSupport::Dependencies.mechanism = ActiveSupport::Dependencies.mechanism, :load
+    this_dir = File.dirname(__FILE__)
+    parent_dir = File.dirname(this_dir)
+    path_copy = $LOAD_PATH.dup
+    $LOAD_PATH.unshift(parent_dir) unless $LOAD_PATH.include?(parent_dir)
+    prior_autoload_paths = ActiveSupport::Dependencies.autoload_paths
+    ActiveSupport::Dependencies.autoload_paths = from.collect { |f| "#{this_dir}/#{f}" }
+    yield
+  ensure
+    $LOAD_PATH.replace(path_copy)
+    ActiveSupport::Dependencies.autoload_paths = prior_autoload_paths
+    ActiveSupport::Dependencies.mechanism = old_mechanism
+    ActiveSupport::Dependencies.explicitly_unloadable_constants = []
+    ActiveSupport::Dependencies.clear
+  end
+
+  def with_autoloading_fixtures(&block)
+    with_loading 'autoloading_fixtures', &block
+  end
+
+  def remove_constants(*constants)
+    constants.each do |constant|
+      Object.send(:remove_const, constant) if Object.const_defined?(constant)
+    end
+  end
+end

data/test/encoded_key_cache_behavior.rb

@@ -0,0 +1,34 @@
+# https://rails.lighthouseapp.com/projects/8994/tickets/6225-memcachestore-cant-deal-with-umlauts-and-special-characters
+# The error is caused by character encodings that can't be compared with ASCII-8BIT regular expressions and by special
+# characters like the umlaut in UTF-8.
+module EncodedKeyCacheBehavior
+  Encoding.list.each do |encoding|
+    define_method "test_#{encoding.name.underscore}_encoded_values" do
+      key = "foo".force_encoding(encoding)
+      assert @cache.write(key, "1", :raw => true)
+      assert_equal "1", @cache.read(key)
+      assert_equal "1", @cache.fetch(key)
+      assert @cache.delete(key)
+      assert_equal "2", @cache.fetch(key, :raw => true) { "2" }
+      assert_equal 3, @cache.increment(key)
+      assert_equal 2, @cache.decrement(key)
+    end
+  end
+
+  def test_common_utf8_values
+    key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
+    assert @cache.write(key, "1", :raw => true)
+    assert_equal "1", @cache.read(key)
+    assert_equal "1", @cache.fetch(key)
+    assert @cache.delete(key)
+    assert_equal "2", @cache.fetch(key, :raw => true) { "2" }
+    assert_equal 3, @cache.increment(key)
+    assert_equal 2, @cache.decrement(key)
+  end
+
+  def test_retains_encoding
+    key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
+    assert @cache.write(key, "1", :raw => true)
+    assert_equal Encoding::UTF_8, key.encoding
+  end
+end

data/test/local_cache_behavior.rb

@@ -0,0 +1,88 @@
+module LocalCacheBehavior
+  def test_local_writes_are_persistent_on_the_remote_cache
+    retval = @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+    end
+    assert retval
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_clear_also_clears_local_cache
+    @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+      @cache.clear
+      assert_nil @cache.read('foo')
+    end
+
+    assert_nil @cache.read('foo')
+  end
+
+  def test_local_cache_of_write
+    @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+      @peek.delete('foo')
+      assert_equal 'bar', @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_read
+    @cache.write('foo', 'bar')
+    @cache.with_local_cache do
+      assert_equal 'bar', @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_write_nil
+    @cache.with_local_cache do
+      assert @cache.write('foo', nil)
+      assert_nil @cache.read('foo')
+      @peek.write('foo', 'bar')
+      assert_nil @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_delete
+    @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+      @cache.delete('foo')
+      assert_nil @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_exist
+    @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+      @peek.delete('foo')
+      assert @cache.exist?('foo')
+    end
+  end
+
+  def test_local_cache_of_increment
+    @cache.with_local_cache do
+      @cache.write('foo', 1, :raw => true)
+      @peek.write('foo', 2, :raw => true)
+      @cache.increment('foo')
+      assert_equal 3, @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_decrement
+    @cache.with_local_cache do
+      @cache.write('foo', 1, :raw => true)
+      @peek.write('foo', 3, :raw => true)
+      @cache.decrement('foo')
+      assert_equal 2, @cache.read('foo')
+    end
+  end
+
+  def test_middleware
+    app = lambda { |env|
+      result = @cache.write('foo', 'bar')
+      assert_equal 'bar', @cache.read('foo') # make sure 'foo' was written
+      assert result
+      [200, {}, []]
+    }
+    app = @cache.middleware.new(app)
+    app.call({})
+  end
+end

data/test/spymemcached_store_test.rb

@@ -0,0 +1,90 @@
+gem 'minitest' # make sure we get the gem, not stdlib
+require 'minitest'
+require "minitest/autorun"
+
+require 'active_support'
+require 'active_support/inflector'
+require 'mocha/setup' # FIXME: stop using mocha
+
+require 'cache_store_behavior'
+require 'local_cache_behavior'
+require 'cache_increment_decrement_behavior'
+require 'encoded_key_cache_behavior'
+require 'autoloading_cache_behavior'
+
+class SpymemcachedStoreTest < ::Minitest::Test
+
+  def setup
+    @cache = @@cache ||= ActiveSupport::Cache.lookup_store(:spymemcached_store, :expires_in => 60)
+    @peek = @@peek ||= ActiveSupport::Cache.lookup_store(:spymemcached_store)
+    @data = @cache.instance_variable_get(:@client)
+    @cache.clear
+    @cache.silence!
+    @cache.logger = ActiveSupport::Logger.new("/dev/null")
+  end
+
+  include CacheStoreBehavior
+  include LocalCacheBehavior
+  include CacheIncrementDecrementBehavior
+  include EncodedKeyCacheBehavior
+  include AutoloadingCacheBehavior
+
+  def test_raw_values
+    cache = @peek
+    cache.write("foo", 2)
+    #spymemcached returns right type
+    assert_equal 2, cache.read("foo")
+  end
+
+  def test_raw_values_with_marshal
+    cache = ActiveSupport::Cache.lookup_store(:spymemcached_store, :raw => true)
+    cache.clear
+    cache.write("foo", Marshal.dump([]))
+    assert_equal [], cache.read("foo")
+  end
+
+  def test_local_cache_raw_values
+    cache = ActiveSupport::Cache.lookup_store(:spymemcached_store, :raw => true)
+    cache.clear
+    cache.with_local_cache do
+      cache.write("foo", '2')
+      assert_equal "2", cache.read("foo")
+    end
+  end
+
+  def test_local_cache_raw_values_with_marshal
+    cache = ActiveSupport::Cache.lookup_store(:spymemcached_store, :raw => true)
+    cache.clear
+    cache.with_local_cache do
+      cache.write("foo", Marshal.dump([]))
+      assert_equal [], cache.read("foo")
+    end
+  end
+
+  def test_read_should_return_a_different_object_id_each_time_it_is_called
+    cache = ActiveSupport::Cache.lookup_store(:spymemcached_store, :raw => true)
+    cache.write('foo', 'bar')
+    value = cache.read('foo')
+    assert_not_equal value.object_id, cache.read('foo').object_id
+    value << 'bingo'
+    assert_not_equal value, cache.read('foo')
+  end
+
+  def test_namespace
+    cache = ActiveSupport::Cache.lookup_store(:spymemcached_store, :namespace => "abc")
+    cache.write('foo', 'bar')
+    assert_equal 'bar', cache.read('foo')
+    assert_nil @cache.read('foo')
+    assert_equal 'bar', @cache.read('abc:foo')
+  end
+
+  def assert_not_equal(expected, result)
+    assert expected != result, "expect #{expected.inspect} not equal #{result.inspect}"
+  end
+
+  def assert_nothing_raised(&block)
+    block.call
+  rescue => e
+    fail("expected nothing raised, but caught #{e.class}: #{e.message}")
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: spymemcached_store
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Xiao Li
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-11-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: spymemcached.jruby
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rack
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: mocha
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: minitest
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  prerelease: false
+  type: :development
+description: Rails 3 & 4 cache store for spymemcached.jruby.
+email:
+- swing1979@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/active_support/cache/spymemcached_store.rb
+- lib/spymemcached_store.rb
+- lib/spymemcached_store/version.rb
+- spymemcached_store.gemspec
+- test/autoloading_cache_behavior.rb
+- test/cache_increment_decrement_behavior.rb
+- test/cache_store_behavior.rb
+- test/dependencies_test_helpers.rb
+- test/encoded_key_cache_behavior.rb
+- test/local_cache_behavior.rb
+- test/spymemcached_store_test.rb
+homepage: https://github.com/ThoughtWorksStudios/spymemcached_store
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: Rails 3 & 4 cache store for spymemcached.jruby.
+test_files:
+- test/autoloading_cache_behavior.rb
+- test/cache_increment_decrement_behavior.rb
+- test/cache_store_behavior.rb
+- test/dependencies_test_helpers.rb
+- test/encoded_key_cache_behavior.rb
+- test/local_cache_behavior.rb
+- test/spymemcached_store_test.rb