pact 1.3.3 → 1.4.0.rc2

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

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

@@ -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/request_spec.rb

@@ -1,111 +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 "#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
-
-    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,21 +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/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

data/spec/support/dsl_spec_support.rb

@@ -1,7 +0,0 @@
-def global_method
-  "I'm global"
-end
-
-def global_app
-  "I'm a global app"
-end