moneta 1.0.0 → 1.5.1

data/spec/moneta/adapters/activesupportcache/adapter_activesupportcache_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../memcached_helper.rb'
+
+describe 'adapter_activesupportcache', adapter: :ActiveSupportCache do
+  before :all do
+    require 'active_support'
+    require 'active_support/cache/moneta_store'
+  end
+
+  shared_examples :adapter_activesupportcache do
+    moneta_build do
+      Moneta::Adapters::ActiveSupportCache.new(backend: backend)
+    end
+
+    moneta_specs ADAPTER_SPECS.without_concurrent.without_create.with_native_expires
+  end
+
+  context 'using MemoryStore' do
+    let(:t_res) { 0.125 }
+    let(:min_ttl) { t_res }
+    use_timecop
+
+    let(:backend) { ActiveSupport::Cache::MemoryStore.new }
+    include_examples :adapter_activesupportcache
+  end
+
+  context 'using MemCacheStore', memcached: true do
+    let(:t_res) { 1 }
+    let(:min_ttl) { 2 }
+    use_timecop
+
+    include_context :start_memcached, 11215
+
+    let(:backend) { ActiveSupport::Cache::MemCacheStore.new('127.0.0.1:11215') }
+    include_examples :adapter_activesupportcache
+  end
+
+  context 'using RedisCacheStore', redis: true do
+    let(:t_res) { 1 }
+    let(:min_ttl) { t_res }
+    use_timecop
+
+    let(:backend) { ActiveSupport::Cache::RedisCacheStore.new(url: "redis://#{redis_host}:#{redis_port}/1") }
+    include_examples :adapter_activesupportcache
+  end
+
+  context 'using MonetaStore' do
+    let(:t_res) { 0.125 }
+    let(:min_ttl) { t_res }
+    use_timecop
+
+    let(:backend) { ActiveSupport::Cache::MonetaStore.new(store: Moneta.new(:Memory)) }
+    include_examples :adapter_activesupportcache
+  end
+end

data/spec/moneta/adapters/activesupportcache/adapter_activesupportcache_with_default_expires_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../memcached_helper'
+
+describe 'adapter_activesupportcache_with_default_expires', adapter: :ActiveSupportCache do
+  before :all do
+    require 'active_support'
+    require 'active_support/cache/moneta_store'
+  end
+
+  shared_examples :adapter_activesupportcache_with_default_expires do
+    moneta_build do
+      Moneta::Adapters::ActiveSupportCache.new(backend: backend, expires: min_ttl)
+    end
+
+    moneta_specs ADAPTER_SPECS.without_concurrent.without_create.with_native_expires.with_default_expires
+  end
+
+  context 'using MemoryStore' do
+    let(:t_res) { 0.125 }
+    let(:min_ttl) { t_res }
+    use_timecop
+
+    let(:backend) { ActiveSupport::Cache::MemoryStore.new }
+    include_examples :adapter_activesupportcache_with_default_expires
+  end
+
+  context 'using MemCacheStore', memcached: true do
+    let(:t_res) { 1 }
+    let(:min_ttl) { 2 }
+    use_timecop
+
+    include_context :start_memcached, 11223
+
+    let(:backend) { ActiveSupport::Cache::MemCacheStore.new('127.0.0.1:11223') }
+    include_examples :adapter_activesupportcache_with_default_expires
+  end
+
+  context 'using RedisCacheStore' do
+    let(:t_res) { 1 }
+    let(:min_ttl) { t_res }
+    use_timecop
+
+    let(:backend) { ActiveSupport::Cache::RedisCacheStore.new(url: "redis://#{redis_host}:#{redis_port}/2") }
+    include_examples :adapter_activesupportcache_with_default_expires
+  end
+
+  context 'using MonetaStore' do
+    let(:t_res) { 0.125 }
+    let(:min_ttl) { t_res }
+    use_timecop
+
+    let(:backend) { ActiveSupport::Cache::MonetaStore.new(store: Moneta.new(:Memory)) }
+    include_examples :adapter_activesupportcache_with_default_expires
+  end
+end

