webspicy 0.18.0 → 0.19.0

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/test_condition.rb

@@ -0,0 +1,26 @@
+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 '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

data/spec/unit/support/world/fixtures/array.json

@@ -0,0 +1,8 @@
+[
+  {
+    "name": "foo"
+  },
+  {
+    "name": "bar"
+  }
+]

data/spec/unit/support/world/fixtures/queue.rb

@@ -0,0 +1 @@
+Webspicy::SpecTests::Queue.new

data/spec/unit/support/world/fixtures/single.json

@@ -0,0 +1,11 @@
+{
+  "id": 1,
+  "name": "single",
+  "version": {
+    "major": "1",
+    "minor": "0"
+  },
+  "hobbies": [
+    { "name": "programming"}
+  ]
+}

data/spec/unit/support/world/fixtures/yaml.yml

@@ -0,0 +1,3 @@
+---
+id: 3
+name: 'YAML'

data/spec/unit/support/world/test_world.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Webspicy
+  module SpecTests
+    class Queue
+      include Webspicy::Support::World::Item
+
+    end
+  end
+end
+
+module Webspicy
+  module Support
+    describe World do
+
+      let(:config){
+        Configuration.new(restful_folder)
+      }
+
+      subject do
+        World.new Path.dir/"fixtures", config
+      end
+
+      it 'supports single objects' do
+        expect(subject.single.name).to eql("single")
+        expect(subject.single.version.minor).to eql("0")
+        expect(subject.single.hobbies[0].name).to eql("programming")
+      end
+
+      it 'supports yaml too' do
+        expect(subject.yaml.name).to eql("YAML")
+      end
+
+      it 'supports arrays' do
+        expect(subject.array[0].name).to eql("foo")
+        expect(subject.array[1].name).to eql("bar")
+      end
+
+      it 'allows setting new attributes on itself' do
+        subject.foo = "bar"
+        expect(subject.foo).to eql("bar")
+      end
+
+      it 'allows setting new attributes on existing objects' do
+        subject.single.foo = "bar"
+        expect(subject.single.foo).to eql("bar")
+      end
+
+      it 'supports ruby files and evaluates them' do
+        q = subject.queue
+        expect(q).to be_a(Webspicy::SpecTests::Queue)
+        expect(q.config).to be(config)
+      end
+    end
+  end
+end

data/spec/unit/test_configuration.rb

@@ -48,6 +48,11 @@ module Webspicy
         expect(c.each_scope.to_a.first.each_specification.to_a.size).to eql(1)
       end
 
+      it 'exposes the world as a World instance' do
+        c = Configuration.dress(restful_folder)
+        expect(c.world).to be_a(Support::World)
+      end
+
       it 'yields the block with the configuration, if given' do
         seen = nil
         Configuration.dress(Path.dir/'configuration'){|c|
@@ -106,6 +111,7 @@ module Webspicy
         ENV['ROBUST'] = 'yes'
         config = Configuration.new
         expect(config.run_counterexamples?).to eql(true)
+        ENV.delete('ROBUST')
       end
 
       it 'ignores the environment is set explicitly' do
@@ -114,6 +120,7 @@ module Webspicy
           c.run_counterexamples = false
         end
         expect(config.run_counterexamples?).to eql(false)
+        ENV.delete('ROBUST')
       end
     end
 
@@ -130,6 +137,7 @@ module Webspicy
         expect(config.file_filter).to be_a(Regexp)
         expect(config.file_filter).to match("foo/bar/getTodo.yml")
         expect(config.file_filter).not_to match("foo/bar/getTodos.yml")
+        ENV.delete('RESOURCE')
       end
 
       it 'allows expressing a no match' do
@@ -138,6 +146,7 @@ module Webspicy
         expect(config.file_filter).to be_a(Proc)
         expect(config.file_filter.call("foo/bar/getTodos.yml")).to eq(true)
         expect(config.file_filter.call("foo/bar/getTodo.yml")).to eq(false)
+        ENV.delete('RESOURCE')
       end
 
       it 'ignores the environment if set explicitly' do
@@ -146,6 +155,7 @@ module Webspicy
           c.file_filter = nil
         end
         expect(config.file_filter).to be_nil
+        ENV.delete('RESOURCE')
       end
     end
 
@@ -160,6 +170,7 @@ module Webspicy
         ENV['METHOD'] = 'GET'
         config = Configuration.new
         expect(config.service_filter).to be_a(Proc)
+        ENV.delete('METHOD')
       end
 
       it 'ignores the environment is set explicitly' do
@@ -168,6 +179,36 @@ module Webspicy
           c.service_filter = nil
         end
         expect(config.service_filter).to be_nil
+        ENV.delete('METHOD')
+      end
+    end
+
+    describe 'insecure' do
+
+      it 'is false by default' do
+        config = Configuration.new
+        expect(config.insecure).to eql(false)
+      end
+
+      it 'is true if INSECURE is set to yes' do
+        ENV['INSECURE'] = 'yes'
+        config = Configuration.new
+        expect(config.insecure).to eql(true)
+        ENV.delete('INSECURE')
+      end
+
+      it 'is true if INSECURE is set to 1' do
+        ENV['INSECURE'] = '1'
+        config = Configuration.new
+        expect(config.insecure).to eql(true)
+        ENV.delete('INSECURE')
+      end
+
+      it 'is false if INSECURE is set to no' do
+        ENV['INSECURE'] = 'no'
+        config = Configuration.new
+        expect(config.insecure).to eql(false)
+        ENV.delete('INSECURE')
       end
     end
 
@@ -187,48 +228,56 @@ module Webspicy
         ENV['TAG'] = 'foo'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(true)
+        ENV.delete('TAG')
       end
 
       it 'allows no matching a single tag' do
         ENV['TAG'] = 'baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(false)
+        ENV.delete('TAG')
       end
 
       it 'allows setting multiple tags' do
         ENV['TAG'] = 'foo,baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(true)
+        ENV.delete('TAG')
       end
 
       it 'allows no matching any of multiple tags' do
         ENV['TAG'] = 'foi,baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(false)
+        ENV.delete('TAG')
       end
 
       it 'allows setting a single negative tag' do
         ENV['TAG'] = '!foo'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(false)
+        ENV.delete('TAG')
       end
 
       it 'allows not matching a single negative tag' do
         ENV['TAG'] = '!baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(true)
+        ENV.delete('TAG')
       end
 
       it 'allows mixing positive & negative tags and have a match' do
         ENV['TAG'] = 'foo,!baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(true)
+        ENV.delete('TAG')
       end
 
       it 'allows mixing positive & negative tags and have no match' do
         ENV['TAG'] = 'foo,!bar'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(false)
+        ENV.delete('TAG')
       end
 
     end