pact-support 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9d55f72d24799e4cfe2fd71d535eaf37eb70c74
-  data.tar.gz: e6c16b4858bd228d4a0d32b43bd11ac14b53bc6a
+  metadata.gz: 1343fbdb3d492b8bd9459ac577fdc636d3c8f907
+  data.tar.gz: 81a624d87c85b4a248025610281356efc28e492e
 SHA512:
-  metadata.gz: 70a1d305f8a0655db237cbf488118f47285f5bcd08e493b597620faf6f2cad99a2a9de0f9a71f89d9fca25422564c3b69743685cfc45df9d11206e3e9925e5e0
-  data.tar.gz: 121e1252a85b993bc22c7becb00b79430754e7e329459f4ec7c5141092b2a04e3587ec98b22c0d1bd8f4c2c027a25cb1cbc282fc2600de40033ebe4dfbd43cdc
+  metadata.gz: 1a8d23e47c421f2ac93136d762af05aa569292120f5c248fc03d2e2b4e7ef536b7a3a92a4c1c80f38c9be855ebd64101aad1ace927ccc2b0f205e8622ce9ccfa
+  data.tar.gz: c7bfe4f8db436d703354b47944761c9bfbcdaae20f2f26aaf63ac638f9235055e82208b2476c7d20eab067713fa1c26795d72198ee8166dd295c1cceef3f1951

data/CHANGELOG.md

@@ -2,6 +2,10 @@ Do this to generate your change history
 
   git log --pretty=format:'  * %h - %s (%an, %ad)'
 
+### 0.4.1 (23 April 2015)
+
+* 7da52f3 - Switch from require_relative to require to avoid double-loading when symlinks are involved (John Meredith, Thu Apr 23 14:46:03 2015 +1000)
+
 ### 0.4.0 (20 March 2015)
 
 * 409bde5 - support url including basic authentication info, e.g.: http://username:password@packtbroker.com (lifei zhou, Wed Mar 18 21:49:29 2015 +1100)

data/lib/pact/array_like.rb

@@ -0,0 +1,49 @@
+require 'pact/symbolize_keys'
+module Pact
+  class ArrayLike
+    include SymbolizeKeys
+
+    attr_reader :contents
+    attr_reader :min
+
+    def initialize contents, options = {}
+      @contents = contents
+      @min = options[:min] || 1
+    end
+
+    def to_hash
+      {
+        :json_class => self.class.name,
+        :contents => contents,
+        :min => min
+      }
+    end
+
+    def as_json opts = {}
+      to_hash
+    end
+
+    def to_json opts = {}
+      as_json.to_json opts
+    end
+
+    def self.json_create hash
+      symbolized_hash = symbolize_keys(hash)
+      new(symbolized_hash[:contents], {min: symbolized_hash[:min]})
+    end
+
+    def eq other
+      self == other
+    end
+
+    def == other
+      other.is_a?(ArrayLike) && other.contents == self.contents && other.min == self.min
+    end
+
+    def generate
+      min.times.collect{ Pact::Reification.from_term contents }
+    end
+  end
+end
+
+

data/lib/pact/consumer_contract/consumer_contract.rb

@@ -6,10 +6,10 @@ require 'pact/shared/active_support_support'
 require 'date'
 require 'json/add/regexp'
 require 'open-uri'
-require_relative 'service_consumer'
-require_relative 'service_provider'
-require_relative 'interaction'
-require_relative 'pact_file'
+require 'pact/consumer_contract/service_consumer'
+require 'pact/consumer_contract/service_provider'
+require 'pact/consumer_contract/interaction'
+require 'pact/consumer_contract/pact_file'
 
 module Pact
 
@@ -72,4 +72,4 @@ module Pact
     end
 
   end
-end
+end

data/lib/pact/consumer_contract/interaction.rb

@@ -19,9 +19,9 @@ module Pact
       end
 
       def self.from_hash hash
-        request_hash = Pact::MatchingRules.merge(hash['request'], hash['request']['requestMatchingRules'])
+        request_hash = Pact::MatchingRules.merge(hash['request'], hash['request']['matchingRules'])
         request = Pact::Request::Expected.from_hash(request_hash)
