webspicy 0.15.7 → 0.16.3

data/lib/webspicy/configuration/scope.rb

@@ -0,0 +1,162 @@
+module Webspicy
+  class Configuration
+    class Scope
+
+      def initialize(config)
+        @config = config
+      end
+      attr_reader :config
+
+      def preconditions
+        config.preconditions
+      end
+
+      def postconditions
+        config.postconditions
+      end
+
+      ###
+      ### Eachers -- Allow navigating the web service definitions
+      ###
+
+      # Yields each specification file in the current scope
+      def each_specification_file(&bl)
+        return enum_for(:each_specification_file) unless block_given?
+        _each_specification_file(config, &bl)
+      end
+
+      # Recursive implementation of `each_specification_file` for each
+      # folder in the configuration.
+      def _each_specification_file(config)
+        folder = config.folder
+        folder.glob("**/*.yml").select(&to_filter_proc(config.file_filter)).each do |file|
+          yield file, folder
+        end
+      end
+      private :_each_specification_file
+
+      # Yields each specification in the current scope in turn.
+      def each_specification(&bl)
+        return enum_for(:each_specification) unless block_given?
+        each_specification_file do |file, folder|
+          yield Webspicy.specification(file.load, file, self)
+        end
+      end
+
+      def each_service(specification, &bl)
+        specification.services.select(&to_filter_proc(config.service_filter)).each(&bl)
+      end
+
+      def each_example(service, &bl)
+        service.examples
+          .map{|e| expand_example(service, e) }
+          .select(&to_filter_proc(config.test_case_filter))
+          .each(&bl) if config.run_examples?
+      end
+
+      def each_counterexamples(service, &bl)
+        service.counterexamples
+          .map{|e| expand_example(service, e) }
+          .select(&to_filter_proc(config.test_case_filter))
+          .each(&bl) if config.run_counterexamples?
+      end
+
+      def each_generated_counterexamples(service, &bl)
+        Webspicy.with_scope(self) do
+          service.generated_counterexamples
+            .map{|e| expand_example(service, e) }
+            .select(&to_filter_proc(config.test_case_filter))
+            .each(&bl) if config.run_generated_counterexamples?
+        end if config.run_generated_counterexamples?
+      end
+
+      def each_testcase(service, &bl)
+        each_example(service, &bl)
+        each_counterexamples(service, &bl)
+        each_generated_counterexamples(service, &bl)
+      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 ||= config.data_system
+      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.
+      #
+      # When no host resolved on the configuration and the url is not
+      # already an absolute URL, yields the block if given, or raise
+      # an exception.
+      def to_real_url(url, test_case = nil, &bl)
+        case config.host
+        when Proc
+          config.host.call(url, test_case)
+        when String
+          url =~ /^http/ ? url : "#{config.host}#{url}"
+        else
+          return url if url =~ /^http/
+          return yield(url) if block_given?
+          raise "Unable to resolve `#{url}` : no host resolver provided\nSee `Configuration#host="
+        end
+      end
+
+      ###
+      ### Private methods
+      ###
+
+      private
+
+        def expand_example(service, example)
+          return example unless service.default_example
+          h1 = service.default_example.to_info
+          h2 = example.to_info
+          ex = Specification::TestCase.new(merge_maps(h1, h2))
+          ex.bind(service, example.counterexample?)
+        end
+
+        def merge_maps(h1, h2)
+          h1.merge(h2) do |k,v1,v2|
+            case v1
+            when Hash  then merge_maps(v1, v2)
+            when Array then v1 + v2
+            else v2
+            end
+          end
+        end
+
+        # 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 # class Scope
+  end # class Configuration
+end # module Webspicy

data/lib/webspicy/configuration/single_url.rb

@@ -0,0 +1,58 @@
+module Webspicy
+  class Configuration
+    class SingleUrl
+
+      class SingleUrlScope < Scope
+
+        def initialize(config, url)
+          super(config)
+          @url = url
+        end
+        attr_reader :url
+
+        def each_specification(&bl)
+          return enum_for(:each_specification) unless block_given?
+          spec = <<~YML
+          ---
+          name: |-
+            Default specification
+          url: |-
+            #{url}
+
+          services:
+          - method: |-
+              GET
+            description: |-
+              Getting #{url}
+
+            input_schema: |-
+              Any
+            output_schema: |-
+              Any
+            error_schema: |-
+              Any
+
+            examples:
+              - description: |-
+                  it returns a 200
+                params: {}
+                expected:
+                  status: 200
+          YML
+          Webspicy.debug(spec)
+          yield Webspicy.specification(spec, nil, self)
+        end
+
+      end # class SingleUrlScope
+
+      def initialize(url)
+        @url = url
+      end
+
+      def call(config)
+        SingleUrlScope.new(config, @url)
+      end
+
+    end # class SingleUrl
+  end # class Configuration
+end # module Webspicy

data/lib/webspicy/configuration/single_yml_file.rb

@@ -0,0 +1,30 @@
+module Webspicy
+  class Configuration
+    class SingleYmlFile
+
+      class SingleYmlFileScope < Scope
+
+        def initialize(config, file)
+          super(config)
+          @file = file
+        end
+        attr_reader :file
+
+        def each_specification(&bl)
+          return enum_for(:each_specification) unless block_given?
+          yield Webspicy.specification(file.read, nil, self)
+        end
+
+      end # class SingleYmlFileScope
+
+      def initialize(file)
+        @file = file
+      end
+
+      def call(config)
+        SingleYmlFileScope.new(config, @file)
+      end
+
+    end # class SingleYmlFile
+  end # class Configuration
+end # module Webspicy

data/lib/webspicy/formaldoc.fio

@@ -17,15 +17,30 @@ FileUpload =
         param_name   :? String
     }
 
-Resource =
-    .Webspicy::Resource <info> {
-        name: String
-        url: String
-        services: [Service]
-    }
+Specification = .Webspicy::Specification
+  <singleservice> {
+    name            :? String
+    url             :  String
+    method          :  Method
+    description     :  String
+    preconditions   :? [String]|String
+    postconditions  :? [String]|String
+    input_schema    :  Schema
+    output_schema   :  Schema
+    error_schema    :  Schema
+    blackbox        :? String
+    default_example :? TestCase
+    examples        :? [TestCase]
+    counterexamples :? [TestCase]
+  }
+  <info> {
+    name: String
+    url: String
+    services: [Service]
+  }
 
 Service =
-    .Webspicy::Resource::Service <info> {
+    .Webspicy::Specification::Service <info> {
         method          :  Method
         description     :  String
         preconditions   :? [String]|String
@@ -40,7 +55,7 @@ Service =
     }
 
 TestCase =
-    .Webspicy::Resource::Service::TestCase <info> {
+    .Webspicy::Specification::TestCase <info> {
         description      :? String
         dress_params     :? Boolean
         params           :? Params

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/mocker/config.ru

@@ -0,0 +1,5 @@
+require "webspicy"
+require "webspicy/mocker"
+require 'rack'
+config = Webspicy::Configuration.dress(Path("/formalspec/"))
+run Webspicy::Mocker.new(config)

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