shark-on-lambda 1.0.0.rc4 → 2.0.0.rc3

data/lib/shark_on_lambda/middleware/jsonapi_rescuer.rb

@@ -2,7 +2,15 @@
 
 module SharkOnLambda
   module Middleware
-    class JsonapiRescuer < Rescuer
+    class JsonapiRescuer < Base
+      def call!(env)
+        app.call(env)
+      rescue Errors::Base => e
+        rescue_shark_error(e)
+      rescue StandardError => e
+        rescue_standard_error(e)
+      end
+
       private
 
       def error_object(status, message)
@@ -26,6 +34,18 @@ module SharkOnLambda
 
         [status, headers, response_body]
       end
+
+      def rescue_shark_error(error)
+        status = error.status || 500
+        error_response(status, {}, error.message)
+      end
+
+      def rescue_standard_error(error)
+        SharkOnLambda.logger.error(error.message)
+        SharkOnLambda.logger.error(error.backtrace.join("\n"))
+
+        error_response(500, {}, error.message)
+      end
     end
   end
 end

data/lib/shark_on_lambda/middleware/lambda_logger.rb

@@ -10,37 +10,34 @@ module SharkOnLambda
         @logger = logger
       end
 
-      private
-
-      def _call(env)
+      def call!(env)
         start_time = Time.now
         response = app.call(env)
-        end_time = Time.now
+        duration = duration_in_ms(start_time, Time.now)
 
         if logger.info?
-          log_request(env: env,
-                      response: response,
-                      start_time: start_time,
-                      end_time: end_time)
+          log_request(env: env, response: response, duration: duration)
         end
 
         response
       end
 
+      private
+
       def body_size(body)
         size = 0
         body.each { |chunk| size += chunk.bytesize }
         size
       end
 
-      def log_request(env:, response:, start_time:, end_time:)
+      def log_request(env:, response:, duration:)
         log_object = {
           url: env['PATH_INFO'],
           method: env['REQUEST_METHOD'],
-          params: params(env),
+          params: env.fetch('action_dispatch.request.parameters', {}),
           status: response[0],
           length: body_size(response[2]),
-          duration: "#{duration_in_ms(start_time, end_time)} ms"
+          duration: "#{duration} ms"
         }
         logger.info log_object.to_json
       end
@@ -49,11 +46,6 @@ module SharkOnLambda
         duration = (end_time - start_time) * 1000
         duration.abs.floor(3)
       end
-
-      def params(env)
-        query_params = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
-        query_params.merge(env['shark.path_parameters'] || {})
-      end
     end
   end
 end

data/lib/shark_on_lambda/rake_tasks.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'action_dispatch/routing/inspector'
+require 'rake'
+require 'shark_on_lambda'
+
+namespace :'shark-on-lambda' do
+  desc 'Print out all defined routes in match order, with names'
+  task :routes do
+    routes = SharkOnLambda.application.routes.routes
+    inspector = ActionDispatch::Routing::RoutesInspector.new(routes)
+    formatter = ActionDispatch::Routing::ConsoleFormatter::Sheet.new
+
+    puts inspector.format(formatter)
+  end
+end

data/lib/shark_on_lambda/request.rb

@@ -2,8 +2,5 @@
 
 module SharkOnLambda
   class Request < ActionDispatch::Request
-    def path_parameters
-      super.merge(env['shark.path_parameters'] || {})
-    end
   end
 end

data/lib/shark_on_lambda/rspec/env_builder.rb

@@ -3,23 +3,14 @@
 module SharkOnLambda
   module RSpec
     class EnvBuilder
-      attr_reader :action, :controller, :headers, :method, :params
-
-      def initialize(options = {})
-        @method = options.fetch(:method).to_s.upcase
-        @controller = options.fetch(:controller)
-        @action = options.fetch(:action)
-
-        @headers = (options[:headers] || {}).deep_stringify_keys
-        @headers.transform_keys!(&:downcase)
-        @params = options[:params]
-
-        initialize_env
-        add_headers
-        add_request_body
+      def initialize(**options)
+        @options = options
       end
 
       def build
