webspicy 0.15.8 → 0.17.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/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/invocation.rb

@@ -0,0 +1,70 @@
+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
+
+      ### 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
+
+      def loaded_body
+        ct = response.content_type || test_case.expected_content_type
+        ct = ct.mime_type if ct.respond_to?(:mime_type)
+        case ct
+        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
+        schema = is_expected_success? ? service.output_schema : service.error_schema
+        begin
+          schema.dress(loaded_body)
+        rescue Finitio::TypeError => ex
+          ex
+        end
+      end
+
+    end # class Invocation
+  end # class Tester
+end # module Webspicy

data/lib/webspicy/version.rb

@@ -1,8 +1,8 @@
 module Webspicy
   module Version
     MAJOR = 0
-    MINOR = 15
-    TINY  = 8
+    MINOR = 17
+    TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/spec/unit/configuration/scope/test_each_service.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+module Webspicy
+  class Configuration
+    describe Scope, 'each_service' do
+
+      let(:scope) {
+        Scope.new(configuration)
+      }
+
+      let(:specification) {
+        scope.each_specification.first
+      }
+
+      subject {
+        scope.each_service(specification).to_a
+      }
+
+      context 'without any filter' do
+
+        let(:configuration) {
+          Configuration.new(restful_folder){|c|
+            c.file_filter = /get.yml/
+          }
+        }
+
+        it 'returns all services' do
+          expect(subject.size).to eql(1)
+        end
+      end
+
+      context 'with a service filter as a proc' do
+
+        let(:configuration) {
+          Configuration.new(restful_folder){|c|
+            c.file_filter = /get.yml/
+            c.service_filter = ->(s) {
+              s.method == "POST"
+            }
+          }
+        }
+
+        it 'returns nothing' do
+          expect(subject.size).to eql(0)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/configuration/scope/test_each_specification.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+module Webspicy
+  class Configuration
+    describe Scope, 'each_specification' do
+
+      let(:scope) {
+        Scope.new(configuration)
+      }
+
+      subject {
+        scope.each_specification.to_a
+      }
+
+      context 'without any filter' do
+
+        let(:configuration) {
+          Configuration.new(restful_folder)
+        }
+
+        it 'returns all files' do
+          expect(subject.size).to eql(restful_folder.glob('**/*.yml').size)
+        end
+      end
+
+      context 'with a file filter as a proc' do
+
+        let(:configuration) {
+          Configuration.new(restful_folder){|c|
+            c.file_filter = ->(f) {
+              f.basename.to_s == "get.yml"
+            }
+          }
+        }
+
+        it 'returns only that files' do
+          expect(subject.size).to eql(2)
+        end
+      end
+
+      context 'with a file filter as a Regex' do
+
+        let(:configuration) {
+          Configuration.new(restful_folder){|c|
+            c.file_filter = /get.yml/
+          }
+        }
+
+        it 'returns only that files' do
+          expect(subject.size).to eql(2)
+        end
+      end
+
+      context 'when having children folders' do
+
+        let(:configuration) {
+          Configuration.new(restful_folder) do |c|
+            c.folder 'formaldef/todo'
+          end
+        }
+
+        it 'returns all files' do
+          expect(subject.size).to eql(restful_folder.glob('**/*.yml').size)
+        end
+      end
+
+    end
+  end
+end