webspicy 0.16.0 → 0.18.0

data/lib/webspicy/tester/asserter.rb

@@ -78,14 +78,19 @@ module Webspicy
           expected = id
           id, path = path, ''
         end
-        unless @assertions.idFD(@target, path, id, expected)
-          _! "Expected #{_s(@target, path)} to meet FD #{expected.inspect}"
+        element = @assertions.element_with_id(@target, path, id)
+        unless element
+          _! "Expected an element with id #{id} to contain the key(s) and value(s) #{expected}, but there is no element with that id"
+        end
+
+        unless @assertions.idFD(element, expected)
+          _! "Expected #{_s(@target, path)} to contain the key(s) and value(s) #{expected}"
         end
       end
 
       def pathFD(path, expected)
         unless @assertions.pathFD(@target, path, expected)
-          _! "#{expected.inspect} vs. #{_s(@target, path)}"
+          _! "Expected #{_s(@target, path)} to contain the key(s) and value(s) #{expected}"
         end
       end
 
@@ -121,7 +126,7 @@ module Webspicy
       end
 
       def _!(msg)
-        raise msg
+        raise Failure, msg
       end
 
     end # class Asserter

data/lib/webspicy/tester/assertions.rb

@@ -63,16 +63,15 @@ module Webspicy
         (ids.to_set & expected.to_set).empty?
       end
 
-      def idFD(target, path, id, expected = NO_ARG)
-        if expected == NO_ARG
-          expected = id
-          id, path = path, ''
-        end
+      def element_with_id(target, path, id)
         target = extract_path(target, path)
-        found = an_array(target).find{|t| t[:id] == id }
-        expected.keys.all?{|k|
-          value_equal(expected[k], found[k])
-        }
+        an_array(target).find { |t| t[:id] == id }
+      end
+
+      def idFD(element, expected) 
+        expected.keys.all? do |k|
+          value_equal(expected[k], element[k])
+        end
       end
 
       def pathFD(target, path, expected)

data/lib/webspicy/tester/failure.rb

@@ -0,0 +1,6 @@
+module Webspicy
+  class Tester
+    class Failure < Exception
+    end # class Failure
+  end # class Tester
+end # module Webspicy

data/lib/webspicy/tester/invocation.rb

@@ -14,36 +14,6 @@ module Webspicy
         test_case.service
       end
 
-      def rspec_assert!(rspec)
-        RSpecAsserter.new(rspec, self).assert!
-      end
-
-      def errors
-        @errors ||= begin
-          errs = [
-            [:expected_status_unmet, true],
-            [:expected_content_type_unmet, !test_case.is_expected_status?(204)],
-            [:expected_headers_unmet, test_case.has_expected_headers?],
-            [:expected_schema_unmet, !test_case.is_expected_status?(204)],
-            [:assertions_unmet, test_case.has_assertions?],
-            [:postconditions_unmet, test_case.service.has_postconditions? && !test_case.counterexample?],
-            [:expected_error_unmet, test_case.has_expected_error?]
-          ].map do |(expectation,only_if)|
-            next unless only_if
-            begin
-              self.send(expectation)
-            rescue => ex
-              ex.message
-            end
-          end
-          errs.compact
-        end
-      end
-
-      def has_error?
-        !errors.empty?
-      end
-
       ### Getters on response
 
       def response_code
@@ -74,121 +44,10 @@ module Webspicy
         response_code >= 300 && response_code < 400
       end
 
