mongo_cache_store 0.2.3 → 0.2.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 00920d89d10ee3956b56d6de55b5bdd9c93a54db
+  data.tar.gz: 09a537ab5771d079419f9a4506a65001e0a125e6
+SHA512:
+  metadata.gz: 58456d15add616876bfd56b98e42a129379412799f8b6576e2a40c51a7e7f1860a8e16f34b8106a0f2c034ed9270ba25da11e0e9b9be2f78ceafcb88d8ae936a
+  data.tar.gz: 889281aeedcbfab621b5811e3141bef5e5ae877b6b7a71aca26de07a7ce4eac3d2fc973f7d8e8cb17dce32dd6afa09c41249d93f04099eafaa10a98be7b9b175

data/README.rdoc

@@ -56,6 +56,25 @@ configured or used.
         Useful for write conditions and read preferences
 
 
+== Increment / Decrement
+
+Increment and decrement values must be an Integer.  In the ActiveSupport test
+suite strings and integers are used interchangeably.  This cache store however
+uses MongoDB's $inc operator which must, be an integer.  
+
+
+== Keys can be a Hash
+
+The following test from ActiveSupport fails with MongoCacheStore:
+
+    def test_hash_as_cache_key
+      @cache.write({:foo => 1, :fu => 2}, "bar")
+      assert_equal "bar", @cache.read("foo=1/fu=2")
+    end
+
+This is because a key can be a true Hash.  It will not be converted to a string.
+
+
 == Backends
 
 == TTL
@@ -67,7 +86,7 @@ TTL backend for MongoCacheStore
 Entries are kept in a namespaced TTL collection that will 
 automatically flush any entries as they pass their expiration 
 time. This keeps the size of the cache in check over time. 
-<b>Requires MongoDB 2.0 or higher</b>
+<b>Requires MongoDB 2.2 or higher</b>
 
 === Additional Options
 

data/lib/active_support/cache/mongo_cache_store.rb

@@ -81,7 +81,7 @@ module ActiveSupport
         when defined?(Rails) && Rails.logger
           @logger = Rails.logger
         else
-          #@logger = Logger.new(STDOUT)
+          @logger = Logger.new(STDOUT)
         end
       
         @logger

data/lib/active_support/cache/mongo_cache_store/backend/base.rb

@@ -7,15 +7,70 @@ module ActiveSupport
         # Base methods used by all MongoCacheStore backends 
         module Base 
 
-          # No public methods are defined for this module
+
+          def increment(name, amount = 1, options = {})
+            write_counter(name,amount.to_i,options)
+          end
+
+          def decrement(name, amount = 1, options = {})
+            write_counter(name,amount.to_i*-1,options)
+          end
+
+          def read_multi(*names)
+            options = names.extract_options!
+            options = merged_options(options)
+            results = {}
+             
+            col = get_collection(options)
+
+            key_map = names.inject({}) do |h, name|
+              h[namespaced_key(name,options)] = name
+              h
+            end
+
+            safe_rescue do 
+              query = {
+                :_id => { '$in' => key_map.keys},
+                :expires_at => {
+                  '$gt' => Time.now 
+                }
+              }
+
+              col.find(query) do |cursor|
+                cursor.each do |r| 
+                  results[key_map[r['_id']]] = inflate_entry(r).value
+                  puts results.inspect
+                end
+              end
+            end
+
+            results
+          end
 
           private 
 
-            def expand_key(key)
-              return key 
+            def expanded_key(key)
+              return key.cache_key.to_s if key.respond_to?(:cache_key)
+
+              case key
+              when Array
+                if key.size > 1
+                  key = key.collect{|element| expanded_key(element)}
+                else
+                  key = key.first
+                end
+              when Hash
+                return key 
+              end
+
+              key.to_param
             end
 
             def namespaced_key(key, options)
+              key = expanded_key(key)
+              key = key.join('/') if key.is_a?(Array)
+              key = key.cache_key if key.methods.include?(:cache_key)
+
               return key 
             end
 
@@ -31,25 +86,62 @@ module ActiveSupport
                 }
 
                 response = col.find_one(query)
