webspicy 0.15.7 → 0.16.3

data/lib/webspicy/{resource.rb → specification.rb}

@@ -1,5 +1,5 @@
 module Webspicy
-  class Resource
+  class Specification
 
     def initialize(raw, location = nil)
       @raw = raw
@@ -12,6 +12,17 @@ module Webspicy
       new(raw)
     end
 
+    def self.singleservice(raw)
+      converted = {
+        name: raw[:name] || "Unamed specification",
+        url: raw[:url],
+        services: [
+          Webspicy.service(raw.reject{|k| k==:url or k==:name }, Webspicy.current_scope)
+        ]
+      }
+      info(converted)
+    end
+
     def located_at!(location)
       @location = Path(location)
     end
@@ -22,6 +33,10 @@ module Webspicy
       file
     end
 
+    def name
+      @raw[:name]
+    end
+
     def url
       @raw[:url]
     end
@@ -51,6 +66,10 @@ module Webspicy
       @raw
     end
 
+    def to_singleservice
+      raise NotImplementedError
+    end
+
   private
 
     def extract_placeholder_value(params, placeholder, split = nil)
@@ -69,10 +88,14 @@ module Webspicy
 
     def bind_services
       (@raw[:services] ||= []).each do |s|
-        s.resource = self
+        s.specification = self
       end
     end
 
-  end
-end
-require_relative 'resource/service'
+  end # class Specification
+end # module Webspicy
+require_relative 'specification/service'
+require_relative 'specification/precondition'
+require_relative 'specification/postcondition'
+require_relative 'specification/test_case'
+require_relative 'specification/file_upload'

data/lib/webspicy/specification/file_upload.rb

@@ -0,0 +1,37 @@
+module Webspicy
+  class Specification
+    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(specification)
+        FileUpload.new({
+          path: specification.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 # class Specification
+end # module Webspicy

data/lib/webspicy/specification/postcondition.rb

@@ -0,0 +1,16 @@
+module Webspicy
+  class Specification
+    module Postcondition
+
+      def self.match(service, descr)
+      end
+
+      def instrument(test_case, client)
+      end
+
+      def check(invocation)
+      end
+
+    end # module Postcondition
+  end # module Specification
+end # module Webspicy

data/lib/webspicy/specification/precondition.rb

@@ -0,0 +1,19 @@
+module Webspicy
+  class Specification
+    module Precondition
+
+      def self.match(service, pre)
+      end
+
+      def instrument(test_case, client)
+      end
+
+      def counterexamples(service)
+        []
+      end
+
+    end # module Precondition
+  end # class Specification
+end # module Webspicy
+require_relative 'precondition/global_request_headers'
+require_relative 'precondition/robust_to_invalid_input'

data/lib/webspicy/specification/precondition/global_request_headers.rb

@@ -0,0 +1,35 @@
+module Webspicy
+  class Specification
+    module Precondition
+      class GlobalRequestHeaders
+        include Precondition
+
+        DEFAULT_OPTIONS = {}
+
+        def initialize(headers, options = {}, &bl)
+          @headers = headers
+          @options = DEFAULT_OPTIONS.merge(options)
+          @matcher = bl
+        end
+        attr_reader :headers, :matcher
+
+        def match(service, pre)
+          if matcher
+            return self if matcher.call(service)
+            nil
+          else
+            self
+          end
+        end
+
+        def instrument(test_case, client)
+          extra = headers.reject{|k|
+            test_case.headers.has_key?(k)
+          }
+          test_case.headers.merge!(extra)
+        end
+
+      end # class GlobalRequestHeaders
+    end # module Precondition
+  end # class Specification
+end # module Webspicy

data/lib/webspicy/specification/precondition/robust_to_invalid_input.rb

@@ -0,0 +1,68 @@
+module Webspicy
+  class Specification
+    module Precondition
+      class RobustToInvalidInput
+        include Precondition
+
+        def self.match(service, pre)
+          self.new
+        end
+
+        def match(service, pre)
+          self
+        end
+
+        def counterexamples(service)
+          spec = service.specification
+          first = service.examples.first
+          cexamples = []
+          cexamples += url_randomness_counterexamples(service, first) if first
+          cexamples += empty_input_counterexamples(service, first) if first
+          cexamples
+        end
+
+      protected
+
+        def url_randomness_counterexamples(service, first)
+          service.specification.url_placeholders.map{|p|
+            first.mutate({
+              :description => "it is robust to URL randomness on param `#{p}` (RobustToInvalidInput)",
+              :dress_params => false,
+              :params => first.params.merge(p => (SecureRandom.random_number * 100000000).to_i),
+              :expected => {
+                status: Support::StatusRange.str("4xx")
+              },
+              :assert => []
+            })
+          }
+        end
+
+        def empty_input_counterexamples(service, first)
+          placeholders = service.specification.url_placeholders
+          empty_input = first.params.reject{|k| !placeholders.include?(k) }
+          if invalid_input?(service, empty_input)
+            [first.mutate({
+              :description => "it is robust to an invalid empty input (RobustToInvalidInput)",
+              :dress_params => false,
+              :params => empty_input,
+              :expected => {
+                status: Support::StatusRange.str("4xx")
+              },
+              :assert => []
+            })]            
+          else
+            []
+          end
+        end
+
+        def invalid_input?(service, empty_input)
+          service.input_schema.dress(empty_input)
+          false
+        rescue Finitio::Error
+          true
+        end
+
+      end # class RobustToInvalidInput
+    end # module Precondition
+  end # class Specification
+end # module Webspicy

data/lib/webspicy/{resource → specification}/service.rb

@@ -1,5 +1,5 @@
 module Webspicy
-  class Resource
+  class Specification
     class Service
 
       def initialize(raw)
@@ -9,7 +9,7 @@ module Webspicy
         @preconditions = compile_preconditions
         @postconditions = compile_postconditions
       end
-      attr_accessor :resource
+      attr_accessor :specification
 
       def self.info(raw)
         new(raw)
@@ -19,6 +19,10 @@ module Webspicy
         @raw[:method]
       end
 
+      def description
+        @raw[:description]
+      end
+
       def preconditions
         @preconditions
       end
@@ -77,7 +81,7 @@ module Webspicy
       end
 
       def to_s
-        "#{method} #{resource.url}"
+        "#{method} #{specification.url}"
       end
 
     private
@@ -97,6 +101,9 @@ module Webspicy
       end
 
       def compile_conditions(descriptions, conditions)
+        # Because we want pre & post to be able to match in all cases
+        # we need at least one condition
+        descriptions = ["all"] if descriptions.empty?
         descriptions
           .map{|descr|
             conditions.map{|c| c.match(self, descr) }.compact
@@ -117,7 +124,5 @@ module Webspicy
       end
 
     end # class Service
-  end # class Resource
+  end # class Specification
 end # module Webspicy
-require_relative 'service/test_case'
-require_relative 'service/invocation'

data/lib/webspicy/specification/test_case.rb

@@ -0,0 +1,139 @@
+module Webspicy
+  class Specification
+    class TestCase
+
+      def initialize(raw)
+        @raw = raw
+        @counterexample = nil
+      end
+      attr_reader :service
+      attr_reader :counterexample
+
+      attr_accessor :raw
+      protected :raw, :raw=
+
+      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 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 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,2 @@
 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