webspicy 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e101e5e0888e85dfb80ab43b4577c9f01ce793c04b0e974dcf12f6225743881a
-  data.tar.gz: a42aa4e7212a25bac508d4cdf2ed8707d2c9f9cb01df8a9ef2dd6646e6b15206
+  metadata.gz: b98da2f8756ded7b4d4a71d2eb227e2adfe25b4fd2922980e9de05a8ecd9ad65
+  data.tar.gz: 4a3c22b30c47e27fe8bc61ad804e5eac6cff87435741f91bd533a59aba7a69ba
 SHA512:
-  metadata.gz: 230a0309efbaef05b78adf7f4ad7f8c5c1caf189be13fa5fba18ffa700e4b1da91659a267905f784e435279848405e639544e8072c9f8b748a577b13bde11aee
-  data.tar.gz: a465e061e7f8aaed5942ad097e243e4a0c18c19e51b88f5805c3e18310d4dcdf70677e8178239368a91f6753c7f33b3530f49383655080a1248d9dbe5f6f1c47
+  metadata.gz: 557e4a8249210b4c64f84c6d9b41f56487d3e4a6ef2ec62a7e80783432de06202a9ca66978136d74880193a409db0587ce2e0aecb1df2f2f9d9296de6747117b
+  data.tar.gz: 71f1c9ee7fed6e38ee4eee06d03f9f8da39d64c4cb64999a5d1135a59d4a03080a77dcc8c7f327eb9d4f6faa355bf4c3b13f2ab83bdb4e6f422e260e5fe77f8d

data/lib/webspicy/specification/pre.rb

@@ -15,5 +15,3 @@ module Webspicy
     end # module Pre
   end # class Specification
 end # module Webspicy
-require_relative 'pre/global_request_headers'
-require_relative 'pre/robust_to_invalid_input'

data/lib/webspicy/tester/asserter.rb

@@ -108,6 +108,18 @@ module Webspicy
         end
       end
 
+      def eq(path, expected = NO_ARG)
+        path, expected = '', path if expected == NO_ARG
+        target = @assertions.extract_path(@target, path)
+        Predicate.eq(target, expected).assert!
+      end
+
+      def eql(path, expected = NO_ARG)
+        path, expected = '', path if expected == NO_ARG
+        target = @assertions.extract_path(@target, path)
+        Predicate.eq(target, expected).assert!
+      end
+
     private
 
       def DateTime(str)

data/lib/webspicy/tester/assertions.rb

@@ -90,6 +90,16 @@ module Webspicy
         !match(target, path, rx)
       end
 
+      def eq(target, path, expected)
+        target = extract_path(target, path)
+        target == expected
+      end
+
+      def eql(target, path, expected)
+        target = extract_path(target, path)
+        value_equal(target, expected)
+      end
+
     public
 
       def extract_path(target, path = NO_ARG)

data/lib/webspicy/version.rb

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

data/lib/webspicy/web/specification/post/etag_caching_protocol.rb

@@ -0,0 +1,38 @@
+module Webspicy
+  module Web
+    class Specification
+      module Post
+        class ETagCachingProtocol
+          include Webspicy::Specification::Post
+
+          MATCH = /It supports the ETag\/If-None-Match caching protocol/
+
+          def self.match(service, descr)
+            return nil unless descr =~ MATCH
+            ETagCachingProtocol.new
+          end
+
+          def check!
+            res = invocation.response
+            etag = res.headers['ETag']
+            fail!("No ETag response header found") unless etag
+
+            url, _ = test_case.specification.instantiate_url(test_case.params)
+            url = scope.to_real_url(url, test_case){|u,_| u }
+
+            response = client.api.get(url, {}, test_case.headers.merge({
+              'If-None-Match' => etag
+            }))
+            fail!("304 expected") unless response.status == 304
+
+            response = client.api.get(url, {}, test_case.headers.merge({
+              'If-None-Match' => "W/somethingelse"
+            }))
+            fail!("2xx expected") if response.status == 304
+          end
+
+        end # class ETagCachingProtocol
+      end # module Post
+    end # module Webspicy
+  end # module Web
+end # class Specification

data/lib/webspicy/web/specification/post/last_modified_caching_protocol.rb

