moneta 0.7.4 → 0.7.5

data/script/benchmarks

@@ -0,0 +1,378 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'benchmark'
+require 'moneta'
+require 'fileutils'
+
+class String
+  def random(n)
+    (1..n).map { self[rand(size),1] }.join
+  end
+end
+
+class Array
+  def sum
+    inject(0, &:+)
+  end
+
+  def randomize
+    rest, result = dup, []
+    result << rest.slice!(rand(rest.size)) until result.size == size
+    result
+  end
+end
+
+class MonetaBenchmarks
+  DIR = __FILE__ + '.tmp'
+  FileUtils.mkpath(DIR)
+
+  STORES = {
+    # SDBM is unstable
+    # :SDBM => { :file => "#{DIR}/sdbm" },
+    # YAML is so fucking slow
+    # :YAML => { :file => "#{DIR}/yaml" },
+    :ActiveRecord => { :connection => { :adapter  => 'sqlite3', :database => ':memory:' } },
+    :Cassandra => {},
+    :Client => {},
+    :Couch => {},
+    :DBM => { :file => "#{DIR}/dbm" },
+    :DataMapper => { :setup => "sqlite3:#{DIR}/datamapper" },
+    :Daybreak => { :file => "#{DIR}/daybreak" },
+    :File => { :dir => "#{DIR}/file" },
+    :GDBM => { :file => "#{DIR}/gdbm" },
+    :HBase => {},
+    :HashFile => { :dir => "#{DIR}/hashfile" },
+    :LRUHash => {},
+    :LevelDB => { :dir => "#{DIR}/leveldb" },
+    :LocalMemCache => { :file => "#{DIR}/lmc" },
+    :MemcachedDalli => {},
+    :MemcachedNative => {},
+    :Memory => {},
+    :Mongo => {},
+    :PStore => { :file => "#{DIR}/pstore" },
+    :Redis => {},
+    :RestClient => { :url => 'http://localhost:8808/' },
+    :Riak => {},
+    :Sequel => { :db => 'sqlite:/' },
+    :Sqlite => { :file => ':memory:' },
+    :TDB => { :file => "#{DIR}/tdb" },
+  }
+
+  CONFIGS = {
+    :uniform_small => {
+      :runs => 3,
+      :keys => 1000,
+      :min_key_length => 1,
+      :max_key_length => 32,
+      :key_dist => :uniform,
+      :min_val_length => 0,
+      :max_val_length => 256,
+      :val_dist => :uniform
+    },
+    :uniform_medium => {
+      :runs => 3,
+      :keys => 100,
+      :min_key_length => 3,
+      :max_key_length => 200,
+      :key_dist => :uniform,
+      :min_val_length => 0,
+      :max_val_length => 1024,
+      :val_dist => :uniform
+    },
+    :uniform_large => {
+      :runs => 3,
+      :keys => 100,
+      :min_key_length => 3,
+      :max_key_length => 200,
+      :key_dist => :uniform,
+      :min_val_length => 0,
+      :max_val_length => 10240,
+      :val_dist => :uniform
+    },
+    :normal_small => {
+      :runs => 3,
+      :keys => 1000,
+      :min_key_length => 1,
+      :max_key_length => 32,
+      :key_dist => :normal,
+      :min_val_length => 0,
+      :max_val_length => 256,
+      :val_dist => :normal
+    },
+    :normal_medium => {
+      :runs => 3,
+      :keys => 100,
+      :min_key_length => 3,
+      :max_key_length => 200,
+      :key_dist => :normal,
+      :min_val_length => 0,
+      :max_val_length => 1024,
+      :val_dist => :normal
+    },
+    :normal_large => {
+      :runs => 3,
+      :keys => 100,
+      :min_key_length => 3,
+      :max_key_length => 200,
+      :key_dist => :normal,
+      :min_val_length => 0,
+      :max_val_length => 10240,
+      :val_dist => :normal
+    },
+  }
+
+  DICT = 'ABCDEFGHIJKLNOPQRSTUVWXYZabcdefghijklnopqrstuvwxyz123456789'.freeze
+  HEADER = "\n                         Minimum  Maximum    Total  Average    Ops/s"
+  SEPARATOR = '=' * 68
+
+  module Rand
+    extend self
+
+    def normal_rand(mean, stddev)
+      # Box-Muller transform
+      theta = 2 * Math::PI * (rand(1e10) / 1e10)
+      scale = stddev * Math.sqrt(-2 * Math.log(1 - (rand(1e10) / 1e10)))
+      [mean + scale * Math.cos(theta),
+       mean + scale * Math.sin(theta)]
+    end
+
+    def uniform(min, max)
+      rand(max - min) + min
+    end
+
+    def normal(min, max)
+      mean = (min + max) / 2
+      stddev = (max - min) / 4
+      loop do
+        val = normal_rand(mean, stddev)
+        return val.first if val.first >= min && val.first <= max
+        return val.last if val.last >= min && val.last <= max
+      end
+    end
+  end
+
+  def parallel(&block)
+    if defined?(JRUBY_VERSION)
+      Thread.new(&block)
+    else
+      Process.fork(&block)
+    end
+  end
+
+  def write_histogram(file, sizes)
+    min = sizes.min
+    delta = sizes.max - min
+    histogram = []
+    sizes.each do |s|
+      s = 10 * (s - min) / delta
+      histogram[s] ||= 0
+      histogram[s] += 1
+    end
+    File.open(file, 'w') do |f|
+      histogram.each_with_index { |n,i| f.puts "#{i*delta/10+min} #{n}" }
+    end
+  end
+
+  def start_servers
+    parallel do
+      begin
+        Moneta::Server.new(Moneta.new(:Memory)).run
+      rescue Exception => ex
+        puts "\e[31mFailed to start Moneta server - #{ex.message}\e[0m"
+      end
+    end
+
+    parallel do
+      begin
+        require 'rack'
+        require 'webrick'
+        require 'rack/moneta_rest'
+
+        # Keep webrick quiet
+        ::WEBrick::HTTPServer.class_eval do
+          def access_log(config, req, res); end
+        end
+        ::WEBrick::BasicLog.class_eval do
+          def log(level, data); end
+        end
+
+        Rack::Server.start(:app => Rack::Builder.app do
+                             use Rack::Lint
+                             run Rack::MonetaRest.new(:store => :Memory)
+                           end,
+                           :environment => :none,
+                           :server => :webrick,
+                           :Port => 8808)
+      rescue Exception => ex
+        puts "\e[31mFailed to start Rack server - #{ex.message}\e[0m"
+      end
+    end
+
+    sleep 1 # Wait for servers
+  end
+
+  def test_stores
+    STORES.each do |name, options|
+      begin
+        if name == :DataMapper
+          begin
+            require 'dm-core'
+            DataMapper.setup(:default, :adapter => :in_memory)
+          rescue LoadError => ex
+            puts "\e[31mFailed to load DataMapper - #{ex.message}\e[0m"
+          end
+        elsif name == :Riak
+          require 'riak'
+          Riak.disable_list_keys_warnings = true
+        end
+
+        cache = Moneta.new(name, options.dup)
+        cache['test'] = 'test'
+      rescue Exception => ex
+        puts "\e[31m#{name} not benchmarked - #{ex.message}\e[0m"
+        STORES.delete(name)
+      ensure
+        cache.close if cache
+      end
+    end
+  end
+
+  def generate_data
+    until @data.size == @config[:keys]
+      key = DICT.random(Rand.send(@config[:key_dist], @config[:min_key_length], @config[:max_key_length]))
+      @data[key] = DICT.random(Rand.send(@config[:val_dist], @config[:min_val_length], @config[:max_val_length]))
+    end
+
+    key_lengths, val_lengths = @data.keys.map(&:size), @data.values.map(&:size)
+    @data = @data.to_a
+
+    write_histogram("#{DIR}/key.histogram", key_lengths)
+    write_histogram("#{DIR}/value.histogram", val_lengths)
+
+    puts "\n\e[1m\e[34m#{SEPARATOR}\n\e[34mComputing keys and values...\n\e[34m#{SEPARATOR}\e[0m"
+    puts %{                         Minimum  Maximum    Total  Average}
+    puts 'Key Length              % 8d % 8d % 8d % 8d ' % [key_lengths.min, key_lengths.max, key_lengths.sum, key_lengths.sum / @data.size]
+    puts 'Value Length            % 8d % 8d % 8d % 8d ' % [val_lengths.min, val_lengths.max, val_lengths.sum, val_lengths.sum / @data.size]
+  end
+
+  def print_config
+    puts "\e[1m\e[36m#{SEPARATOR}\n\e[36mConfig #{@config_name}\n\e[36m#{SEPARATOR}\e[0m"
+    @config.each do |k,v|
+      puts '%-16s = %-10s' % [k,v]
+    end
+  end
+
+  def print_store_stats(name)
+    puts HEADER
+    [:write, :read, :sum].each do |i|
+      total = @stats[name][i].sum
+      ops = (@config[:runs] * @data.size) / total
+      line = '%-17.17s %-5s % 8d % 8d % 8d % 8d % 8d' %
+        [name, i, @stats[name][i].min * 1000, @stats[name][i].max * 1000,
+         total * 1000, total * 1000 / @config[:runs], ops]
+      @summary << [-ops, line << "\n"] if i == :sum
+      puts line
+    end
+
+    errors = @stats[name][:error].sum
+    if errors > 0
+      puts "\e[31m%-23.23s % 8d % 8d % 8d % 8d\e[0m" %
+        ['Read errors', @stats[name][:error].min, @stats[name][:error].max, errors, errors / @config[:runs]]
+    else
+      puts "\e[32mNo read errors"
+    end
+  end
+
+  def benchmark_store(name, options)
+    puts "\n\e[1m\e[34m#{SEPARATOR}\n\e[34m#{name}\n\e[34m#{SEPARATOR}\e[0m"
+
+    store = Moneta.new(name, options.dup)
+
+    @stats[name] = {
+      :write => [],
+      :read => [],
+      :sum => [],
+      :error => []
+    }
+
+    %w(Rehearse Measure).each do |type|
+      state = ''
+      print "%s [%#{2 * @config[:runs]}s] " % [type, state]
+
+      @config[:runs].times do |run|
+        store.clear
+        print "%s[%-#{2 * @config[:runs]}s] " % ["\b" * (2 * @config[:runs] + 3), state << 'W']
+
+        @data = @data.randomize
+        m1 = Benchmark.measure do
+          @data.each {|k,v| store[k] = v }
+        end
+
+        print "%s[%-#{2 * @config[:runs]}s] " % ["\b" * (2 * @config[:runs] + 3), state << 'R']
+
+        @data = @data.randomize
+        error = 0
+        m2 = Benchmark.measure do
+          @data.each do |k, v|
+            error += 1 if v != store[k]
+          end
+        end
+
+        if type == 'Measure'
+          @stats[name][:write] << m1.real
+          @stats[name][:error] << error
+          @stats[name][:read] << m2.real
+          @stats[name][:sum] << (m1.real + m2.real)
+        end
+      end
+    end
+
+    print_store_stats(name)
+  rescue StandardError => ex
+    puts "\n\e[31mFailed to benchmark #{name} - #{ex.message}\e[0m\n"
+  ensure
+    store.close if store
+  end
+
+  def run_benchmarks
+    STORES.each {|name, options| benchmark_store(name, options) }
+  end
+
+  def print_summary
+    puts "\n\e[1m\e[36m#{SEPARATOR}\n\e[36mSummary #{@config_name}: #{@config[:runs]} runs, #{@data.size} keys\n\e[36m#{SEPARATOR}\e[0m#{HEADER}\n"
+    @summary.sort_by(&:first).each do |entry|
+      puts entry.last
+    end
+  end
+
+  def initialize(args)
+    @config_name = args.size == 1 ? args.first.to_sym : :uniform_medium
+    unless @config = CONFIGS[@config_name]
+      puts "Configuration #{@config_name} not found"
+      exit
+    end
+
+    # Disable jruby stdout pollution by memcached
+    if defined?(JRUBY_VERSION)
+      require 'java'
+      properties = java.lang.System.getProperties();
+      properties.put('net.spy.log.LoggerImpl', 'net.spy.memcached.compat.log.SunLogger');
+      java.lang.System.setProperties(properties);
+      java.util.logging.Logger.getLogger('').setLevel(java.util.logging.Level::OFF)
+    end
+
+    @stats, @data, @summary = {}, {}, []
+  end
+
+  def run
+    start_servers
+    test_stores
+    print_config
+    generate_data
+    run_benchmarks
+    print_summary
+  end
+end
+
+MonetaBenchmarks.new(ARGV).run