-        response_hash = Pact::MatchingRules.merge(hash['response'], hash['response']['responseMatchingRules'])
+        response_hash = Pact::MatchingRules.merge(hash['response'], hash['response']['matchingRules'])
         response = Pact::Response.from_hash(response_hash)
         new(symbolize_keys(hash).merge(request: request, response: response))
       end

data/lib/pact/consumer_contract/query.rb

@@ -1,5 +1,5 @@
-require_relative 'query_hash'
-require_relative 'query_string'
+require 'pact/consumer_contract/query_hash'
+require 'pact/consumer_contract/query_string'
 
 module Pact
   class Query
@@ -13,4 +13,4 @@ module Pact
     end
 
   end
-end
+end

data/lib/pact/logging.rb

@@ -1,5 +1,5 @@
 require 'logger'
-require_relative 'configuration'
+require 'pact/configuration'
 
 module Pact
   module Logging
@@ -11,4 +11,4 @@ module Pact
       Pact.configuration.logger
     end
   end
-end
+end

data/lib/pact/matchers.rb

@@ -1 +1 @@
-require_relative 'matchers/matchers'
+require 'pact/matchers/matchers'

data/lib/pact/matchers/matchers.rb

@@ -37,6 +37,7 @@ module Pact
       when Array then array_diff(expected, actual, options)
       when Regexp then regexp_diff(expected, actual, options)
       when Pact::SomethingLike then calculate_diff(expected.contents, actual, options.merge(:type => true))
+      when Pact::ArrayLike then array_like_diff(expected, actual, options)
       else object_diff(expected, actual, options)
       end
     end
@@ -76,6 +77,16 @@ module Pact
       diff_found ? difference : NO_DIFF
     end
 
+    def array_like_diff array_like, actual, options
+      if actual.is_a? Array
+        expected_size = [array_like.min, actual.size].max
+        expected_array = expected_size.times.collect{ Pact::Term.unpack_regexps(array_like.contents) }
+        actual_array_diff expected_array, actual, options.merge(:type => true)
+      else
+        Difference.new array_like.generate, actual
+      end
+    end
+
     def hash_diff expected, actual, options
       if actual.is_a? Hash
         actual_hash_diff expected, actual, options

data/lib/pact/matching_rules/extract.rb

@@ -21,16 +21,15 @@ module Pact
       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 recurse_something_like(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
         else
-          record_rule object, path, match_type
+          record_match_type_rule path, match_type
         end
-
       end
 
       def recurse_hash hash, path, match_type
@@ -45,19 +44,32 @@ module Pact
         end
       end
 
-      def recurse_something_like something_like, path, match_type
+      def handle_something_like something_like, path, match_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] = rules[path].merge(rule)
+      end
+
       def record_regex_rule term, path
         rules[path] ||= {}
         rules[path]['match'] = 'regex'
         rules[path]['regex'] = term.matcher.inspect[1..-2]
       end
 
-      def record_rule object, path, match_type
-        rules[path] ||= {}
-        rules[path]['match'] = 'type'
+      def record_match_type_rule path, match_type
+        unless match_type == :array_like
+          rules[path] ||= {}
+          rules[path]['match'] = match_type
+        end
       end
     end
   end

data/lib/pact/matching_rules/merge.rb

@@ -1,3 +1,5 @@
+require 'pact/array_like'
+
 module Pact
   module MatchingRules
     class Merge
@@ -34,22 +36,43 @@ module Pact
       end
 
       def recurse_array array, path
-        new_array = []
-        array.each_with_index do | item, index |
-          new_path = path + "[#{index}]"
-          new_array << recurse(wrap(item, new_path), new_path)
+        array_like_path = "#{path}[*].*"
+        array_match_type = @matching_rules[array_like_path] && @matching_rules[array_like_path]['match']
+
+        if array_match_type == 'type'
+          warn_when_not_one_example_item(array, path)
+          min = @matching_rules[path]['min']
+          # log_ignored_rules(path, @matching_rules[path], {'min' => min})
+          Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
+        else
+          new_array = []
+          array.each_with_index do | item, index |
+            new_path = path + "[#{index}]"
+            new_array << recurse(wrap(item, new_path), new_path)
+          end
+          new_array
         end
