moneta 1.4.0 → 1.5.0

data/spec/moneta/adapters/memcached/native/adapter_memcached_native_spec.rb

@@ -7,9 +7,19 @@ describe 'adapter_memcached_native', isolate: true, unstable: defined?(JRUBY_VER
 
   include_context :start_memcached, 11214
 
-  moneta_build do
-    Moneta::Adapters::MemcachedNative.new(server: "127.0.0.1:11214")
+  describe 'without default expires' do
+    moneta_build do
+      Moneta::Adapters::MemcachedNative.new(server: "127.0.0.1:11214")
+    end
+
+    moneta_specs ADAPTER_SPECS.with_native_expires
   end
 
-  moneta_specs ADAPTER_SPECS.with_native_expires
+  describe 'with default expires' do
+    moneta_build do
+      Moneta::Adapters::MemcachedNative.new(server: '127.0.0.1:11214', expires: min_ttl)
+    end
+
+    moneta_specs NATIVE_EXPIRY_SPECS.with_default_expires
+  end
 end

data/spec/moneta/adapters/mongo/adapter_mongo_spec.rb

@@ -2,11 +2,13 @@ describe 'adapter_mongo', adapter: :Mongo do
   let(:t_res) { 0.125 }
   let(:min_ttl) { t_res }
 
+  let(:database) { File.basename(__FILE__, '.rb') }
+
   moneta_build do
-    Moneta::Adapters::Mongo.new(mongo_config(
-      db: File.basename(__FILE__, '.rb'),
+    Moneta::Adapters::Mongo.new(
+      database: database,
       collection: 'adapter_mongo'
-    ))
+    )
   end
 
   moneta_specs ADAPTER_SPECS.with_each_key.with_native_expires.simplevalues_only
@@ -24,4 +26,16 @@ describe 'adapter_mongo', adapter: :Mongo do
     i.should be > 0 # Indicates that it took at least one sleep to expire
     query.count.should == 0
   end
+
+  it 'uses the database specified via the :database option' do
+    expect(store.config.database).to eq database
+  end
+
+  it 'uses the database specified via the :db option' do
+    store = Moneta::Adapters::Mongo.new(
+      db: database,
+      collection: 'adapter_mongo'
+    )
+    expect(store.config.database).to eq database
+  end
 end

data/spec/moneta/adapters/mongo/adapter_mongo_with_default_expires_spec.rb

@@ -1,13 +1,13 @@
 describe 'adapter_mongo_with_default_expires', isolate: true, adapter: :Mongo do
   let(:t_res) { 0.125 }
-  let(:min_ttl) { t_res }
+  let(:min_ttl) { t_res * 4 }
 
   moneta_build do
-    Moneta::Adapters::Mongo.new(mongo_config(
-    	db: File.basename(__FILE__, '.rb'),
+    Moneta::Adapters::Mongo.new(
+    	database: File.basename(__FILE__, '.rb'),
       collection: 'adapter_mongo_with_default_expires',
       expires: min_ttl
-    ))
+    )
   end
 
   moneta_specs ADAPTER_SPECS.with_each_key.with_expires.with_default_expires.simplevalues_only

data/spec/moneta/adapters/mongo/standard_mongo_spec.rb

@@ -2,6 +2,6 @@ describe 'standard_mongo', adapter: :Mongo do
   let(:t_res) { 0.125 }
   let(:min_ttl) { t_res }
 
-  moneta_store :Mongo, MongoHelper::mongo_config(db: File.basename(__FILE__, '.rb'), collection: 'standard_mongo')
+  moneta_store :Mongo, {database: File.basename(__FILE__, '.rb'), collection: 'standard_mongo'}
   moneta_specs STANDARD_SPECS.with_native_expires.with_each_key
 end

data/spec/moneta/adapters/redis/adapter_redis_spec.rb

@@ -2,9 +2,19 @@ describe 'adapter_redis', adapter: :Redis do
   let(:t_res) { 0.125 }
   let(:min_ttl) { t_res }
 
-  moneta_build do
-    Moneta::Adapters::Redis.new(db: 6)
+  describe 'without default expiry' do
+    moneta_build do
+      Moneta::Adapters::Redis.new(host: redis_host, port: redis_port, db: 6)
+    end
+
+    moneta_specs ADAPTER_SPECS.with_each_key.with_native_expires
   end
 
-  moneta_specs ADAPTER_SPECS.with_each_key.with_native_expires
+  describe 'with default expiry' do
+    moneta_build do
+      Moneta::Adapters::Redis.new(host: redis_host, port: redis_port, db: 6, expires: min_ttl)
+    end
+
+    moneta_specs NATIVE_EXPIRY_SPECS.with_default_expires
+  end
 end

data/spec/moneta/adapters/redis/standard_redis_spec.rb

@@ -2,6 +2,13 @@ describe 'standard_redis', adapter: :Redis do
   let(:t_res) { 0.125 }
   let(:min_ttl) { t_res }
 
-  moneta_store :Redis, db: 4
+  moneta_store :Redis do
+    {
+      db: 4,
+      host: redis_host,
+      port: redis_port
+    }
+  end
+
   moneta_specs STANDARD_SPECS.with_native_expires.with_each_key
 end

data/spec/moneta/adapters/sequel/adapter_sequel_spec.rb

@@ -5,7 +5,7 @@ describe ':Sequel adapter', adapter: :Sequel do
 
   specs = ADAPTER_SPECS.with_each_key.with_values(:nil)
 
-  context 'with MySQL backend' do
+  context 'with MySQL backend', mysql: true do
     moneta_build do
       Moneta::Adapters::Sequel.new(opts.merge(db: mysql_uri))
     end
@@ -13,7 +13,7 @@ describe ':Sequel adapter', adapter: :Sequel do
     include_examples :adapter_sequel, specs
   end
 
-  context "with SQLite backend" do
+  context "with SQLite backend", sqlite: true do
     moneta_build do
       Moneta::Adapters::Sequel.new(opts.merge(db: sqlite_uri('adapter_sequel.db')))
     end
@@ -21,7 +21,7 @@ describe ':Sequel adapter', adapter: :Sequel do
     include_examples :adapter_sequel, specs.without_concurrent
   end
 
-  context "with Postgres backend" do
+  context "with Postgres backend", postgres: true do
     moneta_build do
       Moneta::Adapters::Sequel.new(opts.merge(postgres_options))
     end
@@ -37,7 +37,7 @@ describe ':Sequel adapter', adapter: :Sequel do
     include_examples :adapter_sequel, specs, optimize: false
   end
 
-  context "with Postgres HStore backend" do
+  context "with Postgres HStore backend", postgres: true do
     moneta_build do
       Moneta::Adapters::Sequel.new(postgres_hstore_options)
     end

data/spec/moneta/adapters/sequel/helper.rb

@@ -2,9 +2,11 @@ RSpec.shared_context :sequel do
   def mysql_uri database=nil
     database ||= mysql_database1
     if defined?(JRUBY_VERSION)
-      "jdbc:mysql://localhost/#{database}?user=#{mysql_username}&useSSL=false"
+      uri = "jdbc:mysql://#{mysql_host}:#{mysql_port}/#{database}?user=#{mysql_username}&useSSL=false"
+      uri += "&password=#{mysql_password}" if mysql_password
+      uri
     else
-      "mysql2://#{mysql_username}:@localhost/#{database}"
+      "mysql2://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{database}"
     end
   end
 
@@ -15,11 +17,14 @@ RSpec.shared_context :sequel do
   def postgres_options database=nil
     database ||= postgres_database1
     if defined?(JRUBY_VERSION)
-      {db: "jdbc:postgresql://localhost/#{database}?user=#{postgres_username}"}
+      uri = "jdbc:postgresql://localhost/#{database}?user=#{postgres_username}"
+      uri += "&password=#{postgres_password}" if postgres_password
+      {db: uri}
     else
       {
         db: "postgres://localhost/#{database}",
-        user: postgres_username
+        user: postgres_username,
+        password: postgres_password
       }
     end
   end
@@ -33,7 +38,7 @@ RSpec.shared_context :sequel do
   def h2_uri
     "jdbc:h2:" + tempdir
   end
-end 
+end
 
 RSpec.shared_examples :adapter_sequel do |specs, optimize: true|
   shared_examples :each_key_server do

data/spec/moneta/adapters/sequel/standard_sequel_spec.rb

@@ -1,6 +1,6 @@
 require_relative './helper.rb'
 
-describe 'standard_sequel', adapter: :Sequel do
+describe 'standard_sequel', adapter: :Sequel, postgres: true do
   include_context :sequel
 
   moneta_store(:Sequel) { postgres_options.merge(table: "standard_sequel") }

data/spec/moneta/adapters/sequel/standard_sequel_with_expires_spec.rb

@@ -1,6 +1,6 @@
 require_relative './helper.rb'
 
-describe 'standard_sequel_with_expires', adapter: :Sequel do
+describe 'standard_sequel_with_expires', adapter: :Sequel, postgres: true do
   include_context :sequel
 
   let(:t_res) { 0.125 }

data/spec/moneta/adapters/sqlite/adapter_sqlite_spec.rb

@@ -1,4 +1,4 @@
-describe 'adapter_sqlite', unsupported: defined?(JRUBY_VERSION), adapter: :Sqlite do
+describe 'adapter_sqlite', unsupported: defined?(JRUBY_VERSION), adapter: :Sqlite, sqlite: true do
   moneta_build do
     Moneta::Adapters::Sqlite.new(file: File.join(tempdir, "adapter_sqlite"))
   end

data/spec/moneta/adapters/sqlite/standard_sqlite_spec.rb

@@ -1,4 +1,4 @@
-describe 'standard_sqlite', unsupported: defined?(JRUBY_VERSION), adapter: :Sqlite do
+describe 'standard_sqlite', unsupported: defined?(JRUBY_VERSION), adapter: :Sqlite, sqlite: true do
   moneta_store :Sqlite do
     {file: File.join(tempdir, "standard_sqlite")}
   end

data/spec/moneta/adapters/sqlite/standard_sqlite_with_expires_spec.rb

@@ -1,4 +1,4 @@
-describe 'standard_sqlite_with_expires', unsupported: defined?(JRUBY_VERSION), adapter: :Sqlite do
+describe 'standard_sqlite_with_expires', unsupported: defined?(JRUBY_VERSION), adapter: :Sqlite, sqlite: true do
   let(:t_res) { 0.125 }
   let(:min_ttl) { 1 }
   use_timecop

data/spec/moneta/config_spec.rb

@@ -0,0 +1,219 @@
+describe Moneta::Config do
+  describe 'without any configuration' do
+    it 'does not set the config attribute' do
+      klass = Class.new do
+        include ::Moneta::Config
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+
+      instance = klass.new(k: 'v')
+      expect(instance.config).to be nil
+    end
+  end
+
+  describe 'basic functionality' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a
+        config :b
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+    end
+
+    it 'sets all config values to nil by default' do
+      instance = klass.new
+      expect(instance.config.a).to eq nil
+      expect(instance.config.b).to be nil
+    end
+
+    it 'sets config values with values provided to #configure' do
+      instance = klass.new(a: 1)
+      expect(instance.config.a).to eq 1
+      expect(instance.config.b).to be nil
+    end
+
+    it 'freezes the config' do
+      instance = klass.new
+      expect(instance.config.frozen?).to be true
+    end
+  end
+
+  describe 'with required arguments' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a, required: true
+        config :b, default: 'x', required: true
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+    end
+
+    it 'raises an ArgumentError if #configure is called without one of the required arguments' do
+      expect { klass.new(a: 1) }.to raise_error ArgumentError, 'b is required'
+      expect { klass.new(b: 1) }.to raise_error ArgumentError, 'a is required'
+    end
+  end
+
+  describe 'with defaults' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a, default: 't'
+        config :b, default: 's'
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+    end
+
+    it 'uses the defaults if no argument is provided' do
+      instance = klass.new(a: 1)
+
+      expect(instance.config.a).to eq 1
+      expect(instance.config.b).to eq 's'
+    end
+
+    it 'allows falsy values to override truthy defaults' do
+      instance = klass.new(a: nil, b: false)
+
+      expect(instance.config.a).to be nil
+      expect(instance.config.b).to be false
+    end
+  end
+
+  describe 'with coercion' do
+    describe 'using a symbol' do
+      subject :klass do
+        Class.new do
+          include ::Moneta::Config
+
+          config :a, coerce: :to_s
+
+          def initialize(**options)
+            configure(**options)
+          end
+        end
+      end
+
+      it "uses the symbol's to_proc property" do
+        instance = klass.new(a: :x)
+        expect(instance.config.a).to eq 'x'
+      end
+    end
+
+    describe 'using a lambda' do
+      subject :klass do
+        Class.new do
+          include ::Moneta::Config
+
+          config :a, coerce: lambda { |a| a.to_sym }
+
+          def initialize(**options)
+            configure(**options)
+          end
+        end
+      end
+
+      it "calls the lambda" do
+        instance = klass.new(a: 'x')
+        expect(instance.config.a).to eq :x
+      end
+    end
+  end
+
+  describe 'with a block' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a do |a:, b:|
+          { a: a, b: b, test: @test }
+        end
+
+        config :b, default: 'b default'
+
+        def initialize(test: nil, **options)
+          @test = test
+          configure(**options)
+        end
+      end
+    end
+
+    it 'calls the block after all arguments and defaults have been processed' do
+      instance1 = klass.new(a: 'a value')
+      expect(instance1.config.a).to include(a: 'a value', b: 'b default')
+
+      instance2 = klass.new(b: 'b value')
+      expect(instance2.config.a).to include(a: nil, b: 'b value')
+    end
+
+    it 'calls the block using instance_exec' do
+      instance = klass.new(test: 'test value')
+      expect(instance.config.a).to include(test: 'test value')
+    end
+  end
+
+  describe 'with inheritance' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+    end
+
+    it 'does not allow subclasses to override superclass config' do
+      expect do
+        Class.new(klass) do
+          config :a
+        end
+      end.to raise_error ArgumentError, 'a is already a config option'
+    end
+
+    it 'does not affect the superclass when additional config is added to the subclass' do
+      klass2 = Class.new(klass) do
+        config :b
+      end
+
+      instance1 = klass.new(a: 1, b: 2)
+      expect(instance1.config.to_h).to eq(a: 1)
+
+      instance2 = klass2.new(a: 1, b: 2)
+      expect(instance2.config.to_h).to eq(a: 1, b: 2)
+    end
+
+    it 'is possible for two subclasses to have the same additional config' do
+      klass2 = Class.new(klass) do
+        config :b
+      end
+
+      klass3 = Class.new(klass) do
+        config :b
+      end
+
+      instance2 = klass2.new(a: 2, b: 1)
+      expect(instance2.config.to_h).to eq(a: 2, b: 1)
+
+      instance3 = klass3.new(a: 1, b: 2)
+      expect(instance3.config.to_h).to eq(a: 1, b: 2)
+    end
+  end
+end

data/spec/moneta/proxies/pool/pool_spec.rb

@@ -1,6 +1,6 @@
 require 'timeout'
 
-describe "pool", proxy: :Pool do
+describe "pool", proxy: :Pool, broken: ::Gem::Version.new(RUBY_ENGINE_VERSION) < ::Gem::Version.new('2.4.0') do
   describe "Moneta::Pool" do
     # To test the pool, we create the store once and pass the same object around
     # whenever a new store is requested.
@@ -153,7 +153,7 @@ describe "pool", proxy: :Pool do
       describe "closing stores after TTL expiry" do
         let(:num) { max || min + 10 }
 
-        it "closes available stores after ttl" do
+        it "closes unneeded stores after ttl" do
           stores.each do |store|
             allow(store).to receive(:close)
           end
@@ -169,6 +169,32 @@ describe "pool", proxy: :Pool do
       end
     end
 
+    shared_examples :ttl_with_nonzero_min do |ttl:, min:, max: nil|
+      describe "TTL check" do
+        let(:num) { max || min + 10 }
+
+        # This is testing that a very specific bug is fixed - see
+        # https://github.com/moneta-rb/moneta/issues/197.  A better long-term
+        # solution would be to have more granular tests of the functions in the
+        # PoolManager
+        it "doesn't cause a busy-loop when there are available stores" do
+          # Check a store in and out - now the manager needs to decide whether to close
+          # stores after ttl seconds.
+          store = subject.check_out
+          subject.check_in(store)
+          sleep ttl
+          expect(subject.stats[:available]).to be > 0
+
+          # needs to be less than the TTL, but otherwise not important.
+          sleep_time = ttl / 2.0
+          sleep sleep_time
+
+          # during the sleep, the pool manager should have been idle.
+          expect(subject.stats[:idle_time]).to be >= sleep_time
+        end
+      end
+    end
+
     shared_examples :timeout do |timeout, max:|
       describe "raising an error after timeout" do
         let(:num) { max }
@@ -233,6 +259,7 @@ describe "pool", proxy: :Pool do
       include_examples :min, 10
       include_examples :max, 20, timeout: 4
       include_examples :ttl, 1, min: 10, max: 20
+      include_examples :ttl_with_nonzero_min, ttl: 1, min: 10, max: 20
       include_examples :timeout, 4, max: 20
     end
 
@@ -243,6 +270,7 @@ describe "pool", proxy: :Pool do
       include_examples :min, 10
       include_examples :max, 10, timeout: 4
       include_examples :ttl, 2, min: 10, max: 10
+      include_examples :ttl_with_nonzero_min, ttl: 2, min: 10, max: 10
       include_examples :timeout, 4, max: 10
     end
 
@@ -292,7 +320,7 @@ describe "pool", proxy: :Pool do
       end
 
       it "raises a ShutdownError if the pool is stopped while waiting for a store" do
-        # Exaust the pool
+        # Exhaust the pool
         store = stores.first
         allow(store).to receive(:close).once
         expect(subject.check_out).to eq store

data/spec/moneta/proxies/transformer/transformer_bson_spec.rb

@@ -1,4 +1,6 @@
-describe 'transformer_bson', proxy: :Transformer do
+# Currently broken in JRuby 9.3 - see https://github.com/jruby/jruby/issues/6941
+
+describe 'transformer_bson', proxy: :Transformer, broken: defined?(JRUBY_VERSION) && ::Gem::Version.new(JRUBY_VERSION) >= ::Gem::Version.new('9.3.0.0') do
   moneta_build do
     Moneta.build do
       use :Transformer, key: :bson, value: :bson

data/spec/moneta/proxies/transformer/transformer_marshal_escape_spec.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 describe 'transformer_marshal_escape', proxy: :Transformer do
   moneta_build do
     Moneta.build do

data/spec/rack/session_moneta_spec.rb

@@ -4,30 +4,50 @@ require 'rack/mock'
 require 'thread'
 
 describe Rack::Session::Moneta do
-  session_key = Rack::Session::Moneta::DEFAULT_OPTIONS[:key]
-  session_match = /#{session_key}=([0-9a-fA-F]+);/
-  incrementor = lambda do |env|
-    env["rack.session"]["counter"] ||= 0
-    env["rack.session"]["counter"] += 1
-    Rack::Response.new(env["rack.session"].inspect).to_a
+  use_timecop
+
+  let(:session_key) { Rack::Session::Moneta::DEFAULT_OPTIONS[:key] }
+  let(:session_match) { /#{session_key}=([0-9a-fA-F]+);/ }
+
+  let :incrementor_proc do
+    lambda do |env|
+      env["rack.session"]["counter"] ||= 0
+      env["rack.session"]["counter"] += 1
+      Rack::Response.new(env["rack.session"].inspect).to_a
+    end
+  end
+
+  let :drop_session do
+    Rack::Lint.new(proc do |env|
+                     env['rack.session.options'][:drop] = true
+                     incrementor_proc.call(env)
+                   end)
+  end
+
+  let :renew_session do
+    Rack::Lint.new(proc do |env|
+                     env['rack.session.options'][:renew] = true
+                     incrementor_proc.call(env)
+                   end)
+  end
+
+  let :defer_session do
+    Rack::Lint.new(proc do |env|
+                     env['rack.session.options'][:defer] = true
+                     incrementor_proc.call(env)
+                   end)
+  end
+
+  let :skip_session do
+    Rack::Lint.new(proc do |env|
+                     env['rack.session.options'][:skip] = true
+                     incrementor_proc.call(env)
+                   end)
+  end
+
+  let :incrementor do
+    Rack::Lint.new(incrementor_proc)
   end
-  drop_session = Rack::Lint.new(proc do |env|
-                                  env['rack.session.options'][:drop] = true
-                                  incrementor.call(env)
-                                end)
-  renew_session = Rack::Lint.new(proc do |env|
-                                   env['rack.session.options'][:renew] = true
-                                   incrementor.call(env)
-                                 end)
-  defer_session = Rack::Lint.new(proc do |env|
-                                   env['rack.session.options'][:defer] = true
-                                   incrementor.call(env)
-                                 end)
-  skip_session = Rack::Lint.new(proc do |env|
-                                  env['rack.session.options'][:skip] = true
-                                  incrementor.call(env)
-                                end)
-  incrementor = Rack::Lint.new(incrementor)
 
   it 'supports different constructors' do
     Rack::Session::Moneta.new(incrementor, :store => :Memory)
@@ -96,8 +116,7 @@ describe Rack::Session::Moneta do
     res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
     res["Set-Cookie"].should == cookie
     res.body.should include '"counter"=>2'
-    puts 'Sleeping to expire session' if $DEBUG
-    sleep 4
+    advance 4
     res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
     res["Set-Cookie"].should_not == cookie
     res.body.should include '"counter"=>1'

data/spec/restserver.rb

@@ -1,18 +1,7 @@
 require 'faraday'
 require 'rack'
 require 'rack/moneta_rest'
-
-MONETA_RESTSERVER_LOGGER =
-  if defined?(JRUBY_VERSION)
-    require 'rjack-logback'
-    RJack::Logback.config_console( :level => :off )
-    require 'fishwife'
-    nil
-  else
-    require 'webrick'
-    # Keep webrick quiet
-    WEBrick::Log.new($stderr, WEBrick::BasicLog::ERROR)
-  end
+require 'webrick'
 
 class MonetaRestServerShutdown < StandardError; end
 
@@ -25,10 +14,10 @@ def start_restserver(port)
       end
     end,
     :environment => 'none',
-    :server => defined?(JRUBY_VERSION) ? :Fishwife : :webrick,
+    :server => :webrick,
     :Port => port,
     :AccessLog => [],
-    :Logger => MONETA_RESTSERVER_LOGGER
+    :Logger => WEBrick::Log.new($stderr, WEBrick::BasicLog::ERROR)
   )
 
   Thread.start { server.start }