segmented-memcache 1.2.0

data/test/memcache_local_server_test.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/memcache/local_server'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
+
+class MemcacheLocalServerTest < Test::Unit::TestCase
+  include MemcacheServerTestHelper
+
+  def setup
+    @memcache = Memcache::LocalServer.new
+  end
+end

data/test/memcache_null_server_test.rb

@@ -0,0 +1,65 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/memcache/null_server'
+
+class MemcacheNullServerTest < Test::Unit::TestCase
+  def setup
+    @memcache = Memcache::NullServer.new
+  end
+
+  def m
+    @memcache
+  end
+
+  def test_set_and_get
+    m.set(2, 'foo', 0)
+    
+    assert_equal nil, m.get('2')
+    assert_equal nil, m.get('2')
+  end
+
+  def test_incr
+    m.incr('foo')
+    assert_equal nil, m.get('foo')
+
+    m.incr('foo', -1)
+    assert_equal nil, m.get('foo')
+
+    m.incr('foo', 52)
+    assert_equal nil, m.get('foo')
+
+    m.incr('foo', -43)
+    assert_equal nil, m.get('foo')
+  end
+
+  def test_multi_get
+    m.set(2, '1,2,3')
+    m.set(3, '4,5')
+    
+    assert_equal Hash.new, m.get([2,3])
+  end
+  
+  def test_delete
+    m.set(2, '1,2,3')
+    
+    assert_equal nil, m.get(2)
+
+    m.delete(2)
+    
+    assert_equal nil, m.get(2)
+  end
+
+  def test_flush_all
+    m.set(2, 'bar')
+    
+    assert_equal nil, m.get(2)
+
+    m.flush_all
+    
+    assert_equal nil, m.get(2)
+  end
+    
+  def test_expiry
+    m.add('test', '1', 1)
+    assert_equal nil, m.get('test')
+  end
+end

data/test/memcache_pg_server_test.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'rubygems'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
+require File.dirname(__FILE__) + '/../lib/memcache/pg_server'
+
+class MemcachePGServerTest < Test::Unit::TestCase
+  ActiveRecord::Base.establish_connection(
+    :adapter  => "postgresql",
+    :host     => "localhost",
+    :username => "postgres",
+    :password => "",
+    :database => "memcache_test"
+  )
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Base.connection.client_min_messages = 'panic'
+
+  include MemcacheServerTestHelper
+
+  def setup
+    Memcache::Migration.table = 'memcache_test'
+    Memcache::Migration.up
+    @memcache = Memcache::PGServer.new(:table => 'memcache_test')
+  end
+
+  def teardown
+    Memcache::Migration.down
+  end
+end

data/test/memcache_segmented_server_test.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
+
+$VERBOSE = nil
+Memcache::SegmentedServer.const_set('MAX_SIZE', 3)
+
+class MemcacheSegmentedServerTest < Test::Unit::TestCase
+  include MemcacheServerTestHelper
+  include MemcacheServerTestHelper::AdvancedMethods
+  PORT = 11212
+
+  def setup
+    start_memcache(PORT)
+    @memcache = Memcache::SegmentedServer.new(:host => 'localhost', :port => PORT)
+
+  end
+  
+  def teardown
+    stop_memcache(PORT)
+  end
+end

data/test/memcache_server_test.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
+
+class MemcacheServerTest < Test::Unit::TestCase
+  include MemcacheServerTestHelper
+  include MemcacheServerTestHelper::AdvancedMethods
+  PORT = 11212
+
+  def setup
+    start_memcache(PORT)
+    @memcache = Memcache::Server.new(:host => 'localhost', :port => PORT)
+  end
+  
+  def teardown
+    stop_memcache(PORT)
+  end
+
+  def test_stats
+    m.set('foo', '1')
+    m.get('foo')
+    m.get('bar')
+
+    stats = m.stats
+    assert_equal 2, stats['cmd_get'] 
+    assert_equal 1, stats['cmd_set']
+    assert_equal 1, stats['curr_items']
+  end
+  
+  def test_clone
+    m.set('foo', 1)
+    c = m.clone
+
+    assert_not_equal m.send(:socket), c.send(:socket)
+  end
+end

