mcmire-cache 0.3.4

data/test/test_active_support_cache_dalli_store.rb

@@ -0,0 +1,77 @@
+require 'helper'
+
+require 'dalli'
+require 'active_support/cache/dalli_store'
+require 'active_support/cache'
+
+class TestActiveSupportCacheDalliStore < TestCase
+  def raw_client_class
+    ActiveSupport::Cache::DalliStore
+  end
+
+  def raw_client
+    raw_client_class.new ['localhost:11211']
+  end
+
+  include SharedTests
+
+  def get_ring_object_id
+    hidden_dalli_client = cache.metal.instance_variable_get :@data
+    hidden_dalli_client.instance_variable_get(:@ring).object_id
+  end
+
+  def test_treats_as_thread_safe
+    # make sure ring is initialized
+    cache.get 'hi'
+
+    # get the main thread's ring
+    main_thread_ring_id = get_ring_object_id
+
+    # sanity check that it's not changing every time
+    cache.get 'hi'
+    assert_equal main_thread_ring_id, get_ring_object_id
+
+    # create a new thread and get its ring
+    new_thread_ring_id = Thread.new { cache.get 'hi'; get_ring_object_id }.value
+
+    # make sure the ring was reinitialized
+    assert_equal main_thread_ring_id, new_thread_ring_id
+  end
+
+  def test_treats_as_not_fork_safe
+    # make sure ring is initialized
+    cache.get 'hi'
+
+    # get the main thread's ring
+    parent_process_ring_id = get_ring_object_id
+
+    # sanity check that it's not changing every time
+    cache.get 'hi'
+    assert_equal parent_process_ring_id, get_ring_object_id
+
+    # fork a new process
+    pid = Kernel.fork do
+      cache.get 'hi'
+      raise "Didn't split!" if parent_process_ring_id == get_ring_object_id
+    end
+    Process.wait pid
+
+    # make sure it didn't raise
+    assert $?.success?
+  end
+
+  def test_set_with_default_dalli_ttl
+    cache = Cache.new(ActiveSupport::Cache::DalliStore.new(:expires_in => 1))
+    cache.set('foo', 'bar')
+    sleep 2
+    assert_equal nil, cache.get('foo')
+  end
+
+  def test_fetch_with_default_dalli_ttl
+    cache = Cache.new(ActiveSupport::Cache::DalliStore.new(:expires_in => 1))
+    cache.fetch('foo') { 'bar' }
+    sleep 2
+    assert_equal nil, cache.fetch('foo')
+    assert_equal 'different', cache.fetch('foo') { 'different' }
+  end
+end

data/test/test_active_support_cache_file_store.rb

@@ -0,0 +1,19 @@
+require 'helper'
+require 'tmpdir'
+require 'fileutils'
+
+require 'active_support/cache'
+
+class TestActiveSupportCacheFileStore < TestCase
+  def raw_client_class
+    ActiveSupport::Cache::FileStore
+  end
+
+  def raw_client
+    tmpdir = File.join(Dir.tmpdir, "Cache-TestActiveSupportCacheFileStore-#{rand(1e11)}")
+    FileUtils.mkdir_p tmpdir
+    raw_client_class.new tmpdir
+  end
+
+  include SharedTests
+end

data/test/test_active_support_cache_memory_store.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+require 'active_support/cache'
+
+class TestActiveSupportCacheMemoryStore < TestCase
+  def raw_client_class
+    ActiveSupport::Cache::MemoryStore
+  end
+
+  include SharedTests
+end
+

data/test/test_dalli_client.rb