data/spec/moneta/adapters/activesupportcache/standard_activesupportcache_spec.rb

@@ -0,0 +1,14 @@
+describe 'standard_activesupportcache' do
+  before :context do
+    require 'active_support'
+  end
+
+  let(:t_res) { 0.1 }
+  let(:min_ttl) { 0.1 }
+
+  moneta_store :ActiveSupportCache do
+    { backend: ActiveSupport::Cache::MemoryStore.new }
+  end
+
+  moneta_specs STANDARD_SPECS.without_create.without_persist.with_native_expires
+end

data/spec/moneta/adapters/cassandra/adapter_cassandra_spec.rb

@@ -0,0 +1,17 @@
+require_relative './helper.rb'
+
+describe 'adapter_cassandra', retry: 3, adapter: :Cassandra, unsupported: RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0') do
+  let(:t_res) { 1 }
+  let(:min_ttl) { 2 }
+
+  include_context :global_cassandra_cluster
+
+  moneta_build do
+    Moneta::Adapters::Cassandra.new(
+      cluster: cluster,
+      keyspace: 'adapter_cassandra',
+      create_keyspace: { durable_writes: false })
+  end
+
+  moneta_specs ADAPTER_SPECS.without_increment.without_create.with_native_expires.with_values(:nil).with_each_key
+end

data/spec/moneta/adapters/cassandra/adapter_cassandra_with_default_expires_spec.rb

@@ -0,0 +1,18 @@
+require_relative './helper.rb'
+
+describe 'adapter_cassandra_with_default_expires', isolate: true, retry: 3, adapter: :Cassandra, unsupported: RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0') do
+  let(:t_res) { 1 }
+  let(:min_ttl) { 2 }
+
+  include_context :global_cassandra_cluster
+
+  moneta_build do
+    Moneta::Adapters::Cassandra.new(
+      cluster: cluster,
+      keyspace: 'adapter_cassandra_with_default_expires',
+      expires: min_ttl,
+      create_keyspace: { durable_writes: false })
+  end
+
+  moneta_specs ADAPTER_SPECS.without_increment.without_create.with_native_expires.with_default_expires.with_values(:nil).with_each_key
+end

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

@@ -0,0 +1,18 @@
+# This is used in order to speed up cassandra specs
+RSpec.shared_context :global_cassandra_cluster do
+  before :all do
+    require 'cassandra'
+    $moneta_cassandra_cluster ||= ::Cassandra.cluster
+  end
+
+  let(:cluster) { $moneta_cassandra_cluster }
+end
+
+RSpec.configure do |config|
+  config.after :suite do
+    if $moneta_cassandra_cluster
+      $moneta_cassandra_cluster.close
+      $moneta_cassandra_cluster = nil
+    end
+  end
+end

data/spec/moneta/adapters/cassandra/standard_cassandra_spec.rb

@@ -0,0 +1,18 @@
+require_relative './helper.rb'
+
+describe "standard_cassandra", retry: 3, adapter: :Cassandra, unsupported: RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0') do
+  let(:t_res) { 1 }
+  let(:min_ttl) { 2 }
+
+  include_context :global_cassandra_cluster
+
+  moneta_store :Cassandra do
+    {
+      cluster: cluster,
+      keyspace: "standard_cassandra",
+      create_keyspace: { durable_writes: false }
+    }
+  end
+
+  moneta_specs STANDARD_SPECS.without_increment.without_create.with_native_expires.with_each_key
+end

data/spec/moneta/adapters/client/adapter_client_spec.rb

@@ -0,0 +1,11 @@
+require_relative './client_helper.rb'
+
+describe 'adapter_client', adapter: :Client do
+  include_context :start_server, port: 9002, backend: ->{ Moneta::Adapters::Memory.new }
+
+  moneta_build do
+    Moneta::Adapters::Client.new(port: 9002)
+  end
+
+  moneta_specs ADAPTER_SPECS.with_each_key
+end