data/test/memcache_server_test_helper.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module MemcacheServerTestHelper
+  def m
+    @memcache
+  end
+
+  def test_set_and_get
+    m.set(2, 'foo', 0)
+    
+    assert_equal 'foo', m.get('2')
+    assert_equal 'foo', m.get('2')
+
+    m.set(2, 'bar', 0)
+
+    assert_equal 'bar', m.get('2')
+    assert_equal 'bar', m.get('2')
+  end
+
+  def test_expiry
+    m.set('foo', 'foo', 1)
+    assert_equal 'foo', m.get('foo')
+
+    m.add('bar', 'bar', 1)
+    assert_equal 'bar', m.get('bar')
+
+    m.set('baz', '')
+    m.replace('baz', 'baz', '1')
+    assert_equal 'baz', m.get('baz')
+
+    m.set('bam', 'bap', Time.now + 1)
+    assert_equal 'bap', m.get('bam')
+
+    sleep 2
+
+    assert_equal nil, m.get('foo')
+    assert_equal nil, m.get('bar')
+    assert_equal nil, m.get('baz')
+    assert_equal nil, m.get('bam')
+  end
+
+  def test_add_and_replace
+    # Replace should do nothing if key doesn't exist.
+    m.replace('foo', 'bar')
+    assert_equal nil, m.get('foo')
+
+    # Add should only work if key doesn't exist.
+    m.add('foo', 'foo')
+    assert_equal 'foo', m.get('foo')
+    assert_equal nil,   m.add('foo', 'bar')
+    assert_equal 'foo', m.get('foo')
+    
+    # Replace should only work if key doesn't exist.
+    m.replace('foo', 'bar')
+    assert_equal 'bar', m.get('foo')
+  end
+
+  def test_append_and_prepend
+    m.append('foo', 'bar')
+    assert_equal nil, m.get('foo')
+
+    m.set('foo', 'foo')
+    m.append('foo', 'bar')
+    assert_equal 'foobar', m.get('foo')
+
+    m.prepend('foo', 'baz')
+    assert_equal 'bazfoobar', m.get('foo')
+  end
+
+  def test_incr
+    # incr does nothing if value doesn't exist
+    m.incr('foo')
+    assert_equal nil, m.get('foo')
+
+    m.decr('foo', 1)
+    assert_equal nil, m.get('foo')
+
+    m.set('foo', '0')
+    m.incr('foo')
+    assert_equal '1', m.get('foo')
+
+    m.incr('foo', 52)
+    assert_equal '53', m.get('foo')
+
+    m.decr('foo', 43)
+    assert_equal '10', m.get('foo')
+
+    # Cannot go below zero.
+    m.decr('foo', 100)
+    assert_equal '0', m.get('foo').strip
+  end
+
+  def test_multi_get
+    m.set(2, '1,2,3')
+    m.set(3, '4,5')
+    
+    expected = { '2' => '1,2,3', '3' => '4,5' }
+    assert_equal expected, m.get([2,3])
+  end
+  
+  def test_delete
+    m.set(2, '1,2,3')
+    
+    assert_equal '1,2,3', m.get(2)
+
+    m.delete(2)
+    
+    assert_equal nil, m.get(2)
+  end
+
+  def test_flush_all
+    m.set(2, 'bar')
+    
+    assert_equal 'bar', m.get(2)
+
+    m.flush_all
+    
+    assert_equal nil, m.get(2)
+  end
+  
+  module AdvancedMethods
+    def test_flags
+      m.set('thom', 'hartmann', 0)
+      value = m.gets('thom')
+      assert_equal 0, value.memcache_flags
+      
+      m.set('thom', 'hartmann', 0, 0b11110001)
+      value = m.gets('thom')
+      assert_equal 0b11110001, value.memcache_flags
+      
+      value = m.get('thom')
+      assert_equal 0b11110001, value.memcache_flags
+      
+      m.set('thom', 'hartmann', 0, 0b10101010)
+      value = m.get('thom')
+      assert_equal 0b10101010, value.memcache_flags
+    end
+    
+    def test_gets_and_cas
+      m.set('thom', 'hartmann')
+      
+      value = m.gets('thom')    
+      assert_equal 'hartmann', value
+      m.cas('thom', 'thompson', value.memcache_cas)
+      assert_equal 'thompson', m.get('thom')
+      
+      value = m.gets('thom')
+      m.delete('thom')
+      assert_nil m.cas('thom', 'hartson', value.memcache_cas)
+      assert_equal nil, m.get('thom')
+      
+      m.add('thom', 'hartmann')
+      value = m.gets('thom')
+      m.set('thom', 'foo')
+      assert_nil m.cas('thom', 'hartson', value.memcache_cas)
+      assert_equal 'foo', m.get('thom')
+    end
+  end
+end