@@ -0,0 +1,70 @@
+require 'helper'
+
+require 'dalli'
+
+class TestDalliClient < TestCase
+  def raw_client_class
+    Dalli::Client
+  end
+
+  include SharedTests
+
+  def get_ring_object_id
+    cache.metal.instance_variable_get(:@ring).object_id
+  end
+
+  def test_treats_as_thread_safe
+    # make sure ring is initialized
+    cache.get 'hi'
+
+    # get the main thread's ring
+    main_thread_ring_id = get_ring_object_id
+
+    # sanity check that it's not changing every time
+    cache.get 'hi'
+    assert_equal main_thread_ring_id, get_ring_object_id
+
+    # create a new thread and get its ring
+    new_thread_ring_id = Thread.new { cache.get 'hi'; get_ring_object_id }.value
+
+    # make sure the ring was reinitialized
+    assert_equal main_thread_ring_id, new_thread_ring_id
+  end
+
+  def test_treats_as_not_fork_safe
+    # make sure ring is initialized
+    cache.get 'hi'
+
+    # get the main thread's ring
+    parent_process_ring_id = get_ring_object_id
+
+    # sanity check that it's not changing every time
+    cache.get 'hi'
+    assert_equal parent_process_ring_id, get_ring_object_id
+
+    # fork a new process
+    pid = Kernel.fork do
+      cache.get 'hi'
+      raise "Didn't split!" if parent_process_ring_id == get_ring_object_id
+    end
+    Process.wait pid
+
+    # make sure it didn't raise
+    assert $?.success?
+  end
+
+  def test_set_with_default_dalli_ttl
+    cache = Cache.new(Dalli::Client.new(nil, :expires_in => 1))
+    cache.set('foo', 'bar')
+    sleep 2
+    assert_equal nil, cache.get('foo')
+  end
+
+  def test_fetch_with_default_dalli_ttl
+    cache = Cache.new(Dalli::Client.new(nil, :expires_in => 1))
+    cache.fetch('foo') { 'bar' }
+    sleep 2
+    assert_equal nil, cache.fetch('foo')
+    assert_equal 'different', cache.fetch('foo') { 'different' }
+  end
+end

data/test/test_mem_cache.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+# the famous memcache-client
+require 'memcache'
+
+class TestMemCache < TestCase
+  def self.startup
+    MemCache
+  end
+
+  def raw_client_class
+    MemCache
+  end
+
+  def raw_client
+    raw_client_class.new ['localhost:11211']
+  end
+
+  include SharedTests
+
+  def get_server_status_ids
+    cache.metal.instance_variable_get(:@servers).map { |s| s.status.object_id }
+  end
+
+  def test_treats_as_thread_safe
+    # make sure servers are connected
+    cache.get 'hi'
+
+    # get the object ids
+    main_thread_server_status_ids = get_server_status_ids
+
+    # sanity check that it's not changing every time
+    cache.get 'hi'
+    assert_equal main_thread_server_status_ids, get_server_status_ids
+
+    # create a new thread and get its server ids
+    new_thread_server_status_ids = Thread.new { cache.get 'hi'; get_server_status_ids }.value
+
+    # make sure the server ids was reinitialized
+    assert_equal main_thread_server_status_ids, new_thread_server_status_ids
+  end
+
+  def test_treats_as_not_fork_safe
+    # make sure server ids is initialized
+    cache.get 'hi'
+
+    # get the main thread's server ids
+    parent_process_server_status_ids = get_server_status_ids
+
+    # sanity check that it's not changing every time
+    cache.get 'hi'
+    assert_equal parent_process_server_status_ids, get_server_status_ids
+
+    # fork a new process
+    pid = Kernel.fork do
+      cache.get 'hi'
+      raise "Didn't split!" if parent_process_server_status_ids == get_server_status_ids
+    end
+    Process.wait pid
+
+    # make sure it didn't raise
+    assert $?.success?
+  end
+end

