pact-support 1.5.2 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b7354b72c73b6c34cd5555a473697b314f612a1
-  data.tar.gz: 26e964d3881d4c65f2c2a6f44b10fb58cba2239b
+  metadata.gz: 9f9bc0e7a4c308bb14cf0e1eb4c86fa4aedc1092
+  data.tar.gz: d95f4eaf140fadf63bcd3fa8aeda797720b2cfb9
 SHA512:
-  metadata.gz: b02995ae45c88bd74314b533b2ed59a57b6047c726455b9a3e541974d5c58ca88d9d9af8450dc545b03895aaf9dd360668462ab44a7a1873b3395dcfbfac7af8
-  data.tar.gz: 9bc59de6ae1cc48434e872c5148723ed43c84dd2a92c11621a8f6ebbdc2bd6620eec4628ac5cccfe69295cc2bca777b00b22e3f32444a86580c7a0323b2db741
+  metadata.gz: b6bb681918c1f7967c58f44467e69f871307d54c16e318f79f6c6f615593fdeec240b75b379887a3e193c9f6c78616b52b2eeae01e6cd74e172ec82ad4322363
+  data.tar.gz: ec0c51ec2b5c13a453d6cca32d5784fc88421e1e65bc517e3822f000852e3bf153a4c38bfa81007852e80a82e7047e5112162441afa0519fa8741e6db5370f1a

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+<a name="v1.6.0"></a>
+### v1.6.0 (2018-04-03)
+
+
+#### Features
+
+* add support for writing v3 matching rules	 ([fc89696](/../../commit/fc89696))
+
+
 <a name="v1.5.2"></a>
 ### v1.5.2 (2018-03-23)
 

data/lib/pact/matching_rules.rb

@@ -1,4 +1,5 @@
 require 'pact/matching_rules/extract'
+require 'pact/matching_rules/v3/extract'
 require 'pact/matching_rules/merge'
 require 'pact/matching_rules/v3/merge'
 
@@ -7,11 +8,18 @@ module Pact
 
     # @api public Used by pact-mock_service
     def self.extract object_graph, options = {}
-      Extract.(object_graph)
+      pact_specification_version = options[:pact_specification_version] || Pact::SpecificationVersion::NIL_VERSION
+      case pact_specification_version.major
+      when nil, 0, 1, 2
+        Extract.(object_graph)
+      else
+        V3::Extract.(object_graph)
+      end
     end
 
     def self.merge object_graph, matching_rules, options = {}
-      case options[:pact_specification_version].major
+      pact_specification_version = options[:pact_specification_version] || Pact::SpecificationVersion::NIL_VERSION
+      case pact_specification_version.major
       when nil, 0, 1, 2
         Merge.(object_graph, matching_rules)
       else

data/lib/pact/matching_rules/v3/extract.rb

@@ -0,0 +1,94 @@
+require 'pact/something_like'
+require 'pact/array_like'
+require 'pact/term'
+
+module Pact
+  module MatchingRules::V3
+    class Extract
+
+      def self.call matchable
+        new(matchable).call
+      end
+
+      def initialize matchable
+        @matchable = matchable
+        @rules = Hash.new
+      end
+
+      def call
+        recurse matchable, "$", nil
+        rules
+      end
+
+      private
+
+      attr_reader :matchable, :rules
+
+      def recurse object, path, match_type
+        case object
+        when Hash then recurse_hash(object, path, match_type)
+        when Array then recurse_array(object, path, match_type)
+        when Pact::SomethingLike then handle_something_like(object, path, match_type)
+        when Pact::ArrayLike then handle_array_like(object, path, match_type)
+        when Pact::Term then record_regex_rule object, path
+        when Pact::QueryString then recurse(object.query, path, match_type)
+        when Pact::QueryHash then recurse_hash(object.query, path, match_type)
+        end
+      end
+
+      def recurse_hash hash, path, match_type
+        hash.each do | (key, value) |
+          recurse value, "#{path}#{next_path_part(key)}", match_type
+        end
+      end
+
+      def recurse_array new_array, path, match_type
+        new_array.each_with_index do | value, index |
+          recurse value, "#{path}[#{index}]", match_type
+        end
+      end
+
+      def handle_something_like something_like, path, match_type
+        record_match_type_rule path, "type"
+        recurse something_like.contents, path, "type"
+      end
+
+      def handle_array_like array_like, path, match_type
+        record_rule "#{path}", 'min' => array_like.min
+        record_match_type_rule "#{path}[*].*", 'type'
+        recurse array_like.contents, "#{path}[*]", :array_like
+      end
+
+      def record_rule path, rule
+        rules[path] ||= {}
+        rules[path]['matchers'] ||= []
+        rules[path]['matchers'] << rule
+      end
+
+      def record_regex_rule term, path
+        rules[path] ||= {}
+        rules[path]['matchers'] ||= []
+        rule = { 'match' => 'regex', 'regex' => term.matcher.inspect[1..-2]}
+        rules[path]['matchers'] << rule
+      end
+
+      def record_match_type_rule path, match_type
+        unless match_type == :array_like || match_type.nil?
+          rules[path] ||= {}
+          rules[path]['matchers'] ||= []
+          rules[path]['matchers'] << { 'match' => match_type }
+        end
+      end
+
+      # Beth: there's a potential bug if the key contains a dot and a single quote.
+      # Not sure what to do then.
+      def next_path_part key
+        if key.to_s.include?('.')
+          "['#{key}']"
+        else
+          ".#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/pact/specification_version.rb

