rswag-specs 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aefe22cf5f08fa506055d2cc653241014d59b968
-  data.tar.gz: c8d0d80117885539b4fe8361c5a26b34cb90d5e2
+  metadata.gz: e08ea4a4b9b1820ae1d7b4729aa995f4118aa0f4
+  data.tar.gz: a02faf75c1c344426b3856ce52d29588251e1b6c
 SHA512:
-  metadata.gz: 10cf3f7a2899a2b01cf34f183e36edcd6340f498d23a90711d5ff8259adc9ae0201678007fe01e5399b078091c1c202202f978c1382006e5073912c0e46124f1
-  data.tar.gz: 5063174caf14bc653bfaea6b5feb4ed97c0676a42f472942b573045bf840e96639aa51ff42fe406a17b323d0f093623af68f3713043addba794b344ad3b493bf
+  metadata.gz: 33f8487725a40410ce5f6c67d9f64511003a12f81b0dd77b23239b935ab215e71b6e2a71d629d6b970c685aaa7ea261dced8c40c6da503ad62c80702bac9c1eb
+  data.tar.gz: be921ad7df6e5c40fe33d1abe9b27a4df61ebb276da2ec4b385b7aae2127334a812b9de0226f92e6ba18d582a73c07ecec2b8a0df3ffef74b15d327ab76ba135

data/lib/rswag/specs/example_group_helpers.rb

@@ -77,7 +77,8 @@ module Rswag
           end
 
           it "returns a #{metadata[:response][:code]} response" do
-            assert_response_matches_metadata(example.metadata, &block)
+            assert_response_matches_metadata(metadata)
+            block.call(response) if block_given?
           end
         else
           before do |example|
@@ -86,6 +87,7 @@ module Rswag
 
           it "returns a #{metadata[:response][:code]} response" do |example|
             assert_response_matches_metadata(example.metadata, &block)
+            example.instance_exec(response, &block) if block_given?
           end
         end
       end

data/lib/rswag/specs/example_helpers.rb

@@ -5,55 +5,30 @@ module Rswag
   module Specs
     module ExampleHelpers
 
-      def submit_request(api_metadata)
-        global_metadata = rswag_config.get_swagger_doc(api_metadata[:swagger_doc])
-        factory = RequestFactory.new(api_metadata, global_metadata)
+      def submit_request(metadata)
+        request = RequestFactory.new.build_request(metadata, self)
 
         if RAILS_VERSION < 5
           send(
-            api_metadata[:operation][:verb],
-            factory.build_fullpath(self),
-            factory.build_body(self),
-            rackify_headers(factory.build_headers(self)) # Rails test infrastructure requires Rack headers
+            request[:verb],
+            request[:path],
+            request[:payload],
+            request[:headers]
           )
         else
           send(
-            api_metadata[:operation][:verb],
-            factory.build_fullpath(self),
+            request[:verb],
+            request[:path],
             {
-              params: factory.build_body(self),
-              headers: factory.build_headers(self)
+              params: request[:payload],
+              headers: request[:headers]
             }
           )
         end
       end
 
-      def assert_response_matches_metadata(api_metadata, &block)
-        global_metadata = rswag_config.get_swagger_doc(api_metadata[:swagger_doc])
-        validator = ResponseValidator.new(api_metadata, global_metadata)
-        validator.validate!(response, &block)
-      end
-
-      private
-
-      def rackify_headers(headers)
-        name_value_pairs = headers.map do |name, value|
-          [
-            case name
-              when 'Accept' then 'HTTP_ACCEPT'
-              when 'Content-Type' then 'CONTENT_TYPE'
-              when 'Authorization' then 'HTTP_AUTHORIZATION'
-              else name
-            end,
-            value
-          ]
-        end
-
-        Hash[ name_value_pairs ]
-      end
-
-      def rswag_config
-        ::Rswag::Specs.config
+      def assert_response_matches_metadata(metadata)
+        ResponseValidator.new.validate!(metadata, response)
       end
     end
   end

