jsapi 2.1.2 → 3.0

data/lib/jsapi/client/session/test/class_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Client
+    module Session
+      module Test
+        module ClassMethods
+          # Stubs all sessions created in the passed block.
+          #
+          # Spying a single request session:
+          #
+          #   Jsapi::Client::Session::SingleRequest.spy(200, '{}') do |spy|
+          #     # Call operation
+          #     assert_equal('...', spy.request.body)
+          #   end
+          #
+          # Spying a session with multiple requests:
+          #
+          #   Jsapi::Client::Session::Base.spy do |spy|
+          #     spy.response_with(200, '{}')
+          #     # Call operation
+          #     assert_equal('...', spy.request.body)
+          #
+          #     spy.response_with(400, '{}')
+          #     # Call operation
+          #     assert_equal('...', spy.request.body)
+          #   end
+          def spy(...)
+            return unless block_given?
+
+            spy = Test::Spy.new(...)
+
+            klass = singleton_class
+            klass.alias_method(:__new__, :new)
+            klass.define_method(:new) { |*| spy }
+
+            begin
+              yield spy
+            ensure
+              klass.undef_method(:new)
+              klass.alias_method(:new, :__new__)
+              klass.undef_method(:__new__)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/client/session/test/response.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Client
+    module Session
+      module Test
+        # Dummy HTTP response.
+        class Response
+          ##
+          # :attr_reader: body
+          # Mimics +body+ of Net::HTTPRespone.
+
+          ##
+          # :attr_reader: code
+          # Mimics +code+ of Net::HTTPRespone.
+
+          ##
+          # :attr_reader: headers
+          # The headers of the HTTP response as a hash.
+
+          ##
+          # :attr_reader: http_version
+          # The HTTP version, always <code>"1.1"</code>
+
+          attr_reader :body, :code, :headers, :http_version
+
+          # Creates a dummy HTTP response. The default status code is <code>"200"</code>.
+          def initialize(status_code = nil, body = nil, **headers)
+            @http_version = '1.1'
+            @code = Status::Code.from(status_code || :ok).to_s
+            @body = body&.to_s
+
+            @headers = headers.to_h do |key, value|
+              [key.to_s.dasherize, value.to_s]
+            end.freeze
+          end
+
+          # Mimics +content_type+ of Net::HTTPRespone.
+          def content_type
+            @headers['content-type']
+          end
+
+          # Mimics +each_header+ of Net::HTTPRespone.
+          def each_header(&block)
+            @headers.each(&block)
+          end
+
+          def inspect # :nodoc:
+            "#<#{self.class.name} code: #{code}, " \
+            "body: #{body.inspect}, headers: #{headers.inspect}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/client/session/test/spy.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Client
+    module Session
+      module Test
+        # Spies an HTTP session.
+        class Spy
+          ##
+          # :attr_reader: request
+          # The last captured request.
+          attr_reader :request
+
+          def initialize(...)
+            @response = Response.new(...)
+            @finished = false
+          end
+
+          # Mimics +finish+ of Session::Base.
+          def finish
+            @finished = true
+          end
+
+          # Returns true if +finish+ has been called before.
+          def finished?
+            @finished == true
+          end
+
+          # Sets the response for subsequent calls.
+          def response_with(...)
+            @response = Response.new(...)
+          end
+
+          # Mimics +send_request+ of Session::Base.
+          def send_request(request)
+            @request = request
+            @response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/client/session/test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'test/response'
+require_relative 'test/spy'
+require_relative 'test/class_methods'
+
+module Jsapi
+  module Client
+    module Session
+      module Test
+        def self.included(base) # :nodoc:
+          base.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/client/session.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'session/test'
+require_relative 'session/logger'
+require_relative 'session/base'
+require_relative 'session/single_request'

data/lib/jsapi/client.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'client/exceptions'
+require_relative 'client/session'
+require_relative 'client/request'
+require_relative 'client/response'
+require_relative 'client/base'

