shark-on-lambda 1.0.1 → 2.0.0.rc1

data/lib/shark_on_lambda/inferrers/serializer_inferrer.rb

@@ -31,14 +31,17 @@ module SharkOnLambda
       def serializer_class_names
         return @serializer_class_names if defined?(@serializer_class_names)
 
-        @serializer_class_names = object_class.ancestors.map do |ancestor|
-          ancestor_name = ancestor.name
-          next if ancestor_name.blank?
+        @serializer_class_names =
+          object_class.ancestors.reduce([]) do |result, ancestor|
+            ancestor_name = ancestor.name
+            next result if ancestor_name.blank?
 
-          name_inferrer = NameInferrer.from_model_name(ancestor_name)
-          name_inferrer.serializer
-        end
-        @serializer_class_names.compact! || @serializer_class_names
+            result << serializer_name_from_model_name(ancestor_name)
+          end
+      end
+
+      def serializer_name_from_model_name(model_name)
+        "#{model_name.underscore}_serializer".camelize
       end
     end
   end

data/lib/shark_on_lambda/jsonapi_renderer.rb

@@ -100,7 +100,7 @@ module SharkOnLambda
     def transform_active_model_errors(errors)
       return errors unless active_model_error?(errors)
 
-      result = errors.messages.map do |attribute, attribute_errors|
+      errors.messages.flat_map do |attribute, attribute_errors|
         attribute_errors.map do |attribute_error|
           error_message = "`#{attribute_name(attribute)}' #{attribute_error}"
           Errors[422].new(error_message).tap do |error|
@@ -108,7 +108,6 @@ module SharkOnLambda
           end
         end
       end
-      result.flatten! || result
     end
 
     def unrenderable_objects(object, options)

data/lib/shark_on_lambda/middleware/honeybadger.rb

@@ -26,12 +26,14 @@ module SharkOnLambda
       end
 
       def notify(error, env)
+        params = env.fetch('action_dispatch.request.parameters', {})
+
         ::Honeybadger.notify(
           error,
           tags: tags,
-          controller: env['shark.controller'],
-          action: env['shark.action'],
-          parameters: env['action_dispatch.request.parameters']
+          controller: params[:controller],
+          action: params[:action],
+          parameters: params
         )
       end
 

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

@@ -13,13 +13,10 @@ module SharkOnLambda
       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
@@ -33,14 +30,14 @@ module SharkOnLambda
         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,25 +3,14 @@
 module SharkOnLambda
   module RSpec
     class EnvBuilder
-      attr_reader :action, :controller, :headers, :method
-      attr_reader :params, :path_parameters
-
-      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] || {}
-        @path_parameters = options[:path_parameters] || {}
-
-        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
 
@@ -29,43 +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,
-          'shark.path_parameters' => path_parameters
+          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,95 +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],
-          path_parameters: options[:path_parameters]
-        )
-        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