webspicy 0.15.8 → 0.16.0

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'

data/lib/webspicy/tester/rspec_asserter.rb

@@ -0,0 +1,108 @@
+module Webspicy
+  class Tester
+    class RSpecAsserter
+
+      def initialize(rspec, invocation)
+        @rspec = rspec
+        @invocation = invocation  
+      end
+      attr_reader :rspec,  :invocation
+
+      def response
+        invocation.response
+      end
+
+      def test_case
+        invocation.test_case
+      end
+
+      def service
+        test_case.service
+      end
+
+      def assert!
+        assert_status_met
+        assert_content_type_met
+        assert_expected_headers
+        assert_output_schema_met
+        assert_assertions_met
+        assert_postconditions_met
+
+        assert_no_other_errors
+      end
+
+      def assert_status_met
+        got = response.status
+        expected = test_case.expected_status
+        rspec.expect(got).to rspec.match_response_status(expected)
+      end
+
+      def assert_content_type_met
+        return if test_case.is_expected_status?(204)
+        return unless ect = test_case.expected_content_type
+        got = response.content_type
+        got = got.mime_type if got.respond_to?(:mime_type)
+        if ect.nil?
+          rspec.expect(ect).to rspec.have_no_response_type
+        else
+          rspec.expect(ect).to rspec.match_content_type(got)
+        end
+      end
+
+      def assert_expected_headers
+        return unless test_case.has_expected_headers?
+        test_case.expected_headers.each_pair do |k,v|
+          got = response.headers[k]
+          if got.nil?
+            rspec.expect(got).to rspec.be_in_response_headers(k)
+          else
+            rspec.expect(got).to rspec.match_response_header(k, v)
+          end
+        end
+      end
+
+      def assert_output_schema_met
+        return if test_case.is_expected_status?(204)
+        return if invocation.is_redirect?
+        if invocation.is_empty_response?
+          body = response.body.to_s.strip
+          rspec.expect(body).to rspec.be_an_empty_response_body
+        else
+          b = invocation.dressed_body
+          if invocation.is_expected_success?
+            rspec.expect(b).to rspec.meet_output_schema
+          else
+            rspec.expect(b).to rspec.meet_error_schema
+          end
+        end
+      end
+
+      def assert_assertions_met
+        return unless test_case.has_assertions?
+        asserter = Tester::Asserter.new(invocation.dressed_body)
+        test_case.assert.each do |assert|
+          begin
+            asserter.instance_eval(assert)
+          rescue => ex
+            rspec.expect(ex).to rspec.meet_assertion(assert)
+          end
+        end
+      end
+
+      def assert_postconditions_met
+        return unless service.has_postconditions?
+        return if test_case.counterexample?
+        service.postconditions.each do |post|
+          msg = post.check(invocation)
+          rspec.expect(msg).to rspec.meet_postcondition(post)
+        end
+      end
+
+      def assert_no_other_errors
+        errors = invocation.errors
+        rspec.expect(errors).to rspec.be_an_empty_errors_array
+      end
+
+    end # class RSpecAsserter
+  end # class Tester
+end # module Webspicy

data/lib/webspicy/tester/rspec_matchers.rb

@@ -0,0 +1,104 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :match_response_status do |expected|
+  match do |actual|
+    expected === actual
+  end
+  failure_message_for_should do |actual|
+    "expected response status #{actual} to be #{expected}"
+  end
+end
+
+RSpec::Matchers.define :have_no_response_type do
+  match do |actual|
+    actual.nil?
+  end
+  failure_message_for_should do |actual|
+    "expected Content-Type not to be present"
+  end
+end
+
+RSpec::Matchers.define :match_content_type do |expected|
+  match do |actual|
+    actual.to_s.start_with?(expected.to_s)
+  end
+  failure_message_for_should do |actual|
+    "expected Content-Type to be `#{expected}`, got `#{actual}`"
+  end
+end
+
+RSpec::Matchers.define :be_in_response_headers do |header_name|
+  match do |actual|
+    !actual.nil?
+  end
+  failure_message_for_should do |actual|
+    "expected response header `#{header_name}` to be set"
+  end
+end
+
+RSpec::Matchers.define :match_response_header do |header_name, expected|
+  match do |actual|
+    expected == actual
+  end
+  failure_message_for_should do |actual|
+    "expected response header `#{header_name}` to be `#{expected}`, got `#{actual}`"
+  end
+end
+
+RSpec::Matchers.define :be_an_empty_response_body do
+  match do |actual|
+    actual.empty?
+  end
+  failure_message_for_should do |actual|
+    "expected response body to be empty, started with `#{actual[0..20]}`"
+  end
+end
+
+RSpec::Matchers.define :meet_output_schema do
+  match do |actual|
+    !actual.is_a?(Exception)
+  end
+  failure_message_for_should do |actual|
+    "expected response body to meet output schema, got following error:\n" + \
+    "    #{actual.message}"
+  end
+end
+
+RSpec::Matchers.define :meet_error_schema do
+  match do |actual|
+    !actual.is_a?(Exception)
+  end
+  failure_message_for_should do |actual|
+    "expected response body to meet error schema, got following error:\n" + \
+    "    #{actual.message}"
+  end
+end
+
+RSpec::Matchers.define :meet_assertion do |assert|
+  match do |actual|
+    actual.nil?
+  end
+  failure_message_for_should do |actual|
+    "expected assertion `#{assert}` to be met, got following error:\n" + \
+    "    #{actual.message}"
+  end
+end
+
+RSpec::Matchers.define :meet_postcondition do |post|
+  match do |actual|
+    actual.nil?
+  end
+  failure_message_for_should do |actual|
+    "expected postcondition `#{post.class.name}` to be met, got following error:\n" + \
+    "    #{actual}"
+  end
+end
+
+RSpec::Matchers.define :be_an_empty_errors_array do
+  match do |actual|
+    actual.empty?
+  end
+  failure_message_for_should do |actual|
+    "expected no webspicy error, got the following ones:\n" + actual.map{|a| "    #{a}" }.join("\n")
+  end
+end