data/script/{generate-specs.rb → generate-specs}

@@ -2,43 +2,55 @@
 
 PATH = File.expand_path(File.join(__FILE__, '..', '..', 'spec'))
 
+class Array
+  def without(*x)
+    a = dup
+    x.each {|y| a.delete(y) }
+    a
+  end
+
+  def with(*x)
+    a = dup
+    x.each {|y| a << y }
+    a
+  end
+end
+
 class Specs
   attr_reader :key, :value, :specs
 
-  def initialize(specs, key = nil, value = nil)
-    @specs = specs
-    @key = key     || %w(object string hash boolean nil integer)
-    @value = value || %w(object string hash boolean nil integer)
+  def initialize(options = {})
+    @specs = options.delete(:specs).to_a
+    @key = options.delete(:key)     || %w(object string hash boolean nil integer)
+    @value = options.delete(:value) || %w(object string hash boolean nil integer)
+  end
+
+  def new(options)
+    Specs.new({:specs => specs, :key => key, :value => value}.merge(options))
   end
 
   def stringkeys_only
-    Specs.new(specs, %w(string), value)
+    new(:key => %w(string))
   end
 
   def stringvalues_only
-    Specs.new(specs, key, %w(string))
+    new(:value => %w(string))
   end
 
   def simplekeys_only
