webspicy 0.1.0.pre.rc1

data/lib/webspicy/tester.rb

@@ -0,0 +1,96 @@
+module Webspicy
+  class Tester
+
+    def initialize(config)
+      @config = config
+    end
+    attr_reader :config
+
+    def call
+      Webspicy.with_scope_for(config) do |scope|
+        client = scope.get_client
+        scope.each_resource do |resource|
+          scope.each_service(resource) do |service|
+            RSpec.describe "#{service.method} `#{resource.url}`" do
+              scope.each_example(service) do |test_case|
+                describe test_case.description do
+
+                  before(:each) do
+                    client.before(test_case, service, resource)
+                  end
+
+                  subject do
+                    client.call(test_case, service, resource)
+                  end
+
+                  it 'can be invoked successfuly' do
+                    expect(subject.done?).to eq(true)
+                  end
+
+                  it 'meets the status and content type specification' do
+                    expect(subject.expected_status_unmet).to(be_nil)
+                    expect(subject.expected_content_type_unmet).to(be_nil)
+                  end
+
+                  it 'has the expected response headers' do
+                    expect(subject.expected_headers_unmet).to(be_nil)
+                  end if test_case.has_expected_headers?
+
+                  it 'meets the output data schema' do
+                    expect(subject.expected_schema_unmet).to(be_nil)
+                  end
+
+                  it 'meets all assertions' do
+                    expect(subject.assertions_unmet).to(be_nil)
+                  end if test_case.has_assertions?
+
+                end
+              end # service.examples
+
+              scope.each_counterexamples(service) do |test_case|
+                describe test_case.description do
+
+                  before(:each) do
+                    client.before(test_case, service, resource)
+                  end
+
+                  subject do
+                    client.call(test_case, service, resource)
+                  end
+
+                  it 'can be invoked successfuly' do
+                    expect(subject.done?).to eq(true)
+                  end
+
+                  it 'meets the status and content type specification' do
+                    expect(subject.expected_status_unmet).to(be_nil)
+                    expect(subject.expected_content_type_unmet).to(be_nil)
+                  end
+
+                  it 'has the expected response headers' do
+                    expect(subject.expected_headers_unmet).to(be_nil)
+                  end if test_case.has_expected_headers?
+
+                  it 'meets the output data schema' do
+                    expect(subject.expected_schema_unmet).to(be_nil)
+                  end
+
+                  it 'meets all assertions' do
+                    expect(subject.assertions_unmet).to(be_nil)
+                  end if test_case.has_assertions?
+
+                  it 'has expected error' do
+                    expect(subject.expected_error_unmet).to(be_nil)
+                  end if test_case.has_expected_error?
+
+                end
+              end
+            end
+          end
+        end
+        RSpec::Core::Runner.run config.rspec_options
+      end
+    end
+
+  end # class Tester
+end # module Webspicy

data/lib/webspicy/version.rb

@@ -0,0 +1,8 @@
+module Webspicy
+  module Version
+    TINY  = "0-rc1"
+    MINOR = 1
+    MAJOR = 0
+  end
+  VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
+end

data/lib/webspicy.rb

