webspicy 0.15.8 → 0.16.0

data/lib/webspicy/client/http_client.rb

@@ -1,145 +0,0 @@
-module Webspicy
-  class HttpClient < Client
-
-    class ::HTTP::Request
-
-      # We monkey patch the URI normalization on Http because
-      # we don't want it to interfere with URIs that are encoded
-      # in tests, especially security tests.
-      def normalize_uri(uri)
-        uri
-      end
-
-    end # class ::HTTP::Request
-
-    def initialize(scope)
-      super(scope)
-      @api = Api.new
-    end
-    attr_reader :api
-
-    def call(test_case)
-      service, resource = test_case.service, test_case.resource
-
-      # Instantiate the parameters
-      headers = test_case.headers
-      params  = test_case.dress_params? ? service.dress_params(test_case.params) : test_case.params
-      body    = test_case.body || test_case.located_file_upload
-
-      # Instantiate the url and strip parameters
-      url, params = resource.instantiate_url(params)
-
-      # Globalize the URL if required
-      url = scope.to_real_url(url, test_case)
-
-      # Invoke the service now
-      api.public_send(service.method.to_s.downcase.to_sym, url, params, headers, body)
-
-      # Return the result
-      Resource::Service::Invocation.new(service, test_case, api.last_response, self)
-    end
-
-    class Api
-      include Client::Support
-
-      attr_reader :last_response
-
-      def options(url, params = {}, headers = nil, body = nil)
-        info_request("OPTIONS", url, params, headers, body)
-
-        params = querystring_params(params)
-        @last_response = HTTP[headers || {}].options(url, params: params)
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def get(url, params = {}, headers = nil, body = nil)
-        info_request("GET", url, params, headers, body)
-
-        params = querystring_params(params)
-        @last_response = HTTP[headers || {}].get(url, params: params)
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def post(url, params = {}, headers = nil, body = nil)
-        info_request("POST", url, params, headers, body)
-
-        url = url + "?" + Rack::Utils.build_query(params) if body && !params.empty?
-
-        headers ||= {}
-
-        case body
-        when NilClass
-          headers['Content-Type'] ||= 'application/json'
-          @last_response = HTTP[headers].post(url, body: params.to_json)
-        when FileUpload
-          file = HTTP::FormData::File.new(body.path.to_s, {
-            content_type: body.content_type,
-            filename: body.path.basename.to_s
-          })
-          @last_response = HTTP[headers].post(url, form: {
-            body.param_name.to_sym => file
-          })
-        else
-          headers['Content-Type'] ||= 'application/json'
-          @last_response = HTTP[headers].post(url, body: body)
-        end
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def patch(url, params = {}, headers = nil, body = nil)
-        info_request("PATCH", url, params, headers, body)
-
-        headers ||= {}
-        headers['Content-Type'] ||= 'application/json'
-        @last_response = HTTP[headers].patch(url, body: params.to_json)
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def put(url, params = {}, headers = nil, body = nil)
-        info_request("PUT", url, params, headers, body)
-
-        headers ||= {}
-        headers['Content-Type'] ||= 'application/json'
-        @last_response = HTTP[headers].put(url, body: params.to_json)
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def post_form(url, params = {}, headers = nil, body = nil)
-        info_request("POST", url, params, headers, body)
-
-        @last_response = HTTP[headers || {}].post(url, form: params)
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def delete(url, params = {}, headers = nil, body = nil)
-        info_request("DELETE", url, params, headers, body)
-
-        @last_response = HTTP[headers || {}].delete(url, body: params.to_json)
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-    end
-
-  end
-end

data/lib/webspicy/client/rack_test_client.rb

