dalli 0.9.2 → 0.9.3

data/lib/dalli/server.rb

@@ -366,8 +366,6 @@ module Dalli
     
     def init_sasl
       require 'dalli/sasl/base'
-      require 'dalli/sasl/base64'
-      require 'dalli/sasl/digest_md5'
       require 'dalli/sasl/plain'
     end
 

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '0.9.2'
+  VERSION = '0.9.3'
 end

data/test/abstract_unit.rb

@@ -0,0 +1,285 @@
+require 'rails'
+# Used to test the full Rails stack.
+# Stolen from the Rails 3.0 source.
+# Needed for the session store tests.
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/string/encoding'
+if "ruby".encoding_aware?
+  # These are the normal settings that will be set up by Railties
+  # TODO: Have these tests support other combinations of these values
+  silence_warnings do
+    Encoding.default_internal = "UTF-8"
+    Encoding.default_external = "UTF-8"
+  end
+end
+
+require 'test/unit'
+require 'abstract_controller'
+require 'action_controller'
+require 'action_view'
+require 'action_dispatch'
+require 'active_support/dependencies'
+require 'action_controller/caching'
+require 'action_controller/caching/sweeping'
+
+require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
+
+module Rails
+  def self.logger
+    @logger ||= begin
+      l = Logger.new(STDOUT)
+      l.level = Logger::INFO; l
+    end
+  end
+end
+
+# Monkey patch the old routes initialization to be silenced.
+class ActionDispatch::Routing::DeprecatedMapper
+  def initialize_with_silencer(*args)
+    ActiveSupport::Deprecation.silence { initialize_without_silencer(*args) }
+  end
+  alias_method_chain :initialize, :silencer
+end
+
+ActiveSupport::Dependencies.hook!
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+ORIGINAL_LOCALES = I18n.available_locales.map {|locale| locale.to_s }.sort
+
+module RackTestUtils
+  def body_to_string(body)
+    if body.respond_to?(:each)
+      str = ""
+      body.each {|s| str << s }
+      str
+    else
+      body
+    end
+  end
+  extend self
+end
+
+module SetupOnce
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :setup_once_block
+    self.setup_once_block = nil
+
+    setup :run_setup_once
+  end
+
+  module ClassMethods
+    def setup_once(&block)
+      self.setup_once_block = block
+    end
+  end
+
+  private
+    def run_setup_once
+      if self.setup_once_block
+        self.setup_once_block.call
+        self.setup_once_block = nil
+      end
+    end
+end
+
+SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
+
+module ActiveSupport
+  class TestCase
+    include SetupOnce
+    # Hold off drawing routes until all the possible controller classes
+    # have been loaded.
+    setup_once do
+      SharedTestRoutes.draw do |map|
+        # FIXME: match ':controller(/:action(/:id))'
+        map.connect ':controller/:action/:id'
+      end
+
+      ActionController::IntegrationTest.app.routes.draw do |map|
+        # FIXME: match ':controller(/:action(/:id))'
+        map.connect ':controller/:action/:id'
+      end
+    end
+  end
+end
+
+class RoutedRackApp
+  attr_reader :routes
+
+  def initialize(routes, &blk)
+    @routes = routes
+    @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
+  end
+
+  def call(env)
+    @stack.call(env)
+  end
+end
+
+class BasicController
+  attr_accessor :request
+
+  def config
+    @config ||= ActiveSupport::InheritableOptions.new(ActionController::Base.config).tap do |config|
+      # VIEW TODO: View tests should not require a controller
+      public_dir = File.expand_path("../fixtures/public", __FILE__)
+      config.assets_dir = public_dir
+      config.javascripts_dir = "#{public_dir}/javascripts"
+      config.stylesheets_dir = "#{public_dir}/stylesheets"
+      config
+    end
+  end
+end
+
+class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
+  setup do
+    @routes = SharedTestRoutes
+  end
+end
+
+class ActionController::IntegrationTest < ActiveSupport::TestCase
+  def self.build_app(routes = nil)
+    RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
+      middleware.use "ActionDispatch::ShowExceptions"
+      middleware.use "ActionDispatch::Callbacks"
+      middleware.use "ActionDispatch::ParamsParser"
+      middleware.use "ActionDispatch::Cookies"
+      middleware.use "ActionDispatch::Flash"
+      middleware.use "ActionDispatch::Head"
+      yield(middleware) if block_given?
+    end
+  end
+
+  self.app = build_app
+
+  # Stub Rails dispatcher so it does not get controller references and
+  # simply return the controller#action as Rack::Body.
+  class StubDispatcher < ::ActionDispatch::Routing::RouteSet::Dispatcher
+    protected
+    def controller_reference(controller_param)
+      controller_param
+    end
+
+    def dispatch(controller, action, env)
+      [200, {'Content-Type' => 'text/html'}, ["#{controller}##{action}"]]
+    end
+  end
+
+  def self.stub_controllers
+    old_dispatcher = ActionDispatch::Routing::RouteSet::Dispatcher
+    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
+    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, StubDispatcher }
+    yield ActionDispatch::Routing::RouteSet.new
+  ensure
+    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
+    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, old_dispatcher }
+  end
+
+  def with_routing(&block)
+    temporary_routes = ActionDispatch::Routing::RouteSet.new
+    old_app, self.class.app = self.class.app, self.class.build_app(temporary_routes)
+    old_routes = SharedTestRoutes
+    silence_warnings { Object.const_set(:SharedTestRoutes, temporary_routes) }
+
+    yield temporary_routes
+  ensure
+    self.class.app = old_app
+    silence_warnings { Object.const_set(:SharedTestRoutes, old_routes) }
+  end
+
+  def with_autoload_path(path)
+    path = File.join(File.dirname(__FILE__), "fixtures", path)
+    if ActiveSupport::Dependencies.autoload_paths.include?(path)
+      yield
+    else
+      begin
+        ActiveSupport::Dependencies.autoload_paths << path
+        yield
+      ensure
+        ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
+        ActiveSupport::Dependencies.clear
+      end
+    end
+  end
+end
+
+# Temporary base class
+class Rack::TestCase < ActionController::IntegrationTest
+  def self.testing(klass = nil)
+    if klass
+      @testing = "/#{klass.name.underscore}".sub!(/_controller$/, '')
+    else
+      @testing
+    end
+  end
+
+  def get(thing, *args)
+    if thing.is_a?(Symbol)
+      super("#{self.class.testing}/#{thing}", *args)
+    else
+      super
+    end
+  end
+
+  def assert_body(body)
+    assert_equal body, Array.wrap(response.body).join
+  end
+
+  def assert_status(code)
+    assert_equal code, response.status
+  end
+
+  def assert_response(body, status = 200, headers = {})
+    assert_body   body
+    assert_status status
+    headers.each do |header, value|
+      assert_header header, value
+    end
+  end
+
+  def assert_content_type(type)
+    assert_equal type, response.headers["Content-Type"]
+  end
+
+  def assert_header(name, value)
+    assert_equal value, response.headers[name]
+  end
+end
+
+class ActionController::Base
+  def self.test_routes(&block)
+    routes = ActionDispatch::Routing::RouteSet.new
+    routes.draw(&block)
+    include routes.url_helpers
+  end
+end
+
+class ::ApplicationController < ActionController::Base
+end
+
+module ActionController
+  class Base
+    include ActionController::Testing
+  end
+
+  Base.view_paths = []
+
+  class TestCase
+    include ActionDispatch::TestProcess
+
+    setup do
+      @routes = SharedTestRoutes
+    end
+  end
+end
+
+# This stub emulates the Railtie including the URL helpers from a Rails application
+module ActionController
+  class Base
+    include SharedTestRoutes.url_helpers
+  end
+end

