moneta 1.0.0 → 1.5.1

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

@@ -0,0 +1,353 @@
+require 'timeout'
+
+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.
+    before :context do
+      tempdir = @pool_tempdir = Dir.mktmpdir
+      @pool_store = Moneta.build do
+        use :Pool, max: 2, timeout: 5 do
+          adapter :File, dir: tempdir
+        end
+      end
+    end
+
+    # Tell the manager to close all open stores
+    after :context do
+      @pool_store.stop
+      FileUtils.remove_dir(@pool_tempdir)
+    end
+
+    moneta_build { @pool_store }
+    moneta_specs ADAPTER_SPECS.with_each_key
+
+    it "raises an error on check-out the builder fails" do
+      store = Moneta.build do
+        use :Pool do
+          adapter(Class.new do
+            def initialize(options = {})
+              raise "boom"
+            end
+          end)
+        end
+      end
+
+      expect { store['x'] }.to raise_error "boom"
+    end
+  end
+
+  describe "Moneta::Pool::PoolManager" do
+    let :builder do
+      double('builder').tap do |builder|
+        i = -1
+        allow(builder).to receive(:build) do
+          [stores[i += 1]]
+        end
+      end
+    end
+
+    let(:stores) { (0...num).map { |i| double("store#{i}") } }
+
+    after { subject.kill! }
+
+    shared_examples :no_ttl do
+      context "with one store" do
+        let(:num) { 1 }
+
+        it "never expires the store" do
+          store = stores.first
+          expect(builder).to receive(:build).once
+          expect(subject.check_out).to be store
+          expect(subject.stats).to include(stores: 1, available: 0)
+          expect(subject.check_in(store)).to eq nil
+          expect(subject.stats).to include(stores: 1, available: 1)
+          sleep 1
+          expect(subject.stats).to include(stores: 1, available: 1)
+          expect(subject.check_out).to be store
+          expect(subject.check_in(store)).to eq nil
+        end
+      end
+    end
+
+    shared_examples :no_max do
+      context "with 1,000 stores" do
+        let(:num) { 1_000 }
+
+        it "never blocks" do
+          # Check out 1000 stores in 1000 threads
+          threads = (0...num).map do
+            Thread.new { subject.check_out }
+          end
+          expect(threads.map(&:value)).to contain_exactly(*stores)
+          expect(subject.stats).to include(stores: num, available: 0, waiting: 0)
+
+          # Check in the first 50
+          expect(stores.take(50).map { |store| subject.check_in(store) }).to all(be nil)
+          expect(subject.stats).to include(stores: num, available: 50, waiting: 0)
+
+          # Now check those 50 out again
+          threads = (0...50).map do
+            Thread.new { subject.check_out }
+          end
+          expect(threads.map(&:value)).to contain_exactly(*stores.take(50))
+
+          # Finally check in all stores
+          expect(stores.map { |store| subject.check_in(store) }).to all(be nil)
+        end
+      end
+    end
+
+    shared_examples :min do |min|
+      describe "initial number of stores" do
+        let(:num) { min }
+
+        it "starts with #{min} available stores" do
+          expect(subject.stats).to include(stores: min, available: min)
+          expect((0...min).map { subject.check_out }).to contain_exactly(*stores)
+        end
+      end
+    end
+
+    shared_examples :max do |max, timeout: 5|
+      describe "maximum number of stores" do
+        let(:num) { max }
+
+        after do
+          expect(stores.map { |store| subject.check_in(store) }).to all be_nil
+        end
+
+        it "blocks after #{max} stores have been created" do
+          # All stores are checked out
+          expect(max.times.map { subject.check_out }).to contain_exactly(*stores)
+
+          # Launch threads that make checkout requests (in order).  These will
+          # all block.
+          threads = max.times.map { Thread.new { subject.check_out } }
+          Timeout.timeout(timeout) { Thread.pass until subject.stats[:waiting] == max }
+          expect(threads).to all be_alive
+
+          # Check all stores except the first one back in.  This will cause all
+          # but one of the threads to return
+          expect(stores.drop(1).map { |store| subject.check_in(store) }).to all be_nil
+          Timeout.timeout(timeout) { Thread.pass until threads.select(&:alive?).length == 1 }
+          expect(subject.stats).to include(waiting: 1)
+
+          # Ensure that the stores that were checked back in are the ones that
+          # were given to the waiting threads.
+          alive, dead = threads.partition(&:alive?)
+          expect(dead.map(&:value)).to contain_exactly(*stores.drop(1))
+
+          # Check the last store back in and make sure it goes to the last
+          # waiting thread.
+          last_thread = alive.first
+          expect(subject.check_in(stores.first)).to eq nil
+          Timeout.timeout(timeout) { Thread.pass while last_thread.alive? }
+          expect(subject.stats).to include(waiting: 0)
+          expect(last_thread.value).to be stores.first
+        end
+      end
+    end
+
+    shared_examples :ttl do |ttl, min: 0, max: nil|
+      describe "closing stores after TTL expiry" do
+        let(:num) { max || min + 10 }
+
+        it "closes unneeded stores after ttl" do
+          stores.each do |store|
+            allow(store).to receive(:close)
+          end
+
+          Timeout.timeout(5) { Thread.pass until subject.stats[:stores] == min }
+          expect(stores.length.times.map { subject.check_out }).to contain_exactly(*stores)
+          expect(subject.stats).to include(stores: num, available: 0)
+          expect(stores.map { |store| subject.check_in(store) }).to all be_nil
+          expect(subject.stats).to include(stores: num, available: num)
+          sleep ttl
+          expect(subject.stats).to include(stores: min, available: min)
+        end
+      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 }
+
+        it "raises a timeout error after waiting too long" do
+          expect((0...num).map { subject.check_out }).to contain_exactly(*stores)
+          # One extra checkout request in a separate thread
+          t = Thread.new do
+            Thread.current.report_on_exception = false if Thread.current.respond_to? :report_on_exception
+            subject.check_out
+          end
+          Timeout.timeout(timeout) { Thread.pass until subject.stats[:waiting] == 1 }
+          expect(subject.stats[:longest_wait]).to be_a Time
+          expect(t).to be_alive
+          sleep timeout
+          Timeout.timeout(timeout) { Thread.pass while t.alive? }
+          expect { t.value }.to raise_error Moneta::Pool::TimeoutError
+          expect(subject.stats).to include(waiting: 0, longest_wait: nil)
+          expect(stores.map { |store| subject.check_in store }).to all be_nil
+        end
+      end
+    end
+
+    context "with default arguments" do
+      subject { Moneta::Pool::PoolManager.new(builder) }
+      after { subject.kill! }
+
+      include_examples :no_ttl
+      include_examples :no_max
+      include_examples :min, 0
+    end
+
+    context "with max: 10, timeout: 4" do
+      subject { Moneta::Pool::PoolManager.new(builder, max: 10, timeout: 4) }
+      after { subject.kill! }
+
+      include_examples :no_ttl
+      include_examples :max, 10, timeout: 4
+      include_examples :min, 0
+      include_examples :timeout, 4, max: 10
+    end
+
+    context "with min: 10" do
+      subject { Moneta::Pool::PoolManager.new(builder, min: 10) }
+      after { subject.kill! }
+
+      include_examples :no_max
+      include_examples :min, 10
+    end
+
+    context "with ttl: 1" do
+      subject { Moneta::Pool::PoolManager.new(builder, ttl: 1) }
+      after { subject.kill! }
+
+      include_examples :ttl, 1, min: 0
+    end
+
+    context "with min: 10, max: 20, ttl: 1, timeout: 4" do
+      subject { Moneta::Pool::PoolManager.new(builder, min: 10, max: 20, ttl: 1, timeout: 4) }
+      after { subject.kill! }
+
+      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
+
+    context "with min: 10, max: 10, ttl: 2, timeout: 4" do
+      subject { Moneta::Pool::PoolManager.new(builder, min: 10, max: 10, ttl: 2, timeout: 4) }
+      after { subject.kill! }
+
+      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
+
+    describe '#check_out' do
+      subject { Moneta::Pool::PoolManager.new(builder, max: 1, timeout: 5) }
+      after { subject.kill! }
+
+      let(:num) { 1 }
+
+      it 'yields the store to requesters first come, first served' do
+        store = stores.first
+        procs = (0...10)
+          .map { |i| double("proc#{i}") }
+          .each { |p| expect(p).to receive(:call).with(store).ordered }
+
+        # Each thread stops immediately after starting.  We can then ensure
+        # that each checkout is called in order.
+        threads = procs.map do |p|
+          Thread.new do
+            Thread.stop
+            p.call(subject.check_out)
+          end
+        end
+
+        Timeout.timeout(5) { Thread.pass until threads.all?(&:stop?) }
+
+        # The first thread should return immediately after waking
+        threads.first.wakeup
+        Timeout.timeout(5) { threads.first.join }
+
+        # Wait for the remaining threads to block, one at a time.
+        threads.drop(1).each_with_index do |thread, i|
+          thread.wakeup
+          Timeout.timeout(5) { Thread.pass until subject.stats[:waiting] == i + 1 }
+        end
+
+        # The remaining threads should be waiting for the store to be checked back in
+        expect(threads.drop(1)).to all be_alive
+        expect(subject.stats).to include(waiting: 9)
+
+        Timeout.timeout(5) do
+          threads.each do |t|
+            t.join
+            subject.check_in(store)
+          end
+        end
+      end
+
+      it "raises a ShutdownError if the pool is stopped while waiting for a store" do
+        # Exhaust the pool
+        store = stores.first
+        allow(store).to receive(:close).once
+        expect(subject.check_out).to eq store
+
+        # Simulate a new thread requesting a check-out
+        t1 = Thread.new do
+          Thread.current.report_on_exception = false if Thread.current.respond_to? :report_on_exception
+          subject.check_out
+        end
+        Timeout.timeout(5) { Thread.pass until subject.stats[:waiting] > 0 }
+        expect(t1).to be_alive
+
+        # Meanwhile in another thread, the pool is stopped.
+        t2 = Thread.new { subject.stop }
+
+        # The requesting thread should error out immediately
+        expect { t1.value }.to raise_error Moneta::Pool::ShutdownError
+
+        # In this thread we return the store to the pool, allowing graceful shutdown to complete.
+        subject.check_in(store)
+        expect(t2.value).to be_nil
+      end
+
+      it "raises a ShutdownError if a the pool is stopped before requesting a store" do
+        subject.stop
+        expect { subject.check_out }.to raise_error Moneta::Pool::ShutdownError
+      end
+    end
+  end
+end

