deas 0.37.0 → 0.37.1

data/lib/deas/logging.rb

@@ -41,7 +41,7 @@ module Deas
       log_error(env['sinatra.error'])
       env['deas.time_taken'] = RoundedTime.new(benchmark.real)
 
-      [ status, headers, body ]
+      [status, headers, body]
     end
 
     def log(message)
@@ -81,11 +81,11 @@ module Deas
       status, headers, body = super(env)
       log "  Redir:   #{headers['Location']}" if headers.key?('Location')
       log "===== Completed in #{env['deas.time_taken']}ms (#{response_display(status)}) ====="
-      [ status, headers, body ]
+      [status, headers, body]
     end
 
     def response_display(status)
-      [ status, RESPONSE_STATUS_NAMES[status.to_i] ].compact.join(', ')
+      [status, RESPONSE_STATUS_NAMES[status.to_i]].compact.join(', ')
     end
 
   end
@@ -101,16 +101,18 @@ module Deas
       line_attrs = {
         'method'  => request.request_method,
         'path'    => request.path,
-        'handler' => env['deas.handler_class'].name,
         'params'  => env['deas.params'],
         'time'    => env['deas.time_taken'],
         'status'  => status
       }
+      if env['deas.handler_class']
+        line_attrs['handler'] = env['deas.handler_class'].name
+      end
       if headers.key?('Location')
         line_attrs['redir'] = headers['Location']
       end
       log SummaryLine.new(line_attrs)
-      [ status, headers, body ]
+      [status, headers, body]
     end
 
   end

data/lib/deas/show_exceptions.rb

@@ -27,24 +27,19 @@ module Deas
         error_body = Body.new(error)
 
         headers['Content-Length'] = error_body.size.to_s
-        headers['Content-Type'] = error_body.mime_type.to_s
+        headers['Content-Type']   = error_body.mime_type.to_s
         body = [error_body.content]
       end
-      [ status, headers, body ]
+      [status, headers, body]
     end
 
     class Body
-      attr_reader :content
-      def initialize(e)
-        @content ||= "#{e.class}: #{e.message}\n#{(e.backtrace || []).join("\n")}"
-      end
+      attr_reader :content, :size, :mime_type
 
-      def size
-        @size ||= Rack::Utils.bytesize(self.content)
-      end
-
-      def mime_type
-        @mime_type ||= "text/plain"
+      def initialize(e)
+        @content   = "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+        @size      = Rack::Utils.bytesize(@content)
+        @mime_type = "text/plain"
       end
     end
 

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.37.0"
+  VERSION = "0.37.1"
 end

data/test/support/fake_sinatra_call.rb

@@ -10,7 +10,7 @@ class FakeSinatraCall
 
   def initialize(settings = nil)
     @request         = FakeRequest.new('GET','/something', {}, OpenStruct.new)
-    @response        = FakeResponse.new
+    @response        = FakeResponse.new(Factory.integer, {}, [Factory.text])
     @session         = @request.session
     @params          = @request.params
     @logger          = Deas::NullLogger.new
@@ -26,6 +26,10 @@ class FakeSinatraCall
     }.merge(settings || {}))
   end
 
+  def call(env)
+    [@response.status, @response.headers, [@response.body]]
+  end
+
   def halt(*args)
     throw :halt, args
   end

data/test/support/routes.rb

@@ -6,7 +6,7 @@ class DeasTestServer
   root TEST_SUPPORT_ROOT
 
   logger TEST_LOGGER
-  verbose_logging true
+  verbose_logging Factory.boolean
 
   set :a_setting, 'something'
 

data/test/unit/logging_tests.rb

@@ -5,41 +5,277 @@ module Deas::Logging
 
   class UnitTests < Assert::Context
     desc "Deas::Logging"
-    setup do
-      @app = Factory.sinatra_call
-    end
     subject{ Deas::Logging }
 
     should have_imeths :middleware
 
