moneta 1.0.0 → 1.1.0

data/spec/features/store_large.rb

@@ -0,0 +1,13 @@
+shared_examples :store_large do
+  it 'should store values up to 32k' do
+    value = 'x' * (32 * 1024)
+    store['large'] = value
+    store['large'].should == value
+  end
+
+  it 'should store keys up to 128 bytes' do
+    key = 'x' * 128
+    store[key] = 'value'
+    store[key].should == 'value'
+  end
+end

data/spec/features/transform_value.rb

@@ -0,0 +1,44 @@
+shared_examples :transform_value do
+  it 'allows to bypass transformer with :raw' do
+    store['key'] = 'value'
+    load_value(store.load('key', raw: true)).should == 'value'
+
+    store.store('key', 'value', raw: true)
+    store.load('key', raw: true).should == 'value'
+    store.delete('key', raw: true).should == 'value'
+  end
+
+  it 'allows to bypass transformer with raw syntactic sugar' do
+    store['key'] = 'value'
+    load_value(store.raw.load('key')).should == 'value'
+
+    store.raw.store('key', 'value')
+    store.raw['key'].should == 'value'
+    store.raw.load('key').should == 'value'
+    store.raw.delete('key').should == 'value'
+
+    store.raw['key'] = 'value2'
+    store.raw['key'].should == 'value2'
+  end
+
+  it 'returns unmarshalled value' do
+    store.store('key', 'unmarshalled value', raw: true)
+    store.load('key', raw: true).should == 'unmarshalled value'
+  end
+
+  it 'might raise exception on invalid value' do
+    store.store('key', 'unmarshalled value', raw: true)
+
+    begin
+      store['key'].should == load_value('unmarshalled value')
+      store.delete('key').should == load_value('unmarshalled value')
+    rescue Exception => ex
+      expect do
+        store['key']
+      end.to raise_error
+      expect do
+        store.delete('key')
+      end.to raise_error
+    end
+  end
+end

data/spec/features/transform_value_expires.rb

@@ -0,0 +1,41 @@
+shared_examples :transform_value_expires do
+  it 'allows to bypass transformer with :raw' do
+    store['key'] = 'value'
+    load_value(store.load('key', raw: true)).should == 'value'
+    store['key'] = [1,2,3]
+    load_value(store.load('key', raw: true)).should == [[1,2,3]]
+    store['key'] = nil
+    load_value(store.load('key', raw: true)).should == [nil]
+    store['key'] = false
+    load_value(store.load('key', raw: true)).should be false
+
+    store.store('key', 'value', expires: 10)
+    load_value(store.load('key', raw: true)).first.should == 'value'
+    load_value(store.load('key', raw: true)).last.should respond_to(:to_int)
+
+    store.store('key', 'value', raw: true)
+    store.load('key', raw: true).should == 'value'
+    store.delete('key', raw: true).should == 'value'
+  end
+
+  it 'returns unmarshalled value' do
+    store.store('key', 'unmarshalled value', raw: true)
+    store.load('key', raw: true).should == 'unmarshalled value'
+  end
+
+  it 'might raise exception on invalid value' do
+    store.store('key', 'unmarshalled value', raw: true)
+
+    begin
+      store['key'].should == load_value('unmarshalled value')
+      store.delete('key').should == load_value('unmarshalled value')
+    rescue Exception => ex
+      expect do
+        store['key']
+      end.to raise_error
+      expect do
+        store.delete('key')
+      end.to raise_error
+    end
+  end
+end

data/spec/helper.rb

@@ -1,9 +1,15 @@
-require 'rspec'
 require 'rspec/core/formatters/base_text_formatter'
-require 'rspec/retry'
 require 'moneta'
 require 'fileutils'
-require 'monetaspecs'
+require 'tmpdir'
+
+ENV['RANTLY_VERBOSE'] ||= '0'
+
+require 'rspec/retry'
+require 'rantly'
+require 'rantly/rspec_extensions'
+# rantly/shrinks
+require 'timecop'
 
 class MonetaParallelFormatter < RSpec::Core::Formatters::BaseTextFormatter
   def start(*args)
@@ -47,13 +53,369 @@ class MonetaParallelFormatter < RSpec::Core::Formatters::BaseTextFormatter
   end
 end
 
