dalli 2.7.2 → 2.7.3

data/test/test_cas_client.rb

@@ -4,7 +4,7 @@ require 'memcached_mock'
 describe 'Dalli::Cas::Client' do
   describe 'using a live server' do
     it 'supports get with CAS' do
-      memcached_cas do |dc|
+      memcached_cas_persistent do |dc|
         dc.flush
 
         expected = { 'blah' => 'blerg!' }
@@ -29,7 +29,7 @@ describe 'Dalli::Cas::Client' do
     end
 
     it 'supports multi-get with CAS' do
-      memcached_cas do |dc|
+      memcached_cas_persistent do |dc|
         dc.close
         dc.flush
 
@@ -41,14 +41,14 @@ describe 'Dalli::Cas::Client' do
         # Invocation without block
         resp = dc.get_multi_cas(%w(a b c d e f))
         resp.each_pair do |k, data|
-          value, cas = [data.first, data.second]
+          value, cas = [data.first, data[1]]
           assert_equal expected_hash[k], value
           assert(cas && cas != 0)
         end
 
         # Invocation with block
         dc.get_multi_cas(%w(a b c d e f)) do |k, data|
-          value, cas = [data.first, data.second]
+          value, cas = [data.first, data[1]]
           assert_equal expected_hash[k], value
           assert(cas && cas != 0)
         end
@@ -56,7 +56,7 @@ describe 'Dalli::Cas::Client' do
     end
 
     it 'supports replace-with-CAS operation' do
-      memcached_cas do |dc|
+      memcached_cas_persistent do |dc|
         dc.flush
         cas = dc.set('key', 'value')
 
@@ -69,7 +69,7 @@ describe 'Dalli::Cas::Client' do
     end
 
     it 'supports delete with CAS' do
-      memcached_cas do |dc|
+      memcached_cas_persistent do |dc|
         cas = dc.set('some_key', 'some_value')
         dc.delete_cas('some_key', cas)
         assert_nil dc.get('some_key')
@@ -77,7 +77,7 @@ describe 'Dalli::Cas::Client' do
     end
 
     it 'handles CAS round-trip operations' do
-      memcached_cas do |dc|
+      memcached_cas_persistent do |dc|
         dc.flush
 
         expected = {'blah' => 'blerg!'}

data/test/test_compressor.rb

@@ -16,15 +16,14 @@ end
 describe 'Compressor' do
 
   it 'default to Dalli::Compressor' do
-    memcached_kill(29199) do |dc|
-      memcache = Dalli::Client.new('127.0.0.1:29199')
-      memcache.set 1,2
-      assert_equal Dalli::Compressor, memcache.instance_variable_get('@ring').servers.first.compressor
+    memcached(29199) do |dc|
+      dc.set 1,2
+      assert_equal Dalli::Compressor, dc.instance_variable_get('@ring').servers.first.compressor
     end
   end
 
   it 'support a custom compressor' do
-    memcached_kill(29199) do |dc|
+    memcached(29199) do |dc|
       memcache = Dalli::Client.new('127.0.0.1:29199', :compressor => NoopCompressor)
       memcache.set 1,2
       begin

data/test/test_dalli.rb

@@ -37,7 +37,7 @@ describe 'Dalli' do
 
   describe 'key validation' do
     it 'not allow blanks' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.set '   ', 1
         assert_equal 1, dc.get('   ')
         dc.set "\t", 1
@@ -54,7 +54,8 @@ describe 'Dalli' do
     end
 
     it 'allow namespace to be a symbol' do
-      memcached(19122, '', :namespace => :wunderschoen) do |dc|
+      memcached_persistent do |dc, port|
+        dc = Dalli::Client.new("localhost:#{port}", :namespace => :wunderschoen)
         dc.set "x" * 251, 1
         assert 1, dc.get("#{'x' * 200}:md5:#{Digest::MD5.hexdigest('x' * 251)}")
       end
@@ -105,7 +106,7 @@ describe 'Dalli' do
   describe 'using a live server' do
 
     it "support get/set" do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.flush
 
         val1 = "1234567890"*105000
@@ -122,7 +123,7 @@ describe 'Dalli' do
     end
 
     it 'supports delete' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.set('some_key', 'some_value')
         assert_equal 'some_value', dc.get('some_key')
 
@@ -132,21 +133,22 @@ describe 'Dalli' do
     end
 
     it 'returns nil for nonexist key' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         assert_equal nil, dc.get('notexist')
       end
     end
 
     it 'allows "Not found" as value' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.set('key1', 'Not found')
         assert_equal 'Not found', dc.get('key1')
       end
     end
 
     it "support stats" do
-      memcached do |dc|
+      memcached_persistent do |dc|
         # make sure that get_hits would not equal 0
