webspicy 0.15.7 → 0.16.3

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

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

@@ -1,132 +0,0 @@
-module Webspicy
-  class Resource
-    class Service
-      class TestCase
-
-        def initialize(raw)
-          @raw = raw
-          @counterexample = nil
-        end
-        attr_reader :service
-        attr_reader :counterexample
-
-        def bind(service, counterexample)
-          @service = service
-          @counterexample = counterexample
-          self
-        end
-
-        def counterexample?
-          !!@counterexample
-        end
-
-        def resource
-          service.resource
-        end
-
-        def self.info(raw)
-          new(raw)
-        end
-
-        def description
-          @raw[:description]
-        end
-
-        def seeds
-          @raw[:seeds]
-        end
-
-        def headers
-          @raw[:headers] ||= {}
-        end
-
-        def metadata
-          @raw[:metadata] ||= {}
-        end
-
-        def tags
-          @raw[:tags] ||= []
-        end
-
-        def dress_params
-          @raw.fetch(:dress_params){ true }
-        end
-        alias :dress_params? :dress_params
-
-        def params
-          @raw[:params] || {}
-        end
-
-        def body
-          @raw[:body]
-        end
-
-        def file_upload
-          @raw[:file_upload]
-        end
-
-        def located_file_upload
-          file_upload ? file_upload.locate(resource) : nil
-        end
-
-        def expected
-          @raw[:expected] || {}
-        end
-
-        def expected_content_type
-          expected.fetch(:content_type){ 'application/json' }
-        end
-
-        def expected_status
-          expected[:status]
-        end
-
-        def is_expected_status?(status)
-          expected_status === status
-        end
-
-        def expected_error
-          expected[:error]
-        end
-
-        def has_expected_error?
-          !expected_error.nil?
-        end
-
-        def expected_headers
-          expected[:headers] || {}
-        end
-
-        def has_expected_headers?
-          !expected_headers.empty?
-        end
-
-        def assert
-          @raw[:assert] || []
-        end
-
-        def has_assertions?
-          !assert.empty?
-        end
-
-        def to_info
-          @raw
-        end
-
-        def instrument(client)
-          service.preconditions.each do |pre|
-            pre.instrument(self, client)
-          end
-          service.postconditions.each do |post|
-            post.instrument(self, client) if post.respond_to?(:instrument)
-          end
-        end
-
-        def to_s
-          description
-        end
-
-      end # class TestCase
-    end # class Service
-  end # class Resource
-end # module Webspicy

data/lib/webspicy/scope.rb

@@ -1,160 +0,0 @@
-module Webspicy
-  class Scope
-
-    def initialize(config)
-      @config = config
-    end
-    attr_reader :config
-
-    def preconditions
-      config.preconditions
-    end
-
-    def postconditions
-      config.postconditions
-    end
-
-    ###
-    ### Eachers -- Allow navigating the web service definitions
-    ###
-
-    # Yields each resource file in the current scope
-    def each_resource_file(&bl)
-      return enum_for(:each_resource_file) unless block_given?
-      _each_resource_file(config, &bl)
-    end
-
-    # Recursive implementation of `each_resource_file` for each
-    # folder in the configuration.
-    def _each_resource_file(config)
-      folder = config.folder
-      folder.glob("**/*.yml").select(&to_filter_proc(config.file_filter)).each do |file|
-        yield file, folder
-      end
-    end
-    private :_each_resource_file
-
-    # Yields each resource in the current scope in turn.
-    def each_resource(&bl)
-      return enum_for(:each_resource) unless block_given?
-      each_resource_file do |file, folder|
-        yield Webspicy.resource(file.load, file, self)
-      end
-    end
-
-    def each_service(resource, &bl)
-      resource.services.select(&to_filter_proc(config.service_filter)).each(&bl)
-    end
-
-    def each_example(service, &bl)
-      service.examples
-        .map{|e| expand_example(service, e) }
-        .select(&to_filter_proc(config.test_case_filter))
-        .each(&bl) if config.run_examples?
-    end
-
-    def each_counterexamples(service, &bl)
-      service.counterexamples
-        .map{|e| expand_example(service, e) }
-        .select(&to_filter_proc(config.test_case_filter))
-        .each(&bl) if config.run_counterexamples?
-    end
-
-    def each_generated_counterexamples(service, &bl)
-      Webspicy.with_scope(self) do
-        service.generated_counterexamples
-          .map{|e| expand_example(service, e) }
-          .select(&to_filter_proc(config.test_case_filter))
-          .each(&bl) if config.run_counterexamples?
-      end if config.run_counterexamples?
-    end
-
-    def each_testcase(service, &bl)
-      each_example(service, &bl)
-      each_counterexamples(service, &bl)
-      each_generated_counterexamples(service, &bl)
-    end
-
-    ###
-    ### Schemas -- For parsing input and output data schemas found in
-    ### web service definitions
-    ###
-
-    # Parses a Finitio schema based on the data system.
-    def parse_schema(fio)
-      data_system.parse(fio)
-    end
-
-    # Returns the Data system to use for parsing schemas
-    def data_system
-      @data_system ||= config.data_system
-    end
-
-
-    ###
-    ### Service invocation: abstract the configuration about what client is
-    ### used and how to instantiate it
-    ###
-
-    # Returns an instance of the client to use to invoke web services
-    def get_client
-      config.client.new(self)
-    end
-
-    # Convert an instantiated URL found in a webservice definition
-    # to a real URL, using the configuration host.
-    #
-    # When no host resolved on the configuration and the url is not
-    # already an absolute URL, yields the block if given, or raise
-    # an exception.
-    def to_real_url(url, test_case = nil, &bl)
-      case config.host
-      when Proc
-        config.host.call(url, test_case)
-      when String
-        url =~ /^http/ ? url : "#{config.host}#{url}"
-      else
-        return url if url =~ /^http/
-        return yield(url) if block_given?
-        raise "Unable to resolve `#{url}` : no host resolver provided\nSee `Configuration#host="
-      end
-    end
-
-    ###
-    ### Private methods
-    ###
-
-    private
-
-      def expand_example(service, example)
-        return example unless service.default_example
-        h1 = service.default_example.to_info
-        h2 = example.to_info
-        ex = Resource::Service::TestCase.new(merge_maps(h1, h2))
-        ex.bind(service, example.counterexample?)
-      end
-
-      def merge_maps(h1, h2)
-        h1.merge(h2) do |k,v1,v2|
-          case v1
-          when Hash  then merge_maps(v1, v2)
-          when Array then v1 + v2
-          else v2
-          end
-        end
-      end
-
-      # Returns a proc that implements file_filter strategy according to the
-      # type of filter installed
-      def to_filter_proc(filter)
-        case ff = filter
-        when NilClass then ->(f){ true }
-        when Proc     then ff
-        when Regexp   then ->(f){ ff =~ f.to_s }
-        else
-          ->(f){ ff === f }
-        end
-      end
-
-  end
-end