-    Specs.new(specs, %w(string hash integer), value)
+    new(:key => %w(string hash integer))
   end
 
   def simplevalues_only
-    Specs.new(specs, key, %w(string hash integer))
+    new(:value => %w(string hash integer))
   end
 
   def without_increment
-    a = specs.dup
-    a.delete(:increment)
-    a << :not_increment
-    Specs.new(a, key, value)
+    new(:specs => specs.without(:increment).with(:not_increment))
   end
 
   def without_persist
-    a = specs.dup
-    a.delete(:persist)
-    a << :not_persist
-    Specs.new(a, key, value)
+    new(:specs => specs.without(:persist).with(:not_persist))
   end
 
   def with_expires
@@ -48,66 +60,45 @@ class Specs
       a << :transform_value_with_expires
     end
     a << :expires
-    Specs.new(a, key, value)
+    new(:specs => a)
   end
 
   def with_native_expires
-    a = specs.dup
-    a << :expires
-    Specs.new(a, key, value)
+    new(:specs => specs.with(:expires))
   end
 
   def without_marshallable
-    a = specs.dup
-    a.delete(:marshallable_value)
-    a.delete(:marshallable_key)
-    Specs.new(a, key, value)
+    new(:specs => specs.without(:marshallable_value, :marshallable_key))
   end
 
   def without_transform