@@ -0,0 +1,112 @@
+require 'http'
+require 'json'
+require 'path'
+require 'finitio'
+require 'logger'
+require 'ostruct'
+require 'yaml'
+require 'rspec'
+module Webspicy
+
+  ###
+  ### Load library
+  ###
+
+  require 'webspicy/configuration'
+  require 'webspicy/scope'
+  require 'webspicy/client'
+  require 'webspicy/client/http_client'
+  require 'webspicy/resource'
+  require 'webspicy/checker'
+  require 'webspicy/tester'
+  require 'webspicy/tester/assertions'
+  require 'webspicy/tester/asserter'
+
+  ###
+  ### About folders
+  ###
+
+  ROOT_FOLDER = Path.backfind('.[Gemfile]')
+
+  EXAMPLES_FOLDER = ROOT_FOLDER/'examples'
+
+  ###
+  ### About formal doc and resources defined there
+  ###
+
+  FORMALDOC = Finitio::DEFAULT_SYSTEM.parse (Path.dir/"webspicy/formaldoc.fio").read
+
+  def resource(raw, file = nil)
+    FORMALDOC["Resource"].dress(raw)
+  end
+  module_function :resource
+
+  def service(raw)
+    FORMALDOC["Service"].dress(raw)
+  end
+  module_function :service
+
+  def test_case(raw)
+    FORMALDOC["TestCase"].dress(raw)
+  end
+  module_function :test_case
+
+  #
+  # Yields a Scope instance for the configuration passed as parameter.
+  #
+  # This method makes sure that the scope will also be accessible for
+  # Finitio world schema parsing/dressing. Given that some global state
+  # is required (see "Schema" ADT, the dresser in particular, which calls
+  # `schema` later), the scope is put as a thread-local variable...
+  #
+  def with_scope_for(config)
+    scope = set_current_scope(Scope.new(config))
+    yield scope
+    set_current_scope(nil)
+  end
+  module_function :with_scope_for
+
+  #
+  # Sets the current scope.
+  #
+  # See `with_scope_for`
+  #
+  def set_current_scope(scope)
+    Thread.current[:webspicy_scope] = scope
+  end
+  module_function :set_current_scope
+
+  #
+  # Parses a webservice schema (typically input or output) in the context
+  # of the current scope previously installed using `with_scope_for`.
+  #
+  # If no scope has previously been installed, Finitio's default system
+  # is used instead of another schema.
+  #
+  def schema(fio)
+    if scope = Thread.current[:webspicy_scope]
+      scope.parse_schema(fio)
+    else
+      Finitio::DEFAULT_SYSTEM.parse(fio)
+    end
+  end
+  module_function :schema
+
+  ###
+  ### Logging facade
+  ###
+
+  LOGGER = ::Logger.new(STDOUT)
+  LOGGER.level = Logger.const_get(ENV['LOG_LEVEL'] || 'WARN')
+
+  def info(*args, &bl)
+    LOGGER && LOGGER.info(*args, &bl)
+  end
+  module_function :info
+
+  def debug(*args, &bl)
+    LOGGER && LOGGER.debug(*args, &bl)
+  end
+  module_function :debug
+
+end

data/spec/unit/resource/service/test_dress_params.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Webspicy
+  class Resource
+    describe Service, "dress_params" do
+
+      it 'symbolizes keys' do
+        service = Webspicy.service({
+          method: "GET",
+          description: "Test service",
+          preconditions: "Foo",
+          input_schema: "{ id: Integer }",
+          output_schema: "{}",
+          error_schema: "{}"
+        })
+        params = service.dress_params("id" => 1247)
+        expect(params).to eq(id: 1247)
+      end
+
+      it 'supports an array' do
+        service = Webspicy.service({
+          method: "GET",
+          description: "Test service",
+          preconditions: "Foo",
+          input_schema: "[{ id: Integer }]",
+          output_schema: "{}",
+          error_schema: "{}"
+        })
+        params = service.dress_params([{"id" => 1247}])
+        expect(params).to eq([{id: 1247}])
+      end
+
+    end
+  end # class Resource
+end # module Webspicy

data/spec/unit/resource/test_instantiate_url.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+module Webspicy
+  describe Resource, "instantiate_url" do
+
+    it 'does nothing when the url has no placeholder' do
+      r = Resource.new(url: "/test/a/url")
+      url, params = r.instantiate_url(foo: "bar")
+      expect(url).to eq("/test/a/url")
+      expect(params).to eq(foo: "bar")
+    end
+
+    it 'instantiates placeholders and strips corresponding params' do
+      r = Resource.new(url: "/test/{foo}/url")
+      url, params = r.instantiate_url(foo: "bar", baz: "coz")
+      expect(url).to eq("/test/bar/url")
+      expect(params).to eq(baz: "coz")
+    end
+
+  end
+end

data/spec/unit/resource/test_url_placeholders.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+module Webspicy
+  describe Resource, "url_placeholders" do
+
+    it 'returns an empty array on none' do
+      r = Resource.new(url: "/test/a/url")
+      expect(r.url_placeholders).to eq([])
+    end
+
+    it 'returns all placeholders' do
+      r = Resource.new(url: "/test/{foo}/url/{bar}")
+      expect(r.url_placeholders).to eq([:foo, :bar])
+    end
+
+  end
+end