data/lib/rswag/specs/request_factory.rb

@@ -1,98 +1,83 @@
 require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/conversions'
 require 'json'
 
 module Rswag
   module Specs
     class RequestFactory
 
-      def initialize(api_metadata, global_metadata)
-        @api_metadata = api_metadata
-        @global_metadata = global_metadata
+      def initialize(config = ::Rswag::Specs.config)
+        @config = config
       end
 
-      def build_fullpath(example)
-        @api_metadata[:path_item][:template].dup.tap do |t|
-          t.prepend(@global_metadata[:basePath] || '')
-          parameters_in(:path).each { |p| t.gsub!("{#{p[:name]}}", example.send(p[:name]).to_s) }
-          t.concat(build_query_string(example))
-        end
-      end
-
-      def build_query_string(example)
-        query_string = parameters_in(:query)
-          .map { |p| build_query_string_part(p, example.send(p[:name])) }
-          .join('&')
-
-        query_string.empty? ? '' : "?#{query_string}"
-      end
-
-      def build_body(example)
-        body_parameter = parameters_in(:body).first
-        body_parameter.nil? ? '' : example.send(body_parameter[:name]).to_json
-      end
+      def build_request(metadata, example)
+        swagger_doc = @config.get_swagger_doc(metadata[:swagger_doc])
+        parameters = expand_parameters(metadata, swagger_doc, example)
 
-      def build_headers(example)
-        name_value_pairs = parameters_in(:header).map do |param|
-          [
-            param[:name],
-            example.send(param[:name]).to_s
-          ]
+        {}.tap do |request|
+          add_verb(request, metadata)
+          add_path(request, metadata, swagger_doc, parameters, example)
+          add_headers(request, metadata, swagger_doc, parameters, example)
+          add_payload(request, parameters, example)
         end
-
-        # Add MIME type headers based on produces/consumes metadata
-        produces = @api_metadata[:operation][:produces] || @global_metadata[:produces]
-        consumes = @api_metadata[:operation][:consumes] || @global_metadata[:consumes]
-        name_value_pairs << [ 'Accept', produces.join(';') ] unless produces.nil?
-        name_value_pairs << [ 'Content-Type', consumes.join(';') ] unless consumes.nil?
-
-        Hash[ name_value_pairs ]
       end
 
       private
 
-      def parameters_in(location)
-        path_item_params = @api_metadata[:path_item][:parameters] || []
-        operation_params = @api_metadata[:operation][:parameters] || []
-        applicable_params = operation_params
+      def expand_parameters(metadata, swagger_doc, example)
+        operation_params = metadata[:operation][:parameters] || []
+        path_item_params = metadata[:path_item][:parameters] || []
+        security_params = derive_security_params(metadata, swagger_doc)
+
+        operation_params
           .concat(path_item_params)
-          .uniq { |p| p[:name] } # operation params should override path_item params
+          .concat(security_params)
+          .map { |p| p['$ref'] ? resolve_parameter(p['$ref'], swagger_doc) : p }
+          .uniq { |p| p[:name] }
+          .reject { |p| p[:required] == false && !example.respond_to?(p[:name]) }
+      end
+
+      def derive_security_params(metadata, swagger_doc)
+        requirements = metadata[:operation][:security] || swagger_doc[:security]
+        scheme_names = requirements ? requirements.map { |r| r.keys.first } : []
+        applicable_schemes = (swagger_doc[:securityDefinitions] || {}).slice(*scheme_names).values
 
-        applicable_params
-          .map { |p| p['$ref'] ? resolve_parameter(p['$ref']) : p } # resolve any references
-          .concat(security_parameters)
-          .select { |p| p[:in] == location }
+        applicable_schemes.map do |scheme|
+          param = (scheme[:type] == :apiKey) ? scheme.slice(:name, :in) : { name: 'Authorization', in: :header }
+          param.merge(type: :string)
+        end
       end
 