@@ -1,8 +1,6 @@
 module Pact
   class SpecificationVersion < Gem::Version
 
-    NIL_VERSION = Pact::SpecificationVersion.new('')
-
     def major
       segments.first
     end
@@ -15,4 +13,6 @@ module Pact
       major && other < major
     end
   end
+
+  SpecificationVersion::NIL_VERSION = Pact::SpecificationVersion.new('')
 end

data/lib/pact/support/version.rb

@@ -1,5 +1,5 @@
 module Pact
   module Support
-    VERSION = "1.5.2"
+    VERSION = "1.6.0"
   end
 end

data/script/release.sh

@@ -5,5 +5,5 @@ git checkout -- lib/pact/support/version.rb
 bundle exec bump ${1:-minor} --no-commit
 bundle exec rake generate_changelog
 git add CHANGELOG.md lib/pact/support/version.rb
-git commit -m "Releasing version $(ruby -r ./lib/pact/support/version.rb -e "puts Pact::Support::VERSION")"
+git commit -m "chore(release): version $(ruby -r ./lib/pact/support/version.rb -e "puts Pact::Support::VERSION")"
 bundle exec rake release

data/spec/lib/pact/matching_rules/v3/extract_spec.rb

@@ -0,0 +1,238 @@
+require 'pact/matching_rules/v3/extract'
+require 'pact/support'
+
+module Pact
+  module MatchingRules::V3
+    describe Extract do
+
+      describe ".call" do
+
+        subject { Extract.call(matchable) }
+
+        context "with a Pact::SomethingLike" do
+          let(:matchable) do
+            {
+              body: Pact::SomethingLike.new(foo: 'bar', alligator: { name: 'Mary' })
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body" => {
+                "matchers" => [ {"match" => "type"} ]
+              }
+            }
+          end
+
+          it "creates a rule that matches by type" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::Term" do
+          let(:matchable) do
+            {
+              body: {
+                alligator: {
+                  name: Pact::Term.new(generate: 'Mary', matcher: /.*a/)
+                }
+              }
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body.alligator.name" => {
+                "matchers" => [ {"match" => "regex", "regex" => ".*a"} ]
+              }
+            }
+          end
+
+          it "creates a rule that matches by regex" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::SomethingLike containing a Term" do
+          let(:matchable) do
+            {
+              body: Pact::SomethingLike.new(
+                foo: 'bar',
+                alligator: { name: Pact::Term.new(generate: 'Mary', matcher: /.*a/) }
+              )
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body" => {
+                "matchers" => [ {"match" => "type"} ]
+              },
+              "$.body.alligator.name" => {
+                "matchers" => [ {"match" => "regex", "regex"=>".*a"} ]
+              },
+            }
+          end
+
+          it "the match:regex overrides the match:type" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::SomethingLike containing an array" do
+          let(:matchable) do
+            {
+              body: Pact::SomethingLike.new(
+                alligators: [
+                  {name: 'Mary'},
+                  {name: 'Betty'}
+                ]
+              )
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body" => {
+                "matchers" => [ {"match" => "type"} ]
+              }
+            }
+          end
+
+          it "lists a rule for each item" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with an ArrayLike" do
+          let(:matchable) do
+            {
+              body: {
+                alligators: Pact::ArrayLike.new(
+                  name: 'Fred'
+                )
+              }
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body.alligators" => {
+                "matchers" => [ {"min" => 1} ]
+              },
+              "$.body.alligators[*].*" => {
+                "matchers" => [ {"match" => "type"} ]
+              }
+            }
+          end
+
+          it "lists a rule for all items" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with an ArrayLike with a Pact::Term inside" do
+          let(:matchable) do
+            {
+              body: {
+                alligators: Pact::ArrayLike.new(
+                  name: 'Fred',
+                  phoneNumber: Pact::Term.new(generate: '1234567', matcher: /\d+/)
+                )
+              }
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.body.alligators" => {
+                "matchers" => [ {"min" => 1} ]
+                },
+              "$.body.alligators[*].*" => {
+                "matchers" => [ {"match" => "type"} ]
+                },
+              "$.body.alligators[*].phoneNumber" => {
+                "matchers" => [ {"match" => "regex", "regex" => "\\d+"} ]
+              }
+            }
+          end
+
+          it "lists a rule that specifies that the regular expression must match" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::QueryString containing a Pact::Term" do
+          let(:matchable) do
+            {
+              query: Pact::QueryString.new(Pact::Term.new(generate: 'foobar', matcher: /foo/))
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.query" => {
+                "matchers" => [ {"match" => "regex", "regex" => "foo"} ]
+              }
+            }
+          end
+
+          it "lists a rule that specifies that the regular expression must match" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a Pact::QueryHash containing a Pact::Term" do
+          let(:matchable) do
+            {
+              query: Pact::QueryHash.new(bar: Pact::Term.new(generate: 'foobar', matcher: /foo/))
+            }
+          end
+
+          let(:rules) do
+            {
+              "$.query.bar[0]" => {
+                "matchers" => [ {"match" => "regex", "regex" => "foo"} ]
+              }
+            }
+          end
+
+          it "lists a rule that specifies that the regular expression must match" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with no special matching" do
+          let(:matchable) do
+            {
+              body: { alligator: { name: 'Mary' } }
+            }
+          end
+
+          let(:rules) do
+            {}
+          end
+
+
+          it "does not create any rules" do
+            expect(subject).to eq rules
+          end
+        end
+
+        context "with a key containing a dot" do
+          let(:matchable) do
+            {
+              "key" => {
+                "key.with.dots" => Pact::SomethingLike.new("foo")
+              }
+            }
+          end
+
+          it "uses square brackets notation for the key with dots" do
+            expect(subject.keys).to include "$.key['key.with.dots']"
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact-support
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - James Fraser
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2018-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp
@@ -303,6 +303,7 @@ files:
 - lib/pact/matching_rules/extract.rb
 - lib/pact/matching_rules/jsonpath.rb
 - lib/pact/matching_rules/merge.rb
+- lib/pact/matching_rules/v3/extract.rb
 - lib/pact/matching_rules/v3/merge.rb
 - lib/pact/reification.rb
 - lib/pact/rspec.rb
@@ -363,6 +364,7 @@ files:
 - spec/lib/pact/matchers/unix_diff_formatter_spec.rb
 - spec/lib/pact/matching_rules/extract_spec.rb
 - spec/lib/pact/matching_rules/merge_spec.rb
+- spec/lib/pact/matching_rules/v3/extract_spec.rb
 - spec/lib/pact/matching_rules/v3/merge_spec.rb
 - spec/lib/pact/matching_rules_spec.rb
 - spec/lib/pact/reification_spec.rb
@@ -422,7 +424,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Shared code for Pact gems
@@ -465,6 +467,7 @@ test_files:
 - spec/lib/pact/matchers/unix_diff_formatter_spec.rb
 - spec/lib/pact/matching_rules/extract_spec.rb
 - spec/lib/pact/matching_rules/merge_spec.rb
+- spec/lib/pact/matching_rules/v3/extract_spec.rb
 - spec/lib/pact/matching_rules/v3/merge_spec.rb
 - spec/lib/pact/matching_rules_spec.rb
 - spec/lib/pact/reification_spec.rb