@@ -0,0 +1,41 @@
+module Webspicy
+  module Web
+    class Specification
+      module Post
+        class LastModifiedCachingProtocol
+          include Webspicy::Specification::Post
+
+          MATCH = /It supports the Last-Modified\/If-Modified-Since caching protocol/
+
+          def self.match(service, descr)
+            return nil unless descr =~ MATCH
+            LastModifiedCachingProtocol.new
+          end
+
+          def check!
+            res = invocation.response
+            last_modified = res.headers['Last-Modified']
+            fail!("No last-modified response header found") unless last_modified
+
+            # check it fits the HTTP-date format or fail
+            Time.httpdate(last_modified) rescue fail!("Not valid Last-Modified response header")
+
+            url, _ = test_case.specification.instantiate_url(test_case.params)
+            url = scope.to_real_url(url, test_case){|u,_| u }
+
+            response = client.api.get(url, {}, test_case.headers.merge({
+              'If-Modified-Since' => last_modified
+            }))
+            fail!("304 expected") unless response.status == 304
+
+            response = client.api.get(url, {}, test_case.headers.merge({
+              'If-Modified-Since' => "Thu, 08 Jun 1970 19:06:27 GMT"
+            }))
+            fail!("2xx expected") if response.status == 304
+          end
+
+        end # class LastModifiedCachingProtocol
+      end # module Post
+    end # module Webspicy
+  end # module Web
+end # class Specification

data/lib/webspicy/web/specification/post/semantics_preserved_by_refactoring.rb

@@ -0,0 +1,67 @@
+module Webspicy
+  module Web
+    class Specification
+      module Post
+        class SemanticsPreservedByRefactoring
+          include ::Webspicy::Specification::Post
+
+          MATCH = /The data output semantics is preserved by the refactoring/
+
+          def self.match(service, descr)
+            return nil unless descr =~ MATCH
+            SemanticsPreservedByRefactoring.new
+          end
+
+          def instrument
+          end
+
+          def check!
+            test_id = {
+              description: test_case.description,
+              seeds: test_case.seeds,
+              url: test_case.service.specification.url,
+              method: test_case.service.method,
+              params: test_case.params,
+              headers: test_case.headers.reject{|k| k == 'Authorization' },
+              metadata: test_case.metadata,
+            }
+            sha1 = Digest::SHA1.hexdigest(test_id.to_json)
+
+            record_file_path = config.folder/".morpheus/#{sha1}.key.json"
+            record_file_path.parent.mkdir_p
+            record_file_path.write(JSON.pretty_generate(test_id))
+
+            response = invocation.response
+            test_data = {
+              status: response.status,
+              headers: response.headers,
+              body: JSON.parse(response.body),
+            }
+
+            case ENV['MORPHEUS'].upcase
+            when 'RECORD'
+              expected_file_path = config.folder/".morpheus/#{sha1}.expected.json"
+              expected_file_path.write(JSON.pretty_generate(test_data))
+            when 'CHECK'
+              expected_file_path = config.folder/".morpheus/#{sha1}.expected.json"
+              expected = expected_file_path.load
+
+              actual_file_path = config.folder/".morpheus/#{sha1}.actual.json"
+              actual_file_path.write(JSON.pretty_generate(test_data))
+              actual = actual_file_path.load
+
+              fail!("Semantics has changed.") unless values_equal?(actual, expected)
+            end
+          end
+
+        private
+
+          def values_equal?(a, b)
+            Tester::Asserter.new(a).eql('', b)
+          end
+
+        end # SemanticsPreservedByRefactoring
+      end # module Post
+    end # module Webspicy
+  end # module Web
+end # class Specification

data/lib/webspicy/web/specification/post.rb

@@ -0,0 +1,9 @@
+module Webspicy
+  module Web
+    class Specification
+      module Post
+        include Webspicy::Specification::Post
+      end # module Post
+    end # class Specification
+  end # module Web
+end # module Webspicy

data/lib/webspicy/web/specification/pre/global_request_headers.rb

