pact 0.1.28

data/spec/lib/pact/request_spec.rb

@@ -0,0 +1,316 @@
+require 'spec_helper'
+require 'pact/request'
+
+shared_examples "a request" do
+  describe "building from a hash" do
+
+    let(:raw_request) do
+      {
+        'method' => 'get',
+        'path' => '/mallory',
+        'headers' => {
+          'Content-Type' => 'application/json'
+        },
+        'body' => 'hello mallory'
+      }
+    end
+
+    subject { described_class.from_hash(raw_request) }
+
+    its(:method) { should == 'get' }
+    its(:path) { should == '/mallory' }
+    its(:body) { should == 'hello mallory' }
+    its(:query) { should eq Pact::Request::NullExpectation.new }
+
+    it "blows up if method is absent" do
+      raw_request.delete 'method'
+      expect { described_class.from_hash(raw_request) }.to raise_error
+    end
+
+    it "blows up if path is absent" do
+      raw_request.delete 'path'
+      expect { described_class.from_hash(raw_request) }.to raise_error
+    end
+
+    it "does not blow up if body is missing" do
+      raw_request.delete 'body'
+      expect { described_class.from_hash(raw_request) }.to_not raise_error
+    end
+
+  end
+end
+
+module Pact
+
+  describe Request::Expected do
+    it_behaves_like "a request"
+
+    describe "matching to actual requests" do
+
+      subject { Request::Expected.new(expected_method, expected_path, expected_headers, expected_body, expected_query) }
+
+      let(:expected_method) { 'get' }
+      let(:expected_path) { '/foo' }
+      let(:expected_headers) { nil }
+      let(:expected_body) { nil }
+      let(:expected_query) { '' }
+
+      let(:actual_request) { Request::Actual.new(actual_method, actual_path, actual_headers, actual_body, actual_query) }
+
+      let(:actual_method) { 'get' }
+      let(:actual_path) { '/foo' }
+      let(:actual_headers) { nil }
+      let(:actual_body) { nil }
+      let(:actual_query) { '' }
+
+      it "matches identical requests" do
+        expect(subject.match 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.match 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.match actual_request).to be_false
+        end
+      end
+
+      context "when the paths are different" do
+        let(:expected_path) { '/foo' }
+        let(:actual_path) { '/bar' }
+
+        it "does not match" do
+          expect(subject.match 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.match 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.match 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) { Request::NullExpectation.new }
+        let(:actual_body) { '' }
+
+        it "matches" do
+          expect(subject.match 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.match 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.match 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.match 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.match 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.*/)
+          }
+        end
+
+        let(:actual_body) do
+          {
+            name: 'Bob',
+            customer_id: 'CN1234'
+          }
+        end
+
+        it "matches" do
+          expect(subject.match 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/)
+          }
+        end
+
+        let(:actual_body) do
+          {
+            name: 'Bob',
+            customer_id: 'CN1234'
+          }
+        end
+
+        it "does not match" do
+          expect(subject.match 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.match 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.match 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.match 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.match actual_request).to be_false
+        end
+      end
+
+      context 'when there is no query expectation' do
+        let(:expected_query) { Request::NullExpectation.new }
+        let(:actual_query) { 'bar' }
+
+        it 'matches' do
+          expect(subject.match 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.match actual_request).to be_false
+        end
+      end
+    end
+  end
+
+  describe Request::Actual do
+    it_behaves_like "a request"
+  end
+end