data/spec/moneta/proxies/proxy/proxy_expires_memory_spec.rb

@@ -0,0 +1,16 @@
+describe "proxy_expires_memory", isolate: true, proxy: :Proxy do
+  let(:t_res) { 0.125 }
+  let(:min_ttl) { t_res }
+  use_timecop
+  
+  moneta_build do
+    Moneta.build do
+      use :Proxy
+      use :Expires
+      use :Proxy
+      adapter :Memory
+    end
+  end
+
+  moneta_specs STANDARD_SPECS.without_transform.with_expires.returnsame.without_persist.with_each_key
+end

data/spec/moneta/proxies/shared/shared_tcp_spec.rb

@@ -0,0 +1,59 @@
+describe "shared_tcp", proxy: :Shared do
+  moneta_build do
+    tempdir = self.tempdir
+    Moneta.build do
+      use(:Shared, port: 9001) do
+        adapter :GDBM, file: File.join(tempdir, 'shared_tcp')
+      end
+    end
+  end
+
+  shared_examples :shared_tcp do
+    moneta_specs ADAPTER_SPECS.with_each_key
+
+    it 'shares values' do
+      store['shared_key'] = 'shared_value'
+      second = new_store
+      second.key?('shared_key').should be true
+      second['shared_key'].should == 'shared_value'
+      second.close
+    end
+  end
+
+  # The first store initialised will be running the server
+  context "running as the server" do
+    before do
+      store.load('dummy')
+      expect(store.server?).to be true
+    end
+
+    include_examples :shared_tcp
+
+    it 'has the underlying adapter' do
+      store.load('dummy')
+      expect(store.adapter.adapter).to be_a Moneta::Adapters::GDBM
+    end
+  end
+
+  context "running as a client" do
+    let!(:server_store) do
+      new_store.tap { |store| store.load('dummy') } # Makes a connection
+    end
+
+    before do
+      store.load('dummy')
+      expect(store.server?).to be false
+    end
+
+    after do
+      server_store.close
+    end
+
+    include_examples :shared_tcp
+
+    it 'has a client adapter' do
+      store.load('dummy')
+      expect(store.adapter).to be_a Moneta::Adapters::Client
+    end
+  end
+end