@@ -0,0 +1,38 @@
+module Webspicy
+  module Web
+    class Specification
+      module Pre
+        class GlobalRequestHeaders
+          include Pre
+
+          DEFAULT_OPTIONS = {}
+
+          def initialize(headers, options = {}, &bl)
+            @headers = headers
+            @options = DEFAULT_OPTIONS.merge(options)
+            @matcher = bl
+          end
+          attr_reader :headers, :matcher
+
+          def match(service, pre)
+            if matcher
+              return self if matcher.call(service)
+              nil
+            else
+              self
+            end
+          end
+
+          def instrument
+            extra = headers.reject{|k|
+              test_case.headers.has_key?(k)
+            }
+            puts "Instrumenting #{test_case.object_id}"
+            test_case.headers.merge!(extra)
+          end
+
+        end # class GlobalRequestHeaders
+      end # module Pre
+    end # class Specification
+  end # module Web
+end # module Webspicy

data/lib/webspicy/web/specification/pre/robust_to_invalid_input.rb

@@ -0,0 +1,70 @@
+module Webspicy
+  module Web
+    class Specification
+      module Pre
+        class RobustToInvalidInput
+          include Pre
+
+          def self.match(service, pre)
+            self.new
+          end
+
+          def match(service, pre)
+            self
+          end
+
+          def counterexamples(service)
+            spec = service.specification
+            first = service.examples.first
+            cexamples = []
+            cexamples += url_randomness_counterexamples(service, first) if first
+            cexamples += empty_input_counterexamples(service, first) if first
+            cexamples
+          end
+
+        protected
+
+          def url_randomness_counterexamples(service, first)
+            service.specification.url_placeholders.map{|p|
+              first.mutate({
+                :description => "it is robust to URL randomness on param `#{p}` (RobustToInvalidInput)",
+                :dress_params => false,
+                :params => first.params.merge(p => (SecureRandom.random_number * 100000000).to_i),
+                :expected => {
+                  status: Support::StatusRange.str("4xx")
+                },
+                :assert => []
+              })
+            }
+          end
+
+          def empty_input_counterexamples(service, first)
+            placeholders = service.specification.url_placeholders
+            empty_input = first.params.reject{|k| !placeholders.include?(k) }
+            if invalid_input?(service, empty_input)
+              [first.mutate({
+                :description => "it is robust to an invalid empty input (RobustToInvalidInput)",
+                :dress_params => false,
+                :params => empty_input,
+                :expected => {
+                  status: Support::StatusRange.str("4xx")
+                },
+                :assert => []
+              })]
+            else
+              []
+            end
+          end
+
+          def invalid_input?(service, empty_input)
+            service.input_schema.dress(empty_input)
+            false
+          rescue Finitio::Error
+            true
+          end
+
+        end # class RobustToInvalidInput
+      end # module Pre
+    end # class Specification
+  end # module Web
+end # module Webspicy

data/lib/webspicy/web/specification/pre.rb

@@ -0,0 +1,9 @@
+module Webspicy
+  module Web
+    class Specification
+      module Pre
+        include Webspicy::Specification::Pre
+      end # module Pre
+    end # class Specification
+  end # module Web
+end # module Webspicy

data/lib/webspicy/web/specification.rb

@@ -63,6 +63,8 @@ module Webspicy
     end # class Specification
   end # module Web
 end # module Webspicy
+require_relative 'specification/pre'
+require_relative 'specification/post'
 require_relative 'specification/service'
 require_relative 'specification/test_case'
 require_relative 'specification/file_upload'

data/lib/webspicy.rb

@@ -10,6 +10,7 @@ require 'mustermann'
 require 'paint'
 require 'securerandom'
 require 'forwardable'
+require 'predicate'
 module Webspicy
 
   ###

data/spec/unit/tester/test_assertions.rb

@@ -3,92 +3,99 @@ require 'spec_helper'
 module Webspicy
   class Tester
     describe Assertions do
-      include Assertions
 
-      public :extract_path
+      class A
+        include Assertions
+
+        public :extract_path
+      end
+
+      let(:a) do
+        A.new
+      end
 
       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")
+        expect(a.extract_path(target)).to be(target)
+        expect(a.extract_path(target, nil)).to be(target)
+        expect(a.extract_path(target, '')).to be(target)
+        expect(a.extract_path(target, 'foo')).to eql("Hello")
+        expect(a.extract_path(target, 'bar/foo')).to eql("Hello")
+        expect(a.extract_path(target, 'baz/0')).to eql({ foo: "world" })
+        expect(a.extract_path(target, 'baz/0/foo')).to eql("world")
       end
 
       it 'has an includes() assertion' do