-      ### Check of HTTP status
-
-      def expected_status_unmet
-        expected = test_case.expected_status
-        got = response.status
-        expected === got ? nil : "[status] #{expected} !== #{got}"
-      end
-
-      def meets_expected_status?
-        expected_status_unmet.nil?
-      end
-
-      ### Check of the expected output type
-
-      def expected_content_type_unmet
-        ect = test_case.expected_content_type
-        return nil unless ect
-        got = response.content_type
-        got = got.mime_type if got.respond_to?(:mime_type)
-        if ect.nil?
-          got.nil? ? nil : "[content type] #{ect} != #{got}"
-        else
-          got.to_s.start_with?(ect.to_s) ? nil : "[content type] #{ect} != #{got}"
-        end
-      end
-
-      def meets_expected_content_type?
-        expected_content_type_unmet.nil?
-      end
-
-      ### Check of output schema
-
-      def expected_schema_unmet
-        if is_empty_response?
-          body = response.body.to_s.strip
-          body.empty? ? nil : "[body] empty vs. #{body}"
-        elsif is_redirect?
-        else
-          case dressed_body
-          when Finitio::TypeError
-            rc = dressed_body.root_cause
-            "#{rc.message} (#{rc.location ? rc.location : 'unknown location'})"
-          when StandardError
-            dressed_body.message
-          else nil
-          end
-        end
-      end
-
-      def meets_expected_schema?
-        expected_schema_unmet.nil?
-      end
-
-      ### Check of assertions
-
-      def assertions_unmet
-        unmet = []
-        asserter = Tester::Asserter.new(dressed_body)
-        test_case.assert.each do |assert|
-          begin
-            asserter.instance_eval(assert)
-          rescue => ex
-            unmet << ex.message
-          end
-        end
-        unmet.empty? ? nil : unmet.join("\n")
-      end
-
-      def value_equal(exp, got)
-        case exp
-        when Hash
-          exp.all?{|(k,v)|
-            got[k] == v
-          }
-        else
-          exp == got
-        end
-      end
-
-      ### Check of expected error message
-
-      def expected_error_unmet
-        expected = test_case.expected_error
-        case test_case.expected_content_type
-        when %r{json}
-          got = meets_expected_schema? ? dressed_body[:description] : response.body
-          expected == got ? nil : "[error message] `#{expected}` vs. `#{got}`"
-        else
-          dressed_body.include?(expected) ? nil : "[error message] `#{expected}` not found" unless expected.nil?
-        end
-      end
-
-      ### Check of expected headers
-
-      def expected_headers_unmet
-        unmet = []
-        expected = test_case.expected_headers
-        expected.each_pair do |k,v|
-          got = response.headers[k]
-          unmet << "[headers] #{v} expected for #{k}, got #{got}" unless (got == v)
-        end
-        unmet.empty? ? nil : unmet.join("\n")
-      end
-
-      ### Check of postconditions
-
-      def postconditions_unmet
-        failures = service.postconditions.map{|post|
-          post.check(self)
-        }.compact
-        failures.empty? ? nil : failures.join("\n")
-      end
-
       def loaded_body
-        case test_case.expected_content_type
+        ct = response.content_type || test_case.expected_content_type
+        ct = ct.mime_type if ct.respond_to?(:mime_type)
+        case ct
         when %r{json}
           raise "Body empty while expected" if response.body.to_s.empty?
           @loaded_body ||= ::JSON.parse(response.body)
@@ -198,21 +57,14 @@ module Webspicy
       end
 
       def dressed_body
-        @dressed_body ||= case test_case.expected_content_type
-        when %r{json}
-          schema = is_expected_success? ? service.output_schema : service.error_schema
-          begin
-            schema.dress(loaded_body)
-          rescue Finitio::TypeError => ex
-            ex
-          end
-        else
-          loaded_body
+        schema = is_expected_success? ? service.output_schema : service.error_schema
+        begin
+          schema.dress(loaded_body)
+        rescue Finitio::TypeError => ex
+          ex
         end
       end
 
     end # class Invocation
   end # class Tester
 end # module Webspicy
-require_relative 'rspec_matchers'
-require_relative 'rspec_asserter'

data/lib/webspicy/version.rb

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

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

@@ -40,7 +40,7 @@ module Webspicy
       end
 
       it 'supports a single .yml file and returns a specific configuration instance' do
-        file = restful_folder/"todo/getTodo.yml"
+        file = restful_folder/"formaldef/todo/get.yml"
         c = Configuration.dress(file)
         expect(c).to be_a(Configuration)
         expect(c.folder).to eq(restful_folder)

data/spec/unit/tester/test_asserter.rb

@@ -3,10 +3,75 @@ require 'spec_helper'
 module Webspicy
   class Tester
     describe Asserter do
