dalli 2.0.1 → 3.2.8

data/test/test_ring.rb

@@ -1,85 +0,0 @@
-require 'helper'
-
-describe 'Ring' do
-
-  context 'a ring of servers' do
-
-    should "have the continuum sorted by value" do
-      servers = [stub(:hostname => "localhost", :port => "11211", :weight => 1),
-                 stub(:hostname => "localhost", :port => "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
-
-    should '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
-
-    context 'containing only a single server' do
-      should "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
-
-      should "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
-
-    context 'containing multiple servers' do
-      should "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
-
-      should "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
-
-    should '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,83 +0,0 @@
-require 'helper'
-
-describe 'Sasl' do
-
-  context 'a server requiring authentication' do
-
-    context '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
-
-      should 'provide one test that passes' do
-        assert true
-      end
-
-      should_eventually 'gracefully handle authentication failures' do
-        memcached(19124, '-S') do |dc|
-          assert_raise Dalli::DalliError, /32/ do
-            dc.set('abc', 123)
-          end
-        end
-      end
-    end
-
-    should_eventually 'fail SASL authentication with wrong options' do
-      memcached(19124, '-S') do |dc|
-        dc = Dalli::Client.new('localhost:19124', :username => 'foo', :password => 'wrongpwd')
-        assert_raise 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'
-    context '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
-
-      should_eventually 'pass SASL authentication' do
-        memcached(19124, '-S') 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
-
-    should_eventually 'pass SASL authentication with options' do
-      memcached(19124, '-S') do |dc|
-        dc = Dalli::Client.new('localhost:19124', :username => 'testuser', :password => 'testtest')
-        # 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
-end

data/test/test_session_store.rb

@@ -1,224 +0,0 @@
-require 'helper'
-require 'abstract_unit'
-require 'action_dispatch/middleware/session/dalli_store'
-
-class Foo
-  def initialize(bar='baz')
-    @bar = bar
-  end
-  def inspect
-    "#<#{self.class} bar:#{@bar.inspect}>"
-  end
-end
-
-class TestSessionStore < ActionController::IntegrationTest
-  class TestController < ActionController::Base
-    def no_session_access
-      head :ok
-    end
-
-    def set_session_value
-      session[:foo] = "bar"
-      head :ok
-    end
-
-    def set_serialized_session_value
-      session[:foo] = Foo.new
-      head :ok
-    end
-
-    def get_session_value
-      render :text => "foo: #{session[:foo].inspect}"
-    end
-
-    def get_session_id
-      render :text => "#{request.session_options[:id]}"
-    end
-
-    def call_reset_session
-      session[:bar]
-      reset_session
-      session[:bar] = "baz"
-      head :ok
-    end
-
-    def rescue_action(e) raise end
-  end
-
-  begin
-    require 'dalli'
-    memcache = Dalli::Client.new('127.0.0.1:11211')
-    memcache.set('ping', '')
-
-    def test_setting_and_getting_session_value
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: "bar"', response.body
-      end
-    end
-
-    def test_getting_nil_session_value
-      with_test_route_set do
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body
-      end
-    end
-
-    def test_getting_session_value_after_session_reset
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-        session_cookie = cookies.send(:hash_for)['_session_id']
-
-        get '/call_reset_session'
-        assert_response :success
-        assert_not_equal [], headers['Set-Cookie']
-
-        cookies << session_cookie # replace our new session_id with our old, pre-reset session_id
-
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body, "data for this session should have been obliterated from memcached"
-      end
-    end
-
-    def test_getting_from_nonexistent_session
-      with_test_route_set do
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body
-        assert_nil cookies['_session_id'], "should only create session on write, not read"
-      end
-    end
-
-    def test_setting_session_value_after_session_reset
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-        session_id = cookies['_session_id']
-
-        get '/call_reset_session'
-        assert_response :success
-        assert_not_equal [], headers['Set-Cookie']
-
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body
-
-        get '/get_session_id'
-        assert_response :success
-        assert_not_equal session_id, response.body
-      end
-    end
-
-    def test_getting_session_id
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-        session_id = cookies['_session_id']
-
-        get '/get_session_id'
-        assert_response :success
-        assert_equal session_id, response.body, "should be able to read session id without accessing the session hash"
-      end
-    end
-
-    def test_deserializes_unloaded_class
-      with_test_route_set do
-        with_autoload_path "session_autoload_test" do
-          get '/set_serialized_session_value'
-          assert_response :success
-          assert cookies['_session_id']
-        end
-        with_autoload_path "session_autoload_test" do
-          get '/get_session_id'
-          assert_response :success
-        end
-        with_autoload_path "session_autoload_test" do
-          get '/get_session_value'
-          assert_response :success
-          assert_equal 'foo: #<Foo bar:"baz">', response.body, "should auto-load unloaded class"
-        end
-      end
-    end
-
-    def test_doesnt_write_session_cookie_if_session_id_is_already_exists
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-
-        get '/get_session_value'
-        assert_response :success
-        assert_equal nil, headers['Set-Cookie'], "should not resend the cookie again if session_id cookie is already exists"
-      end
-    end
-
-    def test_prevents_session_fixation
-      with_test_route_set do
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body
-        session_id = cookies['_session_id']
-
-        reset!
-
-        get '/set_session_value', :_session_id => session_id
-        assert_response :success
-        assert_not_equal session_id, cookies['_session_id']
-      end
-    end
-
-    def test_expire_after
-      with_test_route_set(:expire_after => 1) do
-        get '/set_session_value'
-        assert_match /expires/, @response.headers['Set-Cookie']
-
-        sleep(1)
-
-        get '/get_session_value'
-        assert_equal 'foo: nil', response.body
-      end
-    end
-
-    def test_expires_in
-      with_test_route_set(:expires_in => 1) do
-        get '/set_session_value'
-        assert_no_match /expires/, @response.headers['Set-Cookie']
-
-        sleep(1)
-
-        get '/get_session_value'
-        assert_equal 'foo: nil', response.body
-      end
-    end
-  rescue LoadError, RuntimeError
-    $stderr.puts "Skipping SessionStore tests. Start memcached and try again: #{$!.message}"
-  end
-
-  private
-
-  def with_test_route_set(options = {})
-    options = {:key => '_session_id', :memcache_server => '127.0.0.1:11211'}.merge(options)
-    with_routing do |set|
-      set.draw do
-        match ':action', :to => ::TestSessionStore::TestController
-      end
-
-      @app = self.class.build_app(set) do |middleware|
-        middleware.use ActionDispatch::Session::DalliStore, options
-      end
-
-      yield
-    end
-  end
-end