-    a = specs.dup
-    a.delete(:marshallable_value)
-    a.delete(:marshallable_key)
-    a.delete(:transform_value)
-    Specs.new(a, key, value)
+    new(:specs => specs.without(:marshallable_value, :marshallable_key, :transform_value))
   end
 
-  def without_returndifferent
-    a = specs.dup
-    a.delete(:returndifferent)
-    Specs.new(a, key, value)
+  def returnsame
+    new(:specs => specs.without(:returndifferent).with(:returnsame))
   end
 
   def without_marshallable_key
-    a = specs.dup
-    a.delete(:marshallable_key)
-    Specs.new(a, key, value)
+    new(:specs => specs.without(:marshallable_key))
   end
 
   def without_marshallable_value
-    a = specs.dup
-    a.delete(:marshallable_value)
-    Specs.new(a, key, value)
+    new(:specs => specs.without(:marshallable_value))
   end
 
   def without_store
-    a = specs.dup
-    a.delete(:store)
-    a.delete(:transform_value)
-    a.delete(:marshallable_value)
-    Specs.new(a, key, value)
+    new(:specs => specs.without(:store, :transform_value, :marshallable_value))
   end
 
   def with_default_expires
-    a = specs.dup
-    a << :default_expires
-    Specs.new(a, key, value)
+    new(:specs => specs.with(:default_expires))
   end
 end
 