+    should "return a middleware class given a verbose flag" do
+      assert_equal Deas::VerboseLogging, subject.middleware(true)
+      assert_equal Deas::SummaryLogging, subject.middleware(false)
+    end
+
+  end
+
+  class CallSetupTests < UnitTests
+    setup do
+      @logger = SpyLogger.new
+      @app = Factory.sinatra_call({
+        :deas_server_data => Factory.server_data(:logger => @logger)
+      })
+
+      @app_call_env = nil
+      @resp_status  = Factory.integer
+      @resp_headers = { 'Location' => Factory.path }
+      @app_response = [@resp_status, @resp_headers, [Factory.text]]
+      Assert.stub(@app, :call) do |env|
+        # dup so we can see what keys were added before supering
+        @app_call_env = env.dup
+        @app_response
+      end
+
+      @env = {
+        'REQUEST_METHOD' => Factory.string(3).upcase,
+        'PATH_INFO'      => Factory.path,
+        'rack.run_once'  => true
+      }
+    end
+    subject{ @middleware_class }
+
+  end
+
+  class BaseLoggingTests < CallSetupTests
+    desc "Deas::BaseLogging"
+    setup do
+      @middleware_class = Deas::BaseLogging
+    end
+
   end
 
-  class VerboseLoggingTests < UnitTests
+  class BaseLoggingInitTests < BaseLoggingTests
+    desc "when init"
+    setup do
+      @benchmark = Benchmark.measure{}
+      Assert.stub(Benchmark, :measure) do |&block|
+        block.call
+        @benchmark
+      end
+
+      @middleware = @middleware_class.new(@app)
+    end
+    subject{ @middleware }
+
+    should have_imeths :call, :call!
+
+    should "call the app and return its response when called" do
+      response = subject.call(@env)
+      assert_not_nil @app_call_env
+      assert_equal @app_response, response
+    end
+
+    should "set the rack.logger env key before its app is called" do
+      subject.call(@env)
+      assert_equal @logger, @env['rack.logger']
+      assert_same @env['rack.logger'], @app_call_env['rack.logger']
+    end
+
+    should "benchmark calling its app and set the deas.time_taken env key" do
+      assert_nil @env['deas.time_taken']
+      subject.call(@env)
+      exp = Deas::RoundedTime.new(@benchmark.real)
+      assert_equal exp, @env['deas.time_taken']
+    end
+
+    should "log a sinatra.error env key if it exists" do
+      @env.delete('sinatra.error')
+      subject.call(@env)
+      assert_empty @logger.info_logged
+
+      @env['sinatra.error'] = Factory.exception(Sinatra::NotFound)
+      subject.call(@env)
+      assert_empty @logger.info_logged
+
+      @env['sinatra.error'] = error = Factory.exception
+      subject.call(@env)
+      exp = "[Deas] #{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+      assert_includes exp, @logger.info_logged
+    end
+
+  end
+
+  class VerboseLoggingTests < CallSetupTests
     desc "Deas::VerboseLogging"
     setup do
+      @middleware_class = Deas::VerboseLogging
+    end
+
+    should "be a base logging middleware" do
+      assert subject < Deas::BaseLogging
+    end
+
+    should "know its response status names" do
+      exp = {
+        200 => 'OK',
+        302 => 'FOUND',
+        400 => 'BAD REQUEST',
+        401 => 'UNAUTHORIZED',
+        403 => 'FORBIDDEN',
+        404 => 'NOT FOUND',
+        408 => 'TIMEOUT',
+        500 => 'ERROR'
+      }
+      assert_equal exp, @middleware_class::RESPONSE_STATUS_NAMES
+    end
+
+  end
+
+  class VerboseLoggingInitTests < VerboseLoggingTests
+    desc "when init"
+    setup do
+      @resp_status = @middleware_class::RESPONSE_STATUS_NAMES.keys.choice
+      @app_response[0] = @resp_status
+
       @middleware = Deas::VerboseLogging.new(@app)
     end
     subject{ @middleware }
 
