moneta 1.0.0 → 1.1.0

data/spec/moneta/adapters/activerecord/adapter_activerecord_existing_connection_spec.rb

@@ -0,0 +1,59 @@
+describe 'adapter_activerecord_existing_connection', adapter: :ActiveRecord do
+  before :all do
+    require 'active_record'
+  end
+
+  before do
+    default_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    ActiveRecord::Base.configurations = {
+      default_env => {
+        'adapter' => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        'database' => mysql_database1,
+        'username' => mysql_username,
+        'password' => mysql_password
+      }
+    }
+
+    ActiveRecord::Base.establish_connection
+  end
+
+  moneta_build do
+    Moneta::Adapters::ActiveRecord.new(table: 'adapter_activerecord_existing_connection')
+  end
+
+  moneta_specs ADAPTER_SPECS.with_each_key
+
+  # This is based on
+  # https://github.com/jjb/rails/blob/ar-connection-management-guide/guides/source/active_record_connection_management.md
+  it "supports use on a forking web server", unsupported: !Process.respond_to?(:fork) do
+    store['a'] = 'b'
+
+    # Before forking, the connection pool is disconnected so that the
+    # forked processes don't use the same connections.
+    ActiveRecord::Base.connection_pool.disconnect!
+
+    pids = 8.times.map do
+      Process.fork do
+        # Connection is then reestablished in the forked process
+        ActiveRecord::Base.establish_connection
+
+        exit 1 unless store['a'] == 'b'
+
+        store[Process.pid.to_s] = '1'
+        exit 1 unless store[Process.pid.to_s] == '1'
+      end
+    end
+
+    pids.each do |pid|
+      pid2, status = Process.wait2(pid)
+      expect(pid2).to eq pid
+      expect(status.exitstatus).to eq 0
+    end
+
+    # Check that the stores were all operating on the same DB
+    ActiveRecord::Base.establish_connection
+    pids.each do |pid|
+      expect(store[pid.to_s]).to eq '1'
+    end
+  end
+end

data/spec/moneta/adapters/activerecord/adapter_activerecord_spec.rb