-ADAPTER_SPECS = Specs.new([:null, :store, :returndifferent, :increment, :persist], %w(string), %w(string))
-STANDARD_SPECS = Specs.new([:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :persist])
-TRANSFORMER_SPECS = Specs.new([:null, :store, :returndifferent, :transform_value, :increment])
+ADAPTER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :increment, :persist], :key => %w(string), :value => %w(string))
+STANDARD_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :persist])
+TRANSFORMER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :transform_value, :increment])
 
 header = "# Generated by #{File.basename(__FILE__)}\n"
 
@@ -402,7 +393,7 @@ end
   },
   'null_adapter' => {
     :build => 'Moneta::Adapters::Null.new',
-    :specs => Specs.new([:null, :not_increment, :not_persist])
+    :specs => Specs.new(:specs => [:null, :not_increment, :not_persist])
   },
   'simple_sequel' => {
     :store => :Sequel,
@@ -478,14 +469,14 @@ end
   use :Expires
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.with_expires.without_persist
+    :specs => STANDARD_SPECS.without_transform.with_expires.without_persist.returnsame
   },
   'expires_memory_with_default_expires' => {
     :build => %{Moneta.build do
   use :Expires, :expires => 1
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.with_expires.with_default_expires.without_persist
+    :specs => STANDARD_SPECS.without_transform.with_expires.with_default_expires.without_persist.returnsame
   },
   'expires_file' => {
     :build => %{Moneta.build do
@@ -522,7 +513,7 @@ end},
   use :Proxy
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.with_expires.without_returndifferent.without_persist
+    :specs => STANDARD_SPECS.without_transform.with_expires.returnsame.without_persist
   },
   'cache_file_memory' => {
     :build => %{Moneta.build do
@@ -531,7 +522,7 @@ end},
     cache { adapter :Memory }
   end
 end},
-    :specs => ADAPTER_SPECS,
+    :specs => ADAPTER_SPECS.returnsame,
     :tests => %{
 it 'stores loaded values in cache' do
   store.backend['foo'] = 'bar'
@@ -552,15 +543,15 @@ end
     cache(Moneta::Adapters::Null.new)
   end
 end},
-    :specs => ADAPTER_SPECS.without_persist
+    :specs => ADAPTER_SPECS.without_persist.returnsame
   },
   'shared' => {
     :build => %{Moneta.build do
   use(:Shared, :port => 9001) do
-    adapter :Memory
+    adapter :PStore, :file => File.join(make_tempdir, 'shared')
   end
 end},
-    :specs => ADAPTER_SPECS.without_persist,
+    :specs => ADAPTER_SPECS,
     :tests => %{
 it 'shares values' do
   store['shared_key'] = 'shared_value'
@@ -576,7 +567,7 @@ end
   use(:Stack) do
     add(Moneta.new(:Null))
     add(Moneta::Adapters::Null.new)
-    add { adapter :File, :dir => File.join(make_tempdir, "stack-file1") }
+    add { adapter :File, :dir => File.join(make_tempdir, "stack_file_memory") }
     add { adapter :Memory }
   end
 end},
@@ -588,17 +579,17 @@ end},
     add(Moneta.new(:Null))
     add(Moneta::Adapters::Null.new)
     add { adapter :Memory }
