pact-support 1.9.0 → 1.15.0

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

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/embedded_diff_formatter'
-require 'pact/matchers/type_difference'
-require 'pact/matchers/expected_type'
-require 'pact/matchers/actual_type'
-
-module Pact
-  module Matchers
-    describe EmbeddedDiffFormatter do
-
-      let(:diff) do
-        {
-          :something => TypeDifference.new(ExpectedType.new("Fred"), ActualType.new(1))
-        }
-      end
-
-      subject { EmbeddedDiffFormatter.call(diff, options) }
-
-      let(:options) { { colour: colour }}
-      let(:expected_coloured) { '"' + ::Term::ANSIColor.red("expected_type") + '":'}
-      let(:actual_coloured) { '"' + ::Term::ANSIColor.green("actual_type") + '":'}
-
-      describe ".call" do
-
-        let(:colour) { false }
-
-        context "when color_enabled is true" do
-
-          let(:colour) { true }
-
-          it "returns nicely formatted json" do
-            expect(subject.split("\n").size).to eq 6
-          end
-
-          it "returns a string displaying the diff in colour" do
-            expect(subject).to include expected_coloured
-            expect(subject).to include actual_coloured
-          end
-        end
-
-        context "when color_enabled is false" do
-
-          let(:colour) { false }
-
-          it "returns nicely formatted json" do
-            expect(subject.split("\n").size).to eq 6
-          end
-
-          it "returns a string displaying the diff without colour" do
-            expect(subject).to_not include expected_coloured
-            expect(subject).to_not include actual_coloured
-          end
-        end
-
-        context "with a Pact::Term" do
-          let(:diff) { {thing: Difference.new(Pact::Term.new(generate: "Joe", matcher: /Jo/), "Mary")} }
-
-          xit "displays the matcher from the Pact::Term" do
-            expect(subject).to_not include("Pact::Term")
-            expect(subject).to include("/Jo/")
-          end
-
-        end
-
-        context "when no options are specified" do
-          subject { EmbeddedDiffFormatter.call(diff) }
-
-          context "when Pact.configuration.color_enabled is true" do
-            it "returns a string displaying the diff in colour" do
-              expect(Pact.configuration).to receive(:color_enabled).and_return(true)
-              expect(subject).to include expected_coloured
-              expect(subject).to include actual_coloured
-            end
-          end
-
-          context "when Pact.configuration.color_enabled is false" do
-            it "returns a string displaying the diff without colour" do
-              expect(Pact.configuration).to receive(:color_enabled).and_return(false)
-              expect(subject).to_not include expected_coloured
-              expect(subject).to_not include actual_coloured
-            end
-          end
-
-        end
-      end
-
-    end
-
-  end
-end

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

