pact-support 1.11.0 → 1.12.0

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

@@ -1,36 +0,0 @@
-require 'pact/matchers/multipart_form_diff_formatter'
-
-module Pact
-  module Matchers
-    describe MultipartFormDiffFormatter do
-      describe ".call" do
-        subject { MultipartFormDiffFormatter.call(diff, options)}
-
-        let(:diff) do
-          {
-            headers: header_diff,
-            body: body_diff
-          }
-        end
-
-        let(:header_diff) do
-          {
-            "Content-Type" => Difference.new("foo", "bar", "Wrong header")
-          }
-        end
-
-        let(:body_diff) do
-          Difference.new("foo", "bar", "A message")
-        end
-
-        let(:options) { {} }
-
-        let(:expected_output) { File.read("spec/fixtures/multipart-form-diff.txt")}
-
-        it "formats the diff" do
-          expect(subject).to eq expected_output
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-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/regexp_difference_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/regexp_difference'
-
-module Pact
-  module Matchers
-    describe RegexpDifference do
-
-      context "when a regexp is expected" do
-
-        subject { RegexpDifference.new(/ap/, 'pear').as_json }
-
-        it "indicates that the actual was indended 'to match'" do
-          expect(subject).to eq({:EXPECTED_TO_MATCH => "/ap/", :ACTUAL => "pear"})
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/type_difference'
-require 'support/ruby_version_helpers'
-
-module Pact
-  module Matchers
-    describe TypeDifference do
-      include RubyVersionHelpers
-
-      describe "#as_json" do
-
-        let(:expected) { ExpectedType.new("Fred") }
-        let(:actual) { ActualType.new(1) }
-        subject { TypeDifference.new expected, actual }
-
-        context "when the actual is a KeyNotFound" do
-          let(:actual) { KeyNotFound.new }
-          let(:expected_hash) { {:EXPECTED_TYPE => "String", :ACTUAL => actual.to_s } }
-
-          it "use the key ACTUAL" do
-            expect(subject.as_json).to eq(expected_hash)
-          end
-        end
-
-        context "when the actual is an ActualType" do
-          let(:expected_hash) { {:EXPECTED_TYPE => "String", :ACTUAL_TYPE => numeric_type.to_s } }
-
-          it "uses the key ACTUAL_TYPE" do
-             expect(subject.as_json).to eq(expected_hash)
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/unexpected_index'
-
-module Pact
-  describe UnexpectedIndex do
-
-    describe "#as_json" do
-      it "returns a string representation of the object" do
-        expect(subject.as_json).to eq subject.to_s
-      end
-    end
-
-    describe "#to_json" do
-      it "serialises the object to JSON" do
-        expect(subject.to_json).to eq "\"#{subject.to_s}\""
-      end
-    end
-
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/unexpected_key'
-
-module Pact
-  describe UnexpectedKey do
-
-    describe "#as_json" do
-      it "returns a string representation of the object" do
-        expect(subject.as_json).to eq subject.to_s
-      end
-    end
-
-    describe "#to_json" do
-      it "serialises the object to JSON" do
-        expect(subject.to_json).to eq "\"#{subject.to_s}\""
-      end
-    end
-
-  end
-end

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

