pact-support 1.9.0 → 1.15.0

data/spec/lib/pact/shared/key_not_found_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/key_not_found'
-
-module Pact
-  describe KeyNotFound 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/shared/multipart_form_differ_spec.rb

@@ -1,39 +0,0 @@
-require 'pact/shared/multipart_form_differ'
-
-module Pact
-  describe MultipartFormDiffer do
-
-    describe ".call" do
-
-      let(:expected_body) do
-        "-------------RubyMultipartPost-1e4912957c7bb64de3c444568326663b\r\nContent-Disposition: form-data; name=\"file\"; filename=\"text.txt\"\r\nContent-Length: 14\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: binary\r\n\r\nThis is a file\r\n-------------RubyMultipartPost-1e4912957c7bb64de3c444568326663b--\r\n\r\n"
-      end
-
-      let(:actual_body) do
-        "-------------RubyMultipartPost-1e4912957c7bb64de3c4445683266XXX\r\nContent-Disposition: form-data; name=\"file\"; filename=\"text.txt\"\r\nContent-Length: 14\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: binary\r\n\r\nThis is a file\r\n-------------RubyMultipartPost-1e4912957c7bb64de3c4445683266XXX--\r\n\r\n"
-      end
-
-      let(:options) do
-        {}
-      end
-
-      subject { MultipartFormDiffer.call(expected_body, actual_body, options) }
-
-      context "when the bodies are the same apart from the boundary" do
-        it "returns an empty diff" do
-          expect(subject).to eq({})
-        end
-      end
-
-      context "when the bodies are not the same" do
-        let(:actual_body) do
-          "-------------RubyMultipartPost-1e4912957c7bb64de3c4445683266XXX\r\nContent-Disposition: form-data; name=\"file\"; filename=\"bar.txt\"\r\nContent-Length: 14\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: binary\r\n\r\nThis is a file\r\n-------------RubyMultipartPost-1e4912957c7bb64de3c4445683266XXX--\r\n\r\n"
-        end
-
-        it "returns a text diff" do
-          expect(subject).to_not eq({})
-        end
-      end
-    end
-  end
-end

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

