webspicy 0.1.0.pre.rc1

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

@@ -0,0 +1,158 @@
+module Webspicy
+  class Resource
+    class Service
+      class Invocation
+
+        def initialize(service, test_case, response)
+          @service = service
+          @test_case = test_case
+          @response = response
+        end
+
+        attr_reader :service, :test_case, :response
+
+        def done?
+          !response.nil?
+        end
+
+        def is_expected_success?
+          test_case.expected_status >= 200 && test_case.expected_status < 300
+        end
+
+        def is_success?
+          response.status.code >= 200 && response.status.code < 300
+        end
+
+        def is_empty_response?
+          response.status.code == 204
+        end
+
+        def is_redirect?
+          response.status.code >= 300 && response.status.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.mime_type.to_s
+          ect == got ? nil : "#{ect} != #{got}"
+        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 then dressed_body.root_cause.message
+            when StandardError      then 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
+
+      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

@@ -0,0 +1,74 @@
+module Webspicy
+  class Resource
+    class Service
+      class TestCase
+
+        def initialize(raw)
+          @raw = raw
+        end
+
+        def self.info(raw)
+          new(raw)
+        end
+
+        def description
+          @raw[:description]
+        end
+
+        def seeds
+          @raw[:seeds]
+        end
+
+        def headers
+          @raw[:headers] || {}
+        end
+
+        def dress_params
+          @raw.fetch(:dress_params){ true }
+        end
+        alias :dress_params? :dress_params
+
+        def params
+          @raw[:params]
+        end
+
+        def expected_content_type
+          @raw[:expected][:content_type] || 'application/json'
+        end
+
+        def expected_status
+          @raw[:expected][:status]
+        end
+
+        def expected_error
+          @raw[:expected][:error]
+        end
+
+        def has_expected_error?
+          !expected_error.nil?
+        end
+
+        def expected_headers
+          @raw[: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
+
+      end # class TestCase
+    end # class Service
+  end # class Resource
+end # module Webspicy

data/lib/webspicy/resource/service.rb

@@ -0,0 +1,49 @@
+module Webspicy
+  class Resource
+    class Service
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def self.info(raw)
+        new(raw)
+      end
+
+      def method
+        @raw[:method]
+      end
+
+      def examples
+        @raw[:examples]
+      end
+
+      def counterexamples
+        @raw[:counterexamples]
+      end
+
+      def input_schema
+        @raw[:input_schema]
+      end
+
+      def output_schema
+        @raw[:output_schema]
+      end
+
+      def error_schema
+        @raw[:error_schema]
+      end
+
+      def dress_params(params)
+        input_schema.dress(params)
+      end
+
+      def to_info
+        @raw
+      end
+
+    end # class Service
+  end # class Resource
+end # module Webspicy
+require_relative 'service/test_case'
+require_relative 'service/invocation'

data/lib/webspicy/resource.rb

@@ -0,0 +1,43 @@
+module Webspicy
+  class Resource
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def self.info(raw)
+      new(raw)
+    end
+
+    def url
+      @raw[:url]
+    end
+
+    def services
+      @raw[:services]
+    end
+
+    def url_placeholders
+      url.scan(/\{([a-zA-Z]+)\}/).map{|x| x.first.to_sym }
+    end
+
+    def instantiate_url(params)
+      url, rest = self.url, params.dup
+      url_placeholders.each do |placeholder|
+        if (params.has_key?(placeholder))
+          url = url.gsub("{#{placeholder}}", params[placeholder].to_s)
+          rest.delete(placeholder)
+        else
+          raise "Missing URL parameter `#{placeholder}`\n\t(#{params.inspect})"
+        end
+      end
+      [ url, rest ]
+    end
+
+    def to_info
+      @raw
+    end
+
+  end
+end
+require_relative 'resource/service'

data/lib/webspicy/scope.rb

@@ -0,0 +1,113 @@
+module Webspicy
+  class Scope
+
+    def initialize(config)
+      @config = config
+    end
+    attr_reader :config
+
+    ###
+    ### 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?
+      config.folders.each do |folder|
+        _each_resource_file(folder, &bl)
+      end
+    end
+
+    # Recursive implementation of `each_resource_file` for each
+    # folder in the configuration.
+    def _each_resource_file(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)
+      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.each(&bl)
+    end
+
+    def each_counterexamples(service, &bl)
+      service.counterexamples.each(&bl) if config.run_counterexamples?
+    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 ||= begin
+        root = config.folders.find{|f| (f/"schema.fio").file? }
+        root ? Finitio::DEFAULT_SYSTEM.parse((root/"schema.fio").read) : Finitio::DEFAULT_SYSTEM
+      end
+    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
+    def to_real_url(url)
+      case config.host
+      when Proc
+        config.host.call(url)
+      when String
+        url =~ /^http/ ? url : "#{config.host}#{url}"
+      else
+        return url if url =~ /^http/
+        raise "Unable to resolve `#{url}` : no host resolver provided\nSee `Configuration#host="
+      end
+    end
+
+    ###
+    ### Private methods
+    ###
+
+    private
+
+      # 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

data/lib/webspicy/tester/asserter.rb

@@ -0,0 +1,94 @@
+module Webspicy
+  class Tester
+    class Asserter
+
+      NO_ARG = Object.new
+
+      class AssertionsClass
+        include Assertions
+      end
+
+      def initialize(target)
+        @target = target
+        @assertions = AssertionsClass.new
+      end
+
+      def exists(path = '')
+        unless @assertions.exists(@target, path)
+          _! "Expected #{_s(@target)} to exists"
+        end
+      end
+
+      def notExists(path = '')
+        unless @assertions.notExists(@target, path)
+          _! "Expected #{_s(@target)} not to exists"
+        end
+      end
+
+      def empty(path = '')
+        unless @assertions.empty(@target, path)
+          _! "Expected #{_s(@target)} to be empty"
+        end
+      end
+
+      def notEmpty(path = '')
+        unless @assertions.notEmpty(@target, path)
+          _! "Expected #{_s(@target)} to be non empty"
+        end
+      end
+
+      def size(path, expected = NO_ARG)
+        path, expected = '', path if expected == NO_ARG
+        unless @assertions.size(@target, path, expected)
+          _! "Expected #{_s(@target)} to have a size of #{expected}"
+        end
+      end
+
+      def idIn(path, *expected)
+        path, expected = '', [path]+expected unless path.is_a?(String)
+        unless @assertions.idIn(@target, path, expected)
+          _! "Expected #{_s(@target)} to have ids #{expected.join(',')}"
+        end
+      end
+
+      def idNotIn(path, *expected)
+        path, expected = '', [path]+expected unless path.is_a?(String)
+        unless @assertions.idNotIn(@target, path, expected)
+          _! "Expected #{_s(@target)} to not have ids #{expected.join(',')}"
+        end
+      end
+
+      def idFD(path, id, expected = NO_ARG)
+        if expected == NO_ARG
+          expected = id
+          id, path = path, ''
+        end
+        unless @assertions.idFD(@target, path, id, expected)
+          _! "Expected #{_s(@target)} to meet FD #{expected.inspect}"
+        end
+      end
+
+      def pathFD(path, expected)
+        unless @assertions.pathFD(@target, path, expected)
+          _! "Expected #{_s(@target)} to meet FD #{expected.inspect}"
+        end
+      end
+
+    private
+
+      def DateTime(str)
+        DateTime.parse(str)
+      end
+
+      def _s(target)
+        target.inspect[0..25]
+      end
+
+      def _!(msg)
+        raise msg
+      end
+
+    end # class Asserter
+  end # class Tester
+end # module Webspicy
+

data/lib/webspicy/tester/assertions.rb

@@ -0,0 +1,103 @@
+module Webspicy
+  class Tester
+    module Assertions
+
+      class InvalidArgError < StandardError; end
+
+      NO_ARG = Object.new
+
+      def exists(target, path = NO_ARG)
+        target = extract_path(target, path)
+        not target.nil?
+      end
+
+      def notExists(target, path = NO_ARG)
+        target = extract_path(target, path)
+        target.nil?
+      end
+
+      def empty(target, path = NO_ARG)
+        target = extract_path(target, path)
+        respond_to!(target, :empty?).empty?
+      end
+
+      def notEmpty(target, path = NO_ARG)
+        not empty(target, path)
+      end
+
+      def size(target, path, expected = NO_ARG)
+        path, expected = '', path if expected == NO_ARG
+        target = extract_path(target, path)
+        respond_to!(target, :size).size == expected
+      end
+
+      def idIn(target, path, expected = NO_ARG)
+        path, expected = '', path if expected == NO_ARG
+        target = extract_path(target, path)
+        ids = an_array(target).map do |tuple|
+          respond_to!(tuple, :[])[:id]
+        end
+        ids.to_set == expected.to_set
+      end
+
+      def idNotIn(target, path, expected = NO_ARG)
+        path, expected = '', path if expected == NO_ARG
+        target = extract_path(target, path)
+        ids = an_array(target).map do |tuple|
+          respond_to!(tuple, :[])[:id]
+        end
+        (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
+        target = extract_path(target, path)
+        found = an_array(target).find{|t| t[:id] == id }
+        expected.keys.all?{|k|
+          value_equal(expected[k], found[k])
+        }
+      end
+
+      def pathFD(target, path, expected)
+        target = extract_path(target, path)
+        expected.keys.all?{|k|
+          value_equal(expected[k], target[k])
+        }
+      end
+
+    private
+
+      def extract_path(target, path = NO_ARG)
+        return target if path.nil? or path==NO_ARG or path.empty?
+        return nil unless target.is_a?(Hash)
+        path.split('/').inject(target) do |memo,key|
+          memo && (memo.is_a?(Array) ? memo[key.to_i] : memo[key.to_sym])
+        end
+      end
+
+      def respond_to!(target, method)
+        unless target.respond_to?(method)
+          raise InvalidArgError, "Expecting instance responding to #{method}"
+        end
+        target
+      end
+
+      def an_array(target)
+        target.is_a?(Array) ? target : [target]
+      end
+
+      def value_equal(exp, got)
+        case exp
+        when Hash
+          exp.all?{|(k,v)| got[k] == v }
+        else
+          exp == got
+        end
+      end
+
+    end # module Assertions
+  end # class Tester
+end # module Webspicy