-        expect(includes [], 1).to be(false)
-        expect(includes [5, 1], 1).to be(true)
+        expect(a.includes [], 1).to be(false)
+        expect(a.includes [5, 1], 1).to be(true)
       end
 
       it 'has a notIncludes() assertion' do
-        expect(notIncludes [], 1).to be(true)
-        expect(notIncludes [5, 1], 1).to be(false)
+        expect(a.notIncludes [], 1).to be(true)
+        expect(a.notIncludes [5, 1], 1).to be(false)
       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)
+        expect(a.exists nil).to be(false)
+        expect(a.exists []).to be(true)
+        expect(a.exists [1]).to be(true)
+        expect(a.exists({ foo: [] }, 'foo')).to be(true)
+        expect(a.exists({ foo: {} }, 'foo')).to be(true)
+        expect(a.exists({ foo: {} }, 'foo/bar')).to be(false)
       end
 
       it 'has a 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)
+        expect(a.notExists nil).to be(true)
+        expect(a.notExists []).to be(false)
+        expect(a.notExists [1]).to be(false)
+        expect(a.notExists({ foo: [] }, 'foo')).to be(false)
+        expect(a.notExists({ foo: {} }, 'foo')).to be(false)
+        expect(a.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)
+        expect(a.empty []).to be(true)
+        expect(a.empty [1]).to be(false)
+        expect(a.empty({ foo: [] }, 'foo')).to be(true)
+        expect(a.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)
+        expect(a.notEmpty []).to be(false)
+        expect(a.notEmpty [1]).to be(true)
+        expect(a.notEmpty({ foo: [] }, 'foo')).to be(false)
+        expect(a.notEmpty({ foo: [1] }, 'foo')).to be(true)
       end
 
       it 'has a 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)
+        expect(a.size [], 0).to be(true)
+        expect(a.size [], 1).to be(false)
+        expect(a.size [12], 1).to be(true)
+        expect(a.size({ foo: [] }, 'foo', 0)).to be(true)
+        expect(a.size({ foo: [] }, 'foo', 1)).to be(false)
+        expect(a.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)
+        expect(a.idIn [{id: 1}, {id: 2}], [1, 2]).to be(true)
+        expect(a.idIn [{id: 1}, {id: 2}], [2, 1]).to be(true)
+        expect(a.idIn [{id: 1}, {id: 2}], [1, 3]).to be(false)
+        expect(a.idIn [{id: 1}, {id: 2}], [1]).to be(false)
+        expect(a.idIn({ foo: [{id: 1}, {id: 2}] }, 'foo', [1, 2])).to be(true)
+
+        expect(a.idIn({id: 1}, [1])).to be(true)
+        expect(a.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)
+        expect(a.idNotIn [{id: 1}, {id: 2}], [3]).to be(true)
+        expect(a.idNotIn [{id: 1}, {id: 2}], [3, 4]).to be(true)
+        expect(a.idNotIn [{id: 1}, {id: 2}], [1]).to be(false)
+        expect(a.idNotIn({ foo: [{id: 1}, {id: 2}] }, 'foo', [1])).to be(false)
+        expect(a.idNotIn({ foo: [{id: 1}, {id: 2}] }, 'foo', [3])).to be(true)
+
+        expect(a.idNotIn({id: 1}, [3])).to be(true)
+        expect(a.idNotIn({id: 1}, [1])).to be(false)
       end
 
       it 'has an idFD assertion' do
@@ -96,35 +103,35 @@ module Webspicy
           { id: 1, bar: "bar" },
           { id: 2, bar: "baz" }
         ] }
-        element = element_with_id(target, 'foo', 1)
-        expect(idFD(element, bar: "bar")).to be(true)
-        expect(idFD(element, bar: "baz")).to be(false)
-        expect(idFD(element, baz: "boz")).to be(false)
+        element = a.element_with_id(target, 'foo', 1)
+        expect(a.idFD(element, bar: "bar")).to be(true)
+        expect(a.idFD(element, bar: "baz")).to be(false)
+        expect(a.idFD(element, baz: "boz")).to be(false)
 
         target = { foo: { id: 1, bar: "bar" } }