+        initialize_env
+        add_headers
+        add_request_body_as_json if body? && jsonable_params? && json_request?
         env.deep_stringify_keys
       end
 
@@ -27,42 +18,88 @@ module SharkOnLambda
 
       attr_reader :env
 
-      def add_header(name, value)
-        name = name.upcase.tr('-', '_')
-        key = case name
-              when 'CONTENT_LENGTH', 'CONTENT_TYPE' then name
-              else "HTTP_#{name}"
-              end
-        @env[key] = value.to_s
+      def action
+        @options.fetch(:action)
       end
 
       def add_headers
-        headers.each_pair { |name, value| add_header(name, value) }
+        headers.each_pair do |name, value|
+          name = name.upcase.tr('-', '_')
+          key = case name
+                when 'CONTENT_LENGTH', 'CONTENT_TYPE' then name
+                else "HTTP_#{name}"
+                end
+          env[key] = value.to_s
+        end
       end
 
-      def add_request_body
-        return if %w[GET HEAD OPTIONS].include?(env['REQUEST_METHOD'])
-        return unless params.is_a?(Hash)
-
+      def add_request_body_as_json
         body = params.to_json
 
         env['rack.input'] = StringIO.new(body).set_encoding(Encoding::BINARY)
-        set_content_type_and_content_length
+        env['CONTENT_TYPE'] = headers['content-type']
+        env['CONTENT_LENGTH'] = env['rack.input'].length.to_s
+      end
+
+      def as
+        @options.fetch(:as, :json)
+      end
+
+      def body?
+        !%w[GET HEAD OPTIONS].include?(env['REQUEST_METHOD'])
       end
 
       def initialize_env
         @env = Rack::MockRequest.env_for(
-          'https://localhost:9292',
+          request_uri.to_s,
           method: method,
-          params: params,
-          'shark.controller' => controller,
-          'shark.action' => action
+          params: params
         )
       end
 
-      def set_content_type_and_content_length
-        env['CONTENT_TYPE'] = headers['content-type']
-        env['CONTENT_LENGTH'] = env['rack.input'].length.to_s
+      def controller
+        @options.fetch(:controller, nil)
+      end
+
+      def headers
+        return @headers if defined?(@headers)
+
+        @headers = @options.fetch(:headers, {}).deep_stringify_keys
+        @headers.transform_keys!(&:downcase)
+        @headers
+      end
+
+      def json_request?
+        as == :json
+      end
+
+      def jsonable_params?
+        params.is_a?(Hash)
+      end
+
+      def method
+        @options.fetch(:method).to_s.upcase
+      end
+
+      def params
+        @options.fetch(:params, {}).deep_stringify_keys
+      end
+
+      def path_from_routes
+        path_params = {
+          controller: controller.name.underscore.sub(/_controller$/, ''),
+          action: action,
+          only_path: true
+        }
+        url = SharkOnLambda.application.routes.url_for(path_params, nil)
+        URI.parse(url).path
+      end
+
+      def request_uri
+        return @request_uri if defined?(@request_uri)
+
+        path = action.is_a?(String) ? action : path_from_routes
+        @request_uri = URI.join('https://localhost:9292', path)
       end
     end
   end

data/lib/shark_on_lambda/rspec/helpers.rb

@@ -3,94 +3,12 @@
 module SharkOnLambda
   module RSpec
     module Helpers