+        dc.set(:a, "1234567890"*100000)
         dc.get(:a)
 
         stats = dc.stats
@@ -185,7 +187,7 @@ describe 'Dalli' do
     end
 
     it "support the fetch operation" do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.flush
 
         expected = { 'blah' => 'blerg!' }
@@ -208,7 +210,7 @@ describe 'Dalli' do
     end
 
     it "support the fetch operation with falsey values" do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.flush
 
         dc.set("fetch_key", false)
@@ -222,7 +224,7 @@ describe 'Dalli' do
     end
 
     it "support the cas operation" do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.flush
 
         expected = { 'blah' => 'blerg!' }
@@ -246,7 +248,7 @@ describe 'Dalli' do
     end
 
     it "support multi-get" do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.close
         dc.flush
         resp = dc.get_multi(%w(a b c d e f))
@@ -283,7 +285,7 @@ describe 'Dalli' do
     end
 
     it 'support raw incr/decr' do
-      memcached do |client|
+      memcached_persistent do |client|
         client.flush
 
         assert op_addset_succeeds(client.set('fakecounter', 0, 0, :raw => true))
@@ -313,7 +315,7 @@ describe 'Dalli' do
     end
 
     it "support incr/decr operations" do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.flush
 
         resp = dc.decr('counter', 100, 5, 0)
@@ -361,7 +363,7 @@ describe 'Dalli' do
     end
 
     it 'support the append and prepend operations' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.flush
         assert op_addset_succeeds(dc.set('456', 'xyz', 0, :raw => true))
         assert_equal true, dc.prepend('456', '0')
@@ -375,7 +377,7 @@ describe 'Dalli' do
     end
 
     it 'supports replace operation' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         dc.flush
         dc.set('key', 'value')
         assert op_replace_succeeds(dc.replace('key', 'value2'))
@@ -385,7 +387,7 @@ describe 'Dalli' do
     end
 
     it 'support touch operation' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         begin
           dc.flush
           dc.set 'key', 'value'