-      let(:asserter) { Asserter.new(target) }
+      describe '#includes' do
+        it 'returns nil when the value is found in an array' do
+          expect(Asserter.new([:a, 'foo', 99]).includes('', 'foo'))
+            .to eq nil
+        end
+
+        it 'returns nil when the assertion is identical to a non-array' do
+          expect(Asserter.new({ foo: Time.at(0) }).includes('', { foo: Time.at(0) }))
+            .to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([:a, 'foo', 99]).includes('', 42) }
+            .to raise_exception Failure,
+                                'Expected ["a","foo",99] to include 42'
+
+        end
+      end
+
+      describe '#notIncludes' do
+        it 'returns nil when the value is not found in an array' do
+          expect(Asserter.new([:a, 'foo', 99]).notIncludes('', 'boom'))
+            .to eq nil
+        end
+
+        it 'returns nil when the assertion and target are not identical' do
+          expect(Asserter.new({ foo: Time.at(0) }).notIncludes('', 'LOL'))
+            .to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([:a, 'foo', 99]).notIncludes('', 'foo') }
+            .to raise_exception Failure,
+                                'Expected ["a","foo",99] not to include foo'
+        end
+      end
+
+      describe '#empty' do
+        it 'returns nil when the target is empty' do
+          expect(Asserter.new([]).empty).to eq nil
+          expect(Asserter.new({}).empty).to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new(['foo']).empty }
+            .to raise_exception Failure,
+                                'Expected ["foo"] to be empty'
+        end
+      end
+
+      describe '#notEmpty' do
+        it 'returns nil when the target is not empty' do
+          expect(Asserter.new(['foo']).notEmpty).to eq nil
+          expect(Asserter.new({ foo: 'bar' }).notEmpty).to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([]).notEmpty }
+            .to raise_exception Failure,
+                                'Expected [] to be non empty'
+          expect { Asserter.new({}).notEmpty }
+            .to raise_exception Failure,
+                                'Expected {} to be non empty'
+        end
+      end
 
       describe '#size' do
         let(:target) { [1, 2, 3, 4] }
+        let(:asserter) { Asserter.new(target) }
 
         it 'returns nil when the assertion is true for a plain array' do
           expect(asserter.size('', 4)).to eq nil
@@ -14,7 +79,7 @@ module Webspicy
 
         it 'raises an exception with a descriptive message when the assertion is false' do
           expect { asserter.size('', 3) }
-            .to raise_exception RuntimeError, 'Expected [1,2,3,4] to have a size of 3, actual size is: 4'
+            .to raise_exception Failure, 'Expected [1,2,3,4] to have a size of 3, actual size is: 4'
         end
 
         context 'with a string' do
@@ -34,7 +99,7 @@ module Webspicy
 
           it 'raises an exception with a descriptive message when the assertion is false' do
             expect { asserter.size('foo/2/bar', 99) }
-              .to raise_exception RuntimeError,
+              .to raise_exception Failure,
                                   'Expected [10,11,12] to have a size of 99, actual size is: 3'
           end
 
@@ -45,6 +110,136 @@ module Webspicy
           end
         end
       end
