pact-support 0.2.1 → 0.3.0

data/lib/pact/support/version.rb

@@ -1,5 +1,5 @@
 module Pact
   module Support
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/pact/term.rb

@@ -27,7 +27,7 @@ module Pact
       @matcher = attributes[:matcher]
       raise "Please specify a matcher for the Term" unless @matcher != nil
       raise "Please specify a value to generate for the Term" unless @generate != nil
-      raise "Value to generate \"#{@generate}\" does not match regular expression #{@matcher}" unless @generate =~ @matcher
+      raise "Value to generate \"#{@generate}\" does not match regular expression #{@matcher.inspect}" unless @generate =~ @matcher
     end
 
     def to_hash

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

@@ -0,0 +1,27 @@
+{
+  "description": "a request to make something",
+  "providerState" : null,
+  "request" : {
+    "method" : "POST",
+    "path" : "/something",
+    "body": {
+      "name": "Mary"
+    },
+    "requestMatchingRules": {
+      "$.body.name" : {"regex" : ".+"}
+    }
+  },
+  "response" : {
+    "status" : 200,
+    "body" : {
+      "_links" : {
+        "self" : {
+          "href" : "http://localhost:1234/things/1"
+        }
+      }
+    },
+    "responseMatchingRules" : {
+      "$.body._links.self.href": {"regex": "http:\\/\\/.*\\/\\d+"}
+    }
+  }
+}

data/spec/integration/matching_rules_extract_and_merge_spec.rb

@@ -0,0 +1,98 @@
+require 'pact/term'
+require 'pact/something_like'
+require 'pact/matching_rules/extract'
+require 'pact/matching_rules/merge'
+require 'pact/reification'
+
+describe "converting Pact::Term and Pact::SomethingLike to matching rules and back again" do
+
+  let(:example) { Pact::Reification.from_term expected }
+  let(:matching_rules) { Pact::MatchingRules::Extract.(expected) }
+  let(:recreated_expected) { Pact::MatchingRules::Merge.(example, matching_rules)}
+
+  context "with a Pact::Term" do
+    let(:expected) do
+      {
+        body: {
+          alligator: {
+            name: Pact::Term.new(generate: 'Mary', matcher: /M/)
+          }
+        }
+      }
+    end
+
+    it "recreates the same object hierarchy" do
+      expect(recreated_expected).to eq expected
+    end
+  end
+
+  context "with a Pact::SomethingLike" do
+    let(:expected) do
+      {
+        body: {
+          alligator: {
+            name: Pact::SomethingLike.new("Mary")
+          }
+        }
+      }
+    end
+
+    it "recreates the same object hierarchy" do
+      expect(recreated_expected).to eq expected
+    end
+  end
+
+  context "with a Pact::SomethingLike containing a Hash" do
+    let(:expected) do
+      {
+        body: {
+          alligator: Pact::SomethingLike.new(name: 'Mary')
+        }
+      }
+    end
+
+    let(:similar) do
+      {
+        body: {
+          alligator: {
+            name: Pact::SomethingLike.new('Mary')
+          }
+        }
+      }
+    end
+
+    it "recreates the same object hierarchy", pending: 'Waiting for Pact JVM to implement nested type matching' do
+      expect(recreated_expected).to eq expected
+    end
+
+    it "recreates a similar object hierarchy that does the same thing" do
+      expect(recreated_expected).to eq similar
+    end
+  end
+
+  context "with a Pact::SomethingLike containing an Array" do
+    let(:expected) do
+      {
+        body: {
+          alligators: Pact::SomethingLike.new(["Mary", "Betty"])
+        }
+      }
+    end
+
+    let(:similar) do
+      {
+        body: {
+          alligators: [Pact::SomethingLike.new("Mary"), Pact::SomethingLike.new("Betty")]
+        }
+      }
+    end
+
+    it "recreates the same object hierarchy", pending: 'Waiting for Pact JVM to implement nested type matching' do
+      expect(recreated_expected).to eq expected
+    end
+
+    it "recreates a similar object hierarchy that does the same thing" do
+      expect(recreated_expected).to eq similar
+    end
+  end
+end

data/spec/lib/pact/consumer_contract/interaction_spec.rb

@@ -61,6 +61,20 @@ module Pact
             expect(subject.provider_state).to eq 'some state'
           end
         end
+
+        context "when there are matching rules" do
+          let(:hash) { load_json_fixture 'interaction-with-matching-rules.json' }
+
+          subject { Interaction.from_hash hash }
+
+          it "merges the rules with the example for the request" do
+            expect(subject.request.body['name']).to be_instance_of(Pact::Term)
+          end
+
+          it "merges the rules with the example for the response" do
+            expect(subject.response.body['_links']['self']['href']).to be_instance_of(Pact::Term)
+          end
+        end
       end
 
       describe "request_modifies_resource_without_checking_response_body?" do

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

@@ -80,7 +80,7 @@ EOS
         end
 
         context "when there is a missing index" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new(1, IndexNotFound.new )]}
+          let(:diff) { [NoDiffAtIndex.new, Difference.new(1, IndexNotFound.new )]}
           it "includes the expected value" do
             expect(subject).to match(/Missing.*1/m)
           end
@@ -91,7 +91,7 @@ EOS
         end
 
         context "when there is an unexpected index" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new(UnexpectedIndex.new, 2), Difference.new(UnexpectedIndex.new, "b")]}
+          let(:diff) { [NoDiffAtIndex.new, Difference.new(UnexpectedIndex.new, 2), Difference.new(UnexpectedIndex.new, "b")]}
           it "includes the unexpected value" do
             expect(subject).to include("Array contained unexpected item:")
           end

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

@@ -143,10 +143,11 @@ module Pact::Matchers
         let(:expected) { [{name: 'Fred'}, {name: 'Mary'}] }
         context "when an item with differing class values is found" do
           let(:actual) { [{name: 'Fred'}, {name: 1}] }
-          let(:difference) { [
-            Pact::Matchers::NO_DIFF_INDICATOR,
-             {:name =>
-                  TypeDifference.new(Pact::ExpectedType.new("Mary"), Pact::ActualType.new(1))
+          let(:difference) {
+            [
+              NoDiffAtIndex.new,
+              {
+                :name => TypeDifference.new(Pact::ExpectedType.new("Mary"), Pact::ActualType.new(1))
               }
             ]
           }
@@ -214,7 +215,7 @@ module Pact::Matchers
       context "when expected is longer than the actual" do
         subject { [1,2,3] }
         let(:actual) { [1,2]}
-        let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Pact::Matchers::NO_DIFF_INDICATOR, Difference.new(3, Pact::IndexNotFound.new)] }
+        let(:difference) { [NoDiffAtIndex.new, NoDiffAtIndex.new, Difference.new(3, Pact::IndexNotFound.new)] }
         it 'returns the diff' do
           expect(diff(subject, actual)).to eq(difference)
         end
@@ -223,7 +224,7 @@ module Pact::Matchers
       context "when the different index is in the middle of an array" do
         subject { [1,2,3] }
         let(:actual) { [1,7,3]}
-        let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Difference.new(2, 7), Pact::Matchers::NO_DIFF_INDICATOR] }
+        let(:difference) { [NoDiffAtIndex.new, Difference.new(2, 7), NoDiffAtIndex.new] }
         it 'returns the diff' do
           expect(diff(subject, actual)).to eq(difference)
         end
@@ -232,7 +233,7 @@ module Pact::Matchers
       context "when actual array is longer than the expected" do
         subject { [1] }
         let(:actual) { [1,2]}
-        let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Difference.new(Pact::UnexpectedIndex.new, 2)] }
+        let(:difference) { [NoDiffAtIndex.new, Difference.new(Pact::UnexpectedIndex.new, 2)] }
         it 'returns the diff' do
           expect(diff(subject, actual)).to eq(difference)
         end
@@ -478,7 +479,7 @@ module Pact::Matchers
       context "when two different arrays are found" do
         subject { [4,5,6] }
         let(:actual) { [4,6,7] }
-        let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Difference.new(5, 6), Difference.new(6, 7)] }
+        let(:difference) { [NoDiffAtIndex.new, Difference.new(5, 6), Difference.new(6, 7)] }
 
         it 'includes this in the diff' do
           expect(diff(subject, actual)).to eq(difference)

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