data/test/helper.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-
 # require 'simplecov-html'
 # SimpleCov.start
 
@@ -17,4 +16,27 @@ class Test::Unit::TestCase
     ex = assert_raise(error, &block)
     assert_match(regexp, ex.message, "#{ex.class.name}: #{ex.message}\n#{ex.backtrace.join("\n\t")}")
   end
+
+  def with_activesupport
+    case Rails.version
+    when '3.0.0'
+      require 'active_support/all'
+    # when '2.3.0'
+    #   require 'active_support'
+    #   require 'active_support/cache/dalli_store23'
+    end
+    yield
+  end
+
+  def with_actionpack
+    case Rails.version
+    when '3.0.0'
+      require 'action_dispatch'
+      require 'action_controller'
+    # when '2.3.0'
+    #   raise NotImplementedError
+    end
+    yield
+  end
+
 end

data/test/memcached_mock.rb

@@ -72,13 +72,8 @@ module MemcachedMock
         sleep 0.3
         yield Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"])
       ensure
-        begin
-          Process.kill("TERM", pid)
-          Process.wait(pid)
-        rescue Errno::ECHILD
-          # the memcached_mock forks will try to run this at_exit block also
-          # but since they are not the parent process, will get an ECHILD error.
-        end
+        Process.kill("TERM", pid)
+        Process.wait(pid)
       end
     end
   end

data/test/test_active_support.rb

@@ -1,77 +1,95 @@
 require 'helper'
-require 'active_support/all'
-require 'active_support/cache/dalli_store'
+require 'rails'
 
-class TestDalli < Test::Unit::TestCase
-  context 'activesupport caching' do
+class TestActiveSupport < Test::Unit::TestCase
+  context 'active_support caching' do
 
     should 'support fetch' do