+
+      describe '#idIn' do
+        it 'returns nil when the specified ids match exactly' do
+          expect(Asserter.new([{ id: 1 }, { id: 2 }]).idIn('', 1, 2)).to eq nil
+          expect(Asserter.new({ id: 123 }).idIn('', 123)).to eq nil
+
+          os = OpenStruct.new(id: 'foo')
+          expect(Asserter.new(os).idIn('', 'foo')).to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([{ id: 1}, { id: 2}]).idIn('', 123, 125) }
+            .to raise_exception Failure,
+                                'Expected [{"id":1},{"id":2}] to have ids 123,125'
+          expect { Asserter.new([{ id: 1}, { id: 2}]).idIn('', 1, 2, 3) }
+            .to raise_exception Failure,
+                                'Expected [{"id":1},{"id":2}] to have ids 1,2,3'
+          expect { Asserter.new([{ id: 1}, { id: 2}]).idIn('', 1) }
+            .to raise_exception Failure,
+                                'Expected [{"id":1},{"id":2}] to have ids 1'
+        end
+      end
+
+      describe '#idNotIn' do
+        it 'returns nil when the specified ids do not match exactly' do
+          expect(Asserter.new([{ id: 1 }, { id: 2 }]).idNotIn('', 123, 125)).to eq nil
+          expect(Asserter.new({ id: 123 }).idNotIn('', 1, 2, 3)).to eq nil
+          expect(Asserter.new({ id: 123 }).idNotIn('', 1)).to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([{ id: 1}, { id: 2}]).idNotIn('', 1, 2) }
+            .to raise_exception Failure,
+                                'Expected [{"id":1},{"id":2}] to not have ids 1,2'
+          expect { Asserter.new({ id: 1}).idNotIn('', 1) }
+            .to raise_exception Failure,
+                                'Expected {"id":1} to not have ids 1'
+
+          os = OpenStruct.new(id: 'foo')
+          expect { Asserter.new(os).idNotIn('', 'foo') }
+            .to raise_exception Failure,
+                                'Expected "#<OpenStruct id=\"foo\">"... to not have ids foo'
+        end
+      end
+    end
+
+    describe '#idFD' do
+      let(:target) do
+        [
+          { id: 1, a: 'a1', b: 'b1' },
+          { id: 2, a: 'a2', b: 'b2' }
+        ]
+      end
+
+      it 'returns nil when the element with specified id matches the expected keys-value pairs' do
+        expect(Asserter.new(target).idFD('', 2, { b: 'b2' })).to eq nil
+        expect(Asserter.new(target).idFD('', 2, { a: 'a2', b: 'b2' })).to eq nil
+      end
+
+      it 'raises an exception when the assertion is false' do
+        expect { Asserter.new(target).idFD('', 2, { c: 'c2' }) }
+          .to raise_exception Failure,
+                              'Expected [{"id":1,"a":"a1","b":"b1"... ' \
+                              'to contain the key(s) and value(s) {:c=>"c2"}'
+        expect { Asserter.new(target).idFD('', 2, { b: 'b1' }) }
+          .to raise_exception Failure,
+                              'Expected [{"id":1,"a":"a1","b":"b1"... ' \
+                              'to contain the key(s) and value(s) {:b=>"b1"}'
+      end
+
+      it 'raises an exception with a descriptive message when no element with the specified id is present in target' do
+        expect { Asserter.new(target).idFD('', 3, { a: 'a3' }) }
+          .to raise_exception Failure,
+                              'Expected an element with id 3 to contain ' \
+                              'the key(s) and value(s) {:a=>"a3"}, '\
+                              'but there is no element with that id'
+      end
+    end
+
+    describe '#pathFD' do
+      let(:target) do
+        [
+          { a: 'a1', b: 'b1' },
+          { a: 'a2', b: 'b2' }
+        ]
+      end
+
+      it 'returns nil when the target matches the expected keys-value pairs' do
+        expect(Asserter.new(target).pathFD('0', { b: 'b1' })).to eq nil
+        expect(Asserter.new(target).pathFD('0', { a: 'a1', b: 'b1' })).to eq nil
+        expect(Asserter.new(target).pathFD('1', { b: 'b2' })).to eq nil
+        expect(Asserter.new(target).pathFD('1', { a: 'a2', b: 'b2' })).to eq nil
+      end
+
+      it 'raises an exception when the assertion is false' do
+        expect { Asserter.new(target).pathFD('0', { c: 'c2' }) }
+          .to raise_exception Failure,
+                              'Expected {"a":"a1","b":"b1"} ' \
+                              'to contain the key(s) and value(s) {:c=>"c2"}'
+        expect { Asserter.new(target).pathFD('0', { b: 'b2' }) }
+          .to raise_exception Failure,
+                              'Expected {"a":"a1","b":"b1"} ' \
+                              'to contain the key(s) and value(s) {:b=>"b2"}'
+      end
+    end
+
+    describe '#match' do
+      it 'returns nil when the target matches the specified regexp' do
+        expect(Asserter.new('Empathise').match('', /path/)).to eq nil
+        expect(Asserter.new('Empathise').match('', /.mp/)).to eq nil
+      end
+
+      it 'raises an exception when the assertion is false' do
+        expect { Asserter.new('Empathise').match('', /ize/) }
+          .to raise_exception Failure,
+                              'Expected "Empathise" to match /ize/'
+      end
+    end
+
+    describe '#notMatch' do
+      it 'returns nil when the target does not matche the specified regexp' do
+        expect(Asserter.new('Empathise').notMatch('', /ize/)).to eq nil
+        expect(Asserter.new('Empathise').notMatch('', /^path/)).to eq nil
+      end
+
+      it 'raises an exception when the assertion is false' do
+        expect { Asserter.new('Empathise').notMatch('', /path/) }
+          .to raise_exception Failure,
+                              'Expected "Empathise" not to match /path/'
+      end
     end
   end
 end