pact 1.3.3 → 1.4.0

data/spec/lib/pact/doc/interaction_view_model_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-require 'pact/doc/interaction_view_model'
-
-module Pact
-  module Doc
-    describe InteractionViewModel do
-
-      let(:consumer_contract) { Pact::ConsumerContract.from_uri './spec/support/interaction_view_model.json'}
-
-      let(:interaction_with_request_with_body_and_headers) { consumer_contract.find_interaction description: "a request with a body and headers" }
-      let(:interaction_with_request_without_body_and_headers) { consumer_contract.find_interaction description: "a request with an empty body and empty headers" }
-      let(:interaction_with_response_with_body_and_headers) { consumer_contract.find_interaction description: "a response with a body and headers" }
-      let(:interaction_with_response_without_body_and_headers) { consumer_contract.find_interaction description: "a response with an empty body and empty headers" }
-
-
-      subject { InteractionViewModel.new interaction, consumer_contract}
-
-      describe "request" do
-
-        let(:interaction) { interaction_with_request_with_body_and_headers }
-
-        it "includes the method" do
-          expect(subject.request).to include('"method"')
-          expect(subject.request).to include('"get"')
-        end
-
-        it "includes the body" do
-          expect(subject.request).to include('"body"')
-          expect(subject.request).to include('"a body"')
-        end
-
-        it "includes the headers" do
-          expect(subject.request).to include('"headers"')
-          expect(subject.request).to include('"a header"')
-        end
-
-        it "includes the query" do
-          expect(subject.request).to include('"query"')
-          expect(subject.request).to include('"some=thing"')
-        end
-
-        it "includes the path" do
-          expect(subject.request).to include('"path"')
-          expect(subject.request).to include('"/path"')
-        end
-
-        it "renders the keys in a meaningful order" do
-          expect(subject.request).to match /"method".*"path".*"query".*"headers".*"body"/m
-        end
-
-        context "when the body hash is empty" do
-
-          let(:interaction) { interaction_with_request_without_body_and_headers }
-
-          it "includes the body" do
-            expect(subject.request).to include("body")
-          end
-        end
-        context "when the headers hash is empty" do
-
-          let(:interaction) { interaction_with_request_without_body_and_headers }
-
-          it "does not include the headers" do
-            expect(subject.request).to_not include("headers")
-          end
-        end
-
-        context "when a Pact::Term is present" do
-          let(:consumer_contract) { Pact::ConsumerContract.from_uri './spec/support/interaction_view_model_with_terms.json'}
-          let(:interaction) { consumer_contract.interactions.first }
-
-          it "uses the generated value" do
-            expect(subject.request).to_not include("Term")
-            expect(subject.request).to include("sunny")
-          end
-        end
-      end
-
-      describe "response" do
-
-        let(:interaction) { interaction_with_response_with_body_and_headers }
-
-        it "includes the status" do
-          expect(subject.response).to include('"status"')
-        end
-
-        it "includes the body" do
-          expect(subject.response).to include('"body"')
-          expect(subject.response).to include('"a body"')
-        end
-        it "includes the headers" do
-          expect(subject.response).to include('"headers"')
-          expect(subject.response).to include('"a header"')
-        end
-
-        it "renders the keys in a meaningful order" do
-          expect(subject.response).to match /"status".*"headers".*"body"/m
-        end
-
-        context "when the body hash is empty" do
-
-          let(:interaction) { interaction_with_response_without_body_and_headers }
-
-          it "does not include the body" do
-            expect(subject.response).to_not include("body")
-          end
-        end
-
-        context "when the headers hash is empty" do
-
-          let(:interaction) { interaction_with_response_without_body_and_headers }
-
-          it "does not include the headers" do
-            expect(subject.response).to_not include("headers")
-          end
-        end
-
-        context "when a Pact::Term is present" do
-          let(:consumer_contract) { Pact::ConsumerContract.from_uri './spec/support/interaction_view_model_with_terms.json'}
-          let(:interaction) { consumer_contract.interactions.first }
-
-          it "uses the generated value" do
-            expect(subject.response).to_not include("Term")
-            expect(subject.response).to include("rainy")
-          end
-        end
-      end
-
-
-    end
-  end
-end

data/spec/lib/pact/doc/markdown/consumer_contract_renderer_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'pact/doc/markdown/consumer_contract_renderer'
-
-module Pact
-  module Doc
-    module Markdown
-      describe ConsumerContractRenderer do
-
-        subject { ConsumerContractRenderer.new(consumer_contract) }
-        let(:consumer_contract) { Pact::ConsumerContract.from_uri './spec/support/markdown_pact.json' }
-
-        let(:expected_output) { File.read("./spec/support/generated_markdown.md") }
-
-        describe "#call" do
-          it "renders an interaction" do
-            expect(subject.call).to eq(expected_output)
-          end
-        end
-
-        describe ".call" do
-          it "renders an interaction" do
-            expect(ConsumerContractRenderer.call consumer_contract).to eq(expected_output)
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/lib/pact/doc/markdown/index_renderer_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'pact/doc/markdown/index_renderer'
-
-module Pact
-  module Doc
-    module Markdown
-      describe IndexRenderer do
-
-        let(:consumer_name) { "Some Consumer" }
-        let(:docs) {  {"Some Provider" => "Some Provider.md", "Some other provider" => "Some other provider.md"} }
-        let(:subject) { IndexRenderer.new(consumer_name, docs) }
-        let(:expected_content) { File.read('./spec/support/generated_index.md')}
-
-        describe "#call" do
-          it "renders the index" do
-            expect(subject.call).to eq expected_content
-          end
-        end
-
-        describe ".call" do
-          it "renders the index" do
-            expect(IndexRenderer.call(consumer_name, docs) ).to eq expected_content
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,214 +0,0 @@
-# encoding: utf-8
-
-# Ripped from spec/rspec/expectations/differ_spec.rb in rspec-expectations 2.14.3
-
-require 'spec_helper'
-require 'ostruct'
-
-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

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

@@ -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/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,114 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/list_diff_formatter'
-require 'pact/matchers/matchers'
-
-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