@@ -0,0 +1,118 @@
+describe 'adapter_activerecord', adapter: :ActiveRecord do
+  activerecord_specs = ADAPTER_SPECS.with_values(:nil).with_each_key
+
+  shared_examples :adapter_activerecord do |specs|
+    moneta_build do
+      Moneta::Adapters::ActiveRecord.new(
+        table: 'adapter_activerecord',
+        connection: connection1)
+    end
+
+
+    moneta_specs specs
+
+    it 'updates an existing key/value' do
+      store['foo/bar'] = '1'
+      store['foo/bar'] = '2'
+      store.with_connection do |conn|
+        count = conn.select_value \
+          store.table.
+            where(store.table[:k].eq('foo/bar')).
+            project(store.table[:k].count)
+        expect(count).to eq 1
+      end
+    end
+
+    it 'supports different tables same database' do
+      store1 = Moneta::Adapters::ActiveRecord.new(
+        table: 'adapter_activerecord1',
+        connection: connection1)
+      store2 = Moneta::Adapters::ActiveRecord.new(
+        table: 'adapter_activerecord2',
+        connection: connection1)
+
+      store1['key'] = 'value1'
+      store2['key'] = 'value2'
+      store1['key'].should == 'value1'
+      store2['key'].should == 'value2'
+
+      store1.close
+      store2.close
+    end
+
+    it 'supports different databases same table' do
+      store1 = Moneta::Adapters::ActiveRecord.new(
+        table: 'adapter_activerecord',
+        connection: connection1)
+      store2 = Moneta::Adapters::ActiveRecord.new(
+        table: 'adapter_activerecord',
+        connection: connection2)
+
+      store1['key'] = 'value1'
+      store2['key'] = 'value2'
+      store1['key'].should == 'value1'
+      store2['key'].should == 'value2'
+
+      store1.close
+      store2.close
+    end
+  end
+
+  context "with MySQL" do
+    let(:connection1) do
+      {
+        adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        database: mysql_database1,
+        username: mysql_username
+      }
+    end
+
+    let(:connection2) do
+      {
+        adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        database: mysql_database2,
+        username: mysql_username
+      }
+    end
+
+    include_examples :adapter_activerecord, activerecord_specs
+  end
+
+  context "with PostgreSQL" do
+    let(:connection1) do
+      {
+        adapter: (defined?(JRUBY_VERSION) ? 'jdbcpostgresql' : 'postgresql'),
+        database: postgres_database1,
+        username: postgres_username
+      }
+    end
+
+    let(:connection2) do
+      {
+        adapter: (defined?(JRUBY_VERSION) ? 'jdbcpostgresql' : 'postgresql'),
+        database: postgres_database2,
+        username: postgres_username
+      }
+    end
+
+    include_examples :adapter_activerecord, activerecord_specs
+  end
+
+  context "with SQLite" do
+    let(:connection1) do
+      {
+        adapter: (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'),
+        database: File.join(tempdir, 'adapter_activerecord1.db')
+      }
+    end
+
+    let(:connection2) do
+      {
+        adapter: (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'),
+        database: File.join(tempdir, 'adapter_activerecord2.db')
+      }
+    end
+
+    include_examples :adapter_activerecord, activerecord_specs.without_concurrent
+  end
+end

data/spec/moneta/adapters/activerecord/standard_activerecord_spec.rb

@@ -0,0 +1,18 @@
+describe "standard_activerecord", adapter: :ActiveRecord do
+  moneta_store :ActiveRecord do
+    {
+      table: 'standard_activerecord',
+      connection: {
+        adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        database: mysql_database1,
+        username: mysql_username
+      }
+    }
+  end
+
+  moneta_loader do |value|
+    ::Marshal.load(value.unpack('m').first)
+  end
+
+  moneta_specs STANDARD_SPECS
+end

data/spec/moneta/adapters/activerecord/standard_activerecord_with_expires_spec.rb

@@ -0,0 +1,24 @@
+describe "standard_activerecord_with_expires", adapter: :ActiveRecord do
+  let(:t_res) { 0.125 }
+  let(:min_ttl) { t_res }
+  use_timecop
+
+  moneta_store :ActiveRecord do
+    {
+      table: 'standard_activerecord_with_expires',
+      connection: {
+        adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        database: mysql_database1,
+        username: mysql_username
+      },
+      expires: true
+    }
+  end
+
+
+  moneta_loader do |value|
+    ::Marshal.load(value.unpack('m').first)
+  end
+
+  moneta_specs STANDARD_SPECS.with_expires
+end

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

@@ -0,0 +1,51 @@
+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' do
+    let(:t_res) { 1 }
+    let(:min_ttl) { 2 }
+    use_timecop
+    start_memcached 11215
+
+    let(:backend) { ActiveSupport::Cache::MemCacheStore.new('127.0.0.1:11215') }
+    include_examples :adapter_activesupportcache
+  end
+
+  context 'using RedisCacheStore' do
+    let(:t_res) { 1 }
+    let(:min_ttl) { t_res }
+    use_timecop
+
+    let(:backend) { ActiveSupport::Cache::RedisCacheStore.new(url: 'redis:///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,51 @@
+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' do
+    let(:t_res) { 1 }
+    let(:min_ttl) { 2 }
+    use_timecop
+    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:///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/cassandra/adapter_cassandra_spec.rb

@@ -0,0 +1,17 @@
+require_relative './helper.rb'
+
+describe 'adapter_cassandra', retry: 3, adapter: :Cassandra 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 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 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
+end

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

@@ -0,0 +1,11 @@
+describe 'adapter_client', isolate: true, adapter: :Client do
+  before :all do
+    start_server(Moneta::Adapters::Memory.new)
+  end
+
+  moneta_build do
+    Moneta::Adapters::Client.new
+  end
+
+  moneta_specs ADAPTER_SPECS
+end

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

@@ -0,0 +1,23 @@
+describe "standard_client_tcp", isolate: true, adapter: :Client do
+  before :all do
+    start_server(Moneta::Adapters::Memory.new)
+  end
+
+  moneta_store :Client
+  moneta_specs STANDARD_SPECS
+
+  it 'supports multiple clients' do
+    store['shared_key'] = 'shared_val'
+    threads = (1..100).map do |i|
+      Thread.new do
+        client = new_store
+        (1..100).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,12 @@
+describe "standard_client_unix", isolate: true, adapter: :Client do
+  before :all do
+    start_server Moneta::Adapters::Memory.new,
+                 socket: File.join(tempdir, 'standard_client_unix')
+  end
+
+  moneta_store :Client do
+    {socket: File.join(tempdir, 'standard_client_unix')}
+  end
+
+  moneta_specs STANDARD_SPECS
+end