webspicy 0.15.8 → 0.16.0

data/lib/webspicy/support/status_range.rb

@@ -42,8 +42,13 @@ module Webspicy
       end
 
       def to_s
-        @range.to_s
+        if @range.first == @range.last
+          @range.first.to_s
+        else
+          @range.to_s
+        end
       end
+      alias :inspect :to_s
 
     end # class StatusRange
   end # module Support

data/lib/webspicy/tester.rb

@@ -1,5 +1,6 @@
 module Webspicy
   class Tester
+    include Webspicy::Support::Colorize
 
     def initialize(config)
       @config = Configuration.dress(config)
@@ -33,8 +34,8 @@ module Webspicy
         end
         tester.config.each_scope do |scope|
           client = scope.get_client
-          scope.each_resource do |resource|
-            scope.each_service(resource) do |service|
+          scope.each_specification do |specification|
+            scope.each_service(specification) do |service|
               tester.rspec_service!(self, service, client, scope)
             end
           end
@@ -44,11 +45,11 @@ module Webspicy
     end
 
     def rspec_service!(on, service, client, scope)
-      on.describe service do
-        scope.each_testcase(service) do |test_case|
-          describe test_case do
-            include_examples 'a successful test case invocation', client, test_case
-          end
+      scope.each_testcase(service) do |test_case|
+        str = "#{service} #{test_case}"
+        str = colorize_highlight(str)
+        on.describe(str) do
+          include_examples 'a successful test case invocation', client, test_case
         end
       end
     end
@@ -61,7 +62,8 @@ module Webspicy
             client.before(test_case)
             test_case.instrument(client)
             client.instrument(test_case)
-            @invocation = client.call(test_case)
+            @response = client.call(test_case)
+            @invocation = Tester::Invocation.new(test_case, @response, client)
             example.run
             client.after(test_case, @invocation)
             @invocation
@@ -72,13 +74,16 @@ module Webspicy
           @invocation
         end
 
-        it 'works' do
+        it "meets its specification" do
           raise "Test not ran" unless invocation.done?
-          errors = invocation.errors
-          raise "\n* " + errors.join("\n* ") + "\n" unless errors.empty?
+          invocation.rspec_assert!(self)
         end
       end
     end
 
   end # class Tester
 end # module Webspicy
+require_relative 'tester/client'
+require_relative 'tester/invocation'
+require_relative 'tester/assertions'
+require_relative 'tester/asserter'

data/lib/webspicy/tester/asserter.rb

@@ -54,7 +54,8 @@ module Webspicy
       def size(path, expected = NO_ARG)
         path, expected = '', path if expected == NO_ARG
         unless @assertions.size(@target, path, expected)
-          _! "Expected #{_s(@target, path)} to have a size of #{expected}"
+          actual = @assertions.actual_size(@target, path)
+          _! "Expected #{_s(@target, path)} to have a size of #{expected}, actual size is: #{actual}"
         end
       end
 
@@ -84,7 +85,7 @@ module Webspicy
 
       def pathFD(path, expected)
         unless @assertions.pathFD(@target, path, expected)
-          _! "Expected #{_s(@target, path)} to meet FD #{expected.inspect}"
+          _! "#{expected.inspect} vs. #{_s(@target, path)}"
         end
       end
 

data/lib/webspicy/tester/assertions.rb

@@ -37,8 +37,12 @@ module Webspicy
 
       def size(target, path, expected = NO_ARG)
         path, expected = '', path if expected == NO_ARG
+        actual_size(target, path) == expected
+      end
+
+      def actual_size(target, path) 
         target = extract_path(target, path)
-        respond_to!(target, :size).size == expected
+        respond_to!(target, :size).size
       end
 
       def idIn(target, path, expected = NO_ARG)

data/lib/webspicy/tester/client.rb

@@ -0,0 +1,63 @@
+module Webspicy
+  class Tester
+    class Client
+
+      def initialize(scope)
+        @scope = scope
+      end
+      attr_reader :scope
+
+      def config
+        scope.config
+      end
+
+      def around(*args, &bl)
+        args << self
+        ls = config.listeners(:around_each)
+        if ls.size == 0
+          bl.call
+        elsif ls.size > 1
+          _around(ls.first, ls[1..-1], args, &bl)
+        else
+          ls.first.call(*args, &bl)
+        end
+      end
+
+      def _around(head, tail, args, &bl)
+        head.call(*args) do
+          if tail.empty?
+            bl.call
+          else
+            _around(tail.first, tail[1..-1], args, &bl)
+          end
+        end
+      end
+      private :_around
+
+      def instrument(*args, &bl)
+        args << self
+        config.listeners(:instrument).each do |i|
+          i.call(*args, &bl)
+        end
+      end
+
+      def before(*args, &bl)
+        args << self
+        config.listeners(:before_each).each do |beach|
+          beach.call(*args, &bl)
+        end
+      end
+
+      def after(*args, &bl)
+        args << self
+        config.listeners(:after_each).each do |aeach|
+          aeach.call(*args, &bl)
+        end
+      end
+
+    end # class Client
+  end # class Tester
+end # module Webspicy
+require_relative 'client/support'
+require_relative 'client/http_client'
+require_relative 'client/rack_test_client'

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