data/spec/moneta/proxies/shared/shared_unix_spec.rb

@@ -0,0 +1,58 @@
+describe "shared_unix", proxy: :Shared do
+  moneta_build do
+    tempdir = self.tempdir
+    Moneta.build do
+      use(:Shared, socket: File.join(tempdir, 'shared_unix.socket')) do
+        adapter :GDBM, file: File.join(tempdir, 'shared_unix')
+      end
+    end
+  end
+
+  shared_examples :shared_unix do
+    moneta_specs ADAPTER_SPECS.with_each_key
+
+    it 'shares values' do
+      store['shared_key'] = 'shared_value'
+      second = new_store
+      second.key?('shared_key').should be true
+      second['shared_key'].should == 'shared_value'
+      second.close
+    end
+  end
+
+  context "runnning as the server" do
+    before do
+      store.load('dummy')
+      expect(store.server?).to be true
+    end
+
+    include_examples :shared_unix
+
+    it "has the underlying adapter" do
+      store.load('dummy')
+      expect(store.adapter.adapter).to be_a Moneta::Adapters::GDBM
+    end
+  end
+
+  context "running as a client" do
+    let!(:server_store) do
+      new_store.tap { |store| store.load('dummy') } # Makes a connection
+    end
+
+    before do
+      store.load('dummy')
+      expect(store.server?).to be false
+    end
+
+    after do
+      server_store.close
+    end
+
+    include_examples :shared_unix
+
+    it 'has a client adapter' do
+      store.load('dummy')
+      expect(store.adapter).to be_a Moneta::Adapters::Client
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+describe 'transformer_bencode', proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, key: :bencode, value: :bencode
+      adapter :Memory
+    end
+  end
+
+  moneta_loader do |value|
+    ::BEncode.load(value)
+  end
+
+  moneta_specs TRANSFORMER_SPECS.simplekeys_only.simplevalues_only.with_each_key
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::BencodeKeyBencodeValue.should_not be_nil
+  end
+end

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

