webspicy 0.15.8 → 0.17.0

data/lib/webspicy/specification/test_case.rb

@@ -0,0 +1,133 @@
+module Webspicy
+  class Specification
+    class TestCase
+      include Support::DataObject
+
+      def initialize(raw)
+        super(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 specification
+        service.specification
+      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(specification) : nil
+      end
+
+      def expected
+        @raw[:expected] || {}
+      end
+
+      def expected_content_type
+        expected[:content_type]
+      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 instrument(client)
+        service.preconditions.each do |pre|
+          pre.instrument(self, client) if pre.respond_to?(:instrument)
+        end
+        service.postconditions.each do |post|
+          post.instrument(self, client) if post.respond_to?(:instrument)
+        end
+      end
+
+      def mutate(override)
+        m = self.dup
+        m.raw = self.raw.merge(override)
+        m
+      end
+
+      def to_s
+        description
+      end
+
+    end # class TestCase
+  end # class Specification
+end # module Webspicy

data/lib/webspicy/support.rb

@@ -1 +1,3 @@
+require_relative 'support/data_object'
 require_relative 'support/status_range'
+require_relative 'support/colorize'

data/lib/webspicy/support/colorize.rb

@@ -0,0 +1,28 @@
+module Webspicy
+  module Support
+    module Colorize
+
+      def colorize(str, kind, config = nil)
+        color = (config || self.config).colors[kind]
+        ColorizedString[str].colorize(color)
+      end
+      module_function :colorize
+
+      def colorize_highlight(str, cfg = nil)
+        colorize(str, :highlight, cfg)
+      end
+      module_function :colorize_highlight
+
+      def colorize_success(str, cfg = nil)
+        colorize(str, :success, cfg)
+      end
+      module_function :colorize_success
+
+      def colorize_error(str, cfg = nil)
+        colorize(str, :error, cfg)
+      end
+      module_function :colorize_error
+
+    end # module Colorize
+  end # module Support
+end # module Webspicy

data/lib/webspicy/support/data_object.rb

@@ -0,0 +1,25 @@
+module Webspicy
+  module Support
+    module DataObject
+
+      def initialize(raw)
+        @raw = raw
+      end
+      attr_accessor :raw
+      protected :raw, :raw=
+
+      def method_missing(name, *args, &bl)
+        if @raw.has_key?(name) && args.empty? && bl.nil?
+          @raw[name]
+        else
+          super
+        end
+      end
+
+      def to_info
+        @raw
+      end
+
+    end # module DataObject
+  end # module Support
+end # module Webspicy

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,84 +1,15 @@
 module Webspicy
   class Tester
 
-    def initialize(config)
-      @config = Configuration.dress(config)
-      @test_suite = load
-    end
-    attr_reader :config
-
-    def call(err=$stderr, out=$stdout)
-      $_rspec_core_load_started_at = nil
-      options = RSpec::Core::ConfigurationOptions.new(config.rspec_options)
-      conf = RSpec::Core::Configuration.new
-      RSpec::Core::Runner.new(options, conf).run(err, out)
-    end
-
-  # protected
-
-    def load
-      tester = self
-      RSpec.reset
-      rspec_config!
-      RSpec.describe "" do
-        before(:all) do
-          tester.config.listeners(:before_all).each do |l|
-            l.call(tester.config)
-          end
-        end
-        after(:all) do
-          tester.config.listeners(:after_all).each do |l|
-            l.call(tester.config)
-          end
-        end
-        tester.config.each_scope do |scope|
-          client = scope.get_client
-          scope.each_resource do |resource|
-            scope.each_service(resource) do |service|
-              tester.rspec_service!(self, service, client, scope)
-            end
-          end
-        end
-      end
-      self
-    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
-        end
-      end
-    end
-
-    def rspec_config!
-      RSpec.shared_examples "a successful test case invocation" do |client, test_case|
-
-        around(:each) do |example|
-          client.around(test_case) do
-            client.before(test_case)
-            test_case.instrument(client)
-            client.instrument(test_case)
-            @invocation = client.call(test_case)
-            example.run
-            client.after(test_case, @invocation)
-            @invocation
-          end
-        end
-
-        let(:invocation) do
-          @invocation
-        end
-
-        it 'works' do
-          raise "Test not ran" unless invocation.done?
-          errors = invocation.errors
-          raise "\n* " + errors.join("\n* ") + "\n" unless errors.empty?
-        end
-      end
+    def self.new(*args, &bl)
+      require_relative 'rspec/tester'
+      RSpecTester.new(*args, &bl)
     end
 
   end # class Tester
 end # module Webspicy
+require_relative 'tester/client'
+require_relative 'tester/invocation'
+require_relative 'tester/failure'
+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
 
@@ -77,14 +78,19 @@ module Webspicy
           expected = id
           id, path = path, ''
         end
-        unless @assertions.idFD(@target, path, id, expected)
-          _! "Expected #{_s(@target, path)} to meet FD #{expected.inspect}"
+        element = @assertions.element_with_id(@target, path, id)
+        unless element
+          _! "Expected an element with id #{id} to contain the key(s) and value(s) #{expected}, but there is no element with that id"
+        end
+
+        unless @assertions.idFD(element, expected)
+          _! "Expected #{_s(@target, path)} to contain the key(s) and value(s) #{expected}"
         end
       end
 
       def pathFD(path, expected)
         unless @assertions.pathFD(@target, path, expected)
-          _! "Expected #{_s(@target, path)} to meet FD #{expected.inspect}"
+          _! "Expected #{_s(@target, path)} to contain the key(s) and value(s) #{expected}"
         end
       end
 
@@ -120,7 +126,7 @@ module Webspicy
       end
 
       def _!(msg)
-        raise msg
+        raise Failure, msg
       end
 
     end # class Asserter

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)
@@ -59,16 +63,15 @@ module Webspicy
         (ids.to_set & expected.to_set).empty?
       end
 
-      def idFD(target, path, id, expected = NO_ARG)
-        if expected == NO_ARG
-          expected = id
-          id, path = path, ''
-        end
+      def element_with_id(target, path, id)
         target = extract_path(target, path)
-        found = an_array(target).find{|t| t[:id] == id }
-        expected.keys.all?{|k|
-          value_equal(expected[k], found[k])
-        }
+        an_array(target).find { |t| t[:id] == id }
+      end
+
+      def idFD(element, expected) 
+        expected.keys.all? do |k|
+          value_equal(expected[k], element[k])
+        end
       end
 
       def pathFD(target, path, expected)

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