pact 1.3.3 → 1.4.0.rc2

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

@@ -1,107 +0,0 @@
-require 'spec_helper'
-require 'pact/reification'
-require 'pact/consumer_contract/interaction'
-
-module Pact
-  module Consumer
-
-    describe Interaction do
-
-      let(:request) { {method: 'get', path: 'path'} }
-      let(:response) { {} }
-
-      describe "==" do
-        subject { InteractionFactory.create }
-        context "when other is the same" do
-          let(:other) { InteractionFactory.create }
-          it "returns true" do
-            expect(subject == other).to be true
-          end
-        end
-        context "when other is not the same" do
-          let(:other) { InteractionFactory.create(:request => {:path => '/a_different_path'}) }
-          it "returns false" do
-            expect(subject == other).to be false
-          end
-        end
-      end
-
-      describe "matches_criteria?" do
-        subject { InteractionFactory.create(:description => 'a request for food') }
-        context "by description" do
-          context "when the interaction matches" do
-            it "returns true" do
-              expect(subject.matches_criteria?(:description => /request.*food/)).to be true
-            end
-          end
-          context "when the interaction does not match" do
-            it "returns false" do
-              expect(subject.matches_criteria?(:description => /blah/)).to be false
-            end
-          end
-        end
-      end
-
-      describe "from_hash" do
-        context "when providerState has been used instead of provider_state" do
-
-          subject { Interaction.from_hash('response' => response, 'request' => request, 'providerState' => 'some state') }
-
-          it "recognises the provider state" do
-            expect(subject.provider_state).to eq 'some state'
-          end
-        end
-      end
-
-      describe "to JSON" do
-        let(:request) do
-          {
-            method: 'post',
-            path: '/foo',
-            body: Term.new(generate: 'waffle', matcher: /ffl/),
-            headers: { 'Content-Type' => 'application/json' },
-            query: '',
-          }
-        end
-
-        let(:response) do
-          { baz: /qux/, wiffle: Term.new(generate: 'wiffle', matcher: /iff/) }
-        end
-
-        let(:parsed_result) do
-          JSON.load(subject.to_json)
-        end
-
-        subject { Interaction.from_hash('response' => response, 'request' => request) }
-
-        it "contains the request" do
-          expect(parsed_result['request']).to eq({
-              'method' => 'post',
-              'path' => '/foo',
-              'headers' => {
-                'Content-Type' => 'application/json'
-              },
-              'body' => Term.new(generate: 'waffle', matcher: /ffl/),
-              'query' => ''
-            })
-        end
-
-        describe "response" do
-
-          it "serialises regexes" do
-            expect(parsed_result['response']['baz']).to eql /qux/
-          end
-
-          it "serialises terms" do
-            term = Term.new(generate:'wiffle', matcher: /iff/)
-            parsed_term = parsed_result['response']['wiffle']
-            expect(term.matcher).to eql parsed_term.matcher
-            expect(term.generate).to eql parsed_term.generate
-          end
-
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,329 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract/request'
-require 'pact/consumer/request'
-require 'support/shared_examples_for_request'
-
-module Pact
-
-  describe Request::Expected do
-    it_behaves_like "a request"
-
-    let(:raw_request) do
-      {
-        'method' => 'get',
-        'path' => '/mallory'
-      }
-    end
-
-    describe "from_hash" do
-      context "when optional field are not defined" do
-        subject { described_class.from_hash(raw_request) }
-        it "sets their values to NullExpectation" do
-          expect(subject.body).to be_instance_of(Pact::NullExpectation)
-          expect(subject.query).to be_instance_of(Pact::NullExpectation)
-          expect(subject.headers).to be_instance_of(Pact::NullExpectation)
-        end
-      end
-    end
-
-    describe "as_json" do
-      subject { Request::Expected.new(:get, '/path', {:header => 'value'}, {:body => 'yeah'}, "query", {some: 'options'}) }
-      context "with options" do
-        it "does not include the options because they are a temporary hack and should leave no trace of themselves in the pact file" do
-          expect(subject.as_json.key?(:options)).to be false
-        end
-      end
-    end
-
-    describe "matching to actual requests" do
-
-      subject { Request::Expected.new(expected_method, expected_path, expected_headers, expected_body, expected_query, options) }
-      let(:options) { {} }
-
-      let(:expected_method) { 'get' }
-      let(:expected_path) { '/foo' }
-      let(:expected_headers) { Pact::NullExpectation.new }
-      let(:expected_body) { Pact::NullExpectation.new }
-      let(:expected_query) { '' }
-
-      let(:actual_request) { Consumer::Request::Actual.new(actual_method, actual_path, actual_headers, actual_body, actual_query) }
-
-      let(:actual_method) { 'get' }
-      let(:actual_path) { '/foo' }
-      let(:actual_headers) { {} }
-      let(:actual_body) { '' }
-      let(:actual_query) { '' }
-
-      it "matches identical requests" do
-        expect(subject.matches? actual_request).to be true
-      end
-
-      context "when the methods are the same but one is symbolized" do
-        let(:expected_method) { :get }
-        let(:actual_method) { 'get' }
-
-        it "matches" do
-          expect(subject.matches? actual_request).to be true
-        end
-      end
-
-      context "when the methods are different" do
-        let(:expected_method) { 'get' }
-        let(:actual_method) { 'post' }
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context "when the methods are the same but different case" do
-        let(:expected_method) { 'get' }
-        let(:actual_method) { 'GET' }
-
-        it "matches" do
-          expect(subject.matches? actual_request).to be true
-        end
-      end
-
-      context "when the paths are different" do
-        let(:expected_path) { '/foo' }
-        let(:actual_path) { '/bar' }
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context "when the paths vary only by a trailing slash" do
-        let(:expected_path) { '/foo' }
-        let(:actual_path) { '/foo/' }
-
-        it "matches" do
-          expect(subject.matches? actual_request).to be true
-        end
-      end
-
-      context "when the expected body is nil and the actual body is empty" do
-        let(:expected_body) { nil }
-        let(:actual_body) { '' }
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context "when the expected body has no expectation and the actual body is empty" do
-        let(:expected_body) { Pact::NullExpectation.new }
-        let(:actual_body) { '' }
-
-        it "matches" do
-          expect(subject.matches? actual_request).to be true
-        end
-      end
-
-      context "when the expected body is nested and the actual body is nil" do
-        let(:expected_body) do
-          {
-            a: 'a'
-          }
-        end
-
-        let(:actual_body) { nil }
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context "when the bodies are different" do
-        let(:expected_body) { 'foo' }
-        let(:actual_body) { 'bar' }
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context "when the expected body contains matching regexes" do
-        let(:expected_body) do
-          {
-            name: 'Bob',
-            customer_id: /CN.*/
-          }
-        end
-
-        let(:actual_body) do
-          {
-            name: 'Bob',
-            customer_id: 'CN1234'
-          }
-        end
-
-        it "matches" do
-          expect(subject.matches? actual_request).to be true
-        end
-      end
-
-      context "when the expected body contains non-matching regexes" do
-        let(:expected_body) do
-          {
-            name: 'Bob',
-            customer_id: /foo/
-          }
-        end
-
-        let(:actual_body) do
-          {
-            name: 'Bob',
-            customer_id: 'CN1234'
-          }
-        end
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context "when the expected body contains matching terms" do
-        let(:expected_body) do
-          {
-            name: 'Bob',
-            customer_id: Term.new(matcher: /CN.*/, generate: 'CN789')
-          }
-        end
-
-        let(:actual_body) do
-          {
-            name: 'Bob',
-            customer_id: 'CN1234'
-          }
-        end
-
-        it "matches" do
-          expect(subject.matches? actual_request).to be true
-        end
-      end
-
-      context "when the expected body contains non-matching terms" do
-        let(:expected_body) do
-          {
-            name: 'Bob',
-            customer_id: Term.new(matcher: /foo/, generate: 'fooool')
-          }
-        end
-
-        let(:actual_body) do
-          {
-            name: 'Bob',
-            customer_id: 'CN1234'
-          }
-        end
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context "when the expected body contains non-matching arrays" do
-        let(:expected_body) do
-          {
-            name: 'Robert',
-            nicknames: ['Bob', 'Bobert']
-          }
-        end
-
-        let(:actual_body) do
-          {
-            name: 'Bob',
-            nicknames: ['Bob']
-          }
-        end
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-      context "when the expected body contains non-matching hash where one field contains a substring of the other" do
-          let(:expected_body) do
-            {
-              name: 'Robert',
-            }
-          end
-
-          let(:actual_body) do
-            {
-              name: 'Rob'
-            }
-          end
-
-          it "does not match" do
-            expect(subject.matches? actual_request).to be false
-          end
-      end
-
-      context "when the expected body contains matching arrays" do
-        let(:expected_body) do
-          {
-            name: 'Robert',
-            nicknames: ['Bob', 'Bobert']
-          }
-        end
-
-        let(:actual_body) do
-          {
-            name: 'Robert',
-            nicknames: ['Bob', 'Bobert']
-          }
-        end
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be true
-        end
-      end
-
-      context "when the queries are different" do
-        let(:expected_query) { 'foo' }
-        let(:actual_query) { 'bar' }
-
-        it "does not match" do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context 'when there is no query expectation' do
-        let(:expected_query) { Pact::NullExpectation.new }
-        let(:actual_query) { 'bar' }
-
-        it 'matches' do
-          expect(subject.matches? actual_request).to be true
-        end
-      end
-
-      context "when a string is expected, but a number is found" do
-        let(:actual_body) { { thing: 123} }
-        let(:expected_body) { { thing: "123" } }
-
-        it 'does not match' do
-          expect(subject.matches? actual_request).to be false
-        end
-      end
-
-      context "when unexpected keys are found in the body" do
-        let(:expected_body) { {a: 1} }
-        let(:actual_body) { {a: 1, b: 2} }
-        context "when allowing unexpected keys" do
-          let(:options) { {'allow_unexpected_keys_in_body' => true} } #From json, these will be strings
-          it "matches" do
-            expect(subject.matches? actual_request).to be true
-          end
-        end
-        context "when not allowing unexpected keys" do
-          let(:options) { {'allow_unexpected_keys_in_body' => false} }
-          it "does not match" do
-            expect(subject.matches? actual_request).to be false
-          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
-