-                return nil if response.nil?
+                return inflate_entry(response)
+              end
+              nil
+            end
+
+
+            def inflate_entry(from_mongo)
+                return nil if from_mongo.nil?
 
                 entry_options = {
-                  :compressed => response[:compressed],
-                  :expires_in => response[:expires_in] 
+                  :compressed => from_mongo['compressed'],
+                  :expires_in => from_mongo['expires_in'] 
                 }
-                if response['serialized']
-                  r_value = response['value'].to_s
+                if from_mongo['serialized']
+                  r_value = from_mongo['value'].to_s
                 else
-                  r_value = Marshal.dump(response['value'])
+                  r_value = Marshal.dump(from_mongo['value'])
                 end
-                ActiveSupport::Cache::Entry.create(r_value,response[:created_at],entry_options)
-              end
+                ActiveSupport::Cache::Entry.create(r_value,from_mongo['created_at'],entry_options)              
             end
 
+            def write_counter(name, amount, options)
+              col = get_collection(options)
+              key = namespaced_key(name,options) 
+
+              safe_rescue do
+                doc = col.find_and_modify(
+                  :query => {
+                    :_id => key
+                  },
+                  :update => {
+                    :$inc => {
+                      :value => amount
+                    }
+                  }
+                )
+
+                doc['value'] + amount
+              end
+            end
 
             def write_entry(key,entry,options)
               col = get_collection(options)
               serialize = options[:serialize] == :always ? true : false
+              serialize = false if entry.value.is_a?(Integer) || entry.value.nil?
+
+              value = begin 
+                if entry.compressed?
+                  BSON::Binary.new(entry.raw_value)
+                elsif serialize 
+                  BSON::Binary.new(entry.raw_value)
+                else
+                  entry.value
+                end
+              end
+
               try_cnt = 0
 
               save_doc = {
@@ -59,7 +151,7 @@ module ActiveSupport
                 :expires_at => entry.expires_in.nil? ? Time.utc(9999) : Time.at(entry.expires_at),
                 :compressed => entry.compressed?,
                 :serialized => serialize,
-                :value      => serialize ? BSON::Binary.new(entry.raw_value) : entry.value 
+                :value => value 
               }.merge(options[:xentry] || {})
 
               safe_rescue do
@@ -74,8 +166,10 @@ module ActiveSupport
                   end
                 end
               end
+
             end
 
+
             def delete_entry(key,options)
               col = get_collection(options)
               safe_rescue do
@@ -86,7 +180,7 @@ module ActiveSupport
             def get_collection_name(options = {})
               name_parts = ['cache'] 
               name_parts.push(backend_name)
-              name_parts.push options[:namespace] unless options[:namespace].nil?
+              name_parts.push options[:namespace] if !options[:namespace].nil?
               name = name_parts.join('.')
               return name
             end

data/lib/mongo_cache_store/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module MongoCacheStore
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/mongo_cache_store.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'mongo'
   gem.add_dependency 'activesupport', '~>3'
   gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'mocha', '~>0.13.3'
 end

data/test/abstract_unit.rb

@@ -0,0 +1,64 @@
+ORIG_ARGV = ARGV.dup
+
+#begin
+#  old, $VERBOSE = $VERBOSE, nil
+#  require File.expand_path('../../../load_paths', __FILE__)
+#ensure
+#  $VERBOSE = old
+#end
+
+lib = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$:.unshift(lib) unless $:.include?('lib') || $:.include?(lib)
+
+require 'active_support/core_ext/kernel/reporting'
+
+require 'active_support/core_ext/string/encoding'
+if "ruby".encoding_aware?
+  # These are the normal settings that will be set up by Railties
+  # TODO: Have these tests support other combinations of these values
+  silence_warnings do
+    Encoding.default_internal = "UTF-8"
+    Encoding.default_external = "UTF-8"
+  end
+end
+
+require 'test/unit'
+#require 'empty_bool'
+
+silence_warnings { require 'mocha' }
+
+ENV['NO_RELOAD'] = '1'
+require 'active_support'
+
+# Include shims until we get off 1.8.6
+require 'active_support/ruby/shim' if RUBY_VERSION < '1.8.7'
+
+def uses_memcached(test_name)
+  require 'memcache'
+  begin
+    MemCache.new('localhost:11211').stats
+    yield
+  rescue MemCache::MemCacheError
+    $stderr.puts "Skipping #{test_name} tests. Start memcached and try again."
+  end
+end
+
+def with_kcode(code)
+  if RUBY_VERSION < '1.9'
+    begin
+      old_kcode, $KCODE = $KCODE, code
+      yield
+    ensure
+      $KCODE = old_kcode
+    end
+  else
+    yield
+  end
+end
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+if RUBY_VERSION < '1.9'
+  $KCODE = 'UTF8'
+end