data/spec/moneta/adapters/client/client_helper.rb

@@ -0,0 +1,25 @@
+RSpec.shared_context :start_server do |**options|
+  before :context do
+    begin
+      options.each do |key, value|
+        options[key] = instance_exec(&value) if value.respond_to? :call
+      end
+      backend = options.delete(:backend)
+      @server = Moneta::Server.new(backend, options)
+      @thread = Thread.new { @server.run }
+      sleep 0.1 until @server.running?
+    rescue Exception => ex
+      puts "Failed to start server - #{ex.message}"
+      tries ||= 0
+      tries += 1
+      timeout = options[:timeout] || Moneta::Server.config_defaults[:timeout]
+      sleep 1
+      tries < 3 ? retry : raise
+    end
+  end
+
+  after :context do
+    @server&.stop
+    @thread&.join
+  end
+end

data/spec/moneta/adapters/client/standard_client_tcp_spec.rb

@@ -0,0 +1,23 @@
+require_relative './client_helper.rb'
+
+describe "standard_client_tcp", adapter: :Client do
+  include_context :start_server, port: 9003, backend: ->{ Moneta::Adapters::Memory.new }
+
+  moneta_store :Client, port: 9003
+  moneta_specs STANDARD_SPECS.with_each_key
+
+  it 'supports multiple clients' do
+    store['shared_key'] = 'shared_val'
+    threads = (1..32).map do |i|
+      Thread.new do
+        client = new_store
+        (1..31).each do |j|
+          client['shared_key'].should == 'shared_val'
+          client["key-\#{j}-\#{i}"] = "val-\#{j}-\#{i}"
+          client["key-\#{j}-\#{i}"].should == "val-\#{j}-\#{i}"
+        end
+      end
+    end
+    threads.map(&:join)
+  end
+end

data/spec/moneta/adapters/client/standard_client_unix_spec.rb

@@ -0,0 +1,28 @@
+require_relative './client_helper.rb'
+
+describe "standard_client_unix", adapter: :Client do
+  include_context :start_server,
+                  backend: ->{ Moneta::Adapters::Memory.new },
+                  socket: ->{ File.join(tempdir, 'standard_client_unix') }
+
+  moneta_store :Client do
+    { socket: File.join(tempdir, 'standard_client_unix') }
+  end
+
+  moneta_specs STANDARD_SPECS.with_each_key
+
+  it 'supports multiple clients' do
+    store['shared_key'] = 'shared_val'
+    threads = (1..32).map do |i|
+      Thread.new do
+        client = new_store
+        (1..31).each do |j|
+          client['shared_key'].should == 'shared_val'
+          client["key-\#{j}-\#{i}"] = "val-\#{j}-\#{i}"
+          client["key-\#{j}-\#{i}"].should == "val-\#{j}-\#{i}"
+        end
+      end
+    end
+    threads.map(&:join)
+  end
+end

data/spec/moneta/adapters/cookie/adapter_cookie_spec.rb

@@ -0,0 +1,7 @@
+describe 'adapter_cookie', adapter: :Cookie do
+  moneta_build do
+    Moneta::Adapters::Cookie.new
+  end
+
+  moneta_specs ADAPTER_SPECS.with_each_key.without_persist.returnsame
+end

data/spec/moneta/adapters/couch/adapter_couch_spec.rb

