webspicy 0.15.4 → 0.16.0

data/lib/webspicy/tester/client/rack_test_client.rb

@@ -0,0 +1,188 @@
+module Webspicy
+  class Tester
+    class RackTestClient < Client
+
+      def self.for(app)
+        Factory.new(app)
+      end
+
+      def initialize(scope, app)
+        super(scope)
+        @api = Api.new(scope, app)
+      end
+      attr_reader :api
+
+      def call(test_case)
+        service, specification = test_case.service, test_case.specification
+
+        # 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 = specification.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 last response
+        api.last_response
+      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(scope, app)
+          @scope = scope
+          @app = app
+        end
+
+        def config
+          @scope.config
+        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 # class Client
+end # module Webspicy

data/lib/webspicy/tester/client/support.rb

@@ -0,0 +1,65 @@
+module Webspicy
+  class Tester
+    class Client
+      module Support
+        include Webspicy::Support::Colorize
+
+        NONE = Object.new
+
+        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(colorize_highlight("~> #{kind} #{url}"))
+          debug("  Req params", json_pretty(params)) if params
+          debug("  Req headers", json_pretty(headers)) if headers
+          debug("  Req body", request_body_to_s(body)) if body
+        end
+
+        def debug_response(response)
+          debug(colorize_highlight("."))
+          debug("  Res status", status_to_s(@last_response.status))
+          debug("  Res headers", json_pretty(last_response.headers.to_h))
+          debug("  Res body", response_body_to_s(last_response))
+          Webspicy.debug("")
+        end
+
+        def debug(what, value = NONE)
+          return Webspicy.debug("  #{what}") if value == NONE
+          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(body)
+        end
+
+        def response_body_to_s(response)
+          case response.content_type.to_s
+          when /json/
+            json_pretty(JSON.load(response.body))
+          else
+            response.body.to_s
+          end
+        end
+
+        def value_to_s(value)
+          value.to_s.gsub(/\n/, "\n      ")
+        end
+
+        def status_to_s(status)
+          case status
+          when 0 ... 400 then colorize_success(status.to_s)
+          else colorize_error(status.to_s)
+          end
+        end
+
+        def json_pretty(s)
+          JSON.pretty_generate(s)
+        end
+
+      end # module Support
+    end # class Client
+  end # class Tester
+end # module Webspicy

data/lib/webspicy/tester/invocation.rb

@@ -0,0 +1,218 @@
+module Webspicy
+  class Tester
+    class Invocation
+
+      def initialize(test_case, response, client)
+        @test_case = test_case
+        @response = response
+        @client = client
+      end
+
+      attr_reader :test_case, :response, :client
+
+      def service
+        test_case.service
+      end
+
+      def rspec_assert!(rspec)
+        RSpecAsserter.new(rspec, self).assert!
+      end
+
+      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 : "[status] #{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
+        return nil unless ect
+        got = response.content_type
+        got = got.mime_type if got.respond_to?(:mime_type)
+        if ect.nil?
+          got.nil? ? nil : "[content type] #{ect} != #{got}"
+        else
+          got.to_s.start_with?(ect.to_s) ? nil : "[content type] #{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 : "[body] empty vs. #{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 : "[error message] `#{expected}` vs. `#{got}`"
+        else
+          dressed_body.include?(expected) ? nil : "[error message] `#{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 << "[headers] #{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
+
+      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 Tester
+end # module Webspicy
+require_relative 'rspec_matchers'
+require_relative 'rspec_asserter'