-    add { adapter :File, :dir => File.join(make_tempdir, "stack-file2") }
+    add { adapter :File, :dir => File.join(make_tempdir, "stack_memory_file") }
   end
 end},
-    :specs => STANDARD_SPECS.without_increment.without_transform.stringkeys_only.stringvalues_only
+    :specs => STANDARD_SPECS.without_increment.returnsame.without_transform.stringkeys_only.stringvalues_only
   },
   'lock' => {
     :build => %{Moneta.build do
   use :Lock
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.without_returndifferent.without_persist
+    :specs => STANDARD_SPECS.without_transform.returnsame.without_persist
   },
   'pool' => {
     :build => %{Moneta.build do
@@ -725,7 +716,7 @@ end},
   use :Transformer, :key => :marshal
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.returnsame,
     :load_value => 'value'
   },
   'transformer_value_marshal' => {
@@ -749,7 +740,7 @@ end},
   use :Transformer, :key => :yaml
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.returnsame,
     :load_value => 'value'
   },
   'transformer_value_yaml' => {
@@ -888,7 +879,7 @@ end
     :specs => ADAPTER_SPECS.without_increment.with_native_expires
   },
   'adapter_cassandra_with_default_expires' => {
-    :build => %{Moneta::Adapters::Cassandra.new(:expires => 1)},
+    :build => %{Moneta::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra_with_default_expires', :expires => 1)},
     :specs => ADAPTER_SPECS.without_increment.with_native_expires.with_default_expires
   },
   'adapter_hbase' => {
@@ -897,7 +888,7 @@ end
   },
   'adapter_cookie' => {
     :build => 'Moneta::Adapters::Cookie.new',
-    :specs => ADAPTER_SPECS.without_persist
+    :specs => ADAPTER_SPECS.without_persist.returnsame
   },
   'adapter_couch' => {
     :build => "Moneta::Adapters::Couch.new(:db => 'adapter_couch')",
@@ -949,7 +940,7 @@ end
   },
   'adapter_daybreak' => {
     :build => 'Moneta::Adapters::Daybreak.new(:file => File.join(make_tempdir, "adapter_daybreak"))',
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.returnsame
   },
   'adapter_file' => {
     :build => 'Moneta::Adapters::File.new(:dir => File.join(make_tempdir, "adapter_file"))',
@@ -962,7 +953,8 @@ end
     :dir                    => 'moneta')",
     # Put Fog into testing mode
     :preamble               => "require 'fog'\nFog.mock!\n",
-    :specs => ADAPTER_SPECS.without_increment
+    # Fog returns same object in mocking mode (in-memory store)
+    :specs => ADAPTER_SPECS.without_increment.returnsame
   },
   'adapter_gdbm' => {
     :build => 'Moneta::Adapters::GDBM.new(:file => File.join(make_tempdir, "adapter_gdbm"))',
@@ -998,11 +990,11 @@ end
   },
   'adapter_memory' => {
     :build => 'Moneta::Adapters::Memory.new',
-    :specs => STANDARD_SPECS.without_transform.without_returndifferent.without_persist
+    :specs => STANDARD_SPECS.without_transform.returnsame.without_persist
   },
   'adapter_lruhash' => {
     :build => 'Moneta::Adapters::LRUHash.new',
-    :specs => ADAPTER_SPECS.without_persist,
+    :specs => ADAPTER_SPECS.without_persist.returnsame,
     :tests => %{
 it 'deletes oldest' do
   store = Moneta::Adapters::LRUHash.new(:max_size => 10)
@@ -1023,7 +1015,7 @@ end}
     :specs => ADAPTER_SPECS.with_native_expires,
     :tests => %{
 it 'automatically deletes expired document' do
-  store.store('key', 'val', :expires => 30)
+  store.store('key', 'val', :expires => 5)
   store.instance_variable_get(:@collection).find_one('_id' => ::BSON::Binary.new('key')).should_not be_nil
   sleep 70 # Mongo needs up to 60 seconds
   store.instance_variable_get(:@collection).find_one('_id' => ::BSON::Binary.new('key')).should be_nil
@@ -1082,7 +1074,7 @@ end}
   },
   'optionmerger' => {
     :store => :Memory,
-    :specs => Specs.new([]),
+    :specs => Specs.new,
     :tests => %{
 it '#with should return OptionMerger' do
   options = {:optionname => :optionvalue}
@@ -1160,6 +1152,19 @@ it 'has method #prefix' do
 
   store.prefix('a').raw.default_options.should == {:store=>{:raw=>true,:prefix=>'a'},:load=>{:raw=>true,:prefix=>'a'},
                                                    :delete=>{:raw=>true,:prefix=>'a'},:key? => {:prefix=>'a'},:increment=>{:prefix=>'a'}}
+end
+
+it 'supports adding proxis using #with' do
+  compressed_store = store.with(:prefix => 'compressed') do
+    use :Transformer, :value => :zlib
+  end
+  store['key'] = 'uncompressed value'
+  compressed_store['key'] = 'compressed value'
+  store['key'].should == 'uncompressed value'
+  compressed_store['key'].should == 'compressed value'
+  store.key?('compressedkey').should be_true
+  # Check if value is compressed
+  compressed_store['key'].should_not == store['compressedkey']
 end}
   },
 }