-        new_array
       end
 
+      def warn_when_not_one_example_item array, path
+        unless array.size == 1
+          Pact.configuration.error_stream.puts "WARN: Only the first item will be used to match the items in the array at #{path}"
+        end
+      end
+
+      # def handle_array_like
+
       def wrap object, path
         rules = @matching_rules[path]
-        return object unless rules
+        array_rules = @matching_rules["#{path}[*].*"]
+        return object unless rules || array_rules
 
         if rules['match'] == 'type'
           handle_match_type(object, path, rules)
         elsif rules['regex']
           handle_regex(object, path, rules)
+        # elsif array_rules['match'] == 'type'
+        #   handle_array_like(object, path, rules)
         else
           log_ignored_rules(path, rules, {})
           object

data/lib/pact/support/version.rb

@@ -1,5 +1,5 @@
 module Pact
   module Support
-    VERSION = "0.4.0"
+    VERSION = "0.4.1"
   end
 end

data/spec/fixtures/interaction-with-matching-rules.json

@@ -7,7 +7,7 @@
     "body": {
       "name": "Mary"
     },
-    "requestMatchingRules": {
+    "matchingRules": {
       "$.body.name" : {"regex" : ".+"}
     }
   },
@@ -20,7 +20,7 @@
         }
       }
     },
-    "responseMatchingRules" : {
+    "matchingRules" : {
       "$.body._links.self.href": {"regex": "http:\\/\\/.*\\/\\d+"}
     }
   }

data/spec/lib/pact/array_like_spec.rb

@@ -0,0 +1,37 @@
+require 'pact/array_like'
+
+module Pact
+  describe ArrayLike do
+
+    describe "#eq" do
+      subject { ArrayLike.new({name: 'Fred'}, {min: 3}) }
+      context "when the contents and min are the same" do
+        let(:other) { ArrayLike.new({name: 'Fred'}, {min: 3}) }
+        it "returns true" do
+          expect(subject).to eq other
+        end
+
+      end
+      context "when the contents are different" do
+        let(:other) { ArrayLike.new({name: 'John'}, {min: 3}) }
+        it "returns false" do
+          expect(subject).to_not eq other
+        end
+      end
+      context "when the min is different" do
+        let(:other) { ArrayLike.new({name: 'Fred'}, {min: 1}) }
+        it "returns false" do
+          expect(subject).to_not eq other
+        end
+      end
+    end
+
+    subject { ArrayLike.new({name: Pact::Term.new(generate: 'Fred', matcher: /F/)}, {min: 2}) }
+
+    describe "#generate" do
+      it "creates an array with the reified example" do
+        expect(subject.generate).to eq [{name: 'Fred'},{name: 'Fred'}]
+      end
+    end
+  end
+end

data/spec/lib/pact/matchers/matchers_array_like_spec.rb