@@ -0,0 +1,204 @@
+require_relative '../faraday_helper.rb'
+
+describe 'adapter_couch', adapter: :Couch do
+  include_context :faraday_adapter
+
+  moneta_build do
+    Moneta::Adapters::Couch.new(db: 'adapter_couch', adapter: faraday_adapter, login: couch_login, password: couch_password)
+  end
+
+  moneta_specs ADAPTER_SPECS.without_increment.simplevalues_only.without_path.with_each_key
+
+  shared_examples :batch do
+    shared_examples :no_batch do
+      it "does not add 'batch=ok' to the query'" do
+        expect(store).not_to receive(:request).with(any_args, hash_including(query: hash_including(batch: 'ok')))
+        expect(store).to receive(:request)
+        store.public_send(m, *args, options)
+      end
+    end
+
+    context 'without a :batch option' do
+      let(:options) { {} }
+      include_examples(:no_batch)
+    end
+
+    context 'with batch: false' do
+      let(:options) { { batch: false } }
+      include_examples(:no_batch)
+    end
+
+    context 'with batch: true' do
+      let(:options) { { batch: true } }
+
+      it "adds 'batch=ok' to the query'" do
+        expect(store).to receive(:request).with(instance_of(Symbol), instance_of(String), any_args,
+                                                hash_including(expect: 202, query: hash_including(batch: 'ok')))
+        store.public_send(m, *args, options)
+      end
+    end
+  end
+
+  shared_examples :full_commit do
+    context 'without a :full_commit option' do
+      let(:options) { {} }
+
+      it "does not add a 'X-Couch-Full-Commit' header'" do
+        expect(store).not_to receive(:request)
+          .with(any_args, hash_including(headers: hash_including('X-Couch-Full-Commit' => instance_of(String))))
+        expect(store).to receive(:request).ordered
+        store.public_send(m, *args, options)
+      end
+    end
+
+    context 'with full_commit: true' do
+      let(:options) { { full_commit: true } }
+
+      it "adds 'X-Couch-Full-Commit: true' to the headers'" do
+        expect(store).to receive(:request)
+          .with(instance_of(Symbol), instance_of(String), any_args,
+                hash_including(headers: hash_including('X-Couch-Full-Commit' => 'true')))
+          .ordered
+        store.public_send(m, *args, options)
+      end
+    end
+
+    context 'with full_commit: false' do
+      let(:options) { { full_commit: false } }
+
+      it "adds 'X-Couch-Full-Commit: false' to the headers'" do
+        expect(store).to receive(:request)
+          .with(instance_of(Symbol), instance_of(String), any_args,
+                hash_including(headers: hash_including('X-Couch-Full-Commit' => 'false')))
+          .ordered
+        store.public_send(m, *args, options)
+      end
+    end
+  end
+
+  describe '#store' do
+    let(:m) { :store }
+    let(:args) { ['a', 'b'] }
+
+    include_examples :batch
+    include_examples :full_commit
+  end
+
+  describe '#delete' do
+    let(:m) { :delete }
+    let(:args) { ['a'] }
+
+    before do
+      expect(store).to receive(:request).with(:get, 'a', any_args).ordered do
+        Faraday::Response.new(
+          Faraday::Env.from(status: 200,
+                            body: '{"type":"Hash","test":1}',
+                            response_headers: { 'ETag' => '"testrev"' }))
+      end
+    end
+
+    include_examples :batch
+    include_examples :full_commit
+  end
+
+  describe '#merge!' do
+    let(:m) { :merge! }
+    let(:args) { [{'a' => '1'}] }
+
+    before do
+      expect(store).to receive(:request).with(:post, '_all_docs', any_args).ordered do
+        { 'rows' => [] }
+      end
+
+      allow(store).to receive(:request).with(:post, '_bulk_docs', any_args) do
+        [
+          {
+            "ok" => true,
+            "id" => 'a',
+            "rev" => 'testrev'
+          }
+        ]
+      end
+    end
+
+    include_examples :full_commit
+  end
+
+  describe '#clear' do
+    context 'changing full commit behaviour' do
+      let(:m) { :clear }
+      let(:args) { [] }
+
+      # This will make the clear method proceed to deletion
+      before do
+        responses = [
+          {
+            'rows' => [
+              {
+                'id' => 'test',
+                'value' => {
+                  'rev' => 'testrev'
+                }
+              }
+            ]
+          },
+          { 'rows' => [] }
+        ]
+
+        expect(store).to receive(:request).at_least(:once).with(:get, '_all_docs', any_args).ordered do
+          responses.shift
+        end
+      end
+
+      include_examples :full_commit
+    end
+
+    shared_examples :no_compact do
+      it 'does not post to the _compact endpoint' do
+        expect(store).not_to receive(:post).with('_compact', any_args)
+        store.clear(options)
+      end
+    end
+
+    context 'without a :compact option' do
+      let(:options) { {} }
+      include_examples :no_compact
+    end
+
+    context 'with compact: true' do
+      it 'posts to the _compact endpoint' do
+        expect(store).to receive(:post).with('_compact', any_args)
+        store.clear(compact: true)
+      end
+    end
+
+    context 'with compact: false' do
+      let(:options) { { compact: false } }
+      include_examples :no_compact
+    end
+
+    context 'with await_compact: true' do
+      it "waits for compaction to complete" do
+        # This simulates an empty DB, so no deletes
+        expect(store).to receive(:get).with('_all_docs', any_args).ordered { { 'rows' => [] } }
+
+        # Next, compact is called.
+        expect(store).to receive(:post).with('_compact', any_args).ordered
+
+        # We expect the method to call get the DB info as many times as the true value is returned.
+        expect(store).to receive(:get).twice.with('', any_args).ordered { { 'compact_running' => true } }
+        expect(store).to receive(:get).once.with('', any_args).ordered { { 'compact_running' => false } }
+        store.clear(compact: true, await_compact: true)
+      end
+    end
+
+    context 'with await_compact: false' do
+      it "does not wait for compaction to complete" do
+        expect(store).to receive(:get).with('_all_docs', any_args).ordered { { 'rows' => [] } }
+        expect(store).to receive(:post).with('_compact', any_args).ordered
+        expect(store).not_to receive(:get).with('', any_args).ordered
+        store.clear(compact: true, await_compact: false)
+      end
+    end
+  end
+end