@@ -1,181 +0,0 @@
-module Webspicy
-  class RackTestClient < Client
-
-    def self.for(app)
-      Factory.new(app)
-    end
-
-    def initialize(scope, app)
-      super(scope)
-      @api = Api.new(app)
-    end
-    attr_reader :api
-
-    def call(test_case)
-      service, resource = test_case.service, test_case.resource
-
-      # Instantiate the parameters
-      headers = test_case.headers.dup
-      params  = test_case.dress_params? ? service.dress_params(test_case.params) : test_case.params
-      body    = test_case.body || test_case.located_file_upload
-
-      # Instantiate the url and strip parameters
-      url, params = resource.instantiate_url(params)
-      url = scope.to_real_url(url, test_case){|u,_| u }
-
-      # Invoke the service now
-      api.public_send(service.method.to_s.downcase.to_sym, url, params, headers, body)
-
-      # Return the result
-      Resource::Service::Invocation.new(service, test_case, api.last_response, self)
-    end
-
-    class Factory
-
-      def initialize(app)
-        @app = app
-      end
-      attr_reader :app
-
-      def new(scope)
-        RackTestClient.new(scope, app)
-      end
-
-    end # class Factory
-
-    class RackHandler
-      include Rack::Test::Methods
-
-      def initialize(app)
-        @app = app
-      end
-      attr_reader :app
-
-    end # class RackHandler
-
-    class Api
-      include Client::Support
-
-      attr_reader :last_response
-
-      def initialize(app)
-        @app = app
-      end
-
-      def options(url, params = {}, headers = nil, body = nil)
-        handler = get_handler(headers)
-
-        info_request("OPTIONS", url, params, headers, body)
-
-        handler.options(url, params)
-        @last_response = handler.last_response
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def get(url, params = {}, headers = nil, body = nil)
-        handler = get_handler(headers)
-
-        params = Hash[params.map{|k,v| [k, v.nil? ? "" : v] }]
-        info_request("GET", url, params, headers, body)
-
-        handler.get(url, params)
-        @last_response = handler.last_response
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def post(url, params = {}, headers = nil, body = nil)
-        handler = get_handler(headers)
-
-        url = url + "?" + Rack::Utils.build_query(params) if body && !params.empty?
-
-        case body
-        when NilClass
-          info_request("POST", url, params, headers, body)
-          handler.post(url, params.to_json, {"CONTENT_TYPE" => "application/json"})
-        when FileUpload
-          file = Rack::Test::UploadedFile.new(body.path, body.content_type)
-          info_request("POST", url, params, headers, body)
-          handler.post(url, body.param_name.to_sym => file)
-        else
-          info_request("POST", url, params, headers, body)
-          handler.post(url, body)
-        end
-        @last_response = handler.last_response
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def patch(url, params = {}, headers = nil, body = nil)
-        handler = get_handler(headers)
-
-        info_request("PATCH", url, params, headers, body)
-
-        handler.patch(url, params.to_json, {"CONTENT_TYPE" => "application/json"})
-        @last_response = handler.last_response
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def put(url, params = {}, headers = nil, body = nil)
-        handler = get_handler(headers)
-
-        info_request("PUT", url, params, headers, body)
-
-        handler.put(url, params.to_json, {"CONTENT_TYPE" => "application/json"})
-        @last_response = handler.last_response
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def post_form(url, params = {}, headers = nil, body = nil)
-        handler = get_handler(headers)
-
-        info_request("POST", url, params, headers, body)
-
-        handler.post(url, params)
-        @last_response = handler.last_response
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-      def delete(url, params = {}, headers = nil, body = nil)
-        handler = get_handler(headers)
-
-        info_request("DELETE", url, params, headers, body)
-
-        handler.delete(url, params.to_json, {"CONTENT_TYPE" => "application/json"})
-        @last_response = handler.last_response
-
-        debug_response(@last_response)
-
-        @last_response
-      end
-
-    private
-
-      def get_handler(hs)
-        handler = RackHandler.new(@app)
-        hs.each_pair do |k,v|
-          handler.header(k,v)
-        end if hs
-        handler
-      end
-
-    end # class Api
-
-  end # class RackTestClient
-end # module Webspicy

data/lib/webspicy/client/support.rb