data/lib/jsapi/configuration.rb

@@ -4,11 +4,11 @@ module Jsapi
   # Holds the \Jsapi configuration.
   class Configuration
     # The path where the API definitions are located relative to +Rails.root+.
-    # The default is <code>"jsapi/api_defs"</code>.
+    # The default is <code>"jsapi"</code>.
     attr_accessor :api_defs_path
 
     def initialize # :nodoc:
-      @api_defs_path = 'jsapi/api_defs'
+      @api_defs_path = 'jsapi'
     end
 
     # Returns the absolute +Pathname+ for +args+ within +api_defs_path+.

data/lib/jsapi/controller/authentication/credentials/http/bearer.rb

@@ -9,19 +9,12 @@ module Jsapi
         module HTTP
           # Holds a token passed according to \HTTP \Bearer \Authentication.
           class Bearer < Base
-            # The decoded token.
-            attr_reader :token
+            ##
+            # :attr_reader: token
+            # The token.
 
-            def initialize(authorization)
-              super
-              @token =
-                Base64.decode64(auth_param) \
-                if auth_scheme == 'Bearer' && auth_param.present?
-            end
-
-            def well_formed? # :nodoc:
-              !token.nil?
-            end
+            # -
+            alias token auth_param
           end
         end
       end

data/lib/jsapi/controller/authentication/credentials.rb

@@ -13,7 +13,7 @@ module Jsapi
           # security scheme.
           def create(request, security_scheme)
             case security_scheme
-            when Meta::SecurityScheme::APIKey
+            when Definition::SecurityScheme::APIKey
               name = security_scheme.name
               APIKey.new(
                 case security_scheme.in
@@ -23,11 +23,11 @@ module Jsapi
                   request.query_parameters[name]
                 end
               )
-            when Meta::SecurityScheme::HTTP::Basic
+            when Definition::SecurityScheme::HTTP::Basic
               HTTP::Basic.new(request.authorization)
-            when Meta::SecurityScheme::HTTP::Bearer
+            when Definition::SecurityScheme::HTTP::Bearer
               HTTP::Bearer.new(request.authorization)
-            when Meta::SecurityScheme::HTTP::Other
+            when Definition::SecurityScheme::HTTP::Other
               HTTP::Base.new(request.authorization)
             end
           end

data/lib/jsapi/controller/authentication.rb

@@ -31,9 +31,9 @@ module Jsapi
       # security schemes are satisfied.
       #
       # +operation_name+ can be omitted if the controller handles one operation only.
-      # If the operation isn't defined, an OperationNotDefined exception is raised.
+      # If the operation does not exist, an OperationNotFound exception is raised.
       def api_authenticated?(operation_name = nil)
-        _api_authenticated?(_api_operation(operation_name))
+        _api_authenticated?(api.find_operation!(operation_name))
       end
 
       private
@@ -49,7 +49,7 @@ module Jsapi
             next false unless authentication_handler
 
             # Find the appropriate security scheme
-            security_scheme = api_definitions.find_security_scheme(scheme_name)
+            security_scheme = api.find_security_scheme(scheme_name)
             next false unless security_scheme
 
             # Create the credentials to be passed to the authenticator

data/lib/jsapi/controller/methods.rb

@@ -4,26 +4,6 @@ require_relative 'methods/callbacks'
 
 module Jsapi
   module Controller
-    # Raised when no operation with the specified name could be found.
-    class OperationNotFound < StandardError
-      def initialize(operation_name)
-        super("operation not found: #{operation_name}")
-      end
-    end
-
-    # Raised when no suitable response could be found.
-    class ResponseNotFound < StandardError
-      def initialize(operation, status)
-        super(
-          if operation.responses.none?
-            "#{operation.name.inspect} has no responses"
-          else
-            "#{operation.name.inspect} has no response for status #{status}"
-          end
-        )
-      end
-    end
-
     # Raised when the current request could not be authenticated.
     class Unauthorized < StandardError
       def initialize # :nodoc:
