pact 0.1.28 → 1.3.3

data/spec/lib/pact/tasks/verification_task_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'pact/tasks/verification_task'
+
+module Pact
+  describe VerificationTask do
+    before :all do
+      @pact_helper = '/custom/path/pact_helper  .rb'
+      @pact_uri = 'http://example.org/pact.json'
+      @task_name = 'pact:verify:pact_rake_spec'
+      @task_name_with_explict_pact_helper = 'pact:verify:pact_rake_spec_with_explict_pact_helper'
+      @consumer = 'some-consumer'
+      @criteria = {:description => /wiffle/}
+
+      VerificationTask.new(:pact_rake_spec_with_explict_pact_helper) do | pact |
+        pact.uri @pact_uri, pact_helper: @pact_helper
+      end
+
+      VerificationTask.new(:pact_rake_spec) do | pact |
+        pact.uri @pact_uri
+      end
+    end
+
+    before do
+      allow(Pact::TaskHelper).to receive(:execute_pact_verify).and_return(0)
+    end
+
+    let(:exit_code) {0}
+
+
+    describe '.initialize' do
+      context 'with an explict pact_helper' do
+        it 'creates the tasks' do
+          expect(Rake::Task.tasks).to include_task @task_name
+        end
+      end
+      context 'with no explict pact_helper' do
+        it 'creates the tasks' do
+          expect(Rake::Task.tasks).to include_task @task_name_with_explict_pact_helper
+        end
+      end
+    end
+
+    describe 'execute' do
+
+      context "with no explicit pact_helper" do
+        it 'verifies the pacts using the TaskHelper' do
+          expect(Pact::TaskHelper).to receive(:execute_pact_verify).with(@pact_uri, nil, nil)
+          Rake::Task[@task_name].execute
+        end
+      end
+
+      context "with an explict pact_helper" do
+        let(:verification_config) { [ uri: @pact_uri, pact_helper: @pact_helper] }
+        it 'verifies the pacts using the TaskHelper' do
+          expect(Pact::TaskHelper).to receive(:execute_pact_verify).with(@pact_uri, @pact_helper, nil)
+          Rake::Task[@task_name_with_explict_pact_helper].execute
+        end
+      end
+
+      context 'when all specs pass' do
+
+        it 'does not raise an exception' do
+          Rake::Task[@task_name].execute
+        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/lib/pact/term_spec.rb

@@ -3,6 +3,38 @@ 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/) }
@@ -14,8 +46,8 @@ module Pact
       end
 
       context "when the generate attrs are different" do
-        let(:this) { Term.new(generate: /A/) }
-        let(:that) { Term.new(generate: /B/) }
+        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
@@ -23,8 +55,8 @@ module Pact
       end
 
       context "when the matcher attrs are different" do
-        let(:this) { Term.new(matcher: 'A') }
-        let(:that) { Term.new(matcher: 'B') }
+        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
@@ -32,5 +64,26 @@ module Pact
       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/pact_specification/compliance-1.0.0.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'pact/consumer/request'
+require 'pact/consumer_contract/request'
+
+PACT_SPEC_DIR = "../pact-specification/testcases"
+REQUEST_TEST_CASE_FOLDERS = Dir.glob("#{PACT_SPEC_DIR}/request/**")
+REQUEST_TEST_CASE_FILES = Dir.glob("#{PACT_SPEC_DIR}/request/**/*.json")
+
+TEST_DESCRIPTIONS = {true => "matches", false => "does not match"}
+
+describe "Pact gem complicance with Pact Specification 1.0.0" do
+
+  directories = Dir.glob("#{PACT_SPEC_DIR}/*")
+
+  directories.each do | dir_name |
+
+    describe File.basename(dir_name) do
+
+      sub_directories = Dir.glob("#{dir_name}/*")
+
+      sub_directories.each do | sub_dir_name |
+
+        context File.basename(sub_dir_name) do
+          testcases = Dir.glob("#{sub_dir_name}/**/*.json")
+
+          testcases.each do | file_name |
+
+            context File.basename(file_name).chomp(".json") do
+
+              file_content = JSON.parse(File.read(file_name))
+              expected = Pact::Request::Expected.from_hash(file_content["expected"])
+              actual = Pact::Consumer::Request::Actual.from_hash(file_content["actual"])
+              expected_result = file_content.fetch("match")
+              comment = file_content["comment"]
+
+              it "#{TEST_DESCRIPTIONS[expected_result]} - #{comment}" do
+                expect(expected.matches?(actual)).to eq expected_result
+              end
+
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,22 @@
 require 'rspec'
+require 'fakefs/spec_helpers'
+require 'rspec'
 require 'pact'
 require 'webmock/rspec'
+require 'support/factories'
+require 'support/spec_support'
+require 'pact/provider/rspec'
 
 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.extend Pact::Provider::RSpec::ClassMethods
+  config.include Pact::Provider::RSpec::InstanceMethods
+  config.include Pact::Provider::TestMethods
+  config.include Pact::SpecSupport
+end
+