@@ -1,78 +0,0 @@
-require 'pact/matchers/extract_diff_messages'
-
-module Pact
-  module Matchers
-    describe ExtractDiffMessages do
-
-      subject { ExtractDiffMessages.call(diff).join("\n") }
-
-      context "<path> with a diff in a Hash" do
-        let(:diff) { {a: Difference.new(nil, nil, "There was a difference at <path>") } }
-
-        it { is_expected.to eq "There was a difference at $.a" }
-      end
-
-      context "<parent_path> with a diff in a Hash" do
-        let(:diff) { {a: Difference.new(nil, nil, "There was a difference at <parent_path>") } }
-
-        it { is_expected.to eq "There was a difference at $" }
-      end
-
-      context "<path> with a diff in a nested Hash" do
-        let(:diff) { {a: {b: Difference.new(nil, nil, "There was a difference at <path>")}} }
-
-        it { is_expected.to eq "There was a difference at $.a.b" }
-      end
-
-      context "<parent_path> with a diff in a nested Hash" do
-        let(:diff) { {a: {b: Difference.new(nil, nil, "There was a difference at <parent_path>")}} }
-
-        it { is_expected.to eq "There was a difference at $.a" }
-      end
-
-      context "<path> with a diff in an Array" do
-        let(:diff) { [NoDiffAtIndex.new, Difference.new(nil, nil, "There was a difference at <path>")] }
-
-        it { is_expected.to eq "There was a difference at $[1]" }
-      end
-
-      context "<parent_path> with a diff in an Array" do
-        let(:diff) { [NoDiffAtIndex.new, Difference.new(nil, nil, "There was a difference at <parent_path>")] }
-
-        it { is_expected.to eq "There was a difference at $" }
-      end
-
-      context "<path> with a diff in a nested Array" do
-        let(:diff) { [NoDiffAtIndex.new,[NoDiffAtIndex.new, Difference.new(nil, nil, "There was a difference at <path>")]] }
-
-        it { is_expected.to eq "There was a difference at $[1][1]" }
-      end
-
-      context "<parent_path> with a diff in a nested Array" do
-        let(:diff) { [NoDiffAtIndex.new,[NoDiffAtIndex.new, Difference.new(nil, nil, "There was a difference at <parent_path>")]] }
-
-        it { is_expected.to eq "There was a difference at $[1]" }
-      end
-
-      context "when there is a space in the key" do
-        let(:diff) do
-          {"Foo Bar" => Difference.new(nil, nil, "There was a difference at <path>")}
-        end
-
-        it { is_expected.to eq "There was a difference at $.\"Foo Bar\"" }
-      end
-
-      context "with two differences" do
-        let(:diff) do
-          {
-            a: Difference.new(nil, nil, "There was a difference at <path>"),
-            b: Difference.new(nil, nil, "There was a difference at <path>")
-          }
-        end
-
-        it { is_expected.to eq "There was a difference at $.a\nThere was a difference at $.b" }
-      end
-
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/index_not_found'
-
-module Pact
-  describe IndexNotFound 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/list_diff_formatter_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/list_diff_formatter'
-require 'pact/matchers/matchers'
-require 'support/ruby_version_helpers'
-
-# Needed to stop the ai printing in color
-# TODO: fix this!
-AwesomePrint.defaults = {
-  plain: true
-}
-
-module Pact
-  module Matchers
-    describe ListDiffFormatter do
-
-      describe ".call" do
-        subject{ ListDiffFormatter.call(diff, {}) }
-
-        context "when using class based matching" do
-          let(:diff) { {root: TypeDifference.new(ExpectedType.new("Fred"), ActualType.new(1)) } }
-          let(:expected_output) { <<-EOS
-\tAt:
-\t\t[:root]
-\tExpected type:
-\t\tString
-\tActual type:
-\t\t#{RubyVersionHelpers.numeric_type}
-EOS
-          }
-
-          it "shows the expected and actual classes" do
-            expect(subject + "\n").to eq(expected_output)
-          end
-
-        end
-
-        context "when there is an unmatched regexp" do
-          let(:diff) { {root: RegexpDifference.new(/fr.*ed/, "mary") } }
-          let(:expected_output) { <<-EOS
-\tAt:
-\t\t[:root]
-\tExpected to match:
-\t\t/fr.*ed/
-\tActual:
-\t\t"mary"
-EOS
-          }
-          it "shows the expected regexp" do
-            expect(subject + "\n").to eq(expected_output)
-          end
-        end
-
-        context "when there is a mismatched value" do
-          let(:diff) { {root: {"blah" => { 1 => Difference.new("alphabet", "woozle")}}} }
-          let(:expected_output) { ""}
-
-          it "includes the expected value" do
-            expect(subject).to match(/Expected:.*"alphabet"/m)
-          end
-          it "includes the actual value" do
-            expect(subject).to match(/Actual:.*"woozle"/m)
-          end
-
-          it "includes the path" do
-            expect(subject).to include('[:root]["blah"][1]')
-          end
-        end
-
-        context "when there is a missing key" do
-          let(:expected_hash) { {"abc" => {"def" => [1,2]}}}
-          let(:diff) { {root: {"blah" => { 1 => Difference.new(expected_hash, Pact::KeyNotFound.new )}}} }
-          let(:expected_output) { ""}
-
-          it "includes the expected value" do
-            expect(subject).to match(/Missing key with value\:.*\{/m)
-          end
-
-          it "includes the path" do
-            expect(subject).to include('[:root]["blah"][1]')
-          end
-        end
-
-        context "when there is a missing index" do
-          let(:diff) { [NoDiffAtIndex.new, Difference.new(1, IndexNotFound.new )]}
-          it "includes the expected value" do
-            expect(subject).to match(/Missing.*1/m)
-          end
-
-          it "includes the path" do
-            expect(subject).to include('[1]')
-          end
-        end
-
-        context "when there is an unexpected index" do
-          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
-
-          it "includes the path" do
-            expect(subject).to include('[1]')
-            expect(subject).to include('[2]')
-          end
-        end
-
-        context "when there is an unexpected key" do
-          let(:diff) { {"blah" => Difference.new(UnexpectedKey.new, "b")}}
-          it "includes the unexpected key" do
-            expect(subject).to include("Hash contained unexpected key with value:")
-          end
-
-          it "includes the path" do
-            expect(subject).to include('["blah"]')
-          end
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,222 +0,0 @@
-require 'pact/matchers'
-
-module Pact
-  describe Matchers do
-
-    let(:min) { 1 }
-    let(:expected) do
-      {
-        animals: Pact::ArrayLike.new({name: 'Fred'}, {min: min})
-      }
-    end
-
-    let(:difference) { Pact::Matchers.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 a hash is found" do
-      let(:actual) do
-        {
-
-        }
-      end
-      let(:expected_difference) do
-        {
-          animals: Matchers::Difference.new([{name: 'Fred'}], Pact::KeyNotFound.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