@@ -401,7 +403,7 @@ describe 'Dalli' do
     end
 
     it 'support version operation' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         v = dc.version
         servers = v.keys
         assert(servers.any? do |s|
@@ -411,7 +413,8 @@ describe 'Dalli' do
     end
 
     it 'allow TCP connections to be configured for keepalive' do
-      memcached(19122, '', :keepalive => true) do |dc|
+      memcached_persistent do |dc, port|
+        dc = Dalli::Client.new("localhost:#{port}", :keepalive => true)
         dc.set(:a, 1)
         ring = dc.send(:ring)
         server = ring.servers.first
@@ -425,7 +428,7 @@ describe 'Dalli' do
     end
 
     it "pass a simple smoke test" do
-      memcached do |dc|
+      memcached_persistent do |dc, port|
         resp = dc.flush
         refute_nil resp
         assert_equal [true, true], resp
@@ -453,7 +456,61 @@ describe 'Dalli' do
         dc.close
         dc = nil
 
-        dc = Dalli::Client.new('localhost:19122')
+        dc = Dalli::Client.new("localhost:#{port}")
+
+        assert op_addset_succeeds(dc.set('456', 'xyz', 0, :raw => true))
+
+        resp = dc.prepend '456', '0'
+        assert_equal true, resp
+
+        resp = dc.append '456', '9'
+        assert_equal true, resp
+
+        resp = dc.get('456', :raw => true)
+        assert_equal '0xyz9', resp
+
+        assert op_addset_succeeds(dc.set('456', false))
+
+        resp = dc.get('456')
+        assert_equal false, resp
+
+        resp = dc.stats
+        assert_equal Hash, resp.class
+
+        dc.close
+      end
+    end
+
+    it "pass a simple smoke test on unix socket" do
+      memcached_persistent(MemcachedMock::UNIX_SOCKET_PATH) do |dc, path|
+        resp = dc.flush
+        refute_nil resp
+        assert_equal [true], resp
+
+        assert op_addset_succeeds(dc.set(:foo, 'bar'))
+        assert_equal 'bar', dc.get(:foo)
+
+        resp = dc.get('123')
+        assert_equal nil, resp
+
+        assert op_addset_succeeds(dc.set('123', 'xyz'))
+
+        resp = dc.get('123')
+        assert_equal 'xyz', resp
+
+        assert op_addset_succeeds(dc.set('123', 'abc'))
+
+        dc.prepend('123', '0')
+        dc.append('123', '0')
+
+        assert_raises Dalli::UnmarshalError do
+          resp = dc.get('123')
+        end
+
+        dc.close
+        dc = nil
+
+        dc = Dalli::Client.new(path)
 
         assert op_addset_succeeds(dc.set('456', 'xyz', 0, :raw => true))
 
@@ -479,7 +536,7 @@ describe 'Dalli' do
     end
 
     it "support multithreaded access" do
-      memcached do |cache|
+      memcached_persistent do |cache|
         cache.flush
         workers = []
 
@@ -522,10 +579,10 @@ describe 'Dalli' do
     end
 
     it "handle namespaced keys" do
-      memcached do |dc|
-        dc = Dalli::Client.new('localhost:19122', :namespace => 'a')
+      memcached_persistent do |dc, port|
+        dc = Dalli::Client.new("localhost:#{port}", :namespace => 'a')
         dc.set('namespaced', 1)
-        dc2 = Dalli::Client.new('localhost:19122', :namespace => 'b')
+        dc2 = Dalli::Client.new("localhost:#{port}", :namespace => 'b')
         dc2.set('namespaced', 2)
         assert_equal 1, dc.get('namespaced')
         assert_equal 2, dc2.get('namespaced')
@@ -533,15 +590,15 @@ describe 'Dalli' do
     end
 
     it "handle nil namespace" do
-      memcached do |dc|
-        dc = Dalli::Client.new('localhost:19122', :namespace => nil)
+      memcached_persistent do |dc, port|
+        dc = Dalli::Client.new("localhost:#{port}", :namespace => nil)
         assert_equal 'key', dc.send(:validate_key, 'key')
       end
     end
 
     it 'truncate cache keys that are too long' do
-      memcached do
-        dc = Dalli::Client.new('localhost:19122', :namespace => 'some:namspace')
+      memcached_persistent do |dc, port|
+        dc = Dalli::Client.new("localhost:#{port}", :namespace => 'some:namspace')
         key = "this cache key is far too long so it must be hashed and truncated and stuff" * 10
         value = "some value"
         assert op_addset_succeeds(dc.set(key, value))
@@ -550,8 +607,8 @@ describe 'Dalli' do
     end
 
     it "handle namespaced keys in multi_get" do
-      memcached do |dc|
-        dc = Dalli::Client.new('localhost:19122', :namespace => 'a')
+      memcached_persistent do |dc, port|
+        dc = Dalli::Client.new("localhost:#{port}", :namespace => 'a')
         dc.set('a', 1)
         dc.set('b', 2)
         assert_equal({'a' => 1, 'b' => 2}, dc.get_multi('a', 'b'))
@@ -559,7 +616,7 @@ describe 'Dalli' do
     end
 
     it "handle application marshalling issues" do
-      memcached do |dc|
+      memcached_persistent do |dc|
         old = Dalli.logger
         Dalli.logger = Logger.new(nil)
         begin
@@ -572,7 +629,7 @@ describe 'Dalli' do
 
     describe 'with compression' do
       it 'allow large values' do
-        memcached do |dc|
+        memcached_persistent do |dc|
           dalli = Dalli::Client.new(dc.instance_variable_get(:@servers), :compress => true)
 
           value = "0"*1024*1024
@@ -585,7 +642,7 @@ describe 'Dalli' do
     describe 'in low memory conditions' do
 
       it 'handle error response correctly' do
-        memcached(19125, '-m 1 -M') do |dc|
+        memcached_low_mem_persistent do |dc|
           failed = false
           value = "1234567890"*100
           1_000.times do |idx|
@@ -602,8 +659,8 @@ describe 'Dalli' do
       end
 
       it 'fit more values with compression' do
-        memcached(19126, '-m 1 -M') do |dc|
-          dalli = Dalli::Client.new('localhost:19126', :compress => true)
+        memcached_low_mem_persistent do |dc, port|
+          dalli = Dalli::Client.new("localhost:#{port}", :compress => true)
           failed = false
           value = "1234567890"*1000
           10_000.times do |idx|

data/test/test_encoding.rb

@@ -6,7 +6,7 @@ describe 'Encoding' do
 
   describe 'using a live server' do
     it 'support i18n content' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         key = 'foo'
         utf_key = utf8 = 'ƒ©åÍÎ'
 
@@ -19,7 +19,7 @@ describe 'Encoding' do
     end
 
     it 'support content expiry' do
-      memcached do |dc|
+      memcached_persistent do |dc|
         key = 'foo'
         assert dc.set(key, 'bar', 1)
         assert_equal 'bar', dc.get(key)

data/test/test_failover.rb

@@ -4,19 +4,20 @@ describe 'failover' do
 
   describe 'timeouts' do
     it 'not lead to corrupt sockets' do
-      memcached(29125) do
-        dc = Dalli::Client.new ['localhost:29125']
+      memcached_persistent do |dc|
+        value = {:test => "123"}
         begin
           Timeout.timeout 0.01 do
-            1_000.times do
-              dc.set("test_123", {:test => "123"})
+            start_time = Time.now
+            10_000.times do
+              dc.set("test_123", value)
             end
-            flunk("Did not timeout")
+            flunk("Did not timeout in #{Time.now - start_time}")
           end
         rescue Timeout::Error
         end
 
-        assert_equal({:test => '123'}, dc.get("test_123"))
+        assert_equal(value, dc.get("test_123"))
       end
     end
   end
@@ -25,38 +26,40 @@ describe 'failover' do
   describe 'assuming some bad servers' do
 
     it 'silently reconnect if server hiccups' do
-      memcached(29125) do
-        dc = Dalli::Client.new ['localhost:29125']
+      server_port = 30124
+      memcached_persistent(server_port) do |dc, port|
         dc.set 'foo', 'bar'
         foo = dc.get 'foo'
         assert_equal foo, 'bar'
 
-        memcached_kill(29125)
-        memcached(29125) do
+        memcached_kill(port)
+        memcached_persistent(port) do
 
           foo = dc.get 'foo'
           assert_nil foo
 
-          memcached_kill(29125)
+          memcached_kill(port)
         end
       end
     end
 
     it 'handle graceful failover' do
-      memcached(29125) do
-        memcached(29126) do
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
+      port_1 = 31777
+      port_2 = 32113
+      memcached_persistent(port_1) do |first_dc, first_port|
+        memcached_persistent(port_2) do |second_dc, second_port|
+          dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
           dc.set 'foo', 'bar'
           foo = dc.get 'foo'
           assert_equal foo, 'bar'
 
-          memcached_kill(29125)
+          memcached_kill(first_port)
 
           dc.set 'foo', 'bar'
           foo = dc.get 'foo'
           assert_equal foo, 'bar'
 
-          memcached_kill(29126)
+          memcached_kill(second_port)
 
           assert_raises Dalli::RingError, :message => "No server available" do
             dc.set 'foo', 'bar'
@@ -66,14 +69,16 @@ describe 'failover' do
     end
 
     it 'handle them gracefully in get_multi' do
-      memcached(29125) do
-        memcached(29126) do
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
+      port_1 = 32971
+      port_2 = 34312
+      memcached_persistent(port_1) do |first_dc, first_port|
+        memcached(port_2) do |second_dc, second_port|
+          dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
           dc.set 'a', 'a1'
           result = dc.get_multi ['a']
           assert_equal result, {'a' => 'a1'}
 
-          memcached_kill(29125)
+          memcached_kill(first_port)
 
           result = dc.get_multi ['a']
           assert_equal result, {'a' => 'a1'}
@@ -82,22 +87,24 @@ describe 'failover' do
     end
 
     it 'handle graceful failover in get_multi' do
-      memcached(29125) do
-        memcached(29126) do
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
+      port_1 = 34541
+      port_2 = 33044
+      memcached_persistent(port_1) do |first_dc, first_port|
+        memcached_persistent(port_2) do |second_dc, second_port|
+          dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
           dc.set 'foo', 'foo1'
           dc.set 'bar', 'bar1'
           result = dc.get_multi ['foo', 'bar']
           assert_equal result, {'foo' => 'foo1', 'bar' => 'bar1'}
 
-          memcached_kill(29125)
+          memcached_kill(first_port)
 
           dc.set 'foo', 'foo1'
           dc.set 'bar', 'bar1'
           result = dc.get_multi ['foo', 'bar']
           assert_equal result, {'foo' => 'foo1', 'bar' => 'bar1'}
 
-          memcached_kill(29126)
+          memcached_kill(second_port)
 
           result = dc.get_multi ['foo', 'bar']
           assert_equal result, {}
@@ -106,21 +113,23 @@ describe 'failover' do
     end
 
     it 'stats it still properly report' do
-      memcached(29125) do
-        memcached(29126) do
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
+      port_1 = 34547
+      port_2 = 33219
+      memcached_persistent(port_1) do |first_dc, first_port|
+        memcached_persistent(port_2) do |second_dc, second_port|
+          dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
           result = dc.stats
-          assert_instance_of Hash, result['localhost:29125']
-          assert_instance_of Hash, result['localhost:29126']
+          assert_instance_of Hash, result["localhost:#{first_port}"]
+          assert_instance_of Hash, result["localhost:#{second_port}"]
 
-          memcached_kill(29125)
+          memcached_kill(first_port)
 
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
+          dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
           result = dc.stats
-          assert_instance_of NilClass, result['localhost:29125']
-          assert_instance_of Hash, result['localhost:29126']
+          assert_instance_of NilClass, result["localhost:#{first_port}"]
+          assert_instance_of Hash, result["localhost:#{second_port}"]
 
-          memcached_kill(29126)
+          memcached_kill(second_port)
         end
       end
     end