data/test/memcache_test.rb

@@ -0,0 +1,233 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+
+class MemcacheTest < Test::Unit::TestCase
+  PORTS = [11212, 11213, 11214, 11215, 11216, 11217]
+
+  def m
+    @memcache
+  end
+
+  def setup
+    start_memcache(*PORTS)
+    @memcache = Memcache.new(:servers => PORTS.collect {|p| "localhost:#{p}"})
+  end
+    
+  def teardown
+    stop_memcache(*PORTS)
+  end
+
+  def test_get_and_set    
+    100.times do |i|
+      m.set(i.to_s, i)
+      assert_equal i, m.get(i.to_s)
+    end
+
+    keys = (0..200).to_a
+    results = m.get(keys)
+    assert_equal 100, results.size
+    results.each do |key, value|
+      assert_equal key.to_i, value
+    end
+    
+    100.times do |i|
+      m.set(i.to_s, i.to_s, :raw => true)
+      assert_equal i.to_s, m.get(i.to_s, :raw => true)
+    end
+
+    results = m.get(keys ,:raw => true)
+    assert_equal 100, results.size
+    results.each do |key, value|
+      assert_equal key, value
+    end
+  end
+
+  def test_alternate_accessors
+    m['baz'] = 24
+    assert_equal 24, m['baz']
+  end
+
+  def test_add_and_replace
+    100.times do |i|
+      m.replace(i.to_s, [:foo, i])
+      assert_equal nil, m.get(i.to_s)
+
+      m.add(i.to_s, [:bar, i])
+      assert_equal [:bar, i], m.get(i.to_s)
+
+      m.replace(i.to_s, [:foo, i])
+      assert_equal [:foo, i], m.get(i.to_s)
+
+      m.add(i.to_s, [:baz, i])
+      assert_equal [:foo, i], m.get(i.to_s)
+
+      m.replace(i.to_s, 'blah', :raw => true)
+      assert_equal 'blah', m.get(i.to_s, :raw => true)
+
+      m.delete(i.to_s)
+      assert_equal nil, m.get(i.to_s, :raw => true)
+
+      m.add(i.to_s, 'homerun', :raw => true)
+      assert_equal 'homerun', m.get(i.to_s, :raw => true)      
+    end
+  end
+
+  def test_append_and_prepend
+    100.times do |i|
+      m.append(i.to_s, 'doh!')
+      assert_equal nil, m.read(i.to_s)
+
+      m.write(i.to_s, 'bar')
+      m.prepend(i.to_s, 'foo')
+      assert_equal 'foobar', m.read(i.to_s)
+
+      m.append(i.to_s, i.to_s)
+      assert_equal "foobar#{i}", m.read(i.to_s)
+    end
+  end
+
+  def test_get_or_set
+    100.times do |i|
+      m.get_or_set("foo#{i}", [i, :foo])
+      assert_equal [i, :foo], m["foo#{i}"]
+
+      m.get_or_set("foo#{i}") {raise}
+      assert_equal [i, :foo], m["foo#{i}"]    
+
+      # Overwrite if changed.
+      m.get_or_set("bar#{i}") do
+        m.set("bar#{i}", [i, :foo])
+        [i, :bar]
+      end
+      assert_equal [i, :bar], m["bar#{i}"]
+    end
+  end
+
+  def test_get_or_add
+    100.times do |i|
+      m.get_or_add("foo#{i}", [:foo, i])
+      assert_equal [:foo, i], m["foo#{i}"]
+
+      m.get_or_add("foo#{i}") {raise}
+      assert_equal [:foo, i], m["foo#{i}"]    
+
+      # Don't overwrite if changed.
+      m.get_or_add("bar#{i}") do
+        m.set("bar#{i}", [:foo, i])
+        :bar
+      end
+      assert_equal [:foo, i], m["bar#{i}"]
+    end
+  end
+
+  def test_update
+    100.times do |i|
+      m.set("foo#{i}", [:foo, i])
+      assert_equal [:foo, i], m["foo#{i}"]
+
+      m.update("foo#{i}") do |list|
+        list << i.to_s
+        list << :bar
+        list
+      end
+      assert_equal [:foo, i, i.to_s, :bar], m["foo#{i}"]
+    end
+  end
+
+  def test_get_some
+    100.times do |i|
+      i = i * 2
+      m.set(i.to_s, i)
+      assert_equal i, m.get(i.to_s)
+    end
+
+    keys = (0...200).to_a
+    results = m.get_some(keys) do |missing_keys|
+      assert_equal 100, missing_keys.size
+      r = {}
+      missing_keys.each do |key|
+        r[key] = key.to_i
+      end
+      r
+    end
+
+    assert_equal 200, results.size
+    results.each do |key, value|
+      assert_equal key.to_i, value
+    end
+  end
+
+  def test_get_with_reset_expiry
+    m.add('foo', 'quick brown fox', :expiry => 1)
+    assert_equal 'quick brown fox', m.get('foo', :expiry => 2)
+    sleep(1)    
+    assert_equal 'quick brown fox', m.get('foo')
+  end
+
+  def test_expiry
+    100.times do |i|
+      m.set("int#{i}", i, :expiry => 1)
+      assert_equal i, m.get("int#{i}")
+
+      m.set("time#{i}", i, :expiry => Time.now + 1)
+      assert_equal i, m.get("time#{i}")
+    end
+
+    sleep 2
+
+    100.times do |i|
+      assert_equal nil, m.get("int#{i}")
+      assert_equal nil, m.get("time#{i}")
+    end
+  end
+
+  def test_in_namespace
+    threads = []
+    10.times do |i|
+      m.in_namespace("_#{i}_") do
+        10.times do |j|
+          m.in_namespace("_#{j}_") do
+            assert_equal nil, m.get('foo')
+            m.set('foo', 'bar')
+            assert_equal 'bar', m.get('foo')
+          end
+        end
+      end
+    end
+  end
+
+  def test_incr_and_decr
+    m.write('foo', 0)
+
+    m.incr('foo', 100)
+    assert_equal 100, m.count('foo')
+
+    m.decr('foo', 100)
+    assert_equal 0, m.count('foo')
+
+    m.incr('foo', 500)
+    assert_equal 500, m.count('foo')
+
+    m.decr('foo', 300)
+    assert_equal 200, m.count('foo')
+
+    m.decr('foo', 300)
+    assert_equal 0, m.count('foo')
+  end
+
+  def test_flags
+    m.set('foo', :foo, :flags => 43)
+    assert_equal 43, m.get('foo').memcache_flags
+
+    m.set('foo', 'foo', :raw => true, :flags => 43)
+    assert_equal 43, m.get('foo', :raw => true).memcache_flags
+  end
+
+  def test_clone
+    m.set('foo', 1)
+    c = m.clone
+
+    assert_not_equal m.servers.collect {|s| s.send(:socket)},
+                     c.servers.collect {|s| s.send(:socket)}
+  end
+end