@@ -0,0 +1,207 @@
+require 'pact/matchers'
+
+module Pact
+  describe Matchers do
+
+    include Pact::Matchers
+
+    let(:min) { 1 }
+    let(:expected) do
+      {
+        animals: Pact::ArrayLike.new({name: 'Fred'}, {min: min})
+      }
+    end
+
+    let(:difference) { diff(expected, actual) }
+
+    context "when each element in the array matches by type" do
+      let(:actual) do
+        {
+          animals: [{name: 'Susan'}, {name: 'Janet'}]
+        }
+      end
+      it "matches" do
+        expect(difference).to be_empty
+      end
+    end
+
+    context "when each element in the array does not match by type" do
+      let(:actual) do
+        {
+          animals: [{name: 'Susan'}, {name: 1}]
+        }
+      end
+      let(:expected_difference) do
+          {
+            animals: [
+                Pact::Matchers::NoDiffAtIndex.new,
+                {
+                    name: Pact::Matchers::TypeDifference.new(ExpectedType.new('Fred'), ActualType.new(1))
+                }
+            ]
+          }
+      end
+      it "returns a diff" do
+        expect(difference).to eq expected_difference
+      end
+    end
+
+    context "when an ArrayLike is expected but a hash is found" do
+      let(:actual) do
+        {
+          animals: {
+            some: 'Animals'
+          }
+        }
+      end
+      let(:expected_difference) do
+        {
+          animals: Matchers::Difference.new([{name: 'Fred'}], {some: 'Animals'})
+        }
+      end
+      it "returns a diff" do
+        expect(difference).to eq expected_difference
+      end
+    end
+
+    context "when an ArrayLike is expected but nil found" do
+      let(:actual) do
+        {
+          animals: nil
+        }
+      end
+      let(:expected_difference) do
+        {
+          animals: Matchers::Difference.new([{name: 'Fred'}], nil)
+        }
+      end
+      it "returns a diff" do
+        expect(difference).to eq expected_difference
+      end
+    end
+
+    context "when an ArrayLike is expected but an empty array is found" do
+      let(:actual) do
+        {
+          animals: []
+        }
+      end
+      let(:expected_difference) do
+        {
+          animals: [Matchers::Difference.new({name: 'Fred'}, Pact::IndexNotFound.new)]
+        }
+      end
+      it "returns a diff" do
+        expect(difference).to eq expected_difference
+      end
+    end
+
+    context "when an ArrayLike is expected but the actual does not have enough elements in it" do
+      let(:min) { 2 }
+      let(:actual) do
+        {
+          animals: [{name: 'Susan'}]
+        }
+      end
+      let(:expected_difference) do
+        {
+          animals: [Pact::Matchers::NoDiffAtIndex.new, Matchers::Difference.new({name: 'Fred'}, Pact::IndexNotFound.new)]
+        }
+      end
+      it "returns a diff" do
+        expect(difference).to eq expected_difference
+      end
+    end
+
+    context "when an ArrayLike is expected with a Pact::Term in it" do
+      let(:expected) do
+        {
+          animals: Pact::ArrayLike.new(name: Pact::Term.new(generate: 'Fred', matcher: /F/))
+        }
+      end
+      let(:actual) do
+        {
+          animals: [{name: 'Susan'}]
+        }
+      end
+      let(:expected_difference) do
+        {
+          animals: [{name: Matchers::RegexpDifference.new(/F/, 'Susan')}]
+        }
+      end
+      it "returns a diff" do
+        expect(difference).to eq expected_difference
+      end
+    end
+
+    context "when an ArrayLike is expected within an ArrayLike and they match" do
+      let(:expected) do
+        {
+          animals: Pact::ArrayLike.new(
+            name: 'Fred',
+            children: Pact::ArrayLike.new(
+              age: 8
+            )
+          )
+        }
+      end
+      let(:actual) do
+        {
+          animals: [
+            {
+              name: 'Susan',
+              children: [
+                {age: 4},{age: 5}
+              ]
+            }
+          ]
+        }
+      end
+      it "returns an empty diff" do
+        expect(difference).to be_empty
+      end
+    end
+
+    context "when an ArrayLike is expected within an ArrayLike and they don't match" do
+      let(:expected) do
+        {
+          animals: Pact::ArrayLike.new(
+            name: 'Fred',
+            children: Pact::ArrayLike.new(
+              age: 8
+            )
+          )
+        }
+      end
+      let(:actual) do
+        {
+          animals: [
+            {
+              name: 'Susan',
+              children: [
+                {age: 4},{foo: 'bar'}
+              ]
+            }
+          ]
+        }
+      end
+      let(:expected_difference) do
+        {
+          animals: [
+            {
+              children: [
+                Matchers::NoDiffAtIndex.new,
+                {
+                  age: Matchers::TypeDifference.new(ExpectedType.new(8), KeyNotFound.new)
+                }
+              ]
+            }
+          ]
+        }
+      end
+      it "returns the diff" do
+        expect(difference).to eq expected_difference
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 require 'pact/matching_rules/extract'
 require 'pact/something_like'
+require 'pact/array_like'
 require 'pact/term'
 
 module Pact
@@ -99,6 +100,54 @@ module Pact
             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" => {"min" => 1},