@@ -0,0 +1,15 @@
+require 'pact/matchers/no_diff_at_index'
+
+module Pact
+  module Matchers
+    describe NoDiffAtIndex do
+
+      describe "#to_json" do
+        it "returns a json string" do
+          expect(NoDiffAtIndex.new.to_json).to eq '"<no difference at this index>"'
+        end
+      end
+
+    end
+  end
+end

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

@@ -61,19 +61,19 @@ EOF
         end
 
         context "with an incorrect value in an array" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new({name: 'Mary'}, "Joe"), NoDiffIndicator.new] }
+          let(:diff) { [NoDiffAtIndex.new, Difference.new({name: 'Mary'}, "Joe"), NoDiffAtIndex.new] }
 
           it "displays '+' next to the incorrect values and '-' next to the missing ones" do
-            expect(subject).to match /no difference here!/
+            expect(subject).to include "... ,"
             expect(subject).to match /\-.*{/
             expect(subject).to match /\-.*}/
             expect(subject).to match /\-.*Mary/
             expect(subject).to match /\+.*Joe/
-            expect(subject).to match /no.*Mary.*Joe.*no/m
+            expect(subject).to match /\.\.\..*Mary.*Joe.*\.\.\./m
           end
 
           it "doesn't display the no difference indicator as a change" do
-            expect(subject).to match(/^\s+"no difference here!",$/)
+            expect(subject).to match(/^\s+... ,$/)
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
@@ -147,7 +147,7 @@ EOF
         end
 
         context "with a missing index" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new({name: 'Mary'}, IndexNotFound.new)] }
+          let(:diff) { [NoDiffAtIndex.new, Difference.new({name: 'Mary'}, IndexNotFound.new)] }
 
           it "displays '-' next to the missing items" do
             expect(subject).to match /\-.*Mary/
@@ -160,13 +160,14 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
+            expect(line_count).to eq 7 + key_lines_count
           end
 
         end
 
         context "with an unexpected index" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'})] }
+          let(:diff) { [NoDiffAtIndex.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'})] }
+          let(:diff) { { some_array: [NoDiffAtIndex.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'})]} }
 
           it "displays '+' next to the unexpected item" do
             expect(subject).to match /\+.*{/
@@ -175,10 +176,10 @@ EOF
             expect(subject).to match /\+.*Mary/
           end
 
-          xit "doesn't mark the 'no difference' as a change" do
-            expect(subject).to match /#{NoDiffIndicator.new.to_s},/
-            expect(subject).to_not match /\-.*#{NoDiffIndicator.new.to_s}/
-            expect(subject).to_not match /\+.*#{NoDiffIndicator.new.to_s}/
+          it "doesn't mark the 'no difference' as a change" do
+            expect(subject).to include "... ,"
+            expect(subject).to_not match /\-.*\.\.\./
+            expect(subject).to_not match /\+.*\.\.\./
           end
 
           it "does not display the UnexpectedIndex" do
@@ -186,13 +187,13 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
+            expect(line_count).to eq 9 + key_lines_count
           end
 
         end
 
         context "with 2 unexpected indexes" do
-          let(:diff) { [NoDiffIndicator.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'}), Difference.new(UnexpectedIndex.new, {name: 'Joe'})] }
+          let(:diff) { [NoDiffAtIndex.new, Difference.new(UnexpectedIndex.new, {name: 'Mary'}), Difference.new(UnexpectedIndex.new, {name: 'Joe'})] }
 
           it "displays '+' next to the unexpected item" do
             expect(subject).to match /\+.*Mary/
@@ -204,7 +205,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 11 + key_lines_count
+            expect(line_count).to eq 10 + key_lines_count
           end
 
         end

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

@@ -0,0 +1,105 @@
+require 'pact/matching_rules/extract'
+require 'pact/something_like'
+require 'pact/term'
+
+module Pact
+  module MatchingRules
+    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.foo" => {"match" => "type"},
+              "$.body.alligator.name" => {"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" => {"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.foo" => {"match" => "type"},
+              "$.body.alligator.name" => {"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.alligators[0].name" => {"match" => "type"},
+              "$.body.alligators[1].name" => {"match" => "type"}
+            }
+          end
+
+          it "lists a rule for each item" do
+            expect(subject).to eq rules
+          end
+        end
+      end
+    end
+  end
+end