data/spec/moneta/adapters/couch/standard_couch_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../faraday_helper.rb'
+
+describe "standard_couch", adapter: :Couch do
+  include_context :faraday_adapter
+
+  moneta_store :Couch do
+    { db: 'standard_couch', adapter: faraday_adapter, login: couch_login, password: couch_password }
+  end
+
+  moneta_loader do |value|
+    ::Marshal.load(value.unpack('m').first)
+  end
+
+  moneta_specs STANDARD_SPECS.without_increment.with_each_key
+end

data/spec/moneta/adapters/couch/standard_couch_with_expires_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../faraday_helper.rb'
+
+describe "standard_couch_with_expires", adapter: :Couch do
+  let(:t_res) { 0.125 }
+  let(:min_ttl) { t_res }
+  use_timecop
+
+  include_context :faraday_adapter
+
+  moneta_store :Couch do
+    { db: 'standard_couch_with_expires', adapter: faraday_adapter, expires: true, login: couch_login, password: couch_password }
+  end
+
+  moneta_loader do |value|
+    ::Marshal.load(value.unpack('m').first)
+  end
+
+  moneta_specs STANDARD_SPECS.without_increment.with_expires.with_each_key
+end

data/spec/moneta/adapters/datamapper/adapter_datamapper_spec.rb