@@ -1299,13 +1304,17 @@ end}
 
       (SPECS["store_#{key_type}key_#{val_type}value"] ||= []) << code
 
-      code = %{it 'guarantees that a different value is retrieved' do
+      if val_type != 'boolean' && val_type != 'nil' && val_type != 'integer'
+        (SPECS["returndifferent_#{key_type}key_#{val_type}value"] ||= []) << %{it 'guarantees that a different value is retrieved' do
   value = #{val1}
-  store[#{key1}] = #{val1}
-  store[#{key1}].should_not be_equal(#{val1})
+  store[#{key1}] = value
+  store[#{key1}].should_not be_equal(value)
+end}
+        (SPECS["returnsame_#{key_type}key_#{val_type}value"] ||= []) << %{it 'guarantees that the same value is retrieved' do
+  value = #{val1}
+  store[#{key1}] = value
+  store[#{key1}].should be_equal(value)
 end}
-      if val_type != 'boolean' && val_type != 'nil' && val_type != 'integer'
-        (SPECS["returndifferent_#{key_type}key_#{val_type}value"] ||= []) << code
       end
 
       code = %{it 'persists values' do
@@ -1374,9 +1383,9 @@ it 'supports updating the expiration time in load' do
   sleep 1
   store.load('key2', :expires => 3).should == 'val2'
   store['key2'].should == 'val2'
-  sleep 1
+  sleep 2
   store['key2'].should == 'val2'
-  sleep 3
+  sleep 2
   store['key2'].should be_nil
 end
 
@@ -1400,9 +1409,9 @@ it 'supports updating the expiration time in key?' do
   sleep 1
   store.key?('key2', :expires => 3).should be_true
   store['key2'].should == 'val2'
-  sleep 1
+  sleep 2
   store['key2'].should == 'val2'
-  sleep 3
+  sleep 2
   store['key2'].should be_nil
 end
 
@@ -1426,9 +1435,9 @@ it 'supports updating the expiration time in fetch' do
   sleep 1
   store.fetch('key1', nil, :expires => 3).should == 'val1'
   store['key1'].should == 'val1'
-  sleep 1
+  sleep 2
   store['key1'].should == 'val1'
-  sleep 3
+  sleep 2
   store['key1'].should be_nil
 end