-    should have_imeths :call, :call!
+    should have_imeths :call!
+
+    should "call the app and return its response when called" do
+      response = subject.call(@env)
+      assert_not_nil @app_call_env
+      assert_equal @app_response, response
+    end
+
+    should "set the deas.logging env key before calling its app" do
+      assert_nil @env['deas.logging']
+      subject.call(@env)
+      assert_instance_of Proc, @env['deas.logging']
+
+      message = Factory.text
+      @env['deas.logging'].call(message)
+      assert_includes "[Deas] #{message}", @logger.info_logged
+
+      assert_same @env['deas.logging'], @app_call_env['deas.logging']
+    end
 
-    should "be a kind of Deas::BaseLogging middleware" do
-      assert_kind_of Deas::BaseLogging, subject
+    should "log the request when called" do
+      assert_empty @logger.info_logged
+      subject.call(@env)
+      status = "#{@resp_status}, " \
+               "#{@middleware_class::RESPONSE_STATUS_NAMES[@resp_status]}"
+      exp = [
+        "[Deas] ===== Received request =====",
+        "[Deas]   Method:  #{@env['REQUEST_METHOD'].inspect}",
+        "[Deas]   Path:    #{@env['PATH_INFO'].inspect}",
+        "[Deas]   Redir:   #{@resp_headers['Location']}",
+        "[Deas] ===== Completed in #{@env['deas.time_taken']}ms (#{status}) ====="
+      ]
+      assert_equal exp, @logger.info_logged
+    end
+
+    should "not log a redir line if it doesn't have a Location header" do
+      @resp_headers.delete('Location')
+      subject.call(@env)
+
+      exp = "[Deas]   Redir:   #{@resp_headers['Location']}"
+      assert_not_includes exp, @logger.info_logged
+    end
+
+    should "not log a status name for unknown statuses" do
+      @resp_status = Factory.integer
+      @app_response[0] = @resp_status
+      subject.call(@env)
+
+      exp = "[Deas] ===== Completed in #{@env['deas.time_taken']}ms (#{@resp_status}) ====="
+      assert_includes exp, @logger.info_logged
     end
 
   end
 
-  class SummaryLoggingTests < UnitTests
+  class SummaryLoggingTests < CallSetupTests
     desc "Deas::SummaryLogging"
     setup do
+      @middleware_class = Deas::SummaryLogging
+    end
+
+    should "be a base logging middleware" do
+      assert subject < Deas::BaseLogging
+    end
+
+  end
+
+  class SummaryLoggingInitTests < SummaryLoggingTests
+    desc "when init"
+    setup do
+      @params = { Factory.string => Factory.string }
+      @handler_class = TestHandler
+      @env.merge!({
+        'deas.params'        => @params,
+        'deas.handler_class' => @handler_class
+      })
+
       @middleware = Deas::SummaryLogging.new(@app)
     end
     subject{ @middleware }
 
-    should have_imeths :call, :call!
+    should "call the app and return its response when called" do
+      response = subject.call(@env)
+      assert_not_nil @app_call_env
+      assert_equal @app_response, response
+    end
 
-    should "be a kind of Deas::BaseLogging middleware" do
-      assert_kind_of Deas::BaseLogging, subject
+    should "set the deas.logging env key before calling its app" do
+      assert_nil @env['deas.logging']
+      subject.call(@env)
+      assert_instance_of Proc, @env['deas.logging']
+      assert_nil @env['deas.logging'].call(Factory.text)
+      assert_same @env['deas.logging'], @app_call_env['deas.logging']
+    end
+
+    should "log the request when called" do
+      assert_empty @logger.info_logged
+      subject.call(@env)
+
+      summary_line = Deas::SummaryLine.new({
+        'method'  => @env['REQUEST_METHOD'],
+        'path'    => @env['PATH_INFO'],
+        'params'  => @env['deas.params'],
+        'time'    => @env['deas.time_taken'],
+        'status'  => @resp_status,
+        'handler' => @handler_class.name,
+        'redir'   => @resp_headers['Location']
+      })
+      assert_includes "[Deas] #{summary_line}", @logger.info_logged
+    end
+
+    should "not log a handler when it doesn't have a handler class" do
+      @env.delete('deas.handler_class')
+      subject.call(@env)
+
+      summary_line = Deas::SummaryLine.new({
+        'method'  => @env['REQUEST_METHOD'],
+        'path'    => @env['PATH_INFO'],
+        'params'  => @env['deas.params'],
+        'time'    => @env['deas.time_taken'],
+        'status'  => @resp_status,
+        'redir'   => @resp_headers['Location']
+      })
+      assert_includes "[Deas] #{summary_line}", @logger.info_logged
+    end
+
+    should "not log a redir if it doesn't have a Location header" do
+      @resp_headers.delete('Location')
+      subject.call(@env)
+
+      summary_line = Deas::SummaryLine.new({
+        'method'  => @env['REQUEST_METHOD'],
+        'path'    => @env['PATH_INFO'],
+        'params'  => @env['deas.params'],
+        'time'    => @env['deas.time_taken'],
+        'status'  => @resp_status,
+        'handler' => @handler_class.name,
+      })
+      assert_includes "[Deas] #{summary_line}", @logger.info_logged
     end
 
   end