@@ -1,235 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/unix_diff_formatter'
-require 'pact/matchers/expected_type'
-require 'pact/matchers/actual_type'
-require 'support/ruby_version_helpers'
-
-module Pact
-  module Matchers
-    describe UnixDiffFormatter do
-      include RubyVersionHelpers
-
-      describe ".call" do
-
-        let(:key_lines_count) { 9 }
-        let(:colour) { false }
-        subject { UnixDiffFormatter.call(diff, {colour: colour}) }
-
-        let(:line_count) { subject.split("\n").size }
-
-        context "when colour = false" do
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-          it "does not include colour" do
-            expect(subject).to_not include("[0m")
-          end
-        end
-
-        context "when colour = true" do
-          let(:colour) { true }
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-          it "uses colour" do
-            expect(subject).to include("[0m")
-          end
-        end
-
-        context "with class based matching" do
-          let(:diff) { {thing: TypeDifference.new(ExpectedType.new("fred"), ActualType.new(1))}}
-          let(:output) { <<-EOF
- {
--  "thing": String
-+  "thing": #{numeric_type}
- }
-EOF
-          }
-
-          it "displays nicely" do
-            expect(remove_ansicolor subject).to include output
-          end
-        end
-
-        context "with an incorrect value in a hash" do
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-
-          it "displays '+' next to the unexpected value, and '-' next to the missing one" do
-            expect(subject).to match /alligator/
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\+.*Joe/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with an incorrect value in an array" do
-          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 include "... ,"
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\+.*Joe/
-            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+... ,$/)
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with a regular expression that was not matched" do
-          let(:regexp) { %r{http://.*/thing/1234} }
-          let(:diff) { {thing: RegexpDifference.new(regexp, "pear")} }
-
-          it "displays the regular expression" do
-            expect(subject).to include(regexp.inspect)
-            expect(subject).to include(regexp.inspect)
-            expect(subject).to match /\-.*thing/
-            expect(subject).to match /\+.*pear/
-          end
-
-          it "does not put quotes around the regular expression" do
-            expect(subject).to match /\/$/
-            expect(subject).to match /: \//
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 4 + key_lines_count
-          end
-
-        end
-
-        context "with a missing key" do
-
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, KeyNotFound.new )}} }
-
-          it "it displays '-' next to the missing key and its value" do
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-            expect(subject).to match /\-.*alligator/
-            expect(subject).to match /\-.*name/
-            expect(subject).to match /\-.*Mary/
-          end
-
-          it "does not display the missing key in the actual output" do
-            expect(subject).to_not match /\+.*alligator/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 7 + key_lines_count
-          end
-        end
-
-        context "with an unexpected key" do
-          let(:diff) { {thing: {alligator: Difference.new(UnexpectedKey.new, {name: 'Mary'} )}} }
-
-          it "displays '+' next to the unexpected key and its value" do
-            expect(subject).to match /\+.*name/
-            expect(subject).to match /\+.*Mary/
-            expect(subject).to match /\+.*alligator/
-            expect(subject).to match /\+.*}/
-            expect(subject).to match /\+.*{/
-          end
-
-          it "does not display the unexpected key in the expected output" do
-            expect(subject).to_not match /\-.*alligator/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 7 + key_lines_count
-          end
-
-        end
-
-        context "with a missing index" do
-          let(:diff) { [NoDiffAtIndex.new, Difference.new({name: 'Mary'}, IndexNotFound.new)] }
-
-          it "displays '-' next to the missing items" do
-            expect(subject).to match /\-.*Mary/
-            expect(subject).to match /\-.*{/
-            expect(subject).to match /\-.*}/
-          end
-
-          it "does not display IndexNotFound" do
-            expect(subject).to_not match /#{IndexNotFound.new.to_s}/
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 6 + key_lines_count
-          end
-
-        end
-
-        context "with an unexpected index" do
-          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 /\+.*{/
-            expect(subject).to match /\+.*}/
-            expect(subject).to match /\+.*name/
-            expect(subject).to match /\+.*Mary/
-          end
-
-          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
-            expect(subject).to_not match UnexpectedIndex.new.to_s
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
-          end
-
-        end
-
-        context "with 2 unexpected indexes" do
-          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/
-            expect(subject).to match /\+.*Joe/
-          end
-
-          it "does not display the UnexpectedIndex" do
-            expect(subject).to_not match UnexpectedIndex.new.to_s
-          end
-
-          it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9 + key_lines_count
-          end
-
-        end
-
-        context "when the explanation should be included (default)" do
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-          subject { UnixDiffFormatter.call(diff, {colour: colour}) }
-
-          it "appends the explanation" do
-            expect(subject).to include ("Key:")
-          end
-        end
-
-        context "when the explanation should not be included" do
-          let(:diff) { {thing: {alligator: Difference.new({name: 'Mary'}, "Joe" )}} }
-          subject { UnixDiffFormatter.call(diff, {colour: colour, include_explanation: false}) }
-
-          it "does not append the explanation" do
-            expect(subject).to_not include ("Key:")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,216 +0,0 @@
-require 'pact/matching_rules/extract'
-require 'pact/something_like'
-require 'pact/array_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" => {"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" => {"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" => {"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" => {"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
-
-        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" => {"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]" => {"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