@@ -1,235 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/request'
-require 'pact/shared/key_not_found'
-
-module Pact
-
-  module Request
-
-    describe Base do
-
-      class TestRequest < Base
-
-        def self.key_not_found
-          Pact::KeyNotFound.new
-        end
-
-      end
-
-      subject { TestRequest.new("get", "/", {some: "things"}, {some: "things"} , "some=things") }
-
-      describe "#full_path" do
-
-        subject { TestRequest.new("get", "/something", {}, {some: "things"} , query).full_path }
-
-        context "with a query that is a Pact::Term" do
-          let(:query) { Pact::Term.new(generate: "some=things", matcher: /some/) }
-          it "reifies and appends the query" do
-            expect(subject).to eq("/something?some=things")
-          end
-        end
-
-        context "with a query that is a string" do
-          let(:query) { "some=things" }
-          it "appends the query" do
-            expect(subject).to eq("/something?some=things")
-          end
-        end
-
-        context "with a query that is a hash" do
-          let(:query) { { params: 'hello', params2: Term.new(generate: 'world', matcher: /w\w+/), params3: 'small' }  }
-          it "appends the query" do
-            expect(subject).to eq("/something?params=hello&params2=world&params3=small")
-          end
-        end
-
-        context "with an empty query" do
-          let(:query) { "" }
-          it "does include a query" do
-            expect(subject).to eq("/something")
-          end
-        end
-
-        context "with a nil query" do
-          let(:query) { nil }
-          it "does not include a query" do
-            expect(subject).to eq("/something")
-          end
-        end
-      end
-
-      describe "#method_and_path" do
-        context "with an empty path" do
-          subject { TestRequest.new("get", "", {}, {} , "").method_and_path }
-
-          it "includes a slash" do
-            expect(subject).to eq("GET /")
-          end
-        end
-
-        context "with a Pact::Term for the path" do
-          subject { TestRequest.new("get", Pact::Term.new(matcher: /a/, generate: '/apple'), {}, {} , "").method_and_path }
-
-          it "uses the generate value" do
-            expect(subject).to eq("GET /apple")
-          end
-        end
-
-        context "with a path" do
-          subject { TestRequest.new("get", "/something", {}, {} , "").method_and_path }
-
-          it "includes the path" do
-            expect(subject).to eq("GET /something")
-          end
-        end
-
-        context "with a query" do
-          subject { TestRequest.new("get", "/something", {}, {} , "test=query").method_and_path }
-
-          it "includes the query" do
-            expect(subject).to eq("GET /something?test=query")
-          end
-        end
-      end
-
-      describe "#content_type" do
-
-        subject { TestRequest.new("get", "/something", headers, {} , "") }
-
-        context "when there are no expected headers" do
-          let(:headers) { Pact::KeyNotFound.new }
-          it "returns nil" do
-            expect(subject.send(:content_type)).to be nil
-          end
-        end
-        context "when there is no Content-Type header" do
-          let(:headers) { {} }
-          it "returns nil" do
-            expect(subject.send(:content_type)).to be nil
-          end
-        end
-        context "when there is a Content-Type header" do
-          let(:headers) { {'Content-Type' => 'blah'} }
-          it "returns the Content-Type" do
-            expect(subject.send(:content_type)).to eq 'blah'
-          end
-        end
-        context "when there is a content-type header" do
-          let(:headers) { {'content-type' => 'blah'} }
-          it "returns the content-type" do
-            expect(subject.send(:content_type)).to eq 'blah'
-          end
-        end
-        context "when the Content-Type header is a Pact::Term" do
-          let(:headers) { {'Content-Type' => Pact::Term.new(generate: 'application/json', matcher: /json/)} }
-          it "returns the reified Content-Type" do
-            expect(subject.send(:content_type)).to eq 'application/json'
-          end
-        end
-      end
-
-      describe "content_type?" do
-        subject { TestRequest.new("get", "/something", headers, {} , "") }
-        let(:headers) { {'content-type' => 'blah'} }
-
-        context "when the content type is the same" do
-          it "returns true" do
-            expect(subject.content_type?('blah')).to be true
-          end
-        end
-        context "when the content type is not the same" do
-          it "returns false" do
-            expect(subject.content_type?('apple')).to be false
-          end
-        end
-
-      end
-
-      describe "modifies_resource?" do
-
-        subject { Pact::Request::Expected.from_hash(request).modifies_resource? }
-
-        shared_examples_for "may modify resource" do
-          context "when the request body is not specified" do
-            let(:request) { {method: http_method, path: '/'} }
-
-            it "returns false" do
-              expect(subject).to be false
-            end
-          end
-
-          context "when the request body is an empty Hash" do
-            let(:request) { {method: http_method, path: '/', body: {}} }
-
-            it "returns true" do
-              expect(subject).to be true
-            end
-          end
-
-          context "when the request body is a Hash and not empty" do
-            let(:request) { {method: http_method, path: '/', body: {some: 'body'}} }
-
-            it "returns true" do
-              expect(subject).to be true
-            end
-          end
-
-          context "when the request body is a String and not empty" do
-            let(:request) { {method: http_method, path: '/', body: 'some body'} }
-
-            it "returns true" do
-              expect(subject).to be true
-            end
-          end
-
-          context "when the request body is a String and is empty" do
-            let(:request) { {method: http_method, path: '/', body: ''} }
-
-            it "returns true" do
-              expect(subject).to be true
-            end
-          end
-        end
-
-        describe "when the method is PUT" do
-          let(:http_method) { :put }
-          include_examples 'may modify resource'
-        end
-
-        describe "when the method is POST" do
-          let(:http_method) { :post }
-          include_examples 'may modify resource'
-        end
-
-        describe "when the method is PATCH" do
-          let(:http_method) { :post }
-          include_examples 'may modify resource'
-        end
-
-        shared_examples_for "does not modify resource" do
-          let(:request) { {method: http_method, path: '/', body: {some: 'body'}} }
-
-          it "returns false" do
-            expect(subject).to be false
-          end
-        end
-
-        describe "when the method is GET" do
-          let(:http_method) { :get }
-          include_examples 'does not modify resource'
-        end
-
-        describe "when the method is DELETE" do
-          let(:http_method) { :delete }
-          include_examples 'does not modify resource'
-        end
-
-        describe "when the method is HEAD" do
-          let(:http_method) { :head }
-          include_examples 'does not modify resource'
-        end
-      end
-
-    end
-  end
-end