+class MonetaSpecs
+  KEYS = {
+    'nil' => [:choose, nil, 0],
+    'integer' => :integer,
+    'float' => :float,
+    'boolean' => :boolean,
+    'string' => proc{ sized(range 5, 10){ string(:alnum) } },
+    'path' => proc{ array(range 2, 3){ sized(range 5, 10){ string(:alpha) } }.join('/') },
+    'binary' => [:string, :cntrl],
+    'object' => proc{ choose Value.new(:objkey1), Value.new(:objkey2) },
+    'hash' => proc{ dict(2){ sized(range 5, 10){ [string(:alnum), string(:alnum)] } } }
+  }
+
+  VALUES = {
+    'nil' => [:literal, nil],
+    'integer' => :integer,
+    'float' => :float,
+    'boolean' => :boolean,
+    'string' => [:string, :alnum],
+    'binary' => [:string, :cntrl],
+    'object' => proc{ choose Value.new(:objval1), Value.new(:objval2) },
+    'hash' => proc{ dict{ [string(:alnum), array(2){ choose(string(:alnum), integer, dict{ [string(:alnum), integer] }) }] } },
+    'smallhash' => proc{ dict(2){ sized(range 5, 10){ [string(:alnum), string(:alnum)] } } }
+  }
+
+  attr_reader :key, :value, :specs, :features
+
+  def initialize(options = {})
+    @specs = options.delete(:specs).to_a
+    @features = @specs & [:expires, :expires_native, :increment, :each_key, :create]
+    @key = options.delete(:key)     || %w(object string binary hash boolean nil integer float)
+    @value = options.delete(:value) || %w(object string binary hash boolean nil integer float)
+  end
+
+  def new(options)
+    self.class.new({specs: specs, key: key, value: value}.merge(options))
+  end
+
+  def with_keys(*keys)
+    new(key: self.key | keys.map(&:to_s))
+  end
+
+  def without_keys(*keys)
+    new(key: self.key - keys.map(&:to_s))
+  end
+
+  def with_values(*values)
+    new(value: self.value | values.map(&:to_s))
+  end
+
+  def without_values(*values)
+    new(value: self.value - values.map(&:to_s))
+  end
+
+  def without_keys_or_values(*types)
+    without_keys(*types).without_values(*types)
+  end
+
+  def without_path
+    new(key: key - %w(path))
+  end
+
+  def stringvalues_only
+    new(value: %w(string))
+  end
+
+  def simplekeys_only
+    new(key: %w(string hash integer))
+  end
+
+  def simplevalues_only
+    new(value: %w(string hash integer))
+  end
+
+  def without_increment
+    new(specs: specs - [:increment, :concurrent_increment] + [:not_increment])
+  end
+
+  def without_large
+    new(specs: specs - [:store_large]).instance_exec do
+      if value.include? 'hash'
+        without_values(:hash).with_values(:smallhash)
+      else
+        self
+      end
+    end
+  end
+
+  def without_concurrent
+    new(specs: specs - [:concurrent_increment, :concurrent_create])
+  end
+
+  def without_persist
+    new(specs: specs - [:persist, :multiprocess, :concurrent_increment, :concurrent_create] + [:not_persist])
+  end
+
+  def without_multiprocess
+    new(specs: specs - [:multiprocess, :concurrent_increment, :concurrent_create])
+  end
+
+  def with_expires
+    a = specs.dup
+    if a.include?(:transform_value)
+      a.delete(:transform_value)
+      a << :transform_value_expires
+    end
+    a << :create_expires if a.include?(:create)
+    a << :expires
+    new(specs: a)
+  end
+
+  def with_native_expires
+    a = specs.dup
+    a << :create_expires if a.include?(:create)
+    new(specs: a + [:expires])
+  end
+
+  def without_marshallable
+    new(specs: specs - [:marshallable_value, :marshallable_key])
+  end
+
+  def without_transform
+    new(specs: specs - [:marshallable_value, :marshallable_key, :transform_value])
+  end
+
+  def returnsame
+    new(specs: specs - [:returndifferent] + [:returnsame])
+  end
+
+  def without_marshallable_key
+    new(specs: specs - [:marshallable_key])
+  end
+
+  def without_marshallable_value
+    new(specs: specs - [:marshallable_value])
+  end
+
+  def without_store
+    new(specs: specs - [:store, :store_large, :transform_value, :marshallable_value])
+  end
+
+  def with_default_expires
+    new(specs: specs + [:default_expires])
+  end
+
+  def with_each_key
+    new(specs: specs - [:not_each_key] | [:each_key])
+  end
+
+  def without_create
+    new(specs: specs - [:create, :concurrent_create, :create_expires] + [:not_create])
+  end
+end
+
+ADAPTER_SPECS = MonetaSpecs.new(
+  specs: [:null, :store, :returndifferent,
+    :increment, :concurrent_increment, :concurrent_create, :persist, :multiprocess,
+    :create, :features, :store_large, :not_each_key],
+  key: %w(string path),
+  value: %w(string path binary))
+STANDARD_SPECS = MonetaSpecs.new(
+  specs: [:null, :store, :returndifferent,
+    :marshallable_key, :marshallable_value, :transform_value, :increment,
+    :concurrent_increment, :concurrent_create, :persist, :multiprocess, :create,
+    :features, :store_large, :not_each_key])
+TRANSFORMER_SPECS = MonetaSpecs.new(
+  specs: [:null, :store, :returndifferent,
+    :transform_value, :increment, :create, :features, :store_large,
+    :not_each_key])
+
+module MonetaHelpers
+  module ClassMethods
+
+    def moneta_store store_name, options={}, &block
+      name = self.description
+      builder = proc do
+        if block
+          options = instance_exec(&block)
+        end
+
+        Moneta.new(store_name, options.merge(logger: {file: File.join(tempdir, "#{name}.log")}))
+      end
+
+      include_context :setup_moneta_store, builder
+    end
+
+    def moneta_build &block
+      include_context :setup_moneta_store, block
+    end
+
+    def moneta_loader &block
+      before do
+        @moneta_value_loader = block
+      end
+    end
+
+    def moneta_specs specs
+      let(:features){ specs.features }
+      let(:keys_meta) do
+        [:branch, *specs.key.map{ |k| MonetaSpecs::KEYS[k] }.compact]
+      end
+      let(:values_meta) do
+        [:branch, *specs.value.map{ |k| MonetaSpecs::VALUES[k] }.compact]
+      end
+
+      # Used by tests that rely on MySQL.  These env vars can be used if you
+      # want to run the tests but don't want to grant root access to moneta
+      let(:mysql_username) { ENV['MONETA_MYSQL_USERNAME'] || 'root' }
+      let(:mysql_password) { ENV['MONETA_MYSQL_PASSWORD'] }
+      let(:mysql_database1) { ENV['MONETA_MYSQL_DATABSASE1'] || 'moneta' }
+      let(:mysql_database2) { ENV['MONETA_MYSQL_DATABSASE2'] || 'moneta2' }
+
+      let(:postgres_username) { ENV['MONETA_POSTGRES_USERNAME'] || 'postgres' }
+      let(:postgres_database1) { ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta1' }
+      let(:postgres_database2) { ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta2' }
+
+      before do
+        store = new_store
+        store.clear
+        store.close
+      end
+
+      specs.specs.sort.each do |s|
+        context "#{s} feature" do
+          include_examples(s)
+        end
+      end
+    end
+
+    # Used to test time-dependent specs (e.g. expiry at different positions
+    # within a second). Once close to the start of the second, and once close
+    # to the end.
+    def usecs
+      [1e4, 99e4].map(&:to_i)
+    end
+
+    def at_each_usec(&block)
+      usecs.each do |usec|
+        context "at #{usec} microseconds", isolate: true do
+          include_examples :at_usec, usec, &block
+        end
+      end
+    end
+
+    def use_timecop
+      before{ @timecop = true }
+    end
+
+    def start_memcached(port)
+      before :context do
+        @memcached = spawn("memcached -p #{port}")
+        sleep 0.5
+      end
+
+      after :context do
+        Process.kill("TERM", @memcached)
+        Process.wait(@memcached)
+        @memcached = nil
+      end
+    end
+  end
+
+  module InstanceMethods
+    def tempdir
+      @moneta_tempdir ||= Dir.mktmpdir
+    end
+
+    def new_store
+      instance_eval(&@moneta_store_builder)
+    end
+
+    def store
+      @store ||= new_store
+    end
+
+    def load_value value
+      if @moneta_value_loader
+        @moneta_value_loader.call value
+      else
+        Marshal.load(value)
+      end
+    end
+
+    def start_restserver
+      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
+
+      Thread.start do
+        Rack::Server.start(:app => Rack::Builder.app do
+                             use Rack::Lint
+                             map '/moneta' do
+                               run Rack::MonetaRest.new(:store => :Memory)
+                             end
+                           end,
+                           :environment => :none,
+                           :server => :webrick,
+                           :Port => 8808)
+      end
+      sleep 1
+    end
+
+    def start_server(*args)
+      server = Moneta::Server.new(*args)
+      Thread.new { server.run }
+      sleep 0.1 until server.running?
+    rescue Exception => ex
+      puts "Failed to start server - #{ex.message}"
+    end
+
+    def moneta_property_of(keys: 0, values: 0)
+      keys_meta = self.keys_meta
+      values_meta = self.values_meta
+      property_of do
+        key_values = keys.times.map { call(keys_meta) }
+        guard key_values.uniq.length == key_values.length
+
+        value_values = values.times.map { call(values_meta) }
+        guard value_values.uniq.length == value_values.length
+
+        [[:keys, key_values], [:values, value_values]].
+          reject { |key, value| value.empty? }.
+          to_h
+      end
+    end
+
+    def advance(seconds)
+      return if seconds < 0
+      if @timecop
+        Timecop.freeze(Time.now + seconds)
+      else
+        sleep seconds
+      end
+    end
+  end
+end
+
 RSpec.configure do |config|
   config.verbose_retry = true
   config.color = true
-  config.tty = true
-  config.formatter = ENV['PARALLEL_TESTS'] ? MonetaParallelFormatter : :progress
+  #config.tty = true
+  #config.formatter = ENV['PARALLEL_TESTS'] ? MonetaParallelFormatter : :progress
+  config.silence_filter_announcements = true if ENV['PARALLEL_TESTS']
+
+  # Allow "should" syntax as well as "expect"
+  config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
+
+  config.extend MonetaHelpers::ClassMethods
+  config.include MonetaHelpers::InstanceMethods
 end
 
+# FIXME: Get rid of this once raise_error expectations no longer generate
+# warnings
+RSpec::Expectations.configuration.on_potential_false_positives = :nothing
+
 # Disable jruby stdout pollution by memcached
 if defined?(JRUBY_VERSION)
   require 'java'
@@ -82,47 +444,6 @@ class Value
   end
 end
 
-def start_restserver
-  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
-
-  Thread.start do
-    Rack::Server.start(:app => Rack::Builder.app do
-                         use Rack::Lint
-                         map '/moneta' do
-                           run Rack::MonetaRest.new(:store => :Memory)
-                         end
-                       end,
-                       :environment => :none,
-                       :server => :webrick,
-                       :Port => 8808)
-  end
-  sleep 1
-end
-
-def start_server(*args)
-  server = Moneta::Server.new(*args)
-  Thread.new { server.run }
-  sleep 0.1 until server.running?
-rescue Exception => ex
-  puts "Failed to start server - #{ex.message}"
-end
-
-def make_tempdir
-  # Expand path since datamapper needs absolute path in setup
-  tempdir = File.expand_path(File.join(File.dirname(__FILE__), 'tmp'))
-  FileUtils.mkpath(tempdir)
-  tempdir
-end
 
 def marshal_error
   # HACK: Marshalling structs in rubinius without class name throws
@@ -134,44 +455,40 @@ def marshal_error
   end
 end
 
-class InitializeStore
-  def initialize(&block)
-    instance_eval(&block)
-    store = new_store
-    store['foo'] = 'bar'
-    store.clear
-    store.close
-  end
 
-  def method_missing(*args)
+RSpec.shared_context :setup_moneta_store do |builder|
+  before do
+    @moneta_store_builder = builder
   end
-end
 
-def describe_moneta(name, &block)
-  begin
-    InitializeStore.new(&block)
-    describe(name, &block)
-  rescue LoadError => ex
-    puts "\e[31mTest #{name} not executed: #{ex.class} - #{ex.message}\e[0m"
-  rescue Exception => ex
-    puts "\e[31mTest #{name} not executed: #{ex.class} - #{ex.message}\e[0m"
-    puts ex.backtrace.join("\n")
+  after do
+    if @store
+      @store.close.should == nil
+      @store = nil
+    end
   end
-end
 
-shared_context 'setup_store' do
-  def store
-    @store ||= new_store
+  after :all do
+    if @moneta_tempdir
+      FileUtils.remove_dir(@moneta_tempdir)
+    end
   end
+end
 
+RSpec.shared_examples :at_usec do |usec|
   before do
-    store.clear
+    now = Time.now
+    # 1000us is a rough guess at how many microseconds this code will take to run
+    if now.usec + 1000 > usec
+      advance(1 - 1e-6 * (now.usec - usec))
+    else
+      advance(1e-6 * (usec - now.usec))
+    end
   end
 
   after do
-    if store
-      store.close.should == nil
-      @store = nil
-    end
+    Timecop.return if @timecop
   end
 end
+
+Dir['./spec/features/*.rb'].each{ |rb| require rb }