+              "$.body.alligators[*].*" => {"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" => {"min" => 1},
+              "$.body.alligators[*].*" => {"match" => "type"},
+              "$.body.alligators[*].phoneNumber" => {"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
       end
     end
   end

data/spec/lib/pact/matching_rules/merge_spec.rb

@@ -142,6 +142,92 @@ module Pact
             expect(subject["_links"]["self"][0]["href"].matcher.inspect).to eq "/http:\\/\\/.*\\/thing/"
           end
         end
+
+        describe "with an array where all elements should match by type" do
+          let(:expected) do
+            {
+
+              'alligators' => [
+                {'name' => 'Mary'}
+              ]
+
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.body.alligators" => { 'min' => 2 },
+              "$.body.alligators[*].*" => { 'match' => 'type'}
+            }
+          end
+          it "creates a Pact::ArrayLike at the appropriate path" do
+            expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+            expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+            expect(subject["alligators"].min).to eq 2
+          end
+        end
+
+        describe "with an array where all elements should match by type nested inside another array where all elements should match by type" do
+          let(:expected) do
+            {
+
+              'alligators' => [
+                {
+                  'name' => 'Mary',
+                  'children' => [
+                    'age' => 9
+                  ]
+                }
+              ]
+
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.body.alligators" => { 'min' => 2 },
+              "$.body.alligators[*].*" => { 'match' => 'type'},
+              "$.body.alligators[*].children" => { 'min' => 1 },
+              "$.body.alligators[*].children[*].*" => { 'match' => 'type'}
+            }
+          end
+          it "creates a Pact::ArrayLike at the appropriate path" do
+            expect(subject["alligators"].contents['children']).to be_instance_of(Pact::ArrayLike)
+            expect(subject["alligators"].contents['children'].contents).to eq 'age' => 9
+            expect(subject["alligators"].contents['children'].min).to eq 1
+          end
+        end
+
+        describe "with an example array with more than one item" do
+          let(:expected) do
+            {
+
+              'alligators' => [
+                {'name' => 'Mary'},
+                {'name' => 'Joe'}
+              ]
+
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.body.alligators" => { 'min' => 2 },
+              "$.body.alligators[*].*" => { 'match' => 'type'}
+            }
+          end
+
+          xit "doesn't warn about the min size being ignored" do
+            expect(Pact.configuration.error_stream).to receive(:puts).once
+            subject
+          end
+
+          it "warns that the other items will be ignored" do
+            allow(Pact.configuration.error_stream).to receive(:puts)
+            expect(Pact.configuration.error_stream).to receive(:puts).with(/WARN: Only the first item/)
+            subject
+          end
+        end
       end
     end
   end

data/spec/pact_specification/compliance-2.0.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'pact/consumer/request'
+require 'pact/consumer_contract/request'
+require 'pact/matchers/embedded_diff_formatter'
+
+
+PACT_SPEC_DIR = "../pact-specification/testcases"
+REQUEST_TEST_CASE_FOLDERS = Dir.glob("#{PACT_SPEC_DIR}/request/**")
+REQUEST_TEST_CASE_FILES = Dir.glob("#{PACT_SPEC_DIR}/request/**/*.json")
+
+TEST_DESCRIPTIONS = {true => "matches", false => "does not match"}
+TESTCASES = "**/*.json"
+# TESTCASES = "array with nested array that matches.json"
+describe "Pact gem complicance with Pact Specification 1.0.0" do
+
+  directories = Dir.glob("#{PACT_SPEC_DIR}/request") # make this a *
+
+  directories.each do | dir_name |
+
+    describe File.basename(dir_name) do
+
+      sub_directories = Dir.glob("#{dir_name}/*")
+
+      sub_directories.each do | sub_dir_name |
+
+        context File.basename(sub_dir_name) do
+          testcases = Dir.glob("#{sub_dir_name}/#{TESTCASES}")
+
+          testcases.each do | file_name |
+
+            context File.basename(file_name).chomp(".json") do
+
+              file_content = nil
+              begin
+                file_content = File.read(file_name)
+                test_content = JSON.parse(file_content)
+                default = {'query' => '', 'headers' => {}}
+
+                request_hash = Pact::MatchingRules.merge(test_content["expected"], test_content["expected"]['matchingRules'])
+                expected = Pact::Request::Expected.from_hash(default.merge(request_hash))
+
+                # expected = Pact::Request::Expected.from_hash(default.merge(test_content["expected"]))
+                actual = Pact::Consumer::Request::Actual.from_hash(default.merge(test_content["actual"]))
+                expected_result = test_content.fetch("match")
+                comment = test_content["comment"]
+
+                it "#{TEST_DESCRIPTIONS[expected_result]} - #{comment}" do
+                  matches = expected.matches?(actual)
+                  if matches != expected_result
+                    puts Pact::Matchers::EmbeddedDiffFormatter.call(expected.difference(actual))
+                  end
+                  expect(matches).to eq expected_result
+                end
+              rescue => e
+                puts "Error parsing json from #{file_name}, #{e.message}: #{file_content}"
+                raise e
+              end
+
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact-support
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - James Fraser
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-20 00:00:00.000000000 Z
+date: 2015-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp
@@ -230,6 +230,7 @@ files:
 - README.md
 - RELEASING.md
 - Rakefile
+- lib/pact/array_like.rb
 - lib/pact/configuration.rb
 - lib/pact/consumer/request.rb
 - lib/pact/consumer_contract.rb
@@ -286,6 +287,7 @@ files:
 - pact-support.gemspec
 - spec/fixtures/interaction-with-matching-rules.json
 - spec/integration/matching_rules_extract_and_merge_spec.rb
+- spec/lib/pact/array_like_spec.rb
 - spec/lib/pact/configuration_spec.rb
 - spec/lib/pact/consumer/request_spec.rb
 - spec/lib/pact/consumer_contract/active_support_support_spec.rb
@@ -302,6 +304,7 @@ files:
 - spec/lib/pact/matchers/embedded_diff_formatter_spec.rb
 - spec/lib/pact/matchers/index_not_found_spec.rb
 - spec/lib/pact/matchers/list_diff_formatter_spec.rb
+- spec/lib/pact/matchers/matchers_array_like_spec.rb
 - spec/lib/pact/matchers/matchers_spec.rb
 - spec/lib/pact/matchers/no_diff_at_index_spec.rb
 - spec/lib/pact/matchers/regexp_difference_spec.rb
@@ -320,6 +323,7 @@ files:
 - spec/lib/pact/shared/text_differ_spec.rb
 - spec/lib/pact/something_like_spec.rb
 - spec/lib/pact/term_spec.rb
+- spec/pact_specification/compliance-2.0.rb
 - spec/spec_helper.rb
 - spec/support/a_consumer-a_producer.json
 - spec/support/a_consumer-a_provider.json
@@ -370,6 +374,7 @@ summary: Shared code for Pact gems
 test_files:
 - spec/fixtures/interaction-with-matching-rules.json
 - spec/integration/matching_rules_extract_and_merge_spec.rb
+- spec/lib/pact/array_like_spec.rb
 - spec/lib/pact/configuration_spec.rb
 - spec/lib/pact/consumer/request_spec.rb
 - spec/lib/pact/consumer_contract/active_support_support_spec.rb
@@ -386,6 +391,7 @@ test_files:
 - spec/lib/pact/matchers/embedded_diff_formatter_spec.rb
 - spec/lib/pact/matchers/index_not_found_spec.rb
 - spec/lib/pact/matchers/list_diff_formatter_spec.rb
+- spec/lib/pact/matchers/matchers_array_like_spec.rb
 - spec/lib/pact/matchers/matchers_spec.rb
 - spec/lib/pact/matchers/no_diff_at_index_spec.rb
 - spec/lib/pact/matchers/regexp_difference_spec.rb
@@ -404,6 +410,7 @@ test_files:
 - spec/lib/pact/shared/text_differ_spec.rb
 - spec/lib/pact/something_like_spec.rb
 - spec/lib/pact/term_spec.rb
+- spec/pact_specification/compliance-2.0.rb
 - spec/spec_helper.rb
 - spec/support/a_consumer-a_producer.json
 - spec/support/a_consumer-a_provider.json
@@ -426,4 +433,3 @@ test_files:
 - spec/support/test_app_fail.json
 - spec/support/test_app_pass.json
 - spec/support/test_app_with_right_content_type_differ.json
-has_rdoc: