deas 0.38.0 → 0.39.0

data/lib/deas/test_runner.rb

@@ -5,100 +5,99 @@ require 'deas/view_handler'
 
 module Deas
 
-  InvalidServiceHandlerError = Class.new(StandardError)
+  InvalidViewHandlerError = Class.new(StandardError)
 
   class TestRunner < Runner
 
-    attr_reader :response_value
+    attr_reader :content_type_args
 
     def initialize(handler_class, args = nil)
       if !handler_class.include?(Deas::ViewHandler)
-        raise InvalidServiceHandlerError, "#{handler_class.inspect} is not a"\
-                                          " Deas::ServiceHandler"
+        raise InvalidViewHandlerError, "#{handler_class.inspect} is not a " \
+                                       "Deas::ViewHandler"
       end
 
-      args = (args || {}).dup
+      @run_return_value  = nil
+      @content_type_args = nil
+      @halted            = false
+
+      a = (args || {}).dup
       super(handler_class, {
-        :request  => args.delete(:request),
-        :response => args.delete(:response),
-        :session  => args.delete(:session),
-        :params   => NormalizedParams.new(args.delete(:params) || {}).value,
-        :logger   => args.delete(:logger),
-        :router   => args.delete(:router),
-        :template_source => args.delete(:template_source)
+        :logger          => a.delete(:logger),
+        :router          => a.delete(:router),
+        :template_source => a.delete(:template_source),
+        :request         => a.delete(:request),
+        :session         => a.delete(:session),
+        :params          => NormalizedParams.new(a.delete(:params) || {}).value
       })
-      args.each{|key, value| self.handler.send("#{key}=", value) }
+      a.each{|key, value| self.handler.send("#{key}=", value) }
 
-      @response_value = catch(:halt){ self.handler.init; nil }
+      catch(:halt){ self.handler.deas_init }
     end
 
+    def halted?; @halted; end
+
     def run
-      @response_value ||= catch(:halt){ self.handler.run }
+      catch(:halt){ self.handler.deas_run } if !self.halted?
+      @run_return_value
     end
 
-    # Helpers
+    # helpers
 
-    def halt(*args)
-      throw(:halt, HaltArgs.new(args))
+    def content_type(extname, params = nil)
+      @content_type_args = ContentTypeArgs.new(extname, params)
+      super
     end
 
-    class HaltArgs < Struct.new(:body, :headers, :status)
-      def initialize(args)
-        super(*[
-          !args.last.kind_of?(::Hash) && !args.last.kind_of?(::Integer) ? args.pop : nil,
-          args.last.kind_of?(::Hash) ? args.pop : nil,
-          args.first.kind_of?(::Integer) ? args.first : nil
-        ])
-      end
+    def halt(*args)
+      @halted = true
+      @run_return_value ||= HaltArgs.new(args)
+      super
     end
 
-    def redirect(path, *halt_args)
-      throw(:halt, RedirectArgs.new(path, halt_args))
+    def redirect(location, *halt_args)
+      @run_return_value ||= RedirectArgs.new(location, HaltArgs.new(halt_args))
+      super
     end
 
-    class RedirectArgs < Struct.new(:path, :halt_args)
-      def redirect?; true; end
+    def send_file(file_path, opts = nil)
+      @run_return_value ||= SendFileArgs.new(file_path, opts)
+      super
     end
 
-    def content_type(*args)
-      return @content_type if args.empty?
-      opts, value = [
-        args.last.kind_of?(Hash) ? args.pop : {},
-        args.last
-      ]
-      @content_type = ContentTypeArgs.new(value, opts)
+    def source_render(source, template_name, locals = nil)
+      @run_return_value ||= RenderArgs.new(source, template_name, locals)
+      super
     end
-    ContentTypeArgs = Struct.new(:value, :opts)
 
-    def status(*args)
-      return @status if args.empty?
-      value = args.last
-      @status = StatusArgs.new(value)
+    def source_partial(source, template_name, locals = nil)
+      # partials don't interact with the response body so they shouldn't affect
+      # the run return value (like renders do).  Render the markup and discard
+      # it to test the template.  Return the render args so you can test the
+      # expected partials were rendered.
+      super
+      RenderArgs.new(source, template_name, locals)
     end
-    StatusArgs = Struct.new(:value)
 
-    def headers(*args)
-      return @headers if args.empty?
-      value = args.last
-      @headers = HeadersArgs.new(value)
-    end
-    HeadersArgs = Struct.new(:value)
+    ContentTypeArgs = Struct.new(:extname, :params)
 
-    def send_file(file_path, options = nil, &block)
-      SendFileArgs.new(file_path, options, block)
+    class HaltArgs < Struct.new(:status, :headers, :body)
+      def initialize(args)
+        a = args.dup
+        super(*[
+          a.first.instance_of?(::Fixnum) ? a.shift : nil,
+          a.first.kind_of?(::Hash)       ? a.shift : nil,
+          a.first.respond_to?(:each)     ? a.shift : nil
+        ])
+      end
     end
-    SendFileArgs = Struct.new(:file_path, :options, :block)
 
-    def source_render(source, template_name, locals = nil)
-      super # render the markup and discard it
-      RenderArgs.new(source, template_name, locals)
+    class RedirectArgs < Struct.new(:location, :halt_args)
+      def redirect?; true; end
     end
-    RenderArgs = Struct.new(:source, :template_name, :locals)
 
-    def source_partial(source, template_name, locals = nil)
-      super # render the markup and discard it
-      RenderArgs.new(source, template_name, locals)
-    end
+    SendFileArgs = Struct.new(:file_path, :opts)
+    RenderArgs   = Struct.new(:source, :template_name, :locals)
 
     class NormalizedParams < Deas::Runner::NormalizedParams
       def file_type?(value)

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.38.0"
+  VERSION = "0.39.0"
 end

data/lib/deas/view_handler.rb

@@ -1,14 +1,14 @@
+require 'much-plugin'
 require 'deas/runner'
 
 module Deas
 
   module ViewHandler
+    include MuchPlugin
 
-    def self.included(klass)
-      klass.class_eval do
-        extend ClassMethods
-        include InstanceMethods
-      end
+    plugin_included do
+      extend ClassMethods
+      include InstanceMethods
     end
 
     module InstanceMethods
@@ -17,30 +17,35 @@ module Deas
         @deas_runner = runner
       end
 
-      def init
-        run_callback 'before_init'
+      def deas_init
+        self.deas_run_callback 'before_init'
         self.init!
-        run_callback 'after_init'
+        self.deas_run_callback 'after_init'
       end
 
       def init!
       end
 
-      def run
-        run_callback 'before_run'
+      def deas_run
+        self.deas_run_callback 'before_run'
         data = self.run!
-        run_callback 'after_run'
+        self.deas_run_callback 'after_run'
         data
       end
 
       def run!
-        raise NotImplementedError
       end
 
       def layouts
         self.class.layouts.map{ |proc| self.instance_eval(&proc) }
       end
 
+      def deas_run_callback(callback)
+        (self.class.send("#{callback}_callbacks") || []).each do |callback|
+          self.instance_eval(&callback)
+        end
+      end
+
       def inspect
         reference = '0x0%x' % (self.object_id << 1)
         "#<#{self.class}:#{reference} @request=#{request.inspect}>"
@@ -54,31 +59,29 @@ module Deas
 
       # Helpers
 
-      def halt(*args);         @deas_runner.halt(*args);         end
-      def redirect(*args);     @deas_runner.redirect(*args);     end
-      def content_type(*args); @deas_runner.content_type(*args); end
+      # utils
+      def logger; @deas_runner.logger; end
+      def router; @deas_runner.router; end
+
+      # request
+      def request; @deas_runner.request; end
+      def session; @deas_runner.session; end
+      def params;  @deas_runner.params;  end
+
+      # response
       def status(*args);       @deas_runner.status(*args);       end
       def headers(*args);      @deas_runner.headers(*args);      end
+      def body(*args);         @deas_runner.body(*args);         end
+      def content_type(*args); @deas_runner.content_type(*args); end
+      def halt(*args);         @deas_runner.halt(*args);         end
+      def redirect(*args);     @deas_runner.redirect(*args);     end
+      def send_file(*args);    @deas_runner.send_file(*args);    end
 
+      # rendering
       def render(*args, &block);         @deas_runner.render(*args, &block);         end
       def source_render(*args, &block);  @deas_runner.source_render(*args, &block);  end
       def partial(*args, &block);        @deas_runner.partial(*args, &block);        end
       def source_partial(*args, &block); @deas_runner.source_partial(*args, &block); end
-      def send_file(*args, &block);      @deas_runner.send_file(*args, &block);      end
-
-      # TODO: make these public when built using the test helpers
-      def logger;   @deas_runner.logger;   end
-      def router;   @deas_runner.router;   end
-      def request;  @deas_runner.request;  end
-      def response; @deas_runner.response; end
-      def params;   @deas_runner.params;   end
-      def session;  @deas_runner.session;  end
-
-      def run_callback(callback)
-        (self.class.send("#{callback}_callbacks") || []).each do |callback|
-          self.instance_eval(&callback)
-        end
-      end
 
     end
 
@@ -106,6 +109,7 @@ module Deas
       def after_init(&block);  self.after_init_callbacks  << block; end
       def before_run(&block);  self.before_run_callbacks  << block; end
       def after_run(&block);   self.after_run_callbacks   << block; end
+
       def prepend_before(&block); self.before_callbacks.unshift(block); end
       def prepend_after(&block);  self.after_callbacks.unshift(block);  end
       def prepend_before_init(&block); self.before_init_callbacks.unshift(block); end
@@ -115,6 +119,27 @@ module Deas
 
     end
 
+    module TestHelpers
+
+      def self.included(klass)
+        require 'rack/request'
+        require 'rack/response'
+        require 'deas/test_runner'
+      end
+
+      def test_runner(handler_class, args = nil)
+        args ||= {}
+        args[:request] ||= Rack::Request.new({})
+        args[:session] ||= args[:request].session
+        TestRunner.new(handler_class, args)
+      end
+
+      def test_handler(handler_class, args = nil)
+        test_runner(handler_class, args).handler
+      end
+
+    end
+
   end
 
 end

