pact-support 0.0.1

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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'pact/consumer_contract/response'
+
+module Pact
+
+  describe Response do
+
+    subject { Response.from_hash(status: 200, headers: {'Content-Type' => 'application/json'}, body: {some: 'body'}) }
+
+    describe "#status" do
+      it "returns the status" do
+        expect(subject.status).to eq 200
+      end
+    end
+
+    describe "#headers" do
+      it "returns the Headers" do
+        expect(subject.headers).to eq Headers.new('Content-Type' => 'application/json')
+      end
+    end
+
+    describe "#body" do
+      it "returns the body" do
+        expect(subject.body).to eq some: 'body'
+      end
+    end
+
+    describe "#body_allows_any_value?" do
+      context "when the body is not specified" do
+        subject { Response.from_hash(status: 200, headers: {'Content-Type' => 'application/json'}) }
+
+        it "returns true" do
+          expect(subject.body_allows_any_value?).to be true
+        end
+      end
+
+      context "when the body is an empty hash" do
+        subject { Response.from_hash(status: 200, headers: {'Content-Type' => 'application/json'}, body: {}) }
+
+        it "returns true" do
+          expect(subject.body_allows_any_value?).to be true
+        end
+      end
+
+      context "when the body is an empty string" do
+        subject { Response.from_hash(status: 200, headers: {'Content-Type' => 'text/plain'}, body: '') }
+
+        it "returns false" do
+          expect(subject.body_allows_any_value?).to be false
+        end
+      end
+
+      context "when the body is a hash with values" do
+        subject { Response.from_hash(status: 200, headers: {'Content-Type' => 'text/plain'}, body: {some: 'body'}) }
+
+        it "returns false" do
+          expect(subject.body_allows_any_value?).to be false
+        end
+      end
+
+      context "when the body is a non-empty String" do
+        subject { Response.from_hash(status: 200, headers: {'Content-Type' => 'text/plain'}, body: 'a string') }
+
+        it "returns false" do
+          expect(subject.body_allows_any_value?).to be false
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,215 @@
+# encoding: utf-8
+
+# Ripped from spec/rspec/expectations/differ_spec.rb in rspec-expectations 2.14.3
+
+require 'spec_helper'
+require 'ostruct'
+require 'pact/matchers/differ'
+
+module Pact
+  module Matchers
+    describe Differ do
+      context "without --color" do
+
+      let(:differ) { Pact::Matchers::Differ.new }
+
+        # color disabled context
+
+      describe '#diff_as_string' do
+        subject { differ.diff_as_string(@expected, @actual) }
+        it "outputs unified diff of two strings" do
+          @expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+          @actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+          expect(subject).to eql(<<-'EOD')
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+        end
+        if RUBY_VERSION.to_f > 1.9
+          it 'copes with encoded strings', :pending => (Diff::LCS::VERSION < '1.2.2') do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has".encode('UTF-16LE')
+            expect(subject).to eql(<<-EOD.encode('UTF-16LE'))
+
+@@ -1,2 +1,2 @@
+-Tu avec carte {count} item has
++Tu avec carté {count} itém has
+EOD
+          end
+          it 'copes with encoded strings', :pending => (Diff::LCS::VERSION >= '1.2.2') do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has".encode('UTF-16LE')
+            expect(subject).to eql 'Could not produce a diff because of the encoding of the string (UTF-16LE)'
+          end
+          it 'ouputs a message when encountering differently encoded strings' do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has"
+            expect(subject).to eql 'Could not produce a diff because the encoding of the actual string (UTF-8) differs from the encoding of the expected string (UTF-16LE)'
+          end
+        end
+      end
+
+      describe '#diff_as_object' do
+        it "outputs unified diff message of two objects" do
+          animal_class = Class.new do
+            def initialize(name, species)
+              @name, @species = name, species
+            end
+
+            def inspect
+              <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+              EOA
+            end
+          end
+
+          expected = animal_class.new "bob", "giraffe"
+          actual   = animal_class.new "bob", "tortoise"
+
+          expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two arrays" do
+          expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+          actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+          expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two hashes" do
+          expected = { :foo => 'bar', :baz => 'quux', :metasyntactic => 'variable', :delta => 'charlie', :width =>'quite wide' }
+          actual   = { :foo => 'bar', :metasyntactic => 'variable', :delta => 'charlotte', :width =>'quite wide' }
+
+          expected_diff = <<'EOD'
+
+@@ -1,4 +1,5 @@
+-:delta => "charlotte",
++:baz => "quux",
++:delta => "charlie",
+ :foo => "bar",
+ :metasyntactic => "variable",
+ :width => "quite wide"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it 'outputs unified diff messaoge of two hashes with differing encoding' do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-"a" => "a"
+#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+"ö" => "ö"} : '+"\303\266" => "\303\266"' }
+}
+
+          diff = differ.diff_as_object({'ö' => 'ö'}, {'a' => 'a'})
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two hashes with object keys" do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-["a", "c"] => "b"
++["d", "c"] => "b"
+}
+
+          diff = differ.diff_as_object({ ['d','c'] => 'b'}, { ['a','c'] => 'b' })
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff of single line strings" do
+          expected = "this is one string"
+          actual   = "this is another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,2 +1,2 @@
+-"this is another string"
++"this is one string"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff of multi line strings" do
+          expected = "this is:\n  one string"
+          actual   = "this is:\n  another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,3 +1,3 @@
+ this is:
+-  another string
++  one string
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          expect(diff).to eq expected_diff
+        end
+      end
+    end
+
+    context "with --color" do
+
+      let(:differ) { Pact::Matchers::Differ.new(true) }
+
+      it "outputs colored diffs" do
+        expected = "foo bar baz"
+        actual = "foo bang baz"
+        expected_diff = "\n\e[34m@@ -1,2 +1,2 @@\n\e[0m\e[31m-foo bang baz\n\e[0m\e[32m+foo bar baz\n\e[0m"
+
+
+        diff = differ.diff_as_string(expected,actual)
+        expect(diff).to eq expected_diff
+      end
+    end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'pact/matchers/difference'
+
+module Pact
+  module Matchers
+    describe Difference do
+
+      describe "#as_json" do
+
+        context "when something other than a regexp is expected" do
+
+          subject { Difference.new("apple", 'pear').as_json }
+
+          it "indicates that the actual was intended 'to eq'" do
+            expect(subject).to eq({:EXPECTED => "apple", :ACTUAL => "pear"})
+          end
+        end
+
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'pact/matchers/list_diff_formatter'
+require 'pact/matchers/matchers'
+
+# 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\tFixnum
+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) { [NoDiffIndicator.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) { [NoDiffIndicator.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