@@ -1,48 +0,0 @@
-module Webspicy
-  class Client
-    module Support
-
-      def querystring_params(params)
-        Hash[params.each_pair.map{|k,v| [k.to_s,v.to_s] }]
-      end
-
-      def info_request(kind, url, params, headers, body)
-        Webspicy.info("#{kind} #{url}")
-        debug("Req params", JSON.pretty_generate(params)) if params
-        debug("Req headers", JSON.pretty_generate(headers)) if headers
-        debug("Req body", request_body_to_s(body)) if body
-        Webspicy.debug("")
-      end
-
-      def debug_response(response)
-        debug("Res status", @last_response.status)
-        debug("Res headers", JSON.pretty_generate(last_response.headers.to_h))
-        debug("Res body", response_body_to_s(last_response))
-        Webspicy.debug("")
-      end
-
-      def debug(what, value)
-        Webspicy.debug("  #{what}: " + value_to_s(value))
-      end
-
-      def request_body_to_s(body)
-        body = body.to_info if body.is_a?(Webspicy::FileUpload)
-        JSON.pretty_generate(body)
-      end
-
-      def response_body_to_s(response)
-        case response.content_type.to_s
-        when /json/
-          JSON.pretty_generate(JSON.load(response.body))
-        else
-          response.body.to_s
-        end
-      end
-
-      def value_to_s(value)
-        value.to_s.gsub(/\n/, "\n        ")
-      end
-
-    end # module Support
-  end # class Client
-end # module Webspicy

data/lib/webspicy/file_upload.rb

@@ -1,35 +0,0 @@
-module Webspicy
-  class FileUpload
-
-    def initialize(raw)
-      @path = raw[:path]
-      @content_type = raw[:content_type]
-      @param_name = raw[:param_name] || "file"
-    end
-
-    attr_reader :path, :content_type, :param_name
-
-    def self.info(raw)
-      new(raw)
-    end
-
-    def locate(resource)
-      FileUpload.new({
-        path: resource.locate(path),
-        content_type: content_type
-      })
-    end
-
-    def to_info
-      { path: path.to_s,
-        content_type: content_type,
-        param_name: param_name }
-    end
-
-    def to_s
-      "FileUpload(#{to_info})"
-    end
-    alias :inspect :to_s
-
-  end # class FileUpload
-end # module Webspicy

data/lib/webspicy/postcondition.rb

@@ -1,14 +0,0 @@
-module Webspicy
-  module Postcondition
-
-    def self.match(service, descr)
-    end
-
-    def instrument(test_case, client)
-    end
-
-    def check(invocation)
-    end
-
-  end # module Postcondition
-end # module Webspicy

data/lib/webspicy/precondition.rb

@@ -1,15 +0,0 @@
-module Webspicy
-  module Precondition
-
-    def self.match(service, pre)
-    end
-
-    def instrument(test_case, client)
-    end
-
-    def counterexamples(service)
-      []
-    end
-
-  end # module Precondition
-end # module Webspicy

data/lib/webspicy/resource/service/invocation.rb