data/spec/standalone/consumer_fail_test.rb

@@ -0,0 +1,55 @@
+require 'pact/consumer/rspec'
+require './spec/support/active_support_if_configured'
+
+Pact.service_consumer "Standalone Consumer" do
+  has_pact_with "Standalone Provider" do
+    mock_service :standalone_service do
+      port 1238
+    end
+  end
+end
+
+class StandaloneClient
+
+  def initialize base_url
+    @base_url = base_url
+  end
+
+  def call
+    uri = URI("#{@base_url}/something")
+    post_req = Net::HTTP::Post.new(uri.path)
+    post_req['Content-Type'] = "application/json"
+    post_req.body = {a: "not matching body"}.to_json
+    response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+      http.request post_req
+    end
+    JSON.parse(response.body)
+  end
+
+end
+
+describe StandaloneClient, pact: true do
+
+  subject { StandaloneClient.new("http://localhost:1238") }
+
+  describe "call" do
+
+    let(:expected_body) { {a: "body"} }
+    let(:expected_headers) { {'Content-Type' => "application/hal+json"} }
+
+    before do
+      standalone_service.
+        upon_receiving("a request to create something").with(method: 'post', path: '/something', headers: expected_headers, body: expected_body).
+        will_respond_with(status: 200, headers: {}, body: {a: 'response body'})
+
+      standalone_service.
+        upon_receiving("a request to create something else").with(method: 'post', path: '/something-else', headers: expected_headers, body: expected_body).
+        will_respond_with(status: 200, headers: {}, body: {a: 'response body'})
+    end
+
+    it "will fail and display a helpful message" do
+      subject.call
+    end
+  end
+
+end

data/spec/standalone/consumer_pass_test.rb

@@ -0,0 +1,51 @@
+require 'pact/consumer/rspec'
+require './spec/support/active_support_if_configured'
+
+Pact.service_consumer "Standalone Consumer" do
+  has_pact_with "Standalone Provider" do
+    mock_service :standalone_service do
+      port 1237
+    end
+  end
+end
+
+class StandaloneClient
+
+  def initialize base_url
+    @base_url = base_url
+  end
+
+  def call
+    uri = URI("#{@base_url}/something")
+    post_req = Net::HTTP::Post.new(uri.path)
+    post_req['Content-Type'] = "application/json"
+    post_req.body = {a: "body"}.to_json
+    response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+      http.request post_req
+    end
+    response.body
+  end
+
+end
+
+describe StandaloneClient, pact: true do
+
+  subject { StandaloneClient.new("http://localhost:1237") }
+
+  describe "call" do
+
+    let(:expected_body) { {a: "body"} }
+    let(:response_body) { {a: 'response body'} }
+
+    before do
+      standalone_service.
+        upon_receiving("a request to create something").with(method: 'post', path: '/something', body: expected_body).
+        will_respond_with(status: 200, headers: {}, body: response_body)
+    end
+
+    it "will pass" do
+      expect(subject.call).to eq response_body.to_json
+    end
+  end
+
+end

data/spec/support/a_consumer-a_producer.json

@@ -1,6 +1,6 @@
 {
   "producer": {
-    "name": "a producer"
+    "name": "an old producer"
   },
   "consumer": {
     "name": "a consumer"
@@ -27,8 +27,6 @@
     }
   ],
   "metadata": {
-    "pact_gem": {
-      "version": "0.1.24"
-    }
+    "pactSpecificationVersion": "1.0"
   }
 }

data/spec/support/a_consumer-a_provider.json

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

data/spec/support/active_support_if_configured.rb

@@ -0,0 +1,6 @@
+if ENV['LOAD_ACTIVE_SUPPORT']
+   puts 'LOADING ACTIVE SUPPORT!!!! Hopefully it all still works'
+   require 'active_support/all'
+   require 'active_support'
+   require 'active_support/json'
+end

data/spec/support/app_for_config_ru.rb

@@ -0,0 +1,4 @@
+class AppForConfigRu
+  def call env
+  end
+end

data/spec/support/consumer_contract_template.json

@@ -0,0 +1,24 @@
+{
+  "provider": {
+    "name": "a provider"
+  },
+  "consumer": {
+    "name": "a consumer"
+  },
+  "interactions": [
+    {
+      "description": "request one",
+      "request": {
+        "method": "get",
+        "path": "/path_one"
+      },
+      "response": {
+        "status" : 200
+      },
+      "provider_state": "state one"
+    }
+  ],
+  "metadata": {
+    "pactSpecificationVersion": "1.0"
+  }
+}

data/spec/support/dsl_spec_support.rb

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

data/spec/support/factories.rb

