pact-support 0.0.1

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'pact/shared/json_differ'
+
+module Pact
+  describe JsonDiffer do
+
+    describe ".call" do
+
+      let(:expected) { {'a' => 'b'} }
+
+      subject { JsonDiffer.call(expected, actual) }
+
+      context "when the actual is valid JSON" do
+
+        let(:actual) { {'a' => 'c'} }
+        let(:difference) { {'a' => Pact::Matchers::Difference.new('b', 'c')} }
+
+        context "when the actual does not equal the expected" do
+          it "parses the JSON and returns a diff" do
+            expect(subject).to eq(difference)
+          end
+        end
+
+        context "when the actual equals the expected" do
+          let(:actual) { expected }
+          it "parses the JSON and returns an empty diff" do
+            expect(subject.any?).to be false
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

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

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

@@ -0,0 +1,196 @@
+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 "#to_json" do
+        it "renders the keys in a sensible order" do
+          expect(subject.to_json).to match(/method.*path.*query.*headers.*body/)
+        end
+      end
+
+      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 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 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 the content-type" 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
+      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

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

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

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

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'rspec'
+require 'fakefs/spec_helpers'
+require 'rspec'
+require 'pact/support'
+require 'webmock/rspec'
+require 'support/factories'
+require 'support/spec_support'
+
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+require './spec/support/active_support_if_configured'
+
+RSpec.configure do | config |
+  config.include(FakeFS::SpecHelpers, :fakefs => true)
+
+  config.include Pact::SpecSupport
+end
+

data/spec/support/a_consumer-a_producer.json

@@ -0,0 +1,32 @@
+{
+  "producer": {
+    "name": "an old producer"
+  },
+  "consumer": {
+    "name": "a consumer"
+  },
+  "interactions": [
+    {
+      "description": "request one",
+      "request": {
+        "method": "get",
+        "path": "/path_one"
+      },
+      "response": {
+      },
+      "producer_state": "state one"
+    },
+    {
+      "description": "request two",
+      "request": {
+        "method": "get",
+        "path": "/path_two"
+      },
+      "response": {
+      }
+    }
+  ],
+  "metadata": {
+    "pactSpecificationVersion": "1.0"
+  }
+}