@@ -88,4 +324,16 @@ module Deas::Logging
 
   end
 
+  TestHandler = Class.new
+
+  class SpyLogger
+    attr_reader :info_logged
+
+    def initialize
+      @info_logged = []
+    end
+
+    def info(message);  @info_logged  << message; end
+  end
+
 end

data/test/unit/show_exceptions_tests.rb

@@ -8,27 +8,60 @@ class Deas::ShowExceptions
   class UnitTests < Assert::Context
     desc "Deas::ShowExceptions"
     setup do
-      exception = Sinatra::NotFound.new
-      @app = proc do |env|
-        env['sinatra.error'] = exception
-        [ 404, {}, [] ]
-      end
-      @exception = exception
-      @show_exceptions = Deas::ShowExceptions.new(@app)
+      @middleware_class = Deas::ShowExceptions
     end
-    subject{ @show_exceptions }
+    subject{ @middleware_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @app = Factory.sinatra_call
+      @env = { 'sinatra.error' => Factory.exception }
+      @middleware = @middleware_class.new(@app)
+    end
+    subject{ @middleware }
 
     should have_imeths :call, :call!
 
-    should "return a body that contains details about the exception" do
-      status, headers, body = subject.call({})
-      expected_body = "#{@exception.class}: #{@exception.message}\n" \
-                      "#{(@exception.backtrace || []).join("\n")}"
-      expected_body_size = Rack::Utils.bytesize(expected_body).to_s
+    should "return a response for the exception when called" do
+      status, headers, body = subject.call(@env)
+      error_body = Body.new(@env['sinatra.error'])
+
+      assert_equal @app.response.status, status
+      assert_equal error_body.size.to_s, headers['Content-Length']
+      assert_equal error_body.mime_type, headers['Content-Type']
+      assert_equal [error_body.content], body
+    end
+
+    should "return the apps response if there isn't an exception" do
+      @env.delete('sinatra.error')
+      status, headers, body = subject.call(@env)
+
+      assert_equal @app.response.status,  status
+      assert_equal @app.response.headers, headers
+      assert_equal [@app.response.body],  body
+    end
+
+  end
+
+  class BodyTests < UnitTests
+    desc "Body"
+    setup do
+      @exception = Factory.exception
+      @body = Body.new(@exception)
+    end
+    subject{ @body }
+
+    should have_readers :content, :size, :mime_type
 
-      assert_equal expected_body_size, headers['Content-Length']
-      assert_equal "text/plain",       headers['Content-Type']
-      assert_equal [expected_body],    body
+    should "know its attributes" do
+      exp_content = "#{@exception.class}: #{@exception.message}\n" \
+                "#{@exception.backtrace.join("\n")}"
+      assert_equal exp_content, subject.content
+      assert_equal Rack::Utils.bytesize(exp_content), subject.size
+      assert_equal "text/plain", subject.mime_type
     end
 
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: deas
 version: !ruby/object:Gem::Version 
-  hash: 139
+  hash: 137
   prerelease: 
   segments: 
   - 0
   - 37
-  - 0
-  version: 0.37.0
+  - 1
+  version: 0.37.1
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-09-14 00:00:00 Z
+date: 2015-10-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -206,7 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.29
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Handler-based web framework powered by Sinatra