webspicy 0.15.4 → 0.16.0

data/lib/webspicy/mocker.rb

@@ -29,8 +29,8 @@ module Webspicy
 
     def has_service?(path)
       config.each_scope do |scope|
-        scope.each_resource do |resource|
-          next unless url_matches?(resource, path)
+        scope.each_specification do |specification|
+          next unless url_matches?(specification, path)
           return true
         end
       end
@@ -39,9 +39,9 @@ module Webspicy
 
     def find_service(method, path)
       config.each_scope do |scope|
-        scope.each_resource do |resource|
-          next unless url_matches?(resource, path)
-          scope.each_service(resource) do |service|
+        scope.each_specification do |specification|
+          next unless url_matches?(specification, path)
+          scope.each_service(specification) do |service|
             return service if service.method == method
           end
         end
@@ -71,8 +71,8 @@ module Webspicy
       end
     end
 
-    def url_matches?(resource, path)
-      resource.url_pattern.match(path)
+    def url_matches?(specification, path)
+      specification.url_pattern.match(path)
     end
 
     def random_body(service, request)
@@ -85,4 +85,4 @@ module Webspicy
     end
 
   end # class Mocker
-end # module Webspicy
+end # module Webspicy

data/lib/webspicy/openapi.rb

@@ -0,0 +1 @@
+require_relative 'openapi/generator'

data/lib/webspicy/openapi/generator.rb

@@ -0,0 +1,127 @@
+require "finitio/generation"
+require "finitio/json_schema"
+module Webspicy
+  module Openapi
+    class Generator
+
+      def initialize(config)
+        @config = Configuration.dress(config)
+        @generator = config.generator || Finitio::Generation.new
+      end
+      attr_reader :config, :generator
+
+      def call
+        {
+          openapi: "3.0.2",
+          info: {
+            version: "1.0.0",
+            title: "Hello API"
+          },
+          paths: paths
+        }
+      end
+
+    private
+
+      def paths
+        config.each_scope.inject({}) do |paths,scope|
+          scope.each_specification.inject(paths) do |paths,specification|
+            paths.merge(path_for(specification)){|k,ps,qs|
+              ps.merge(qs)
+            }
+          end
+        end
+      end
+
+      def path_for(specification)
+        {
+          specification.url => {
+            summary: specification.name
+          }.merge(verbs_for(specification))
+        }
+      end
+
+      def verbs_for(specification)
+        specification.services.inject({}) do |verbs,service|
+          verb = service.method.downcase
+          verb_defn = {
+            description: service.description,
+            responses: responses_for(service)
+          }
+          unless ["get", "options", "delete", "head"].include?(verb)
+            verb_defn[:requestBody] = request_body_for(service)
+          end
+          verbs.merge({ verb => verb_defn })
+        end
+      end
+
+      def request_body_for(service)
+        schema = actual_input_schema(service)
+        {
+          required: true,
+          content: {
+            "application/json" => {
+              schema: schema.to_json_schema,
+              example: generator.call(schema, {})
+            }
+          }
+        }
+      end
+
+      def responses_for(service)
+        result = {}
+        service.examples.each_with_object(result) do |test_case, rs|
+          rs.merge!(response_for(test_case, false)){|k,r1,r2| r1 }
+        end
+        service.counterexamples.each_with_object(result) do |test_case, rs|
+          rs.merge!(response_for(test_case, true)){|k,r1,r2| r1 }
+        end
+        result
+      end
+
+      def response_for(test_case, counterexample)
+        res = {
+          description: test_case.description,
+        }
+        status = (test_case.expected_status && test_case.expected_status.to_int) || 200
+        if test_case.expected_content_type && status != 204
+          content = {
+            schema: schema_for(test_case, counterexample)
+          }
+          unless counterexample
+            content[:example] = example_for(test_case, counterexample)
+          end
+          res[:content] = {
+            test_case.expected_content_type => content
+          }
+        end
+        {
+          status => res
+        }
+      end
+
+      def schema_for(test_case, counterexample)
+        schema = actual_output_schema(test_case, counterexample)
+        schema.to_json_schema
+      end
+
+      def example_for(test_case, counterexample)
+        schema = actual_output_schema(test_case, counterexample)
+        generator.call(schema, {})
+      end
+
+      def actual_output_schema(test_case, counterexample)
+        if counterexample
+          test_case.service.error_schema['Main']
+        else
+          test_case.service.output_schema['Main']
+        end
+      end
+
+      def actual_input_schema(service)
+        service.input_schema['Main']
+      end
+
+    end # class Generator
+  end # module Openapi
+end # module Webspicy

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,15 @@ module Webspicy
       new(raw)
     end
 
+    def self.singleservice(raw)
+      converted = {
+        name: raw.has_key?(:name) ? raw[:name] : "Unamed specification",
+        url: raw[:url],
+        services: [raw.reject{|k, _| k == :name || k == :url}]
+      }
+      self.info(raw)
+    end
+
     def located_at!(location)
       @location = Path(location)
     end
@@ -22,6 +31,10 @@ module Webspicy
       file
     end
 
+    def name
+      @raw[:name]
+    end
+
     def url
       @raw[:url]
     end
@@ -51,6 +64,10 @@ module Webspicy
       @raw
     end
 
+    def to_singleservice
+      raise NotImplementedError
+    end
+
   private
 
     def extract_placeholder_value(params, placeholder, split = nil)
@@ -69,10 +86,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 !empty_input.empty? && 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'