data/test/multi_ttl_test.rb

@@ -0,0 +1,24 @@
+require_relative 'abstract_unit'
+require 'mongo'
+require 'active_support/test_case'
+require 'active_support/cache'
+require_relative 'test_modules'
+
+
+
+class MongoCacheStoreTTLTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(
+      :mongo_cache_store, :TTL, 
+      :db => Mongo::DB.new('db_name',Mongo::Connection.new),
+      :expires_in => 60
+    )
+    @cache.clear
+  end
+
+  include CacheStoreBehavior
+  # include LocalCacheBehavior
+  include CacheIncrementDecrementBehavior
+  # include EncodedKeyCacheBehavior
+
+end

data/test/standard_test.rb

@@ -0,0 +1,24 @@
+require_relative 'abstract_unit'
+require 'mongo'
+require 'active_support/test_case'
+require 'active_support/cache'
+require_relative 'test_modules'
+
+
+
+class MongoCacheStoreTTLTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(
+      :mongo_cache_store, :Standard, 
+      :db => Mongo::DB.new('db_name',Mongo::Connection.new),
+      :expires_in => 60
+    )
+    @cache.clear
+  end
+
+  include CacheStoreBehavior
+  # include LocalCacheBehavior
+  include CacheIncrementDecrementBehavior
+  # include EncodedKeyCacheBehavior
+
+end

data/test/test_modules.rb

