webspicy 0.16.3 → 0.20.1

data/lib/webspicy/{tester → web}/client/rack_test_client.rb

@@ -1,5 +1,5 @@
 module Webspicy
-  class Tester
+  module Web
     class RackTestClient < Client
 
       def self.for(app)
@@ -12,7 +12,7 @@ module Webspicy
       end
       attr_reader :api
 
-      def call(test_case)
+      def _call(test_case)
         service, specification = test_case.service, test_case.specification
 
         # Instantiate the parameters
@@ -184,5 +184,5 @@ module Webspicy
       end # class Api
 
     end # class RackTestClient
-  end # class Client
+  end # module Web
 end # module Webspicy

data/lib/webspicy/{tester → web}/client/support.rb

@@ -1,6 +1,6 @@
 module Webspicy
-  class Tester
-    class Client
+  module Web
+    class Client < Tester::Client
       module Support
         include Webspicy::Support::Colorize
 

data/lib/webspicy/web/invocation.rb

@@ -0,0 +1,68 @@
+module Webspicy
+  module Web
+    class Invocation < Tester::Invocation
+
+      ### Getters on response
+
+      def response_code
+        code = response.status
+        code = code.code unless code.is_a?(Integer)
+        code
+      end
+
+      ### Query methods
+
+      def done?
+        !response.nil?
+      end
+
+      def is_expected_success?
+        test_case.expected_status.to_i >= 200 && test_case.expected_status.to_i < 300
+      end
+
+      def is_success?
+        response_code >= 200 && response_code < 300
+      end
+
+      def is_empty_response?
+        response_code == 204
+      end
+
+      def is_redirect?
+        response_code >= 300 && response_code < 400
+      end
+
+      def raw_output
+        response.body.to_s
+      end
+
+      def is_structured_output?
+        ct = response.content_type || test_case.expected_content_type
+        ct = ct.mime_type if ct.respond_to?(:mime_type)
+        ct =~ /json/
+      end
+
+      def loaded_output
+        if is_structured_output?
+          raise "Body empty while expected" if raw_output.empty?
+          @loaded_output ||= ::JSON.parse(response.body)
+        else
+          raw_output
+        end
+      end
+      alias :loaded_body :loaded_output
+
+      def output
+        schema = is_expected_success? ? service.output_schema : service.error_schema
+        begin
+          schema.dress(loaded_output)
+        rescue Finitio::TypeError => ex
+          ex
+        end
+      end
+      alias :dressed_body :output
+      alias :error :output
+
+    end # class Invocation
+  end # module Web
+end # module Webspicy

data/lib/webspicy/web/mocker.rb

@@ -0,0 +1,90 @@
+require "finitio/generation"
+require "json"
+module Webspicy
+  module Web
+    class Mocker
+
+      def initialize(config)
+        @config = Configuration.dress(config)
+        @generator = config.generator || Finitio::Generation.new
+      end
+      attr_reader :config, :generator
+
+      def call(env)
+        req = Rack::Request.new(env)
+        path = req.path
+        meth = req.request_method
+        if meth == "OPTIONS" && has_service?(path)
+          [204, {}, []]
+        elsif service = find_service(meth, path)
+          status = best_status_code(service)
+          body = status == 204 ? "" : random_body(service, req)
+          headers = generate_headers(service)
+          [ status, headers, [ body ].compact ]
+        else
+          [404, {}, []]
+        end
+      end
+
+    private
+
+      def has_service?(path)
+        config.each_scope do |scope|
+          scope.each_specification do |specification|
+            next unless url_matches?(specification, path)
+            return true
+          end
+        end
+        return false
+      end
+
+      def find_service(method, path)
+        config.each_scope do |scope|
+          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
+        end
+        nil
+      end
+
+      def generate_headers(service)
+        {
+          "Content-Type" => best_content_type(service)
+        }.delete_if{|k,v| v.nil? }
+      end
+
+      def best_status_code(service)
+        if ex = service.examples.first
+          (ex.expected_status && ex.expected_status.to_i) || 200
+        else
+          200
+        end
+      end
+
+      def best_content_type(service)
+        if ex = service.examples.first
+          ex.expected_content_type
+        else
+          "application/json"
+        end
+      end
+
+      def url_matches?(specification, path)
+        specification.url_pattern.match(path)
+      end
+
+      def random_body(service, request)
+        world = OpenStruct.new({
+          service: service,
+          request: request
+        })
+        data = generator.call(service.output_schema.main, world)
+        JSON.pretty_generate(data) if data
+      end
+
+    end # class Mocker
+  end # module Web
+end # module Webspicy

data/lib/webspicy/{mocker → web/mocker}/config.ru

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

data/lib/webspicy/web/openapi/generator.rb

@@ -0,0 +1,129 @@
+require "finitio/generation"
+require "finitio/json_schema"
+module Webspicy
+  module Web
+    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 Web
+end # module Webspicy

data/spec/unit/configuration/scope/test_each_service.rb

@@ -19,7 +19,7 @@ module Webspicy
 
         let(:configuration) {
           Configuration.new(restful_folder){|c|
-            c.file_filter = /getTodo.yml/
+            c.file_filter = /get.yml/
           }
         }
 
@@ -32,7 +32,7 @@ module Webspicy
 
         let(:configuration) {
           Configuration.new(restful_folder){|c|
-            c.file_filter = /getTodo.yml/
+            c.file_filter = /get.yml/
             c.service_filter = ->(s) {
               s.method == "POST"
             }

data/spec/unit/configuration/scope/test_each_specification.rb

@@ -27,13 +27,13 @@ module Webspicy
         let(:configuration) {
           Configuration.new(restful_folder){|c|
             c.file_filter = ->(f) {
-              f.basename.to_s == "getTodo.yml"
+              f.basename.to_s == "get.yml"
             }
           }
         }
 
-        it 'returns only that file' do
-          expect(subject.size).to eql(1)
+        it 'returns only that files' do
+          expect(subject.size).to eql(2)
         end
       end
 
@@ -41,12 +41,12 @@ module Webspicy
 
         let(:configuration) {
           Configuration.new(restful_folder){|c|
-            c.file_filter = /getTodo.yml/
+            c.file_filter = /get.yml/
           }
         }
 
-        it 'returns only that file' do
-          expect(subject.size).to eql(1)
+        it 'returns only that files' do
+          expect(subject.size).to eql(2)
         end
       end
 
@@ -54,7 +54,7 @@ module Webspicy
 
         let(:configuration) {
           Configuration.new(restful_folder) do |c|
-            c.folder 'todo'
+            c.folder 'formaldef/todo'
           end
         }
 

data/spec/unit/specification/{precondition → pre}/test_global_request_headers.rb

@@ -2,16 +2,21 @@ require 'spec_helper'
 
 module Webspicy
   class Specification
-    module Precondition
+    module Pre
       describe GlobalRequestHeaders do
         let(:gbr){
           GlobalRequestHeaders.new('Accept' => 'application/json')
         }
 
+        def instrument(tc)
+          t = OpenStruct.new(test_case: tc)
+          gbr.bind(t).instrument
+        end
+
         describe "instrument" do
           it 'injects the headers' do
             tc = TestCase.new({})
-            gbr.instrument(tc, nil)
+            instrument(tc)
             expect(tc.headers['Accept']).to eql("application/json")
           end
 
@@ -21,7 +26,7 @@ module Webspicy
                 'Content-Type' => 'text/plain'
               }
             })
-            gbr.instrument(tc, nil)
+            instrument(tc)
             expect(tc.headers['Content-Type']).to eql("text/plain")
             expect(tc.headers['Accept']).to eql("application/json")
           end
@@ -32,7 +37,7 @@ module Webspicy
                 'Accept' => 'text/plain'
               }
             })
-            gbr.instrument(tc, nil)
+            instrument(tc)
             expect(tc.headers['Accept']).to eql("text/plain")
           end
         end

data/spec/unit/specification/test_condition.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+module Webspicy
+  class Specification
+    describe Condition do
+      describe "sooner_or_later" do
+        include Condition
+
+        it 'works when the block returns anything non falsy' do
+          x = sooner_or_later(max: 1){ 12 }
+          expect(x).to eql(12)
+        end
+
+        it 'returns nil otherwise' do
+          x = sooner_or_later(max: 1){ nil }
+          expect(x).to eql(nil)
+        end
+
+        it 'supports the block raising a Failure' do
+          expect {
+            sooner_or_later(max: 2){
+              raise Tester::Failure
+            }
+          }.to raise_error(Tester::Failure)
+        end
+
+        it 'catches Failure occuring before successes' do
+          seen = 0
+          x = sooner_or_later(max: 2){
+              seen += 1
+            raise Tester::Failure if seen == 1
+            12
+          }
+          expect(x).to eql(12)
+        end
+
+        it 'can raise for us' do
+          expect{
+            sooner_or_later(max: 1, raise: true){ nil }
+          }.to raise_error(TimeoutError)
+        end
+      end
+    end
+  end
+end