data/test/support/empty_view_handler.rb

@@ -0,0 +1,7 @@
+require 'deas/template_source'
+require 'deas/view_handler'
+
+class EmptyViewHandler
+  include Deas::ViewHandler
+
+end

data/test/support/factory.rb

@@ -3,6 +3,7 @@ require 'deas/logger'
 require 'deas/router'
 require 'deas/server_data'
 require 'deas/template_source'
+require 'test/support/fake_request'
 require 'test/support/fake_sinatra_call'
 
 module Factory
@@ -25,6 +26,10 @@ module Factory
     }.merge(opts || {}))
   end
 
+  def self.request(args = nil)
+    FakeRequest.new(args)
+  end
+
   def self.sinatra_call(settings = nil)
     FakeSinatraCall.new(settings)
   end

data/test/support/fake_request.rb

@@ -0,0 +1,29 @@
+require 'ostruct'
+
+class FakeRequest < Struct.new(:http_method, :path, :params, :session, :env)
+  alias :request_method :http_method
+
+  attr_reader :logging_msgs
+
+  def initialize(args = nil)
+    args ||= {}
+    super(*[
+      args[:http_method] || 'GET',
+      args[:path]        || Factory.path,
+      args[:params]      || {},
+      args[:session]     || OpenStruct.new,
+      args[:env]         || {}
+    ])
+
+    self.env.merge!({
+      'rack.url_scheme' => Factory.boolean ? 'http' : 'https',
+      'HTTP_HOST'       => "#{Factory.string}.#{Factory.string}",
+
+      'deas.logging' => Proc.new do |msg|
+        @logging_msgs ||= []
+        @logging_msgs.push(msg)
+      end
+    })
+  end
+
+end

data/test/support/fake_sinatra_call.rb

@@ -1,4 +1,4 @@
-require 'ostruct'
+require 'test/support/fake_request'
 
 class FakeSinatraCall
 
@@ -9,8 +9,8 @@ class FakeSinatraCall
   attr_accessor :settings
 
   def initialize(settings = nil)
-    @request         = FakeRequest.new('GET','/something', {}, OpenStruct.new)
-    @response        = FakeResponse.new(Factory.integer, {}, [Factory.text])
+    @request         = FakeRequest.new
+    @response        = FakeResponse.new
     @session         = @request.session
     @params          = @request.params
     @logger          = Deas::NullLogger.new
@@ -69,18 +69,13 @@ class FakeSinatraCall
 
 end
 
-class FakeRequest < Struct.new(:http_method, :path, :params, :session)
-  alias :request_method :http_method
-
-  attr_reader :logging_msgs
-
-  def env
-    @env ||= {
-      'deas.logging' => Proc.new do |msg|
-        @logging_msgs ||= []
-        @logging_msgs.push(msg)
-      end
-    }
+class FakeResponse < Struct.new(:status, :headers, :body)
+  def initialize(args = nil)
+    args ||= {}
+    super(*[
+      args[:status]  || Factory.integer,
+      args[:headers] || {},
+      args[:body]    || [Factory.text]
+    ])
   end
 end
-FakeResponse = Struct.new(:status, :headers, :body)

data/test/support/file1.txt

@@ -0,0 +1 @@
+this is just a file to use in send file tests.

data/test/support/file2.txt

@@ -0,0 +1 @@
+this is just another file to use in send file tests.

data/test/support/routes.rb

@@ -59,7 +59,7 @@ class DeasDevServer
 
   show_exceptions true
 
-  get  '/error', 'ErrorHandler'
+  get '/error', 'ErrorHandler'
 
 end
 
@@ -73,7 +73,7 @@ class ShowHandler
   end
 
   def run!
-    @message
+    body @message
   end
 
 end
@@ -88,7 +88,7 @@ class ShowMobileHandler
   end
 
   def run!
-    @message
+    body @message
   end
 
 end
@@ -111,7 +111,7 @@ class ShowLatinJsonHandler
   include Deas::ViewHandler
 
   def run!
-    content_type :json, :charset => 'latin1'
+    content_type '.json', :charset => 'latin1'
   end
 
 end
@@ -177,7 +177,7 @@ class UseSessionHandler
   include Deas::ViewHandler
 
   def run!
-    session[:secret]
+    body session[:secret]
   end
 
 end
@@ -189,7 +189,6 @@ class HandlerTestsHandler
     @data = {}
     set_data('logger_class_name'){ logger.class.name }
     set_data('request_method'){ request.request_method.to_s }
-    set_data('response_firstheaderval'){ response.headers.sort.first.to_s }
     set_data('params_a_param'){ params['a-param'] }
     set_data('session_inspect'){ session.inspect }
   end
@@ -202,7 +201,8 @@ class HandlerTestsHandler
   end
 
   def run!
-    [200, {}, @data.inspect]
+    status 200
+    body   @data.inspect
   end
 
 end