webspicy 0.16.1 → 0.19.0

data/lib/webspicy/tester/failure.rb

@@ -0,0 +1,6 @@
+module Webspicy
+  class Tester
+    class Failure < Exception
+    end # class Failure
+  end # class Tester
+end # module Webspicy

data/lib/webspicy/tester/file_checker.rb

@@ -0,0 +1,22 @@
+module Webspicy
+  class Tester
+    class FileChecker < Tester
+
+      def default_reporter
+        @reporter = Reporter::Composite.new
+        @reporter << Reporter::FileProgress.new
+        @reporter << Reporter::Exceptions.new
+        @reporter << Reporter::FileSummary.new
+        @reporter << Reporter::ErrorCount.new
+      end
+
+      def run_scope
+        scope.each_specification_file do |spec_file|
+          @specification = load_specification(spec_file)
+          reporter.spec_file_done
+        end
+      end
+
+    end # class FileChecker
+  end # class Tester
+end # module Webspicy

data/lib/webspicy/tester/invocation.rb

@@ -1,218 +1,37 @@
 module Webspicy
   class Tester
     class Invocation
+      extend Forwardable
 
       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
+      def_delegators :@client, *[
+        :config
+      ]
 
-      ### Check of postconditions
+      def_delegators :@test_case, *[
+        :scope,
+        :specification,
+        :service
+      ]
 
-      def postconditions_unmet
-        failures = service.postconditions.map{|post|
-          post.check(self)
-        }.compact
-        failures.empty? ? nil : failures.join("\n")
+      def raw_output
+        raise NotImplementedError
       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
+      def loaded_output
+        raise NotImplementedError
       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
+      def output
+        raise NotImplementedError
       end
 
     end # class Invocation
   end # class Tester
 end # module Webspicy
-require_relative 'rspec_matchers'
-require_relative 'rspec_asserter'

data/lib/webspicy/tester/reporter.rb

@@ -0,0 +1,85 @@
+module Webspicy
+  class Tester
+    class Reporter
+      include Support::Colorize
+
+      def initialize(io = STDOUT)
+        @io = io
+      end
+      attr_reader :io
+
+      def init(tester)
+        @tester = tester
+      end
+      attr_reader :tester
+
+      [
+        :config,
+        :scope,
+        :client,
+        :spec_file,
+        :specification,
+        :service,
+        :test_case,
+        :invocation,
+        :result
+      ].each do |meth|
+        define_method(meth) do |*args, &bl|
+          tester.send(meth, *args, &bl)
+        end
+      end
+
+      HOOKS = [
+        :before_all,
+        :before_all_done,
+        :before_scope,
+        :scope_done,
+        :before_spec_file,
+        :spec_file_error,
+        :spec_file_done,
+        :before_specification,
+        :specification_done,
+        :before_service,
+        :service_done,
+        :before_test_case,
+        :test_case_done,
+        :before_each,
+        :before_each_done,
+        :before_instrument,
+        :instrument_done,
+        :before_invocation,
+        :invocation_done,
+        :before_assertions,
+        :check_success,
+        :check_failure,
+        :check_error,
+        :assertions_done,
+        :after_each,
+        :after_each_done,
+        :after_all,
+        :after_all_done,
+        :report
+      ]
+
+      HOOKS.each do |meth|
+        define_method(meth){|*args, &bl|
+        }
+      end
+
+    protected
+
+      def plural(word, count)
+        "%d #{word}#{count>1 ? 's' : ''}" % [count]
+      end
+
+    end # class Reporter
+  end # class Tester
+end # module Webspicy
+require_relative 'reporter/error_count'
+require_relative 'reporter/progress'
+require_relative 'reporter/summary'
+require_relative 'reporter/documentation'
+require_relative 'reporter/exceptions'
+require_relative 'reporter/composite'
+require_relative 'reporter/file_progress'
+require_relative 'reporter/file_summary'

data/lib/webspicy/tester/reporter/composite.rb

@@ -0,0 +1,38 @@
+module Webspicy
+  class Tester
+    class Reporter
+      class Composite < Reporter
+
+        def initialize(*args, &bl)
+          super
+          @reporters = []
+        end
+
+        def <<(reporter)
+          @reporters << reporter
+          self
+        end
+
+        def init(tester)
+          super
+          @reporters.each do |r|
+            r.init(tester)
+          end
+        end
+
+        HOOKS.each do |meth|
+          define_method(meth) do |*args, &bl|
+            @reporters.each do |r|
+              r.send(meth, *args, &bl)
+            end
+          end
+        end
+
+        def find(kind)
+          @reporters.find{|r| r.is_a?(kind) }
+        end
+
+      end # class Composite
+    end # class Reporter
+  end # class Tester
+end # module Webspicy

data/lib/webspicy/tester/reporter/documentation.rb

@@ -0,0 +1,67 @@
+module Webspicy
+  class Tester
+    class Reporter
+      class Documentation < Reporter
+
+        module Helpers
+          def spec_file_error_line(spec_file, ex)
+            str = colorize_highlight(spec_file.to_s)
+            str += "\n  " + colorize_error("X  #{ex.message}")
+            if ex.root_cause && ex.root_cause != ex
+              str += "\n    " + colorize_error("#{ex.root_cause.message}")
+            end
+            str
+          end
+
+          def service_line(service, test_case)
+            str = service.to_s + ", " + test_case.to_s
+            str = colorize_highlight(str)
+          end
+
+          def check_success_line(check)
+            "  " + colorize_success("v") + "  " + check.behavior
+          end
+
+          def check_failure_line(check, ex)
+            "  " + colorize_error("F  " + ex.message)
+          end
+
+          def check_error_line(check, ex)
+            "  " + colorize_error("E  " + ex.message)
+          end
+        end
+        include Helpers
+
+        def spec_file_error(e)
+          io.puts spec_file_error_line(spec_file, e)
+          io.puts
+        end
+
+        def before_test_case
+          io.puts service_line(service, test_case)
+        end
+
+        def check_success(check)
+          io.puts check_success_line(check)
+        end
+
+        def check_failure(check, ex)
+          io.puts check_failure_line(check, ex)
+        end
+
+        def check_error(check, ex)
+          io.puts check_error_line(check, ex)
+        end
+
+        def test_case_done
+          io.puts
+        end
+
+        def service_done
+          io.puts
+        end
+
+      end # class Documentation
+    end # class Reporter
+  end # class Tester
+end # module Webspicy