-      def resolve_parameter(ref)
-        defined_params = @global_metadata[:parameters]
+      def resolve_parameter(ref, swagger_doc)
+        definitions = swagger_doc[:parameters]
         key = ref.sub('#/parameters/', '')
-        raise "Referenced parameter '#{ref}' must be defined" unless defined_params && defined_params[key]
-        defined_params[key]
+        raise "Referenced parameter '#{ref}' must be defined" unless definitions && definitions[key]
+        definitions[key]
       end
 
-      def security_parameters
-        applicable_security_schemes.map do |scheme|
-          if scheme[:type] == :apiKey
-            { name: scheme[:name], type: :string, in: scheme[:in] }
-          else
-            { name: 'Authorization', type: :string, in: :header } # use auth header for basic & oauth2
-          end
-        end
+      def add_verb(request, metadata) 
+        request[:verb] = metadata[:operation][:verb]
       end
 
-      def applicable_security_schemes
-        # First figure out the security requirement applicable to the operation
-        requirements = @api_metadata[:operation][:security] || @global_metadata[:security]
-        scheme_names = requirements ? requirements.map { |r| r.keys.first } : []
+      def add_path(request, metadata, swagger_doc, parameters, example)
+        template = (swagger_doc[:basePath] || '') + metadata[:path_item][:template]
+
+        request[:path] = template.tap do |template|
+          parameters.select { |p| p[:in] == :path }.each do |p|
+            template.gsub!("{#{p[:name]}}", example.send(p[:name]).to_s)
+          end
 
-        # Then obtain the scheme definitions for those requirements
-        (@global_metadata[:securityDefinitions] || {}).slice(*scheme_names).values
+          parameters.select { |p| p[:in] == :query }.each_with_index do |p, i|
+            template.concat(i == 0 ? '?' : '&')
+            template.concat(build_query_string_part(p, example.send(p[:name])))
+          end
+        end
       end
 
       def build_query_string_part(param, value)
-        return "#{param[:name]}=#{value.to_s}" unless param[:type].to_sym == :array
-
         name = param[:name]
+        return "#{name}=#{value.to_s}" unless param[:type].to_sym == :array
+
         case param[:collectionFormat]
         when :ssv
           "#{name}=#{value.join(' ')}"
@@ -106,6 +91,68 @@ module Rswag
           "#{name}=#{value.join(',')}" # csv is default
         end
       end
+
+      def add_headers(request, metadata, swagger_doc, parameters, example)
+        tuples = parameters
+          .select { |p| p[:in] == :header }
+          .map { |p| [ p[:name], example.send(p[:name]).to_s ] }
+
+        # Accept header
+        produces = metadata[:operation][:produces] || swagger_doc[:produces]
+        if produces
+          accept = example.respond_to?(:'Accept') ? example.send(:'Accept') : produces.first
+          tuples << [ 'Accept', accept ]
+        end
+
+        # Content-Type header
+        consumes = metadata[:operation][:consumes] || swagger_doc[:consumes] 
+        if consumes
+          content_type = example.respond_to?(:'Content-Type') ? example.send(:'Content-Type') : consumes.first
+          tuples << [ 'Content-Type', content_type ]
+        end
+
+        # Rails test infrastructure requires rackified headers
+        rackified_tuples = tuples.map do |pair|
+          [
+            case pair[0]
+              when 'Accept' then 'HTTP_ACCEPT'
+              when 'Content-Type' then 'CONTENT_TYPE'
+              when 'Authorization' then 'HTTP_AUTHORIZATION'
+              else pair[0]
+            end,
+            pair[1]
+          ]
+        end
+
+        request[:headers] = Hash[ rackified_tuples ]
+      end
+
+      def add_payload(request, parameters, example)
+        content_type = request[:headers]['CONTENT_TYPE']
+        return if content_type.nil?
+
+        if [ 'application/x-www-form-urlencoded', 'multipart/form-data' ].include?(content_type)
+          request[:payload] = build_form_payload(parameters, example)
+        else
+          request[:payload] = build_json_payload(parameters, example)
+        end
+      end
+
+      def build_form_payload(parameters, example)
+        # See http://seejohncode.com/2012/04/29/quick-tip-testing-multipart-uploads-with-rspec/
+        # Rather that serializing with the appropriate encoding (e.g. multipart/form-data),
+        # Rails test infrastructure allows us to send the values directly as a hash
+        # PROS: simple to implement, CONS: serialization/deserialization is bypassed in test
+        tuples = parameters
+          .select { |p| p[:in] == :formData }
+          .map { |p| [ p[:name], example.send(p[:name]) ] }
+        Hash[ tuples ]
+      end
+
+      def build_json_payload(parameters, example)
+        body_param = parameters.select { |p| p[:in] == :body }.first
+        body_param ? example.send(body_param[:name]).to_json : nil
+      end
     end
   end
 end