data/test/test_memcached.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+unless RUBY_PLATFORM == 'java'
+  require 'memcached'
+
+  class TestMemcached < TestCase
+    def raw_client_class
+      Memcached
+    end
+
+    def raw_client
+      raw_client_class.new 'localhost:11211', :support_cas => true
+    end
+
+    include SharedTests
+
+    def get_bare_id
+      cache.thread_metal.object_id
+    end
+
+    def test_treats_as_not_thread_safe
+      # make sure bare client is initialized
+      cache.get 'hi'
+
+      # get the main thread's bare client
+      main_thread_bare_id = get_bare_id
+
+      # sanity check that it's not changing every time
+      cache.get 'hi'
+      assert_equal main_thread_bare_id, get_bare_id
+
+      # create a new thread and get its bare client
+      new_thread_bare_id = Thread.new { cache.get 'hi'; get_bare_id }.value
+
+      # make sure the bare client was reinitialized
+      assert(main_thread_bare_id != new_thread_bare_id)
+
+      # make sure the main thread's client wasn't messed with
+      assert_equal main_thread_bare_id, get_bare_id
+    end
+
+    def test_treats_as_not_fork_safe
+      # make sure bare client is initialized
+      cache.get 'hi'
+
+      # get the main process's bare client
+      parent_process_bare_id = get_bare_id
+
+      # sanity check that it's not changing every time
+      cache.get 'hi'
+      assert_equal parent_process_bare_id, get_bare_id
+
+      # fork a new process
+      pid = Kernel.fork do
+        cache.get 'hi'
+        raise "Didn't split!" if parent_process_bare_id == get_bare_id
+      end
+      Process.wait pid
+
+      # make sure it didn't raise
+      assert $?.success?
+    end
+  end
+end

data/test/test_memcached_rails.rb

@@ -0,0 +1,61 @@
+require 'helper'
+
+unless RUBY_PLATFORM == 'java'
+  require 'memcached'
+
+  class TestMemcachedRails < TestCase
+    def raw_client_class
+      Memcached::Rails
+    end
+
+    def raw_client
+      raw_client_class.new 'localhost:11211', :support_cas => true
+    end
+
+    include SharedTests
+
+    def get_bare_id
+      cache.thread_metal.object_id
+    end
+
+    def test_treats_as_not_thread_safe
+      # make sure bare client is initialized
+      cache.get 'hi'
+
+      # get the main thread's bare client
+      main_thread_bare_id = get_bare_id
+
+      # sanity check that it's not changing every time
+      cache.get 'hi'
+      assert_equal main_thread_bare_id, get_bare_id
+
+      # create a new thread and get its bare client
+      new_thread_bare_id = Thread.new { cache.get 'hi'; get_bare_id }.value
+
+      # make sure the bare client was reinitialized
+      assert(main_thread_bare_id != new_thread_bare_id)
+    end
+
+    def test_treats_as_not_fork_safe
+      # make sure bare client is initialized
+      cache.get 'hi'
+
+      # get the main process's bare client
+      parent_process_bare_id = get_bare_id
+
+      # sanity check that it's not changing every time
+      cache.get 'hi'
+      assert_equal parent_process_bare_id, get_bare_id
+
+      # fork a new process
+      pid = Kernel.fork do
+        cache.get 'hi'
+        raise "Didn't split!" if parent_process_bare_id == get_bare_id
+      end
+      Process.wait pid
+
+      # make sure it didn't raise
+      assert $?.success?
+    end
+  end
+end

data/test/test_memcached_with_binary.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+unless RUBY_PLATFORM == 'java'
+  require 'memcached'
+
+  class TestMemcachedWithBinary < TestCase
+    def raw_client_class
+      Memcached
+    end
+
+    def raw_client
+      raw_client_class.new 'localhost:11211', :support_cas => true, :binary => true
+    end
+
+    include SharedTests
+  end
+end

data/test/test_missing_driver.rb

@@ -0,0 +1,16 @@
+
+require 'helper'
+
+class TestMissingDriver < TestCase
+  class FooClient; end
+
+  def raw_client_class
+    FooClient
+  end
+
+  def test_missing_driver
+    assert_raises(Cache::DriverNotFound) do
+      Cache.new(raw_client)
+    end
+  end
+end

data/test/test_nothing.rb