@@ -49,7 +29,9 @@ module Jsapi
 
       # Overrides <code>Exception#message</code> to lazily generate the error message.
       def message
-        "#{@params.errors.full_messages.map { |m| m.delete_suffix('.') }.join('. ')}."
+        @params.errors.full_messages.map do |message|
+          message.end_with?('.') ? message : "#{message}."
+        end.join(' ')
       end
     end
 
@@ -58,15 +40,17 @@ module Jsapi
         base.include(Callbacks)
       end
 
-      # Returns the Meta::Definitions instance associated with the controller class. In
+      # Returns the Definition::API instance associated with the controller class. In
       # particular, this method can be used to create an OpenAPI document, for example:
       #
-      #   render(json: api_definitions.openapi_document)
+      #   render(json: api.openapi_document)
       #
-      def api_definitions
-        self.class.api_definitions
+      def api
+        self.class.api
       end
 
+      alias api_definitions api
+
       ##
       # :method: api_operation
       # :args: operation_name = nil, omit: nil, status: nil, strong: false, &block
@@ -92,11 +76,10 @@ module Jsapi
       #   end
       #
       # +operation_name+ can be omitted if the controller handles one operation only.
-      #
-      # If no operation could be found for +operation_name+, an OperationNotFound exception
-      # is raised.
+      # If the operation does not exist, an OperationNotFound error is raised.
       #
       # +:status+ specifies the HTTP status code of the response to be produced.
+      # If no suitable response exists, a ResponseNotFound error is raised.
       #
       # If +:strong+ is +true+, parameters that can be mapped are accepted only. That means
       # that the model passed to the block is invalid if there are any request parameters
@@ -108,7 +91,7 @@ module Jsapi
       # - +:empty+ - All of the  properties whose value is empty are omitted.
       # - +:nil+ - All of the properties whose value is +nil+ are omitted.
       #
-      # Raises an Unauthorized exception if the Authentication module is included and the
+      # Raises an Unauthorized error if the Authentication module is included and the
       # current request could not be authenticated.
       #
       # See Callbacks::ClassMethods for possible callbacks.
@@ -117,8 +100,8 @@ module Jsapi
       # :method: api_operation!
       # :args: operation_name = nil, omit: nil, status: nil, strong: false, &block
       #
-      # Like +api_operation+, except that a ParametersInvalid exception is raised
-      # when request parameters are invalid.
+      # Like +api_operation+, except it raises a ParametersInvalid error when the request
+      # parameters are invalid.
       #
       #   api_operation!('foo') do |api_params|
       #     # ...
@@ -127,14 +110,14 @@ module Jsapi
       [true, false].each do |bang|
         define_method(bang ? :api_operation! : :api_operation) \
         do |operation_name = nil, omit: nil, status: nil, strong: false, &block|