-        element = element_with_id(target, 'foo', 1)
-        expect(idFD(element, bar: "bar")).to be(true)
-        expect(idFD(element, bar: "baz")).to be(false)
-        expect(idFD(element, baz: "boz")).to be(false)
+        element = a.element_with_id(target, 'foo', 1)
+        expect(a.idFD(element, bar: "bar")).to be(true)
+        expect(a.idFD(element, bar: "baz")).to be(false)
+        expect(a.idFD(element, baz: "boz")).to be(false)
       end
 
       it 'has a 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)
+        expect(a.pathFD(target, 'foo', bar: "baz")).to be(true)
+        expect(a.pathFD(target, 'foo', bar: "boz")).to be(false)
+        expect(a.pathFD(target, 'foo', boz: "biz")).to be(false)
       end
 
       it 'has a match assertion' do
         target = "hello world"
-        expect(match(target, '', /world/)).to be(true)
-        expect(match(target, '', /foobar/)).to be(false)
+        expect(a.match(target, '', /world/)).to be(true)
+        expect(a.match(target, '', /foobar/)).to be(false)
       end
 
       it 'has a notMatch assertion' do
         target = "hello world"
-        expect(notMatch(target, '', /world/)).to be(false)
-        expect(notMatch(target, '', /foobar/)).to be(true)
+        expect(a.notMatch(target, '', /world/)).to be(false)
+        expect(a.notMatch(target, '', /foobar/)).to be(true)
       end
 
     end

data/spec/unit/web/specification/pre/test_global_request_headers.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'webspicy/web/specification/pre/global_request_headers'
+
+module Webspicy
+  module Web
+    class Specification
+      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 = Web::Specification::TestCase.new({})
+              instrument(tc)
+              expect(tc.headers['Accept']).to eql("application/json")
+            end
+
+            it 'keeps original headers unchanged' do
+              tc = Web::Specification::TestCase.new({
+                headers: {
+                  'Content-Type' => 'text/plain'
+                }
+              })
+              instrument(tc)
+              expect(tc.headers['Content-Type']).to eql("text/plain")
+              expect(tc.headers['Accept']).to eql("application/json")
+            end
+
+            it 'has low precedence' do
+              tc = Web::Specification::TestCase.new({
+                headers: {
+                  'Accept' => 'text/plain'
+                }
+              })
+              instrument(tc)
+              expect(tc.headers['Accept']).to eql("text/plain")
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: webspicy
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-26 00:00:00.000000000 Z
+date: 2023-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -138,22 +138,22 @@ dependencies:
   name: rack-robustness
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: mustermann
   requirement: !ruby/object:Gem::Requirement
@@ -266,6 +266,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: predicate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Webspicy helps testing web services as software operation black boxes
 email: blambeau@gmail.com
 executables:
@@ -300,8 +320,6 @@ files:
 - lib/webspicy/specification/post/missing_condition_impl.rb
 - lib/webspicy/specification/post/unexpected_condition_impl.rb
 - lib/webspicy/specification/pre.rb
-- lib/webspicy/specification/pre/global_request_headers.rb
-- lib/webspicy/specification/pre/robust_to_invalid_input.rb
 - lib/webspicy/specification/service.rb
 - lib/webspicy/specification/test_case.rb
 - lib/webspicy/support.rb
@@ -361,6 +379,13 @@ files:
 - lib/webspicy/web/openapi/generator.rb
 - lib/webspicy/web/specification.rb
 - lib/webspicy/web/specification/file_upload.rb
+- lib/webspicy/web/specification/post.rb
+- lib/webspicy/web/specification/post/etag_caching_protocol.rb
+- lib/webspicy/web/specification/post/last_modified_caching_protocol.rb
+- lib/webspicy/web/specification/post/semantics_preserved_by_refactoring.rb
+- lib/webspicy/web/specification/pre.rb
+- lib/webspicy/web/specification/pre/global_request_headers.rb
+- lib/webspicy/web/specification/pre/robust_to_invalid_input.rb
 - lib/webspicy/web/specification/service.rb
 - lib/webspicy/web/specification/test_case.rb
 - spec/spec_helper.rb
@@ -369,7 +394,6 @@ files:
 - spec/unit/configuration/scope/test_each_specification.rb
 - spec/unit/configuration/scope/test_expand_example.rb
 - spec/unit/configuration/scope/test_to_real_url.rb