-      def delete(controller_method, options = {})
-        make_request('DELETE', controller_method, options)
-      end
-
-      def get(controller_method, options = {})
-        make_request('GET', controller_method, options)
-      end
-
-      def patch(controller_method, options = {})
-        make_request('PATCH', controller_method, options)
-      end
-
-      def post(controller_method, options = {})
-        make_request('POST', controller_method, options)
-      end
-
-      def put(controller_method, options = {})
-        make_request('PUT', controller_method, options)
-      end
-
-      def response
-        if @response.nil?
-          raise 'You must make a request before you can request a response.'
-        end
-
-        @response
-      end
-
-      private
-
-      def build_env(method, action, options = {})
-        env_builder = EnvBuilder.new(
-          method: method,
-          controller: controller_name,
-          action: action,
-          headers: options[:headers],
-          params: options[:params]
-        )
-        env_builder.build
-      end
-
-      def controller?
-        controller_name.present?
-      end
-
-      def controller_name
-        self.class.ancestors.find do |klass|
-          klass.name.end_with?('Controller')
-        end&.description
-      end
-
-      def default_content_type
-        'application/json'
-      end
-
-      def dispatch_request(env, skip_middleware: false)
-        return SharkOnLambda.application.call(env) unless skip_middleware
-
-        controller_class = env['shark.controller'].constantize
-        action = env['shark.action']
-
-        request = Request.new(env)
-        response = Response.new
-        controller_class.dispatch(action, request, response)
-        response.prepare!
-      end
-
-      def headers_with_content_type(headers)
-        headers ||= {}
-        headers.transform_keys! { |key| key.to_s.downcase }
-        headers['content-type'] ||= default_content_type
-        headers
-      end
-
-      def make_request(method, action, options = {})
-        raise ArgumentError, 'Cannot find controller name.' unless controller?
-
-        options = options.with_indifferent_access
-        options[:headers] = headers_with_content_type(options[:headers])
-
-        env = build_env(method, action, options)
+      extend ActiveSupport::Concern
+      include RequestHelpers
+      include ResponseHelpers
 
-        status, headers, body = dispatch_request(
-          env,
-          skip_middleware: options[:skip_middleware]
-        )
-        errors = env['rack.errors']
-        @response = Rack::MockResponse.new(status, headers, body, errors)
+      included do
+        include SharkOnLambda.application.routes.url_helpers
       end
     end
   end

data/lib/shark_on_lambda/rspec/request_helpers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module RSpec
+    module RequestHelpers
+      attr_writer :app
+
+      SUPPORTED_HTTP_METHODS = %w[
+        DELETE GET HEAD OPTIONS PATCH POST PUT
+      ].freeze
+
+      SUPPORTED_HTTP_METHODS.each do |http_method|
+        define_method(http_method.underscore) do |action, **options|
+          make_request(http_method, action, **options)
+        end
+      end
+
+      def app
+        @app ||= SharkOnLambda.application
+      end
+
+      def response
+        if @response.nil?
+          raise 'You must make a request before you can request a response.'
+        end
+
+        @response
+      end
+
+      private
+
+      def build_env(method, action, **options)
+        headers = options.fetch(:headers, {})
+        env_builder = EnvBuilder.new(
+          method: method,
+          controller: described_class,
+          action: action,
+          headers: normalized_headers(headers),
+          params: options.fetch(:params, {})
+        )
+        env_builder.build
+      end
+
+      def default_content_type
+        'application/vnd.api+json'
+      end
+
+      def make_request(method, action, **options)
+        env = build_env(method, action, **options)
+
+        status, headers, body = app.call(env)
+        errors = env['rack.errors']
+        @response = Rack::MockResponse.new(status, headers, body, errors)
+      end
+
+      def normalized_headers(headers)
+        headers.transform_keys! { |key| key.to_s.downcase }
+        headers['content-type'] ||= default_content_type
+        headers
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/rspec/{jsonapi_helpers.rb → response_helpers.rb}

@@ -2,27 +2,21 @@
 
 module SharkOnLambda
   module RSpec
-    module JsonapiHelpers
-      include Helpers
-
+    module ResponseHelpers
       def jsonapi_attributes
-        jsonapi_data[:attributes] || {}
+        jsonapi_data.fetch(:attributes, {})
       end
 
       def jsonapi_data
-        parsed_body[:data] || {}
+        parsed_body.fetch(:data, {})
       end
 
       def jsonapi_errors
-        parsed_body[:errors] || []
+        parsed_body.fetch(:errors, [])
       end
 
       private
 
-      def default_content_type
-        'application/vnd.api+json'
-      end
-
       def parsed_body
         @parsed_body ||= JSON.parse(response.body).with_indifferent_access
       end