@@ -0,0 +1,388 @@
+# Tests the base functionality that should be identical across all cache stores.
+
+module EncodedKeyCacheBehavior
+  if defined?(Encoding)
+    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
+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
+
+  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
+  end
+end
+
+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
+    }
+    app = @cache.middleware.new(app)
+    app.call({})
+  end
+end
+
+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_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_should_read_cached_numeric_from_previous_rails_versions
+    @old_cache = ActiveSupport::Cache::Entry.create( 1, Time.now )
+    assert_equal( 1, @old_cache.value )
+  end
+
+  def test_should_read_cached_hash_from_previous_rails_versions
+    @old_cache = ActiveSupport::Cache::Entry.create( {}, Time.now )
+    assert_equal( {}, @old_cache.value )
+  end
+
+  def test_should_read_cached_string_from_previous_rails_versions
+    @old_cache = ActiveSupport::Cache::Entry.create( 'string', Time.now )
+    assert_equal( 'string', @old_cache.value )
+  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
+    @cache.write('foo', 'bar', :expires_in => 0.001)
+    @cache.write('fu', 'baz')
+    @cache.write('fud', 'biz')
+    sleep(0.002)
+    assert_equal({"fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  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')
+    assert_equal 'bar', Marshal.load(raw_value)
+  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
+
+  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 @cache.exist?('foo')
+    assert !@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_read_should_return_a_different_object_id_each_time_it_is_called
+    @cache.write('foo', 'bar')
+    assert_not_equal @cache.read('foo').object_id, @cache.read('foo').object_id
+    value = @cache.read('foo')
+    value << 'bingo'
+    assert_not_equal value, @cache.read('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 + 71)
+    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/ttl_test.rb

@@ -0,0 +1,24 @@
+require_relative 'abstract_unit'
+require 'mongo'
+require 'active_support/test_case'
+require 'active_support/cache'
+require_relative 'test_modules'
+
+
+
+class MongoCacheStoreTTLTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(
+      :mongo_cache_store, :TTL, 
+      :db => Mongo::DB.new('db_name',Mongo::Connection.new),
+      :expires_in => 60
+    )
+    @cache.clear
+  end
+
+  include CacheStoreBehavior
+  # include LocalCacheBehavior
+  include CacheIncrementDecrementBehavior
+  # include EncodedKeyCacheBehavior
+
+end

metadata

@@ -1,36 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: mongo_cache_store
 version: !ruby/object:Gem::Version
-  version: 0.2.3
-  prerelease: 
+  version: 0.2.4
 platform: ruby
 authors:
 - Kevin McGrath
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-24 00:00:00.000000000 Z
+date: 2013-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -46,19 +41,31 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.3
 description: A MongoDB ActiveSupport Cache
 email:
 - kmcgrath@baknet.com
@@ -79,32 +86,37 @@ files:
 - lib/active_support/cache/mongo_cache_store/backend/ttl.rb
 - lib/mongo_cache_store/version.rb
 - mongo_cache_store.gemspec
-- spec/active_support/cache/mongo_cache_store_spec.rb
-- spec/spec_helper.rb
+- test/abstract_unit.rb
+- test/multi_ttl_test.rb
+- test/standard_test.rb
+- test/test_modules.rb
+- test/ttl_test.rb
 homepage: https://github.com/kmcgrath/mongo_cache_store
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.0.rc.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A MongoDB ActiveSupport Cache
 test_files:
-- spec/active_support/cache/mongo_cache_store_spec.rb
-- spec/spec_helper.rb
+- test/abstract_unit.rb
+- test/multi_ttl_test.rb
+- test/standard_test.rb
+- test/test_modules.rb
+- test/ttl_test.rb

data/spec/active_support/cache/mongo_cache_store_spec.rb

@@ -1,179 +0,0 @@
-# -*- encoding : utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-
-class MongoCacheStoreTestSaveClass
-
-  attr_reader :set_me
-  def initialize(set_me)
-    @set_me = set_me
-  end
-
-end
-
-
-module ActiveSupport 
-  module Cache
-    class MongoCacheStoreTest
-      shared_examples "a cache store" do
-        describe "Caching" do
-      
-          it "can write values" do
-            @store.write('forever!', 'I live forever!')
-            @store.fetch('forever!').should == "I live forever!"
-          end
-
-          it "can expire" do
-            @store.fetch 'testkey', expires_in: 2.minutes do 
-              "I will expire."
-            end
-            @store.exist?("testkey").should == true
-
-            sleep 60 
-
-            response = @store.fetch 'testkey'
-            response.should == "I will expire."
-
-            sleep 120 
-
-            response = @store.fetch 'testkey'
-            response.should == nil
-          end
-
-          it "can cache a hash" do
-            @store.write('hashme',
-              {"1"=>{:name=>"Uptime", :zenoss_instance=>"cust", :path=>"/zport/RenderServer/render?gopts=k4VJvRM2K1Dahl3RzJWcqoicTSIz0QJ1Ja10idqC412ptG5_lrmcroRy3BDIqioB561tB4UjtjSg1ib_YaGOXBWOEHBhPbEmA6ZXXjd8LiIOmItqTDZjuFkZvOV38_CF_YEi7t9xUtFKOIxibyVo67jzbyK6P-ORc7i07rK5GUYeA2CnJxm4UDCNKcKRpDCzmdzR-NwcOp0w55KH8YeU6NpgHyM_tpu8G42d7nBQebs1DKvn20sktezqy_LiIizKk3eMzDW-c8w1EZTESWa4rIihXfHrrv9PNxvCw41wU9f3dxQt2c3OFfhSx6riSUbeVsUNEo6s_35KdKJkbr6rEZaaxL2RGR47eLBzifIcZAg="}, "2"=>{:name=>"CPU Utilization", :zenoss_instance=>"cust", :path=>"/zport/RenderServer/render?gopts=WN-Oc9wB_CFbVKzzN75ij-qQcZ6lSOC3jj_ALTzkdMEZ_EzgcvfWOdU7vmlrm9MFY6zrOUeW2Z_uzyJkhRrl_81bVs96xoa7y2S29NVU_oSIIxQj1rUElV04u3wGRXnEbfyYPjLp0m6QEDOthqCs3SLcc7jKkCI15V0Js1b6FpFleWdmO9dCMLvKqdBiE-yhSjfwPS7Rh0wPLAoxXTyIkFFHHBXIu_g69_xnESZhYz0rAWn0W0Ag5N46LuNqwbzW1PwIfczY1Hqw2iKQAq1C4fMry3DNiQvnRmUZdF_w11quhIo-XccH1em3iopVdyy6ik83vMvJN3DfhLUbXcZjnA=="}, "3"=>{:name=>"Memory Utilization", :instance=>"cust", :path=>"/zport/RenderServer/render?gopts=_E6b8KAZjy9xzEYtckX_RDQOsGfIRZnG5WRu7ekbUIlsgWmNZNJ8AgEfr7AM0rV6lZMC4PzCPacRN1zeVQ-nHgTBBDbq4sIQuUMl3ETW9DRM2wgjrmnCRwcl7Dz_qGL6PWkhsJzhQ231SuNi7pM6mDw8dbE_pmZ3F6xKa7_8frJLWoMGLji8sIklFf45YckRkIohkMsffZKMsIspx8JEOvR9mP24vGs0Wv4gRXxqFoE1FlgchuKf2KDvWbwp92RrdOmhOAqMxHWmNA2faAC75072ao9bf6UnxZUu5WFUcNsvJJFcEl2U30TEX5vyjf_9C-1Rvnyf8Q6ajvRKA1VNIl6fpItv8dsKTNViX27RWsI="}, "4"=>{:name=>"Swap", :instance=>"cust", :path=>"/zport/RenderServer/render?gopts=nBpbINZ6hhzV8IUJq49zWOTsQ4hX5F5ZGPyoHZ6KWPUx_4Xk0_URWbZPQO4yicu14u81lDFqfRCoFTwofkA0NJIqoOQfAx2gWrwbE7RtulqYeMol47KWQpSITLSV4Mkh1Sbp9VZqpc4YVjiu1EvWSOIHCeUPXZPSBWFh0R2VoPB_VutBricdimwkvRsHbU9-BlKyJcT-_vEnTMi2MHlB3iKWY329OkN-J2chI3MtoLvSw9sN2LJbrO4ynFQPX4WFY9D18Zhv1bzOapn0XcCsxj88XHZ2eZeEZ0uv33_9EKSVxKtOOYo3Y08mjEKduOme"}, "5"=>{:name=>"Load Average", :instance=>"cust", :path=>"/zport/RenderServer/render?gopts=0y-dExjiyMFT0yWeOf-FR3hBIgIVZZortlKSFUETQYjwMuSDfhB-JhsEYI-feAC0Bmh5T8fZQRuYi5MkD3C2S6Qwd_kzvPrjwxCfxjTaQzidN-DxlWjqTkTfZ-AiPQ3F8JVXr-8kP8ZA10XDcV2VpIHJwZatzxDBVk7isEdKAXEJm-1X_TY7BCdU9uFlcBT1XGEYESM5anyR3282Z77yiYX6PsUcoPwFtLzg1l6Ql8cda8n4d2zLK4ZBX5G25ZQoC0MAmHZPyXRIsI-GGZjKcvXHjZ350tEpyvPiSX8a7PG-dRtWIGEEecM9czU3MF5Xzl-qOVfoRWc8pmlc-5E37Z5TcAoZpUHSlssJdjwoLfOlhFkLGyAVZpVXRCVRWdXNxilLS9N4GbuIEqhsEILyM0MzPvEHwPO3rcPSlzcS4s_SXnjp6XLg2bB6NZjAvbz5Vyb6OPg-8b9C-MmzcpWzVHzP5nYo9RVPR_lpFcmOBUSO_cJO22pIqqMyn1vXbtVz"}, "6"=>{:name=>"Paging", :instance=>"cust", :path=>"/zport/RenderServer/render?gopts=N7sjMwpMD3JE0ZNya07IgWj6t7yn7uX4GJ1XHlmyhRcqcea0HpfXTen6ptASVAZIvWT7fW4kufkvtNBsxKfDMX9JMzqoR-kpfWqoRRfI3eGmqYecg6gcQgXSEnu5Mzf4r-lbo1_Cqp8dYuSmC37uWrKi0gTWVr54ZmQ6w4dSymQ4xSkCH2-MO1X8wxZdtm804NJy6yQ4l7JZYBkWD9rABoPhVfZq4mZpHmZN27UlbK14Z9R3EEF6MG0jKCbJ7gJVEjpOoX_y5ka4S3aRULFSByrZIA290_ZMO21DAnsJbJyMXAEP9r8UanaotdVrPLSOXJkYD4WvdcdDeZ3wMtvdL42oHdhwLDyG9J8i9GkcvwsU04MlTTl270LkX31HJjxjB8IChpDke-9LEmxG_1icmGcAcWr26gTk9HOULwTyso4sX_ZqqCnrrnRRQLCpCZtlqxIB9iAMUtSdkEUdZlsAuw=="}},
-              expires_in: 1.hour
-            )
-
-            hash = @store.read('hashme')
-            hash["1"].should be_a_kind_of(Hash)
-
-          end
-
-          it "can cache class instances" do
-            @store.fetch 'my_class', expires_in: 30.seconds do
-              MongoCacheStoreTestSaveClass.new('what did i say?')
-            end
-
-            my_class = @store.fetch 'my_class'
-            my_class.set_me.should == 'what did i say?'
-          end
-
-          it "can use a hash as a key" do
-            hash_key = {
-              :class_name => 'my_class',
-              :option2 => 2
-            }
-
-            miss_key = {
-              :class_name => 'my_class',
-              :option2 => 1
-            }
-
-            hit_key = {
-              :class_name => 'my_class',
-              :option2 => 2
-            }
-
-
-            @store.fetch(hash_key, expires_in: 30.seconds) do
-              MongoCacheStoreTestSaveClass.new('what did i say?')
-            end
-
-            my_class = @store.fetch(hash_key)
-            my_class.set_me.should == 'what did i say?'
-
-            my_class = @store.fetch(hit_key)
-            my_class.set_me.should == 'what did i say?'
-
-            my_class = @store.fetch(miss_key)
-            my_class.should == nil
-           
-          end
-
-          after(:all) do
-            @store.clear.should == true
-          end 
-        end
-      end
-
-
-      describe MongoCacheStore do
-        describe "initializing" do
-          it "can take a Mongo::DB object" do
-            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
-            store = ActiveSupport::Cache::MongoCacheStore.new(:TTL, :db => db)
-          end
-        end
-
-        describe "TTL Caching" do
-          it_behaves_like "a cache store" 
-          before(:all) do
-            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
-            @store = ActiveSupport::Cache::MongoCacheStore.new(:TTL, :db => db)
-          end
-        end
-
-        describe "TTL Caching On Fail Serialization" do
-          it_behaves_like "a cache store" 
-          before(:all) do
-            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
-            @store = ActiveSupport::Cache::MongoCacheStore.new(:TTL, :db => db, :serialize => :on_fail)
-          end
-        end
-
-        describe "MultiTTL Caching" do
-          it_behaves_like "a cache store" 
-          before(:all) do
-            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
-            @store = ActiveSupport::Cache::MongoCacheStore.new(:MultiTTL, :db => db)
-          end
-        end
-
-        describe "MultiTTL Caching On Fail Serialization" do
-          it_behaves_like "a cache store" 
-          before(:all) do
-            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
-            @store = ActiveSupport::Cache::MongoCacheStore.new(:MultiTTL, :db => db, :serialize => :on_fail)
-          end
-        end
-
-        describe "Standard Caching" do
-          it_behaves_like "a cache store"
-          before(:all) do
-            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
-            @store = ActiveSupport::Cache::MongoCacheStore.new(:Standard, :db => db)
-          end
-        end
-
-        describe "Standard Caching On Fail Serialization" do
-          it_behaves_like "a cache store"
-          before(:all) do
-            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
-            @store = ActiveSupport::Cache::MongoCacheStore.new(:Standard, :db => db, :serialize => :on_fail)
-          end
-        end
-
-        describe "Pass Collection Options" do
-          before(:all) do
-            db = Mongo::DB.new('mongo_cache_store_test', Mongo::Connection.new)
-            @store = ActiveSupport::Cache::MongoCacheStore.new(
-              :Standard, 
-              :db => db, 
-              :collection_opts => {
-                :read => :nearest
-              }
-            )
-          end
-
-          it "can set collection opts" do
-            col = @store.send(:get_collection,{:collection_opts => {:read => :nearest}})
-            col.instance_eval { @read }.should == :nearest
-          end
-
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,6 +0,0 @@
-# -*- encoding : utf-8 -*-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'mongo'
-require 'active_support/cache/mongo_cache_store'
-require 'rspec'