data/spec/lib/pact/shared/text_differ_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/text_differ'
-
-module Pact
-  describe TextDiffer do
-
-    describe ".call" do
-
-      subject { TextDiffer.call expected, actual }
-
-      let(:expected) { "This is the string you are looking for" }
-
-      context "when the expected and actual are both strings" do
-
-        context "when they equal each other" do
-          let(:actual) { "This is the string you are looking for" }
-
-          it "returns an empty diff" do
-            expect(subject.any?).to be false
-          end
-        end
-
-        context "when they don't equal each other" do
-          let(:actual) { "This is not the string you are looking for" }
-
-          it "returns the diff" do
-            expect(subject).to eq Pact::Matchers::Difference.new(expected, actual)
-          end
-        end
-      end
-
-      context "when the actual is not a String" do
-        let(:actual) { {some: 'hash'} }
-        let(:difference) { Pact::Matchers::Difference.new(expected, actual)}
-        it "returns the diff" do
-          expect(subject)
-        end
-      end
-
-      context "when the expected and actual are both objects" do
-        let(:actual) { {some: 'hash', blah: 'blah'} }
-        let(:expected) { {some: 'hash'} }
-        let(:difference) { Pact::Matchers::Difference.new(expected, actual)}
-
-        it "returns the diff using the JSON matching logic, allowing extra keys. But should it really if the expected Content-Type isn't actually JSON?" do
-          expect(subject)
-        end
-
-        it "potentially should treat both expected and actual as Strings"
-      end
-
-    end
-  end
-end

data/spec/lib/pact/something_like_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-module Pact
-  describe SomethingLike do
-
-    describe 'json_create' do
-      let(:json) do
-'
-{
-    "json_class": "Pact::SomethingLike",
-    "contents" : { "thing" : "blah" }
-}
-'
-      end
-
-      subject { SomethingLike.json_create(JSON.parse(json)) }
-
-      it "creates a SomethingLike object from json" do
-        expect(subject).to eq(SomethingLike.new({"thing" => "blah"}))
-      end
-    end
-  end
-end

data/spec/lib/pact/support_spec.rb

@@ -1,9 +0,0 @@
-require 'pact/support'
-
-describe Pact do
-
-  it "includes the Pact::Helpers" do
-    expect(Pact).to respond_to(:each_like)
-  end
-
-end

data/spec/lib/pact/symbolize_keys_spec.rb

@@ -1,15 +0,0 @@
-require 'pact/symbolize_keys'
-
-module Pact
-  module SymbolizeKeys
-    describe "#symbolize_keys" do
-      context "when nil is provided" do
-        include Pact::SymbolizeKeys
-
-        it "returns nil" do
-          expect(symbolize_keys(nil)).to be nil
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/term_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-module Pact
-  describe Term do
-
-    describe 'initialize' do
-      let(:matcher) { /e/ }
-      let(:generate) { 'apple'}
-      subject { Term.new(generate: generate, matcher: matcher) }
-      context "when a matcher and generate are specified" do
-        context "when the matcher matches the generated value" do
-          it 'does not raise an exception' do
-            subject
-          end
-        end
-
-        context "when the matcher does not match the generated value" do
-          let(:generate) { 'banana' }
-          it 'raises an exception' do
-            expect { subject }.to raise_error /does not match/
-          end
-        end
-      end
-      context 'when a matcher is not specified' do
-        let(:matcher) { nil }
-        it 'raises an exception' do
-          expect { subject }.to raise_error /Please specify a matcher/
-        end
-      end
-      context 'when a generate is not specified' do
-        let(:generate) { nil }
-        it 'raises an exception' do
-          expect { subject }.to raise_error /Please specify a value/
-        end
-      end
-    end
-
-    describe "equality" do
-      context "when the matcher and generate attrs are the same" do
-        let(:this) { Term.new(generate: 'A', matcher: /A/) }
-        let(:that) { Term.new(generate: 'A', matcher: /A/) }
-
-        it "is equal" do
-          expect(this).to eq that
-        end
-      end
-
-      context "when the generate attrs are different" do
-        let(:this) { Term.new(generate: 'A', matcher: /.*/) }
-        let(:that) { Term.new(generate: 'B', matcher: /.*/) }
-
-        it "is not equal" do
-          expect(this).to_not eq that
-        end
-      end
-
-      context "when the matcher attrs are different" do
-        let(:this) { Term.new(matcher: /A/, generate: 'AB') }
-        let(:that) { Term.new(matcher: /B/, generate: 'AB') }
-
-        it "is not equal" do
-          expect(this).to_not eq that
-        end
-      end
-    end
-
-    describe 'empty?' do
-
-      subject { Term.new(generate: 'some', matcher: /some/) }
-
-      it 'should return false' do
-        expect(subject).to_not be_empty
-      end
-
-    end
-
-    describe 'unpack_regexps' do
-      let(:term) { Term.new(generate: 'some', matcher: /s/) }
-      let(:body) { [{a: [{b: term}], c:term, d: 1, e: 'blah'}] }
-      let(:expected) { [{:a=>[{:b=>/s/}], :c=>/s/, :d=>1, :e=>"blah"}] }
-
-      it "returns a structure with the Pact::Terms replaced by their regexps" do
-        expect(Term.unpack_regexps(body)).to eq expected
-      end
-
-    end
-
-  end
-end