@@ -0,0 +1,154 @@
+module Webspicy
+  class Tester
+    class HttpClient < Client
+
+      class ::HTTP::Request
+
+        # We monkey patch the URI normalization on Http because
+        # we don't want it to interfere with URIs that are encoded
+        # in tests, especially security tests.
+        def normalize_uri(uri)
+          uri
+        end
+
+      end # class ::HTTP::Request
+
+      def initialize(scope)
+        super(scope)
+        @api = Api.new(scope)
+      end
+      attr_reader :api
+
+      def call(test_case)
+        service, specification = test_case.service, test_case.specification
+
+        # Instantiate the parameters
+        headers = test_case.headers
+        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)
+
+        # Globalize the URL if required
+        url = scope.to_real_url(url, test_case)
+
+        # Invoke the service now
+        api.public_send(service.method.to_s.downcase.to_sym, url, params, headers, body)
+
+        # Return the response
+        api.last_response
+      end
+
+      class Api
+        include Client::Support
+
+        attr_reader :last_response
+
+        def initialize(scope)
+          @scope = scope
+        end
+
+        def config
+          @scope.config
+        end
+
+        def options(url, params = {}, headers = nil, body = nil)
+          info_request("OPTIONS", url, params, headers, body)
+
+          params = querystring_params(params)
+          @last_response = HTTP[headers || {}].options(url, params: params)
+
+          debug_response(@last_response)
+
+          @last_response
+        end
+
+        def get(url, params = {}, headers = nil, body = nil)
+          info_request("GET", url, params, headers, body)
+
+          params = querystring_params(params)
+          @last_response = HTTP[headers || {}].get(url, params: params)
+
+          debug_response(@last_response)
+
+          @last_response
+        end
+
+        def post(url, params = {}, headers = nil, body = nil)
+          info_request("POST", url, params, headers, body)
+
+          url = url + "?" + Rack::Utils.build_query(params) if body && !params.empty?
+
+          headers ||= {}
+
+          case body
+          when NilClass
+            headers['Content-Type'] ||= 'application/json'
+            @last_response = HTTP[headers].post(url, body: params.to_json)
+          when FileUpload
+            file = HTTP::FormData::File.new(body.path.to_s, {
+              content_type: body.content_type,
+              filename: body.path.basename.to_s
+            })
+            @last_response = HTTP[headers].post(url, form: {
+              body.param_name.to_sym => file
+            })
+          else
+            headers['Content-Type'] ||= 'application/json'
+            @last_response = HTTP[headers].post(url, body: body)
+          end
+
+          debug_response(@last_response)
+
+          @last_response
+        end
+
+        def patch(url, params = {}, headers = nil, body = nil)
+          info_request("PATCH", url, params, headers, body)
+
+          headers ||= {}
+          headers['Content-Type'] ||= 'application/json'
+          @last_response = HTTP[headers].patch(url, body: params.to_json)
+
+          debug_response(@last_response)
+
+          @last_response
+        end
+
+        def put(url, params = {}, headers = nil, body = nil)
+          info_request("PUT", url, params, headers, body)
+
+          headers ||= {}
+          headers['Content-Type'] ||= 'application/json'
+          @last_response = HTTP[headers].put(url, body: params.to_json)
+
+          debug_response(@last_response)
+
+          @last_response
+        end
+
+        def post_form(url, params = {}, headers = nil, body = nil)
+          info_request("POST", url, params, headers, body)
+
+          @last_response = HTTP[headers || {}].post(url, form: params)
+
+          debug_response(@last_response)
+
+          @last_response
+        end
+
+        def delete(url, params = {}, headers = nil, body = nil)
+          info_request("DELETE", url, params, headers, body)
+
+          @last_response = HTTP[headers || {}].delete(url, body: params.to_json)
+
+          debug_response(@last_response)
+
+          @last_response
+        end
+      end # class Api
+
+    end # class HttpClient
+  end # class Tester
+end # module Webspicy

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