data/spec/unit/scope/test_each_resource.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+module Webspicy
+  describe Scope, 'each_resource' do
+
+    with_scope_management
+
+    let(:scope) {
+      Scope.new(configuration)
+    }
+
+    subject {
+      scope.each_resource.to_a
+    }
+
+    context 'without any filter' do
+
+      let(:configuration) {
+        Configuration.new{|c|
+          c.add_folder restful_folder
+        }
+      }
+
+      it 'returns all files' do
+        expect(subject.size).to eql(restful_folder.glob('**/*.yml').size)
+      end
+    end
+
+    context 'with a file filter as a proc' do
+
+      let(:configuration) {
+        Configuration.new{|c|
+          c.add_folder restful_folder
+          c.file_filter = ->(f) {
+            f.basename.to_s == "getTodo.yml"
+          }
+        }
+      }
+
+      it 'returns only that file' do
+        expect(subject.size).to eql(1)
+      end
+    end
+
+    context 'with a file filter as a Regex' do
+
+      let(:configuration) {
+        Configuration.new{|c|
+          c.add_folder restful_folder
+          c.file_filter = /getTodo.yml/
+        }
+      }
+
+      it 'returns only that file' do
+        expect(subject.size).to eql(1)
+      end
+    end
+
+  end
+end

data/spec/unit/scope/test_each_service.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Webspicy
+  describe Scope, 'each_service' do
+
+    with_scope_management
+
+    let(:scope) {
+      Scope.new(configuration)
+    }
+
+    let(:resource) {
+      scope.each_resource.first
+    }
+
+    subject {
+      scope.each_service(resource).to_a
+    }
+
+    context 'without any filter' do
+
+      let(:configuration) {
+        Configuration.new{|c|
+          c.add_folder restful_folder
+          c.file_filter = /getTodo.yml/
+        }
+      }
+
+      it 'returns all services' do
+        expect(subject.size).to eql(1)
+      end
+    end
+
+    context 'with a service filter as a proc' do
+
+      let(:configuration) {
+        Configuration.new{|c|
+          c.add_folder restful_folder
+          c.file_filter = /getTodo.yml/
+          c.service_filter = ->(s) {
+            s.method == "POST"
+          }
+        }
+      }
+
+      it 'returns nothing' do
+        expect(subject.size).to eql(0)
+      end
+    end
+
+  end
+end

data/spec/unit/scope/test_to_real_url.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+module Webspicy
+  describe Scope, 'to_real_url' do
+
+    let(:scope) {
+      Scope.new(configuration)
+    }
+
+    context 'when no host at all' do
+
+      let(:configuration) {
+        Configuration.new
+      }
+
+      it 'does nothing on absolute URLs already' do
+        url = 'http://127.0.0.1:4567/todo'
+        got = scope.to_real_url(url)
+        expect(got).to eql(url)
+      end
+
+      it 'fails on relative URLs' do
+        expect(->(){
+          scope.to_real_url("/todo")
+        }).to raise_error(/Unable to resolve `\/todo`/)
+      end
+    end
+
+    context 'with a static host' do
+
+      let(:configuration) {
+        Configuration.new do |c|
+          c.host = "http://127.0.0.1:4568"
+        end
+      }
+
+      it 'does nothing on absolute URLs already' do
+        url = 'http://127.0.0.1:4567/todo'
+        got = scope.to_real_url(url)
+        expect(got).to eql(url)
+      end
+
+      it 'resolves relative URLs as expected' do
+        url = '/todo'
+        got = scope.to_real_url(url)
+        expect(got).to eql("http://127.0.0.1:4568/todo")
+      end
+
+    end
+
+    context 'with a dynamic host resolver' do
+
+      let(:configuration) {
+        Configuration.new do |c|
+          c.host = ->(url) {
+            "http://127.0.0.1:4568#{url}"
+          }
+        end
+      }
+
+      it 'resolves absolute URLs' do
+        url = 'http://127.0.0.1:4567/todo'
+        got = scope.to_real_url(url)
+        expect(got).to eql("http://127.0.0.1:4568#{url}")
+      end
+
+      it 'resolves relative URLs as expected' do
+        url = '/todo'
+        got = scope.to_real_url(url)
+        expect(got).to eql("http://127.0.0.1:4568/todo")
+      end
+
+    end
+
+  end
+end