@@ -0,0 +1,19 @@
+describe 'transformer_bert', unsupported: defined?(JRUBY_VERSION), proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, key: :bert, value: :bert
+      adapter :Memory
+    end
+  end
+
+  moneta_loader do |value|
+    ::BERT.decode(value)
+  end
+
+  moneta_specs TRANSFORMER_SPECS.simplekeys_only.simplevalues_only.with_each_key
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::BertKeyBertValue.should_not be_nil
+  end
+end

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

@@ -0,0 +1,25 @@
+# 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
+      adapter :Memory
+    end
+  end
+
+  moneta_loader do |value|
+    if ::BSON::VERSION >= '4.0.0'
+      ::BSON::Document.from_bson(::BSON::ByteBuffer.new(value))['v']
+    else
+      ::BSON::Document.from_bson(::StringIO.new(value))['v']
+    end
+  end
+
+  moneta_specs TRANSFORMER_SPECS.simplekeys_only.simplevalues_only.with_each_key
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::BsonKeyBsonValue.should_not be_nil
+  end
+end

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

@@ -0,0 +1,19 @@
+describe 'transformer_bzip2', proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, value: :bzip2
+      adapter :Memory
+    end
+  end
+
+  moneta_loader do |value|
+    ::RBzip2.default_adapter::Decompressor.new(::StringIO.new(value)).read
+  end
+
+  moneta_specs TRANSFORMER_SPECS.stringvalues_only.with_each_key
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::Bzip2Value.should_not be_nil
+  end
+end

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

@@ -0,0 +1,19 @@
+describe 'transformer_json', proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, key: :json, value: :json
+      adapter :Memory
+    end
+  end
+
+  moneta_loader do |value|
+    ::MultiJson.load(value)
+  end
+
+  moneta_specs TRANSFORMER_SPECS.simplekeys_only.simplevalues_only.with_each_key
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::JsonKeyJsonValue.should_not be_nil
+  end
+end

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

@@ -0,0 +1,17 @@
+describe 'transformer_key_inspect', proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, key: :inspect
+      adapter :Memory
+    end
+  end
+
+  moneta_loader{ |value| value }
+
+  moneta_specs TRANSFORMER_SPECS.returnsame.simplekeys_only
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::InspectKey.should_not be_nil
+  end
+end

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

@@ -0,0 +1,17 @@
+describe 'transformer_key_marshal', proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, key: :marshal
+      adapter :Memory
+    end
+  end
+
+  moneta_loader{ |value| value }
+
+  moneta_specs TRANSFORMER_SPECS.returnsame.with_each_key
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::MarshalKey.should_not be_nil
+  end
+end

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

@@ -0,0 +1,17 @@
+describe 'transformer_key_to_s', proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, key: :to_s
+      adapter :Memory
+    end
+  end
+
+  moneta_loader{ |value| value }
+
+  moneta_specs TRANSFORMER_SPECS.returnsame.simplekeys_only
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::ToSKey.should_not be_nil
+  end
+end

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

@@ -0,0 +1,17 @@
+describe 'transformer_key_yaml', proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, key: :yaml
+      adapter :Memory
+    end
+  end
+
+  moneta_loader{ |value| value }
+
+  moneta_specs TRANSFORMER_SPECS.returnsame.with_each_key
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::YamlKey.should_not be_nil
+  end
+end

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

@@ -0,0 +1,19 @@
+describe 'transformer_lz4', unsupported: defined?(JRUBY_VERSION), proxy: :Transformer do
+  moneta_build do
+    Moneta.build do
+      use :Transformer, value: :lz4
+      adapter :Memory
+    end
+  end
+
+  moneta_loader do |value|
+    ::LZ4.uncompress(value)
+  end
+
+  moneta_specs TRANSFORMER_SPECS.stringvalues_only.with_each_key
+
+  it 'compile transformer class' do
+    store.should_not be_nil
+    Moneta::Transformer::Lz4Value.should_not be_nil
+  end
+end