pact-support 1.11.0 → 1.12.0

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

@@ -1,82 +0,0 @@
-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 "initialize" do
-      context "with invalid params" do
-        it "ignores the invalid params" do
-          response = Response.new(foo: 'bar')
-          expect(response).to_not have_key(:foo)
-        end
-      end
-    end
-
-    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/helpers_spec.rb

@@ -1,143 +0,0 @@
-require 'pact/helpers'
-
-module Pact
-  describe Helpers do
-
-    include Pact::Helpers
-
-    describe "#term" do
-
-      context "with a Hash argument" do
-        it "creates a Pact::Term" do
-          expect(term(generate: 'food', matcher: /foo/)).to eq Pact::Term.new(generate: 'food', matcher: /foo/)
-        end
-      end
-
-      context "with a Regexp and a String" do
-        it "creates a Pact::Term" do
-          expect(term(/foo/, 'food')).to eq Pact::Term.new(generate: 'food', matcher: /foo/)
-        end
-      end
-
-      context "with a String and a Regexp" do
-        it "creates a Pact::Term" do
-          expect(term('food', /foo/)).to eq Pact::Term.new(generate: 'food', matcher: /foo/)
-        end
-      end
-
-      context "with anything else" do
-        it "raises an ArgumentError" do
-          expect{ term(1, /foo/) }.to raise_error(ArgumentError, /Cannot create.*1.*foo/)
-        end
-      end
-    end
-
-    describe "#like" do
-      it "creates a Pact::SomethingLike" do
-        expect(like(1)).to eq Pact::SomethingLike.new(1)
-      end
-    end
-
-    describe "#each_like" do
-      it "creates a Pact::ArrayLike" do
-        expect(each_like(1)).to eq Pact::ArrayLike.new(1)
-        expect(each_like(1, min: 2)).to eq Pact::ArrayLike.new(1, min: 2)
-      end
-    end
-
-    describe "#like_uuid" do
-      let(:uuid) { '11111111-2222-3333-4444-000000000000' }
-
-      it "creates a Pact::Term with UUID matcher" do
-        expect(like_uuid(uuid)).to eq Pact::Term.new(
-          generate: uuid,
-          matcher: /^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/
-        )
-      end
-    end
-
-    describe "#like_datetime" do
-      let(:datetime) { '2015-08-06T16:53:10+01:00' }
-
-      it "creates a Pact::Term with DateTime matcher" do
-        expect(like_datetime(datetime)).to eq Pact::Term.new(
-          generate: datetime,
-          matcher: /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)$/
-        )
-      end
-    end
-
-    describe "#like_datetime_with_milliseconds" do
-      let(:datetime) { '2015-08-06T16:53:10.123+01:00' }
-
-      it "creates a Pact::Term with DateTime and Millisecond precision matcher" do
-        expect(like_datetime_with_milliseconds(datetime)).to eq Pact::Term.new(
-          generate: datetime,
-          matcher: /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d{3}([+-][0-2]\d:[0-5]\d|Z)$/
-        )
-      end
-    end
-
-    describe "#like_date" do
-      let(:date) { '2015-08-06' }
-
-      it "creates a Pact::Term with Date matcher" do
-        expect(like_date(date)).to eq Pact::Term.new(
-          generate: date,
-          matcher: /^\d{4}-[01]\d-[0-3]\d$/
-        )
-      end
-
-      describe "#like_datetime_rfc822" do
-        context "Day is Tue" do
-          let(:datetime) { 'Tue, 04 Apr 2017 19:03:19 +0000' }
-          it "creates a Pact::Term with a rfc822 matcher" do
-            expect(like_datetime_rfc822(datetime)).to eq Pact::Term.new(
-              generate: datetime,
-              matcher: /(?x)(Mon|Tue|Wed|Thu|Fri|Sat|Sun),
-                        \s\d{2}\s
-                        (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)
-                        \s\d{4}\s\d{2}:\d{2}:\d{2}\s(\+|-)\d{4}/)
-          end
-        end
-
-        context "Day is Sun" do
-          let(:datetime) { 'Sun, 09 Apr 2017 19:03:19 +0000' }
-          it "creates a Pact::Term with a rfc822 matcher" do
-            expect(like_datetime_rfc822(datetime)).to eq Pact::Term.new(
-              generate: datetime,
-              matcher: /(?x)(Mon|Tue|Wed|Thu|Fri|Sat|Sun),
-                        \s\d{2}\s
-                        (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)
-                        \s\d{4}\s\d{2}:\d{2}:\d{2}\s(\+|-)\d{4}/)
-          end
-        end
-
-        context "Month is Jan" do
-          let(:datetime) { 'Mon, 02 Jan 2017 19:03:19 +0000' }
-          it "creates a Pact::Term with a rfc822 matcher" do
-            expect(like_datetime_rfc822(datetime)).to eq Pact::Term.new(
-              generate: datetime,
-              matcher: /(?x)(Mon|Tue|Wed|Thu|Fri|Sat|Sun),
-                        \s\d{2}\s
-                        (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)
-                        \s\d{4}\s\d{2}:\d{2}:\d{2}\s(\+|-)\d{4}/)
-          end
-        end
-
-        context "Negative Offset" do
-          let(:datetime) { 'Mon, 31 Oct 2016 15:21:41 -0400' }
-          it "creates a Pact::Term with a rfc822 matcher" do
-            expect(like_datetime_rfc822(datetime)).to eq Pact::Term.new(
-              generate: datetime,
-              matcher: /(?x)(Mon|Tue|Wed|Thu|Fri|Sat|Sun),
-                        \s\d{2}\s
-                        (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)
-                        \s\d{4}\s\d{2}:\d{2}:\d{2}\s(\+|-)\d{4}/)
-          end
-        end
-
-      end
-    end
-  end
-end

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

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

@@ -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