data/spec/unit/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rspec'
+require 'webspicy'
+
+module SpecHelper
+
+  def restful_folder
+    Webspicy::EXAMPLES_FOLDER/'restful/webspicy'
+  end
+
+end
+
+module ScopeManagement
+
+  def with_scope_management
+    before(:each) {
+      Webspicy.set_current_scope(scope)
+    }
+    after(:each) {
+      Webspicy.set_current_scope(nil)
+    }
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include SpecHelper
+  c.extend  ScopeManagement
+end

data/spec/unit/test_configuration.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+module Webspicy
+  describe Configuration do
+
+    it 'yields itself at construction' do
+      seen = nil
+      Configuration.new do |c|
+        seen = c
+      end
+      expect(seen).to be_a(Configuration)
+    end
+
+    describe 'run_counterexamples' do
+
+      it 'is true by default' do
+        config = Configuration.new
+        expect(config.run_counterexamples?).to eql(true)
+      end
+
+      it 'implements backward compatibility with ROBUST env variable' do
+        ENV['ROBUST'] = 'no'
+        config = Configuration.new
+        expect(config.run_counterexamples?).to eql(false)
+
+        ENV['ROBUST'] = 'yes'
+        config = Configuration.new
+        expect(config.run_counterexamples?).to eql(true)
+      end
+
+      it 'ignores the environment is set explicitly' do
+        ENV['ROBUST'] = 'yes'
+        config = Configuration.new do |c|
+          c.run_counterexamples = false
+        end
+        expect(config.run_counterexamples?).to eql(false)
+      end
+    end
+
+    describe 'file_filter' do
+
+      it 'is nil by default' do
+        config = Configuration.new
+        expect(config.file_filter).to be_nil
+      end
+
+      it 'is implements backward compatibility with the RESOURCE env variable' do
+        ENV['RESOURCE'] = 'getTodo.yml'
+        config = Configuration.new
+        expect(config.file_filter).to be_a(Regexp)
+      end
+
+      it 'ignores the environment is set explicitly' do
+        ENV['RESOURCE'] = 'getTodo.yml'
+        config = Configuration.new do |c|
+          c.file_filter = nil
+        end
+        expect(config.file_filter).to be_nil
+      end
+    end
+
+    describe 'service_filter' do
+
+      it 'is nil by default' do
+        config = Configuration.new
+        expect(config.service_filter).to be_nil
+      end
+
+      it 'is implements backward compatibility with the RESOURCE env variable' do
+        ENV['METHOD'] = 'GET'
+        config = Configuration.new
+        expect(config.service_filter).to be_a(Proc)
+      end
+
+      it 'ignores the environment is set explicitly' do
+        ENV['METHOD'] = 'POST'
+        config = Configuration.new do |c|
+          c.service_filter = nil
+        end
+        expect(config.service_filter).to be_nil
+      end
+    end
+
+  end
+end