-- spec/unit/specification/pre/test_global_request_headers.rb
 - spec/unit/specification/service/test_dress_params.rb
 - spec/unit/specification/test_case/test_mutate.rb
 - spec/unit/specification/test_condition.rb
@@ -392,6 +416,7 @@ files:
 - spec/unit/web/inferer/test_inferer.rb
 - spec/unit/web/mocker/test_mocker.rb
 - spec/unit/web/openapi/test_generator.rb
+- spec/unit/web/specification/pre/test_global_request_headers.rb
 - spec/unit/web/specification/test_instantiate_url.rb
 - spec/unit/web/specification/test_url_placeholders.rb
 - tasks/gem.rake

data/lib/webspicy/specification/pre/global_request_headers.rb

@@ -1,35 +0,0 @@
-module Webspicy
-  class Specification
-    module Pre
-      class GlobalRequestHeaders
-        include Pre
-
-        DEFAULT_OPTIONS = {}
-
-        def initialize(headers, options = {}, &bl)
-          @headers = headers
-          @options = DEFAULT_OPTIONS.merge(options)
-          @matcher = bl
-        end
-        attr_reader :headers, :matcher
-
-        def match(service, pre)
-          if matcher
-            return self if matcher.call(service)
-            nil
-          else
-            self
-          end
-        end
-
-        def instrument
-          extra = headers.reject{|k|
-            test_case.headers.has_key?(k)
-          }
-          test_case.headers.merge!(extra)
-        end
-
-      end # class GlobalRequestHeaders
-    end # module Pre
-  end # class Specification
-end # module Webspicy

data/lib/webspicy/specification/pre/robust_to_invalid_input.rb

@@ -1,68 +0,0 @@
-module Webspicy
-  class Specification
-    module Pre
-      class RobustToInvalidInput
-        include Pre
-
-        def self.match(service, pre)
-          self.new
-        end
-
-        def match(service, pre)
-          self
-        end
-
-        def counterexamples(service)
-          spec = service.specification
-          first = service.examples.first
-          cexamples = []
-          cexamples += url_randomness_counterexamples(service, first) if first
-          cexamples += empty_input_counterexamples(service, first) if first
-          cexamples
-        end
-
-      protected
-
-        def url_randomness_counterexamples(service, first)
-          service.specification.url_placeholders.map{|p|
-            first.mutate({
-              :description => "it is robust to URL randomness on param `#{p}` (RobustToInvalidInput)",
-              :dress_params => false,
-              :params => first.params.merge(p => (SecureRandom.random_number * 100000000).to_i),
-              :expected => {
-                status: Support::StatusRange.str("4xx")
-              },
-              :assert => []
-            })
-          }
-        end
-
-        def empty_input_counterexamples(service, first)
-          placeholders = service.specification.url_placeholders
-          empty_input = first.params.reject{|k| !placeholders.include?(k) }
-          if invalid_input?(service, empty_input)
-            [first.mutate({
-              :description => "it is robust to an invalid empty input (RobustToInvalidInput)",
-              :dress_params => false,
-              :params => empty_input,
-              :expected => {
-                status: Support::StatusRange.str("4xx")
-              },
-              :assert => []
-            })]
-          else
-            []
-          end
-        end
-
-        def invalid_input?(service, empty_input)
-          service.input_schema.dress(empty_input)
-          false
-        rescue Finitio::Error
-          true
-        end
-
-      end # class RobustToInvalidInput
-    end # module Pre
-  end # class Specification
-end # module Webspicy

data/spec/unit/specification/pre/test_global_request_headers.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-module Webspicy
-  class Specification
-    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 = Web::Specification::TestCase.new({})
-            instrument(tc)
-            expect(tc.headers['Accept']).to eql("application/json")
-          end
-
-          it 'keeps original headers unchanged' do
-            tc = Web::Specification::TestCase.new({
-              headers: {
-                'Content-Type' => 'text/plain'
-              }
-            })
-            instrument(tc)
-            expect(tc.headers['Content-Type']).to eql("text/plain")
-            expect(tc.headers['Accept']).to eql("application/json")
-          end
-
-          it 'has low precedence' do
-            tc = Web::Specification::TestCase.new({
-              headers: {
-                'Accept' => 'text/plain'
-              }
-            })
-            instrument(tc)
-            expect(tc.headers['Accept']).to eql("text/plain")
-          end
-        end
-      end
-    end
-  end
-end