@@ -0,0 +1,82 @@
+require 'hashie'
+require 'hashie/extensions/key_conversion'
+
+module Pact
+  module HashUtils
+
+    class Converter < Hash
+      include Hashie::Extensions::KeyConversion
+      include Hashie::Extensions::DeepMerge
+    end
+
+    def symbolize_keys hash
+      Hash[Converter[hash].symbolize_keys]
+    end
+
+    def stringify_keys hash
+      Hash[Converter[hash].stringify_keys]
+    end
+
+    def deep_merge hash1, hash2
+      Converter[hash1].deep_merge(Converter[hash2])
+    end
+  end
+end
+
+class InteractionFactory
+
+  extend Pact::HashUtils
+
+  def self.create hash = {}
+    defaults = {
+        'description' => 'a description',
+        'provider_state' => 'a thing exists',
+        'request' => {
+            'path' => '/path',
+            'method' => 'get',
+        },
+        'response' => {
+            'status' => 200,
+            'body' => {a: 'response body'}
+        }
+    }
+    Pact::Interaction.from_hash(stringify_keys(deep_merge(defaults, stringify_keys(hash))))
+  end
+end
+
+
+class ConsumerContractFactory
+  extend Pact::HashUtils
+  DEFAULTS = {:consumer_name => 'consumer',
+      :provider_name => 'provider',
+      :interactions => [InteractionFactory.create]}
+
+  def self.create overrides = {}
+    options = deep_merge(symbolize_keys(DEFAULTS), symbolize_keys(overrides))
+    Pact::ConsumerContract.new({:consumer => Pact::ServiceConsumer.new(name: options[:consumer_name]),
+      :provider => Pact::ServiceProvider.new(name: options[:provider_name]),
+      :interactions => options[:interactions]})
+  end
+end
+
+
+
+class ResponseFactory
+  extend Pact::HashUtils
+  DEFAULTS = {:status => 200, :body => {a: 'body'}}.freeze
+  def self.create_hash overrides = {}
+    deep_merge(DEFAULTS, overrides)
+  end
+end
+
+class RequestFactory
+  extend Pact::HashUtils
+  DEFAULTS = {:path => '/path', :method => 'get', :query => 'query', :headers => {}}.freeze
+  def self.create_hash overrides = {}
+   deep_merge(DEFAULTS, overrides)
+  end
+
+  def self.create_actual overrides = {}
+    Pact::Consumer::Request::Actual.from_hash(create_hash(overrides))
+  end
+end

data/spec/support/generated_index.md

@@ -0,0 +1,4 @@
+### Pacts for Some Consumer
+
+* [Some Provider](Some Provider.md)
+* [Some other provider](Some other provider.md)

data/spec/support/generated_markdown.md

@@ -0,0 +1,55 @@
+### A pact between Some Consumer and Some Provider
+
+#### Requests from Some Consumer to Some Provider
+
+* [A request for alligators](#a_request_for_alligators_given_alligators_exist) given alligators exist
+
+* [A request for polar bears](#a_request_for_polar_bears)
+
+#### Interactions
+
+<a name="a_request_for_alligators_given_alligators_exist"></a>
+Given **alligators exist**, upon receiving **a request for alligators** from Some Consumer, with
+```json
+{
+  "method": "get",
+  "path": "/alligators"
+}
+```
+Some Provider will respond with:
+```json
+{
+  "status": 200,
+  "headers": {
+    "Content-Type": "application/json"
+  },
+  "body": {
+    "alligators": [
+      {
+        "name": "Bob",
+        "phoneNumber": "12345678"
+      }
+    ]
+  }
+}
+```
+<a name="a_request_for_polar_bears"></a>
+Upon receiving **a request for polar bears** from Some Consumer, with
+```json
+{
+  "method": "get",
+  "path": "/polar-bears"
+}
+```
+Some Provider will respond with:
+```json
+{
+  "status": 404,
+  "headers": {
+    "Content-Type": "application/json"
+  },
+  "body": {
+    "message": "Sorry, due to climate change, the polar bears are currently unavailable."
+  }
+}
+```

data/spec/support/interaction_view_model.json

@@ -0,0 +1,63 @@
+{
+    "provider": {
+        "name": "a provider"
+    },
+    "consumer": {
+        "name": "a consumer"
+    },
+    "interactions": [
+        {
+            "description": "a request with a body and headers",
+            "request": {
+                "method": "get",
+                "path": "/path",
+                "query": "some=thing",
+                "headers": {
+                    "key": "a header"
+                },
+                "body": {
+                    "key": "a body"
+                }
+            },
+            "response": {}
+        },
+        {
+            "description": "a request with an empty body and empty headers",
+            "request": {
+                "method": "get",
+                "path": "/",
+                "headers": {},
+                "body": {}
+            },
+            "response": {}
+        },
+        {
+            "description": "a response with a body and headers",
+            "request": {
+                "method": "get",
+                "path": "/"
+            },
+            "response": {
+                "headers": {
+                    "key": "a header"
+                },
+                "body": {
+                    "key": "a body"
+                },
+                "status": 200
+            }
+        },
+        {
+            "description": "a response with an empty body and empty headers",
+            "request": {
+                "method": "get",
+                "path": "/"
+            },
+            "response": {
+                "status": 200,
+                "headers": {},
+                "body": {}
+            }
+        }
+    ]
+}