data/spec/unit/tester/test_assertions.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module Webspicy
+  class Tester
+    describe Assertions do
+      include Assertions
+
+      public :extract_path
+
+      it 'has an extract_path helper' do
+        target = { foo: "Hello", bar: { foo: "Hello" }, baz: [{ foo: "world" }] }
+        expect(extract_path(target)).to be(target)
+        expect(extract_path(target, nil)).to be(target)
+        expect(extract_path(target, '')).to be(target)
+        expect(extract_path(target, 'foo')).to eql("Hello")
+        expect(extract_path(target, 'bar/foo')).to eql("Hello")
+        expect(extract_path(target, 'baz/0')).to eql({ foo: "world" })
+        expect(extract_path(target, 'baz/0/foo')).to eql("world")
+      end
+
+      it 'has an exists() assertion' do
+        expect(exists nil).to be(false)
+        expect(exists []).to be(true)
+        expect(exists [1]).to be(true)
+        expect(exists({ foo: [] }, 'foo')).to be(true)
+        expect(exists({ foo: {} }, 'foo')).to be(true)
+        expect(exists({ foo: {} }, 'foo/bar')).to be(false)
+      end
+
+      it 'has an notExists() assertion' do
+        expect(notExists nil).to be(true)
+        expect(notExists []).to be(false)
+        expect(notExists [1]).to be(false)
+        expect(notExists({ foo: [] }, 'foo')).to be(false)
+        expect(notExists({ foo: {} }, 'foo')).to be(false)
+        expect(notExists({ foo: {} }, 'foo/bar')).to be(true)
+      end
+
+      it 'has an empty() assertion' do
+        expect(empty []).to be(true)
+        expect(empty [1]).to be(false)
+        expect(empty({ foo: [] }, 'foo')).to be(true)
+        expect(empty({ foo: [1] }, 'foo')).to be(false)
+      end
+
+      it 'has a notEmpty() assertion' do
+        expect(notEmpty []).to be(false)
+        expect(notEmpty [1]).to be(true)
+        expect(notEmpty({ foo: [] }, 'foo')).to be(false)
+        expect(notEmpty({ foo: [1] }, 'foo')).to be(true)
+      end
+
+      it 'has an size() assertion' do
+        expect(size [], 0).to be(true)
+        expect(size [], 1).to be(false)
+        expect(size [12], 1).to be(true)
+        expect(size({ foo: [] }, 'foo', 0)).to be(true)
+        expect(size({ foo: [] }, 'foo', 1)).to be(false)
+        expect(size({ foo: ['bar'] }, 'foo', 1)).to be(true)
+      end
+
+      it 'has an idIn assertion' do
+        expect(idIn [{id: 1}, {id: 2}], [1, 2]).to be(true)
+        expect(idIn [{id: 1}, {id: 2}], [2, 1]).to be(true)
+        expect(idIn [{id: 1}, {id: 2}], [1, 3]).to be(false)
+        expect(idIn [{id: 1}, {id: 2}], [1]).to be(false)
+        expect(idIn({ foo: [{id: 1}, {id: 2}] }, 'foo', [1, 2])).to be(true)
+
+        expect(idIn({id: 1}, [1])).to be(true)
+        expect(idIn({id: 1}, [2])).to be(false)
+      end
+
+      it 'has an idNotIn assertion' do
+        expect(idNotIn [{id: 1}, {id: 2}], [3]).to be(true)
+        expect(idNotIn [{id: 1}, {id: 2}], [3, 4]).to be(true)
+        expect(idNotIn [{id: 1}, {id: 2}], [1]).to be(false)
+        expect(idNotIn({ foo: [{id: 1}, {id: 2}] }, 'foo', [1])).to be(false)
+        expect(idNotIn({ foo: [{id: 1}, {id: 2}] }, 'foo', [3])).to be(true)
+
+        expect(idNotIn({id: 1}, [3])).to be(true)
+        expect(idNotIn({id: 1}, [1])).to be(false)
+      end
+
+      it 'has an idFD assertion' do
+        target = { foo: [
+          { id: 1, bar: "bar" },
+          { id: 2, bar: "baz" }
+        ] }
+        expect(idFD(target, 'foo', 1, bar: "bar")).to be(true)
+        expect(idFD(target, 'foo', 1, bar: "baz")).to be(false)
+        expect(idFD(target, 'foo', 1, baz: "boz")).to be(false)
+
+        target = { foo: { id: 1, bar: "bar" } }
+        expect(idFD(target, 'foo', 1, bar: "bar")).to be(true)
+        expect(idFD(target, 'foo', 1, bar: "baz")).to be(false)
+        expect(idFD(target, 'foo', 1, baz: "boz")).to be(false)
+      end
+
+      it 'has an pathFD assertion' do
+        target = { foo: { bar: "baz"} }
+        expect(pathFD(target, 'foo', bar: "baz")).to be(true)
+        expect(pathFD(target, 'foo', bar: "boz")).to be(false)
+        expect(pathFD(target, 'foo', boz: "biz")).to be(false)
+      end
+
+    end
+  end # class Tester
+end # module Webspicy