@@ -0,0 +1,147 @@
+
+require 'helper'
+
+class TestNothing < TestCase
+  def raw_client
+    :nothing
+  end
+
+  def test_get
+    assert_equal nil, cache.get('hello')
+    cache.set 'hello', 'world'
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_set
+    assert_nothing_raised do
+      cache.set 'hello', 'world'
+    end
+  end
+
+  def test_set_with_ttl
+    cache.set 'hello', 'world', 1
+    assert_equal nil, cache.get('hello')
+    sleep 2
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_set_with_zero_ttl_meaning_eternal
+    cache.set 'hello', 'world', 0
+    assert_equal nil, cache.get('hello')
+    sleep 1
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_delete
+    cache.set 'hello', 'world'
+    assert_equal nil, cache.get('hello')
+    cache.delete 'hello'
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_flush
+    cache.set 'hello', 'world'
+    assert !cache.exist?('hello')
+  end
+
+  def test_exist
+    assert !cache.exist?('hello')
+    cache.set 'hello', 'world'
+    assert !cache.exist?('hello')
+  end
+
+  def test_exists
+    assert !cache.exists?('hello')
+    cache.set 'hello', 'world'
+    assert !cache.exists?('hello')
+  end
+
+  def test_fetch
+    assert_equal nil, cache.fetch('hello')
+    assert_equal 'world', cache.fetch('hello') { 'world' }
+  end
+
+  def test_fetch_with_false_boolean
+    assert_equal nil, cache.fetch('hello')
+    assert_equal false, cache.fetch('hello') { false }
+  end
+
+  def test_fetch_with_expires_in
+    assert_equal 'world', cache.fetch('hello', :expires_in => 5) { 'world' }
+  end
+
+  def test_fetch_with_expires_in_stringified
+    assert_equal 'world', cache.fetch('hello', 'expires_in' => 5) { 'world' }
+  end
+
+  def test_fetch_with_ignored_options
+    assert_equal 'world', cache.fetch('hello', :foo => 'bar') { 'world' }
+  end
+
+  def test_cas
+    toggle = lambda do |current|
+      current == 'on' ? 'off' : 'on'
+    end
+
+    cache.set 'lights', 'on'
+    assert_equal nil, cache.get('lights')
+    cache.cas 'lights', &toggle
+    assert_equal nil, cache.get('lights')
+    cache.cas 'lights', &toggle
+    assert_equal nil, cache.get('lights')
+    cache.cas 'lights', &toggle
+    assert_equal nil, cache.get('lights')
+  end
+
+  def test_write
+    cache.write 'hello', 'world'
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_write_with_expires_in
+    cache.write 'hello', 'world', :expires_in => 1
+    assert_equal nil, cache.get('hello')
+    sleep 2
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_write_with_ignored_options
+    cache.write 'hello', 'world', :foobar => 'bazboo'
+    assert_equal nil, cache.get('hello')
+  end
+
+  def test_read
+    cache.set 'hello', 'world'
+    assert_equal nil, cache.read('hello')
+  end
+
+  def test_increment
+    assert !cache.exist?('high-fives')
+    assert_equal 1, cache.increment('high-fives')
+    assert_equal nil, cache.get('high-fives')
+    assert_equal 1, cache.increment('high-fives')
+    assert_equal nil, cache.get('high-fives')
+  end
+
+  def test_decrement
+    assert !cache.exist?('high-fives')
+    assert_equal -1, cache.decrement('high-fives')
+    assert_equal nil, cache.get('high-fives')
+    assert_equal -1, cache.decrement('high-fives')
+    assert_equal nil, cache.get('high-fives')
+  end
+
+  def test_get_multi
+    cache.set 'hello', 'world'
+    cache.set 'privyet', 'mir'
+    assert_equal({}, cache.get_multi('hello', 'privyet', 'yoyoyo'))
+  end
+
+  # https://github.com/fauna/memcached/pull/50
+  def test_get_set_behavior
+    cache.flush
+    cache.get 'get_set'
+    cache.set 'get_set', 'go'
+    assert_equal nil, cache.get('get_set')
+  end
+end