@@ -0,0 +1,60 @@
+describe 'adapter_datamapper', unsupported: defined?(JRUBY_VERSION) || RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0'), adapter: :DataMapper, mysql: true do
+  before :all do
+    require 'dm-core'
+
+    # DataMapper needs default repository to be setup
+    DataMapper.setup(:default, adapter: :in_memory)
+  end
+
+  moneta_build do
+    Moneta::Adapters::DataMapper.new(
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "adapter_datamapper"
+    )
+  end
+
+  moneta_specs ADAPTER_SPECS.without_increment.with_values(:nil).without_values(:binary)
+
+  it 'does not cross contaminate when storing' do
+    first = Moneta::Adapters::DataMapper.new(
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "datamapper_first"
+    )
+    first.clear
+
+    second = Moneta::Adapters::DataMapper.new(
+      repository: :sample,
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "datamapper_second"
+    )
+    second.clear
+
+    first['key'] = 'value'
+    second['key'] = 'value2'
+
+    first['key'].should == 'value'
+    second['key'].should == 'value2'
+  end
+
+  it 'does not cross contaminate when deleting' do
+    first = Moneta::Adapters::DataMapper.new(
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "datamapper_first"
+    )
+    first.clear
+
+    second = Moneta::Adapters::DataMapper.new(
+      repository: :sample,
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "datamapper_second"
+    )
+    second.clear
+
+    first['key'] = 'value'
+    second['key'] = 'value2'
+
+    first.delete('key').should == 'value'
+    first.key?('key').should be false
+    second['key'].should == 'value2'
+  end
+end

data/spec/moneta/adapters/datamapper/standard_datamapper_spec.rb

@@ -0,0 +1,21 @@
+describe "standard_datamapper", unsupported: defined?(JRUBY_VERSION) || RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0'), adapter: :DataMapper, mysql: true do
+  before :all do
+    require 'dm-core'
+
+    # DataMapper needs default repository to be setup
+    DataMapper.setup(:default, adapter: :in_memory)
+  end
+
+  moneta_store :DataMapper do
+    {
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "simple_datamapper"
+    }
+  end
+
+  moneta_loader do |value|
+    ::Marshal.load(value.unpack('m').first)
+  end
+
+  moneta_specs STANDARD_SPECS.without_increment
+end

data/spec/moneta/adapters/datamapper/standard_datamapper_with_expires_spec.rb

@@ -0,0 +1,26 @@
+describe "standard_datamapper_with_expires", unsupported: defined?(JRUBY_VERSION) || RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0'), adapter: :DataMapper, mysql: true do
+  let(:t_res) { 0.125 }
+  let(:min_ttl) { t_res }
+  use_timecop
+
+  before :all do
+    require 'dm-core'
+
+    # DataMapper needs default repository to be setup
+    DataMapper.setup(:default, adapter: :in_memory)
+  end
+
+  moneta_store :DataMapper do
+    {
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "simple_datamapper_with_expires",
+      expires: true
+    }
+  end
+
+  moneta_loader do |value|
+    ::Marshal.load(value.unpack('m').first)
+  end
+
+  moneta_specs STANDARD_SPECS.without_increment.with_expires
+end

data/spec/moneta/adapters/datamapper/standard_datamapper_with_repository_spec.rb

@@ -0,0 +1,22 @@
+describe 'standard_datamapper_with_repository', unsupported: defined?(JRUBY_VERSION) || RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0'), adapter: :DataMapper, mysql: true do
+  before :all do
+    require 'dm-core'
+
+    # DataMapper needs default repository to be setup
+    DataMapper.setup(:default, adapter: :in_memory)
+  end
+
+  moneta_store :DataMapper do
+    {
+      repository: :repo,
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "simple_datamapper_with_repository"
+    }
+  end
+
+  moneta_loader do |value|
+    ::Marshal.load(value.unpack('m').first)
+  end
+
+  moneta_specs STANDARD_SPECS.without_increment
+end

data/spec/moneta/adapters/daybreak/adapter_daybreak_spec.rb

@@ -0,0 +1,7 @@
+describe 'adapter_daybreak', adapter: :Daybreak do
+  moneta_build do
+    Moneta::Adapters::Daybreak.new(file: File.join(tempdir, "adapter_daybreak"))
+  end
+
+  moneta_specs ADAPTER_SPECS.without_multiprocess.returnsame.with_each_key
+end