data/spec/lib/pact/term_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Pact
+  describe Term do
+
+    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/) }
+        let(:that) { Term.new(generate: /B/) }
+
+        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') }
+        let(:that) { Term.new(matcher: 'B') }
+
+        it "is not equal" do
+          expect(this).to_not eq that
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/pact/verification_task_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'pact/verification_task'
+
+module Pact
+	describe VerificationTask do
+		before :all do
+			@support_file = 'some_file.rb'
+			@pact_uri = 'http://example.org/pact.json'
+			@task_name = 'pact:verify:pact_rake_spec'
+			@consumer = 'some-consumer'
+
+			VerificationTask.new(:pact_rake_spec) do | pact |
+				pact.uri @pact_uri, support_file: @support_file, consumer: @consumer
+			end
+		end
+
+		describe '.initialize' do
+
+			it 'creates the tasks' do
+				Rake::Task.tasks.should include_task @task_name
+			end
+
+		end
+
+		describe 'execute' do
+
+			let(:consumer_contract) { [ uri: @pact_uri, support_file: @support_file, consumer: @consumer] }
+
+			it 'verifies the pacts using PactSpecRunner' do
+				Producer::PactSpecRunner.should_receive(:run).with(consumer_contract).and_return(0)
+				Rake::Task[@task_name].execute
+			end
+
+			context 'when all specs pass' do
+
+				before do
+					Producer::PactSpecRunner.stub(:run).and_return(0)
+				end
+
+				it 'does not raise an exception' do
+					Rake::Task[@task_name].execute
+				end
+			end
+
+			context 'when one or more specs fail' do
+
+				before do
+					Producer::PactSpecRunner.stub(:run).and_return(1)
+				end
+
+				it 'raises an exception' do
+					expect { Rake::Task[@task_name].execute }.to raise_error RuntimeError
+				end
+
+			end
+		end
+	end
+end
+
+RSpec::Matchers.define :include_task do |expected|
+	match do |actual|
+	  actual.any? { |task| task.name == expected }
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rspec'
+require 'pact'
+require 'webmock/rspec'
+
+WebMock.disable_net_connect!(allow_localhost: true)

data/spec/support/a_consumer-a_producer.json

@@ -0,0 +1,34 @@
+{
+  "producer": {
+    "name": "a 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": {
+    "pact_gem": {
+      "version": "0.1.24"
+    }
+  }
+}

data/spec/support/pact_rake_support.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module Pact
+	module Test
+		class TestApp
+			def call env
+				if env['PATH_INFO'] == '/weather'
+					[200, {'Content-Type' => 'application/json'}, [{message: WEATHER[:current_state]}.to_json]]
+				else
+					raise "unexpected path #{env['PATH_INFO']}!!!"
+				end
+			end
+		end
+
+		Pact.configure do | config |
+			config.producer do
+				name "Some Producer"
+				app { TestApp.new }
+			end
+		end
+
+
+		#one with a top level consumer
+		Pact.with_consumer 'some-test-consumer' do
+			producer_state "the weather is sunny" do
+				set_up do
+					WEATHER ||= {}
+					WEATHER[:current_state] = 'sunny'
+				end
+			end
+		end
+
+		#one without a top level consumer
+		Pact.producer_state "the weather is cloudy" do
+			set_up do
+				WEATHER ||= {}
+				WEATHER[:current_state] = 'cloudy'
+			end
+		end
+	end
+end

data/spec/support/test_app_fail.json

@@ -0,0 +1,22 @@
+{
+    "consumer": {
+        "name": "an unknown consumer"
+    },
+    "interactions": [
+        {
+            "description": "A test request",
+            "request": {
+                "method": "get",
+                "path": "/weather",
+                "query": ""
+            },
+            "response": {
+                "status": 200,
+                "headers" : {"Content-type": "application/json"},
+                "body": {"message" : "this is not the weather you are looking for"}
+
+            },
+            "producer_state": "the weather is cloudy"
+        }
+    ]
+}

data/spec/support/test_app_pass.json

@@ -0,0 +1,21 @@
+{
+    "consumer": {
+        "name": "some-test-consumer"
+    },
+    "interactions": [
+        {
+            "description": "A test request",
+            "request": {
+                "method": "get",
+                "path": "/weather",
+                "query": ""
+            },
+            "response": {
+                "status": 200,
+                "headers" : {"Content-type": "application/json"},
+                "body": {"message" : "sunny"}
+            },
+            "producer_state": "the weather is sunny"
+        }
+    ]
+}

data/tasks/pact-test.rake

@@ -0,0 +1,19 @@
+require './lib/pact/producer/pact_spec_runner'
+
+namespace :pact do
+
+	desc 'Runs pact tests against a sample application, testing failure and success.'
+	task :tests do
+		puts "Running task pact:tests"
+		# Run these specs silently, otherwise expected failures will be written to stdout and look like unexpected failures.
+
+		result = Pact::Producer::PactSpecRunner.run([{ uri: './spec/support/test_app_pass.json', support_file: './spec/support/pact_rake_support.rb', consumer: 'some-test-consumer' }], silent: true)
+		fail 'Expected pact to pass' unless (result == 0)
+
+		result = Pact::Producer::PactSpecRunner.run([{ uri: './spec/support/test_app_fail.json', support_file: './spec/support/pact_rake_support.rb' }], silent: true)
+		fail 'Expected pact to fail' if (result == 0)
+
+		puts "Task pact:tests completed succesfully."
+	end
+
+end