-          raise ArgumentError, Messages.invalid_value(
+          raise ArgumentError, Support::Messages.invalid_value(
             name: 'omit',
             value: omit,
             valid_values: %i[empty nil]
           ) if [nil, :empty, :nil].exclude?(omit)
 
-          operation = _api_operation(operation_name)
-          response_model = nil
+          operation = api.find_operation!(operation_name)
+          response_definition = nil
 
           result = begin
             # Authenticate request first if Authentication is included
@@ -145,7 +128,7 @@ module Jsapi
             end
 
             status = Status::Code.from(status)
-            response_model = _api_response_model(operation, status)
+            response_definition = operation.find_response_for!(status)
 
             api_params = _api_params(operation, strong: strong)
 
@@ -157,19 +140,17 @@ module Jsapi
 
             block&.call(api_params)
           rescue StandardError => e
-            definitions = api_definitions
-
             # Lookup a rescue handler
-            rescue_handler = definitions.rescue_handler_for(e)
+            rescue_handler = api.rescue_handler_for(e)
             raise e if rescue_handler.nil?
 
-            # Replace the status code and response model
+            # Replace the status code and response definition
             status = rescue_handler.status_code
-            response_model = operation.find_response(status)
-            raise e if response_model.nil?
+            response_definition = operation.find_response_for(status)
+            raise e if response_definition.nil?
 
             # Call on_rescue callbacks
-            definitions.on_rescue_callbacks.each do |callback|
+            api.on_rescue_callbacks.each do |callback|
               callback.respond_to?(:call) ? callback.call(e) : send(callback, e)
             end
 
@@ -179,9 +160,12 @@ module Jsapi
           return if response_body
 
           # Produce response
-          media_type, content_model = _api_media_type_and_content_model(response_model)
+          media_type, content_definition =
+            response_definition
+            .media_type_and_content_for(*_api_accept)
+
           status = status&.to_i
-          return head(status) unless content_model
+          return head(status) unless content_definition
 
           result = _api_before_rendering(operation_name, result, api_params)
 
@@ -194,9 +178,9 @@ module Jsapi
           elsif media_type.json? || media_type.json_seq?
             api_response = Response.new(
               result,
-              content_model,
+              content_definition,
               omit: omit,
-              locale: response_model.locale
+              locale: response_definition.locale
             )
             if media_type.json?
               render(
@@ -225,8 +209,7 @@ module Jsapi
       #
       # +operation_name+ can be omitted if the controller handles one operation only.
       #
-      # If no operation could be found for +operation_name+, an OperationNotFound exception
-      # is raised.
+      # If the operation does not exist, an OperationNotFound error is raised.
       #
       # If +strong+ is +true+, parameters that can be mapped are accepted only. That means
       # that the model returned is invalid if there are any request parameters that can't be
@@ -234,20 +217,19 @@ module Jsapi
       #
       # Note that each call of +api_params+ returns a newly created instance.
       def api_params(operation_name = nil, strong: false)
-        _api_params(_api_operation(operation_name), strong: strong)
+        _api_params(api.find_operation!(operation_name), strong: strong)
       end
 
-      # Returns a Response to serialize the JSON representation of +result+ according to the
-      # appropriate +response+ specification.
+      # Returns a Response to serialize the JSON representation of +result+ according to
+      # the appropriate +response+ specification.
       #
       #   render(json: api_response(bar, 'foo', status: 200))
       #
       # +operation_name+ can be omitted if the controller handles one operation only.
-      #
-      # If no operation could be found for +operation_name+, an OperationNotFound exception
-      # is raised.
+      # If the operation does not exist, an OperationNotFound error is raised.
       #
       # +:status+ specifies the HTTP status code of the response to be produced.
+      # If no suitable response exists, a ResponseNotFound error is raised.
       #
       # The +:omit+ option specifies on which conditions properties are omitted.
       # Possible values are:
@@ -255,37 +237,28 @@ module Jsapi
       # - +:empty+ - All of the  properties whose value is empty are omitted.
       # - +:nil+ - All of the properties whose value is +nil+ are omitted.
       def api_response(result, operation_name = nil, omit: nil, status: nil)
-        raise ArgumentError, Messages.invalid_value(
+        raise ArgumentError, Support::Messages.invalid_value(
           name: 'omit',
           value: omit,
           valid_values: %i[empty nil]
         ) if [nil, :empty, :nil].exclude?(omit)
 
         status = Status::Code.from(status)
-        operation = _api_operation(operation_name)
-        response_model = _api_response_model(operation, status)
+        operation = api.find_operation!(operation_name)
+        response_definition = operation.find_response_for!(status)
 
         Response.new(
           result,
-          _api_media_type_and_content_model(response_model).second,
+          response_definition.content_for(*_api_accept),
           omit: omit,
-          locale: response_model.locale
+          locale: response_definition.locale
         )
       end
 
       private
 
-      def _api_media_type_and_content_model(response_model)
-        response_model.media_type_and_content_for(
-          *(request.headers['Accept']&.split(',').presence || [Media::Range::ALL])
-        )
-      end
-
-      def _api_operation(operation_name)
-        operation = api_definitions.find_operation(operation_name)
-        return operation if operation
-
-        raise OperationNotFound.new(operation_name)
+      def _api_accept
+        request.headers['Accept']&.split(',').presence || [Media::Range::ALL]
       end
 
       def _api_params(operation, strong:)
@@ -298,13 +271,6 @@ module Jsapi
           )
         )
       end
-
-      def _api_response_model(operation, status)
-        response_model = operation.find_response(status)
-        return response_model if response_model
-
-        raise ResponseNotFound.new(operation, status)
-      end
     end
   end
 end

data/lib/jsapi/controller/parameters.rb

@@ -20,11 +20,11 @@ module Jsapi
         @params_to_be_validated = strong == true ? params.dup : {}
 
         # Parameters
-        @raw_attributes = operation.parameters.transform_values do |parameter_model|
+        @raw_attributes = operation.parameters.transform_values do |parameter_definition|
           JSON.wrap(
-            case parameter_model.in
+            case parameter_definition.in
             when 'header'
-              request.headers[parameter_model.name]
+              request.headers[parameter_definition.name]
             when 'querystring'
               query_params = request.query_parameters
               keys = query_params.keys
@@ -32,11 +32,11 @@ module Jsapi
               unassigned_params.except!(*keys)
               @params_to_be_validated.except!(*keys)
 
-              parameter_model.object? ? params.slice(*keys) : query_params.to_query
+              parameter_definition.object? ? params.slice(*keys) : query_params.to_query
             else
-              unassigned_params.delete(parameter_model.name)
+              unassigned_params.delete(parameter_definition.name)
             end,
-            parameter_model.schema,
+            parameter_definition.schema,
             context: :request
           )
         end

data/lib/jsapi/controller/response.rb

@@ -4,16 +4,16 @@ module Jsapi
   module Controller
     # Used to jsonify a response.
     class Response
-      # Creates a new instance to jsonify +object+ according to +content_model+.
+      # Creates a new instance to jsonify +object+ according to +content_definition+.
       #
       # The +:omit+ option specifies on which conditions properties are omitted.
       # Possible values are:
       #
       # - +:empty+ - All of the  properties whose value is empty are omitted.
       # - +:nil+ - All of the properties whose value is +nil+ are omitted.
-      def initialize(object, content_model, locale: nil, omit: nil)
+      def initialize(object, content_definition, locale: nil, omit: nil)
         @object = object
-        @content_model = content_model
+        @content_definition = content_definition
         @locale = locale
         @omit = omit
       end
@@ -21,13 +21,13 @@ module Jsapi
       # Returns the \JSON representation of the response.
       def as_json(*)
         with_locale do
-          @content_model.schema.jsonify(
+          @content_definition.schema.jsonify(
             @object,
             context: :response,
             omit: @omit
           )
         end
-      rescue JsonifyError => e
+      rescue Definition::Schema::JsonifyError => e
         e.prepend('response body') if e.path.blank?
         raise e
       end
@@ -43,7 +43,7 @@ module Jsapi
 
       # Writes the response in \JSON sequence text format to +stream+.
       def write_json_seq_to(stream)
-        schema = @content_model.schema
+        schema = @content_definition.schema
         object = @object
         object = schema.default_value(context: :response) if object.nil?
 
@@ -65,7 +65,7 @@ module Jsapi
               ).to_json
             )
             stream.write("\n")
-          rescue JsonifyError => e
+          rescue Definition::Schema::JsonifyError => e
             raise e.prepend("[#{index}]")
           end
         end