dalli 2.7.4 → 2.7.5

data/test/test_ring.rb

@@ -1,85 +0,0 @@
-require 'helper'
-
-describe 'Ring' do
-
-  describe 'a ring of servers' do
-
-    it "have the continuum sorted by value" do
-      servers = [stub(:name => "localhost:11211", :weight => 1),
-                 stub(:name => "localhost:9500", :weight => 1)]
-      ring = Dalli::Ring.new(servers, {})
-      previous_value = 0
-      ring.continuum.each do |entry|
-        assert entry.value > previous_value
-        previous_value = entry.value
-      end
-    end
-
-    it 'raise when no servers are available/defined' do
-      ring = Dalli::Ring.new([], {})
-      assert_raises Dalli::RingError, :message => "No server available" do
-        ring.server_for_key('test')
-      end
-    end
-
-    describe 'containing only a single server' do
-      it "raise correctly when it's not alive" do
-        servers = [
-          Dalli::Server.new("localhost:12345"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        assert_raises Dalli::RingError, :message => "No server available" do
-          ring.server_for_key('test')
-        end
-      end
-
-      it "return the server when it's alive" do
-        servers = [
-          Dalli::Server.new("localhost:19191"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        memcached(19191) do |mc|
-          ring = mc.send(:ring)
-          assert_equal ring.servers.first.port, ring.server_for_key('test').port
-        end
-      end
-    end
-
-    describe 'containing multiple servers' do
-      it "raise correctly when no server is alive" do
-        servers = [
-          Dalli::Server.new("localhost:12345"),
-          Dalli::Server.new("localhost:12346"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        assert_raises Dalli::RingError, :message => "No server available" do
-          ring.server_for_key('test')
-        end
-      end
-
-      it "return an alive server when at least one is alive" do
-        servers = [
-          Dalli::Server.new("localhost:12346"),
-          Dalli::Server.new("localhost:19191"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        memcached(19191) do |mc|
-          ring = mc.send(:ring)
-          assert_equal ring.servers.first.port, ring.server_for_key('test').port
-        end
-      end
-    end
-
-    it 'detect when a dead server is up again' do
-      memcached(19997) do
-        down_retry_delay = 0.5
-        dc = Dalli::Client.new(['localhost:19997', 'localhost:19998'], :down_retry_delay => down_retry_delay)
-        assert_equal 1, dc.stats.values.compact.count
-
-        memcached(19998) do
-          assert_equal 2, dc.stats.values.compact.count
-        end
-      end
-    end
-  end
-end

data/test/test_sasl.rb

@@ -1,105 +0,0 @@
-require 'helper'
-
-describe 'Sasl' do
-
-  # https://github.com/seattlerb/minitest/issues/298
-  def self.xit(msg, &block)
-  end
-
-  describe 'a server requiring authentication' do
-    before do
-      @server = mock()
-      @server.stubs(:request).returns(true)
-      @server.stubs(:weight).returns(1)
-      @server.stubs(:name).returns("localhost:19124")
-    end
-
-    describe 'without authentication credentials' do
-      before do
-        ENV['MEMCACHE_USERNAME'] = 'foo'
-        ENV['MEMCACHE_PASSWORD'] = 'wrongpwd'
-      end
-
-      after do
-        ENV['MEMCACHE_USERNAME'] = nil
-        ENV['MEMCACHE_PASSWORD'] = nil
-      end
-
-      xit 'gracefully handle authentication failures' do
-        memcached_sasl_persistent do |dc|
-          assert_error Dalli::DalliError, /32/ do
-            dc.set('abc', 123)
-          end
-        end
-      end
-    end
-
-    xit 'fail SASL authentication with wrong options' do
-      memcached_sasl_persistent do |dc, port|
-        dc = Dalli::Client.new("localhost:#{port}", :username => 'testuser', :password => 'testtest')
-        assert_error Dalli::DalliError, /32/ do
-          dc.set('abc', 123)
-        end
-      end
-    end
-
-    # OSX: Create a SASL user for the memcached application like so:
-    #
-    # saslpasswd2 -a memcached -c testuser
-    #
-    # with password 'testtest'
-    describe 'in an authenticated environment' do
-      before do
-        ENV['MEMCACHE_USERNAME'] = 'testuser'
-        ENV['MEMCACHE_PASSWORD'] = 'testtest'
-      end
-
-      after do
-        ENV['MEMCACHE_USERNAME'] = nil
-        ENV['MEMCACHE_PASSWORD'] = nil
-      end
-
-      xit 'pass SASL authentication' do
-        memcached_sasl_persistent do |dc|
-          # I get "Dalli::DalliError: Error authenticating: 32" in OSX
-          # but SASL works on Heroku servers. YMMV.
-          assert_equal true, dc.set('abc', 123)
-          assert_equal 123, dc.get('abc')
-          results = dc.stats
-          assert_equal 1, results.size
-          assert_equal 38, results.values.first.size
-        end
-      end
-    end
-
-    xit 'pass SASL authentication with options' do
-        memcached_sasl_persistent do |dc, port|
-        dc = Dalli::Client.new("localhost:#{port}", sasl_credentials)
-        # I get "Dalli::DalliError: Error authenticating: 32" in OSX
-        # but SASL works on Heroku servers. YMMV.
-        assert_equal true, dc.set('abc', 123)
-        assert_equal 123, dc.get('abc')
-        results = dc.stats
-        assert_equal 1, results.size
-        assert_equal 38, results.values.first.size
-      end
-    end
-
-    it 'pass SASL as URI' do
-      Dalli::Server.expects(:new).with("localhost:19124",
-        :username => "testuser", :password => "testtest").returns(@server)
-      dc = Dalli::Client.new('memcached://testuser:testtest@localhost:19124')
-      dc.flush_all
-    end
-
-    it 'pass SASL as ring of URIs' do
-      Dalli::Server.expects(:new).with("localhost:19124",
-        :username => "testuser", :password => "testtest").returns(@server)
-      Dalli::Server.expects(:new).with("otherhost:19125",
-        :username => "testuser2", :password => "testtest2").returns(@server)
-      dc = Dalli::Client.new(['memcached://testuser:testtest@localhost:19124',
-      'memcached://testuser2:testtest2@otherhost:19125'])
-      dc.flush_all
-    end
-  end
-end

data/test/test_serializer.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-require 'helper'
-require 'json'
-require 'memcached_mock'
-
-describe 'Serializer' do
-
-  it 'default to Marshal' do
-    memcached(29198) do |dc|
-      dc.set 1,2
-      assert_equal Marshal, dc.instance_variable_get('@ring').servers.first.serializer
-    end
-  end
-
-  it 'support a custom serializer' do
-    memcached(29198) do |dc, port|
-      memcache = Dalli::Client.new("127.0.0.1:#{port}", :serializer => JSON)
-      memcache.set 1,2
-      begin
-        assert_equal JSON, memcache.instance_variable_get('@ring').servers.first.serializer
-
-        memcached(21956) do |newdc|
-          assert newdc.set("json_test", {"foo" => "bar"})
-          assert_equal({"foo" => "bar"}, newdc.get("json_test"))
-        end
-      end
-    end
-  end
-end

data/test/test_server.rb

@@ -1,110 +0,0 @@
-require 'helper'
-
-describe Dalli::Server do
-  describe 'hostname parsing' do
-    it 'handles unix socket with no weight' do
-      s = Dalli::Server.new('/var/run/memcached/sock')
-      assert_equal '/var/run/memcached/sock', s.hostname
-      assert_equal 1, s.weight
-      assert_equal :unix, s.socket_type
-    end
-
-    it 'handles unix socket with a weight' do
-      s = Dalli::Server.new('/var/run/memcached/sock:2')
-      assert_equal '/var/run/memcached/sock', s.hostname
-      assert_equal 2, s.weight
-      assert_equal :unix, s.socket_type
-    end
-
-    it 'handles no port or weight' do
-      s = Dalli::Server.new('localhost')
-      assert_equal 'localhost', s.hostname
-      assert_equal 11211, s.port
-      assert_equal 1, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'handles a port, but no weight' do
-      s = Dalli::Server.new('localhost:11212')
-      assert_equal 'localhost', s.hostname
-      assert_equal 11212, s.port
-      assert_equal 1, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'handles a port and a weight' do
-      s = Dalli::Server.new('localhost:11212:2')
-      assert_equal 'localhost', s.hostname
-      assert_equal 11212, s.port
-      assert_equal 2, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'handles ipv4 addresses' do
-      s = Dalli::Server.new('127.0.0.1')
-      assert_equal '127.0.0.1', s.hostname
-      assert_equal 11211, s.port
-      assert_equal 1, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'handles ipv6 addresses' do
-      s = Dalli::Server.new('[::1]')
-      assert_equal '::1', s.hostname
-      assert_equal 11211, s.port
-      assert_equal 1, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'handles ipv6 addresses with port' do
-      s = Dalli::Server.new('[::1]:11212')
-      assert_equal '::1', s.hostname
-      assert_equal 11212, s.port
-      assert_equal 1, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'handles ipv6 addresses with port and weight' do
-      s = Dalli::Server.new('[::1]:11212:2')
-      assert_equal '::1', s.hostname
-      assert_equal 11212, s.port
-      assert_equal 2, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'handles a FQDN' do
-      s = Dalli::Server.new('my.fqdn.com')
-      assert_equal 'my.fqdn.com', s.hostname
-      assert_equal 11211, s.port
-      assert_equal 1, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'handles a FQDN with port and weight' do
-      s = Dalli::Server.new('my.fqdn.com:11212:2')
-      assert_equal 'my.fqdn.com', s.hostname
-      assert_equal 11212, s.port
-      assert_equal 2, s.weight
-      assert_equal :tcp, s.socket_type
-    end
-
-    it 'throws an exception if the hostname cannot be parsed' do
-      lambda { Dalli::Server.new('[]') }.must_raise Dalli::DalliError
-      lambda { Dalli::Server.new('my.fqdn.com:') }.must_raise Dalli::DalliError
-      lambda { Dalli::Server.new('my.fqdn.com:11212,:2') }.must_raise Dalli::DalliError
-      lambda { Dalli::Server.new('my.fqdn.com:11212:abc') }.must_raise Dalli::DalliError
-    end
-  end
-
-  describe 'ttl translation' do
-    it 'does not translate ttls under 30 days' do
-      s = Dalli::Server.new('localhost')
-      assert_equal s.send(:sanitize_ttl, 30*24*60*60), 30*24*60*60
-    end
-
-    it 'translates ttls over 30 days into timestamps' do
-      s = Dalli::Server.new('localhost')
-      assert_equal s.send(:sanitize_ttl, 30*24*60*60 + 1), Time.now.to_i + 30*24*60*60+1
-    end
-  end
-end