-      memcached do
-        connect
-        dvalue = @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
-        mvalue = @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
-        assert_equal mvalue, dvalue
+      with_activesupport do
+        memcached do
+          connect
+          dvalue = @mc.fetch('somekeywithoutspaces', :expires_in => 1.second) { 123 }
+          mvalue = @dalli.fetch('someotherkeywithoutspaces', :expires_in => 1.second) { 123 }
+          assert_equal mvalue, dvalue
 
-        o = Object.new
-        o.instance_variable_set :@foo, 'bar'
-        dvalue = @mc.fetch(rand_key, :raw => true) { o }
-        mvalue = @dalli.fetch(rand_key, :raw => true) { o }
-        assert_equal mvalue, dvalue
-        assert_equal o, dvalue
+          o = Object.new
+          o.instance_variable_set :@foo, 'bar'
+          dvalue = @mc.fetch(rand_key, :raw => true) { o }
+          mvalue = @dalli.fetch(rand_key, :raw => true) { o }
+          assert_equal mvalue, dvalue
+          assert_equal o, dvalue
 
-        dvalue = @mc.fetch(rand_key) { o }
-        mvalue = @dalli.fetch(rand_key) { o }
-        assert_equal mvalue, dvalue
-        assert_equal o, dvalue
+          dvalue = @mc.fetch(rand_key) { o }
+          mvalue = @dalli.fetch(rand_key) { o }
+          assert_equal mvalue, dvalue
+          assert_equal o, dvalue
+        end
       end
     end
 
+    should 'support keys with spaces' do
+      with_activesupport do
+        memcached do
+          connect
+          dvalue = @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
+          mvalue = @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
+          assert_equal mvalue, dvalue
+        end
+      end
+    end      
+
     should 'support read_multi' do
-      memcached do
-        connect
-        x = rand_key
-        y = rand_key
-        assert_equal({}, @mc.read_multi(x, y))
-        assert_equal({}, @dalli.read_multi(x, y))
-        @dalli.write(x, '123')
-        @dalli.write(y, 123)
-        @mc.write(x, '123')
-        @mc.write(y, 123)
-        assert_equal({ x => '123', y => 123 }, @dalli.read_multi(x, y))
-        assert_equal({ x => '123', y => 123 }, @mc.read_multi(x, y))
+      with_activesupport do
+        memcached do
+          connect
+          x = rand_key
+          y = rand_key
+          assert_equal({}, @mc.read_multi(x, y))
+          assert_equal({}, @dalli.read_multi(x, y))
+          @dalli.write(x, '123')
+          @dalli.write(y, 123)
+          @mc.write(x, '123')
+          @mc.write(y, 123)
+          assert_equal({ x => '123', y => 123 }, @dalli.read_multi(x, y))
+          assert_equal({ x => '123', y => 123 }, @mc.read_multi(x, y))
+        end
       end
     end
 
     should 'support read, write and delete' do
-      memcached do
-        connect
-        x = rand_key
-        y = rand_key
-        assert_nil @mc.read(x)
-        assert_nil @dalli.read(y)
-        mres = @mc.write(x, 123)
-        dres = @dalli.write(y, 123)
-        assert_equal mres, dres
+      with_activesupport do
+        memcached do
+          connect
+          x = rand_key
+          y = rand_key
+          assert_nil @mc.read(x)
+          assert_nil @dalli.read(y)
+          mres = @mc.write(x, 123)
+          dres = @dalli.write(y, 123)
+          assert_equal mres, dres
 
-        mres = @mc.read(x)
-        dres = @dalli.read(y)
-        assert_equal mres, dres
-        assert_equal 123, dres
+          mres = @mc.read(x)
+          dres = @dalli.read(y)
+          assert_equal mres, dres
+          assert_equal 123, dres
       
-        mres = @mc.delete(x)
-        dres = @dalli.delete(y)
-        assert_equal mres, dres
-        assert_equal true, dres
+          mres = @mc.delete(x)
+          dres = @dalli.delete(y)
+          assert_equal mres, dres
+          assert_equal true, dres
+        end
       end
     end
     
     should 'support other esoteric commands' do
-      memcached do
-        connect
-        ms = @mc.stats
-        ds = @dalli.stats
-        assert_equal ms.keys.sort, ds.keys.sort
-        assert_equal ms[ms.keys.first].keys.sort, ds[ds.keys.first].keys.sort
+      with_activesupport do
+        memcached do
+          connect
+          ms = @mc.stats
+          ds = @dalli.stats
+          assert_equal ms.keys.sort, ds.keys.sort
+          assert_equal ms[ms.keys.first].keys.sort, ds[ds.keys.first].keys.sort
+        end
       end
     end
   end