data/lib/rswag/specs/response_validator.rb

@@ -7,47 +7,43 @@ module Rswag
   module Specs
     class ResponseValidator
 
-      def initialize(api_metadata, global_metadata)
-        @api_metadata = api_metadata
-        @global_metadata = global_metadata
+      def initialize(config = ::Rswag::Specs.config)
+        @config = config
       end
 
-      def validate!(response, &block)
-        validate_code!(response.code)
-        validate_headers!(response.headers)
-        validate_body!(response.body, &block)
-        block.call(response) if block_given?
+      def validate!(metadata, response)
+        swagger_doc = @config.get_swagger_doc(metadata[:swagger_doc])
+
+        validate_code!(metadata, response.code)
+        validate_headers!(metadata, response.headers)
+        validate_body!(metadata, swagger_doc, response.body)
       end
 
       private
 
-      def validate_code!(code)
-        if code.to_s != @api_metadata[:response][:code].to_s
-          raise UnexpectedResponse, "Expected response code '#{code}' to match '#{@api_metadata[:response][:code]}'"
+      def validate_code!(metadata, code)
+        expected = metadata[:response][:code].to_s
+        if code != expected
+          raise UnexpectedResponse, "Expected response code '#{code}' to match '#{expected}'"
         end
       end
 
-      def validate_headers!(headers)
-        header_schema = @api_metadata[:response][:headers]
-        return if header_schema.nil?
-
-        header_schema.keys.each do |header_name|
-          raise UnexpectedResponse, "Expected response header #{header_name} to be present" if headers[header_name.to_s].nil?
+      def validate_headers!(metadata, headers)
+        expected = (metadata[:response][:headers] || {}).keys
+        expected.each do |name|
+          raise UnexpectedResponse, "Expected response header #{name} to be present" if headers[name.to_s].nil?
         end
       end
 
-      def validate_body!(body)
-        response_schema = @api_metadata[:response][:schema]
+      def validate_body!(metadata, swagger_doc, body)
+        response_schema = metadata[:response][:schema]
         return if response_schema.nil?
 
-        begin
-          validation_schema = response_schema
-            .merge('$schema' => 'http://tempuri.org/rswag/specs/extended_schema')
-            .merge(@global_metadata.slice(:definitions))
-          JSON::Validator.validate!(validation_schema, body)
-        rescue JSON::Schema::ValidationError => ex
-          raise UnexpectedResponse, "Expected response body to match schema: #{ex.message}"
-        end
+        validation_schema = response_schema
+          .merge('$schema' => 'http://tempuri.org/rswag/specs/extended_schema')
+          .merge(swagger_doc.slice(:definitions))
+        errors = JSON::Validator.fully_validate(validation_schema, body)
+        raise UnexpectedResponse, "Expected response body to match schema: #{errors[0]}" if errors.any?
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rswag-specs
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Richie Morris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-11 00:00:00.000000000 Z
+date: 2017-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport