webspicy 0.18.0 → 0.20.3

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/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

data/spec/unit/support/hooks/test_fire_after_each.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Webspicy
+  module Support
+    describe Hooks, "fire_after_each" do
+
+      class Hooker
+        include Hooks
+        def initialize(config)
+          @config = config
+        end
+        attr_reader :config
+      end
+
+      it 'work with no after_each at all' do
+        config = Configuration.new
+        Hooker.new(config).fire_after_each(1, 2, 3)
+      end
+
+      it 'work with one after_each' do
+        config = Configuration.new
+
+        seen_args = nil
+        config.after_each do |*args|
+          seen_args = args
+        end
+
+        Hooker.new(config).fire_after_each(1, 2, 3)
+
+        expect(seen_args).to eql([1, 2, 3])
+      end
+
+      it 'works with two after_each' do
+        config = Configuration.new
+
+        seen = false
+
+        seen_args = []
+        config.after_each do |*args|
+          seen_args << args
+        end
+        config.after_each do |*args|
+          seen_args << args
+        end
+
+        Hooker.new(config).fire_after_each(1, 2, 3)
+
+        expect(seen_args.size).to eql(2)
+        expect(seen_args.all?{|sa| sa == [1,2,3] }).to be(true)
+      end
+
+    end
+  end
+end

data/spec/unit/{tester/client/test_around.rb → support/hooks/test_fire_around.rb}

@@ -1,7 +1,15 @@
 require 'spec_helper'
 module Webspicy
-  class Tester
-    describe Client, "around" do
+  module Support
+    describe Hooks, "fire_around" do
+
+      class Hooker
+        include Hooks
+        def initialize(config)
+          @config = config
+        end
+        attr_reader :config
+      end
 
       it 'work with no around at all' do
         config = Configuration.new
@@ -9,8 +17,7 @@ module Webspicy
         seen = false
         block = ->(){ seen = true }
 
-        scope = Configuration::Scope.new(config)
-        Client.new(scope).around(1, 2, 3, &block)
+        Hooker.new(config).fire_around(1, 2, 3, &block)
         expect(seen).to be(true)
       end
 
@@ -24,11 +31,10 @@ module Webspicy
           bl.call
         end
 
-        scope = Configuration::Scope.new(config)
         block = ->(){ seen = true }
-        Client.new(scope).around(1, 2, 3, &block)
+        Hooker.new(config).fire_around(1, 2, 3, &block)
 
-        expect(seen_args[0...-1]).to eql([1, 2, 3])
+        expect(seen_args).to eql([1, 2, 3])
         expect(seen).to be(true)
       end
 
@@ -47,12 +53,11 @@ module Webspicy
           bl.call
         end
 
-        scope = Configuration::Scope.new(config)
         block = ->(){ seen = true }
-        Client.new(scope).around(1, 2, 3, &block)
+        Hooker.new(config).fire_around(1, 2, 3, &block)
 
         expect(seen_args.size).to eql(2)
-        expect(seen_args.all?{|sa| sa[0...-1] == [1,2,3] }).to be(true)
+        expect(seen_args.all?{|sa| sa == [1,2,3] }).to be(true)
         expect(seen).to be(true)
       end
 

data/spec/unit/support/hooks/test_fire_before_each.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Webspicy
+  module Support
+    describe Hooks, "fire_before_each" do
+
+      class Hooker
+        include Hooks
+        def initialize(config)
+          @config = config
+        end
+        attr_reader :config
+      end
+
+      it 'work with no before_each at all' do
+        config = Configuration.new
+        Hooker.new(config).fire_before_each(1, 2, 3)
+      end
+
+      it 'work with one before_each' do
+        config = Configuration.new
+
+        seen_args = nil
+        config.before_each do |*args|
+          seen_args = args
+        end
+
+        Hooker.new(config).fire_before_each(1, 2, 3)
+
+        expect(seen_args).to eql([1, 2, 3])
+      end
+
+      it 'works with two before_each' do
+        config = Configuration.new
+
+        seen = false
+
+        seen_args = []
+        config.before_each do |*args|
+          seen_args << args
+        end
+        config.before_each do |*args|
+          seen_args << args
+        end
+
+        Hooker.new(config).fire_before_each(1, 2, 3)
+
+        expect(seen_args.size).to eql(2)
+        expect(seen_args.all?{|sa| sa == [1,2,3] }).to be(true)
+      end
+
+    end
+  end
+end