@@ -1,212 +0,0 @@
-module Webspicy
-  class Resource
-    class Service
-      class Invocation
-
-        def initialize(service, test_case, response, client)
-          @service = service
-          @test_case = test_case
-          @response = response
-          @client = client
-        end
-
-        attr_reader :service, :test_case, :response, :client
-
-        def errors
-          @errors ||= begin
-            errs = [
-              [:expected_status_unmet, true],
-              [:expected_content_type_unmet, !test_case.is_expected_status?(204)],
-              [:expected_headers_unmet, test_case.has_expected_headers?],
-              [:expected_schema_unmet, !test_case.is_expected_status?(204)],
-              [:assertions_unmet, test_case.has_assertions?],
-              [:postconditions_unmet, test_case.service.has_postconditions? && !test_case.counterexample?],
-              [:expected_error_unmet, test_case.has_expected_error?]
-            ].map do |(expectation,only_if)|
-              next unless only_if
-              begin
-                self.send(expectation)
-              rescue => ex
-                ex.message
-              end
-            end
-            errs.compact
-          end
-        end
-
-        def has_error?
-          !errors.empty?
-        end
-
-        ### Getters on response
-
-        def response_code
-          code = response.status
-          code = code.code unless code.is_a?(Integer)
-          code
-        end
-
-        ### Query methods
-
-        def done?
-          !response.nil?
-        end
-
-        def is_expected_success?
-          test_case.expected_status.to_i >= 200 && test_case.expected_status.to_i < 300
-        end
-
-        def is_success?
-          response_code >= 200 && response_code < 300
-        end
-
-        def is_empty_response?
-          response_code == 204
-        end
-
-        def is_redirect?
-          response_code >= 300 && response_code < 400
-        end
-
-        ### Check of HTTP status
-
-        def expected_status_unmet
-          expected = test_case.expected_status
-          got = response.status
-          expected === got ? nil : "#{expected} !== #{got}"
-        end
-
-        def meets_expected_status?
-          expected_status_unmet.nil?
-        end
-
-        ### Check of the expected output type
-
-        def expected_content_type_unmet
-          ect = test_case.expected_content_type
-          got = response.content_type
-          got = got.mime_type if got.respond_to?(:mime_type)
-          if ect.nil?
-            got.nil? ? nil : "#{ect} != #{got}"
-          else
-            got.to_s.start_with?(ect.to_s) ? nil : "#{ect} != #{got}"
-          end
-        end
-
-        def meets_expected_content_type?
-          expected_content_type_unmet.nil?
-        end
-
-        ### Check of output schema
-
-        def expected_schema_unmet
-          if is_empty_response?
-            body = response.body.to_s.strip
-            body.empty? ? nil : "Expected empty body, got #{body}"
-          elsif is_redirect?
-          else
-            case dressed_body
-            when Finitio::TypeError
-              rc = dressed_body.root_cause
-              "#{rc.message} (#{rc.location ? rc.location : 'unknown location'})"
-            when StandardError
-              dressed_body.message
-            else nil
-            end
-          end
-        end
-
-        def meets_expected_schema?
-          expected_schema_unmet.nil?
-        end
-
-        ### Check of assertions
-
-        def assertions_unmet
-          unmet = []
-          asserter = Tester::Asserter.new(dressed_body)
-          test_case.assert.each do |assert|
-            begin
-              asserter.instance_eval(assert)
-            rescue => ex
-              unmet << ex.message
-            end
-          end
-          unmet.empty? ? nil : unmet.join("\n")
-        end
-
-        def value_equal(exp, got)
-          case exp
-          when Hash
-            exp.all?{|(k,v)|
-              got[k] == v
-            }
-          else
-            exp == got
-          end
-        end
-
-        ### Check of expected error message
-
-        def expected_error_unmet
-          expected = test_case.expected_error
-          case test_case.expected_content_type
-          when %r{json}
-            got = meets_expected_schema? ? dressed_body[:description] : response.body
-            expected == got ? nil : "`#{expected}` vs. `#{got}`"
-          else
-            dressed_body.include?(expected) ? nil : "#{expected} not found" unless expected.nil?
-          end
-        end
-
-        ### Check of expected headers
-
-        def expected_headers_unmet
-          unmet = []
-          expected = test_case.expected_headers
-          expected.each_pair do |k,v|
-            got = response.headers[k]
-            unmet << "#{v} expected for #{k}, got #{got}" unless (got == v)
-          end
-          unmet.empty? ? nil : unmet.join("\n")
-        end
-
-        ### Check of postconditions
-
-        def postconditions_unmet
-          failures = service.postconditions.map{|post|
-            post.check(self)
-          }.compact
-          failures.empty? ? nil : failures.join("\n")
-        end
-
-      private
-
-        def loaded_body
-          case test_case.expected_content_type
-          when %r{json}
-            raise "Body empty while expected" if response.body.to_s.empty?
-            @loaded_body ||= ::JSON.parse(response.body)
-          else
-            response.body.to_s
-          end
-        end
-
-        def dressed_body
-          @dressed_body ||= case test_case.expected_content_type
-          when %r{json}
-            schema = is_expected_success? ? service.output_schema : service.error_schema
-            begin
-              schema.dress(loaded_body)
-            rescue Finitio::TypeError => ex
-              ex
-            end
-          else
-            loaded_body
-          end
-        end
-
-      end # class Invocation
-    end # class Service
-  end # class Resource
-end # module Webspicy