pacto 0.3.1 → 0.4.0.rc1

data/spec/integration/e2e_spec.rb

@@ -1,31 +1,30 @@
-describe 'Pacto' do
-  let(:contract_path) { 'spec/integration/data/simple_contract.json' }
-  let(:strict_contract_path) { 'spec/integration/data/strict_contract.json' }
+# -*- encoding : utf-8 -*-
+describe Pacto do
+  let(:contract_path) { 'spec/fixtures/contracts/simple_contract.json' }
+  let(:strict_contract_path) { 'spec/fixtures/contracts/strict_contract.json' }
 
   before :all do
     WebMock.allow_net_connect!
   end
 
-  context 'Contract validation' do
-    before :all do
-      @server = Pacto::Server::Dummy.new 8000, '/hello', '{"message": "Hello World!"}'
-      @server.start
-    end
-
-    after :all do
-      @server.terminate
+  context 'Contract investigation' do
+    around :each do |example|
+      run_pacto do
+        example.run
+      end
     end
 
     it 'verifies the contract against a producer' do
-      contract = Pacto.load_contracts(contract_path, 'http://localhost:8000')
-      expect(contract.validate_all.flatten).to eq([])
+      # FIXME: Does this really test what it says it does??
+      contract = described_class.load_contracts(contract_path, 'http://localhost:8000')
+      expect(contract.simulate_consumers.map(&:successful?).uniq).to eq([true])
     end
   end
 
   context 'Stubbing a collection of contracts' do
     it 'generates a server that stubs the contract for consumers' do
-      contracts = Pacto.load_contracts(contract_path, 'http://dummyprovider.com')
-      contracts.stub_all
+      contracts = described_class.load_contracts(contract_path, 'http://dummyprovider.com')
+      contracts.stub_providers
 
       response = get_json('http://dummyprovider.com/hello')
       expect(response['message']).to eq 'bar'
@@ -34,20 +33,20 @@ describe 'Pacto' do
 
   context 'Journey' do
     it 'stubs multiple services with a single use' do
-      Pacto.configure do |c|
+      described_class.configure do |c|
         c.strict_matchers = false
         c.register_hook Pacto::Hooks::ERBHook.new
       end
 
-      contracts = Pacto.load_contracts 'spec/integration/data/', 'http://dummyprovider.com'
-      contracts.stub_all(:device_id => 42)
+      contracts = described_class.load_contracts 'spec/fixtures/contracts/', 'http://dummyprovider.com'
+      contracts.stub_providers(device_id: 42)
 
       login_response = get_json('http://dummyprovider.com/hello')
       expect(login_response.keys).to eq ['message']
       expect(login_response['message']).to be_kind_of(String)
 
       devices_response = get_json('http://dummyprovider.com/strict')
-      expect(devices_response['devices']).to have(2).items
+      expect(devices_response['devices'].size).to eq(2)
       expect(devices_response['devices'][0]).to eq('/dev/42')
       expect(devices_response['devices'][1]).to eq('/dev/43')
     end
@@ -55,7 +54,7 @@ describe 'Pacto' do
 
   def get_json(url)
     response = Faraday.get(url) do |req|
-      req.headers = {'Accept' => 'application/json' }
+      req.headers = { 'Accept' => 'application/json' }
     end
     MultiJson.load(response.body)
   end

data/spec/integration/forensics/integration_matcher_spec.rb

@@ -0,0 +1,90 @@
+# -*- encoding : utf-8 -*-
+require 'pacto/rspec'
+
+module Pacto
+  describe '#have_investigated' do
+    let(:contract_path) { 'spec/fixtures/contracts/simple_contract.json' }
+    let(:strict_contract_path) { 'spec/fixtures/contracts/strict_contract.json' }
+
+    around :each do |example|
+      run_pacto do
+        example.run
+      end
+    end
+
+    def expect_to_raise(message_pattern = nil, &blk)
+      expect { blk.call }.to raise_error(RSpec::Expectations::ExpectationNotMetError, message_pattern)
+    end
+
+    def json_response(url)
+      response = Faraday.get(url) do |req|
+        req.headers = { 'Accept' => 'application/json' }
+      end
+      MultiJson.load(response.body)
+    end
+
+    def play_bad_response
+      contracts.stub_providers(device_id: 1.5)
+      Faraday.get('http://dummyprovider.com/strict') do |req|
+        req.headers = { 'Accept' => 'application/json' }
+      end
+    end
+
+    context 'successful investigations' do
+      let(:contracts) do
+        Pacto.load_contracts 'spec/fixtures/contracts/', 'http://dummyprovider.com'
+      end
+
+      before(:each) do
+        Pacto.configure do |c|
+          c.strict_matchers = false
+          c.register_hook Pacto::Hooks::ERBHook.new
+        end
+
+        contracts.stub_providers(device_id: 42)
+        Pacto.validate!
+
+        Faraday.get('http://dummyprovider.com/hello') do |req|
+          req.headers = { 'Accept' => 'application/json' }
+        end
+      end
+
+      it 'performs successful assertions' do
+        # High level assertions
+        expect(Pacto).to_not have_unmatched_requests
+        expect(Pacto).to_not have_failed_investigations
+
+        # Increasingly strict assertions
+        expect(Pacto).to have_investigated('Simple Contract')
+        expect(Pacto).to have_investigated('Simple Contract').with_request(headers: hash_including('Accept' => 'application/json'))
+        expect(Pacto).to have_investigated('Simple Contract').with_request(http_method: :get, url: 'http://dummyprovider.com/hello')
+      end
+
+      it 'supports negative assertions' do
+        expect(Pacto).to_not have_investigated('Strict Contract')
+        Faraday.get('http://dummyprovider.com/strict') do |req|
+          req.headers = { 'Accept' => 'application/json' }
+        end
+        expect(Pacto).to have_investigated('Strict Contract')
+      end
+
+      it 'raises useful error messages' do
+        # Expected failures
+        header_matcher  = hash_including('Accept' => 'text/plain')
+        matcher_description = Regexp.quote(header_matcher.description)
+        expect_to_raise(/but no requests matched headers #{matcher_description}/) { expect(Pacto).to have_investigated('Simple Contract').with_request(headers: header_matcher) }
+      end
+
+      it 'displays Contract investigation problems' do
+        play_bad_response
+        expect_to_raise(/investigation errors were found:/) { expect(Pacto).to have_investigated('Strict Contract') }
+      end
+
+      it 'displays the Contract file' do
+        play_bad_response
+        schema_file_uri = Addressable::URI.convert_path(File.absolute_path strict_contract_path).to_s
+        expect_to_raise(/in schema #{schema_file_uri}/) { expect(Pacto).to have_investigated('Strict Contract') }
+      end
+    end
+  end
+end

data/spec/integration/rspec_spec.rb

@@ -1,17 +1,14 @@
+# -*- encoding : utf-8 -*-
 require 'pacto/rspec'
 
 describe 'pacto/rspec' do
-  let(:contract_path) { 'spec/integration/data/simple_contract.json' }
-  let(:strict_contract_path) { 'spec/integration/data/strict_contract.json' }
+  let(:contract_path) { 'spec/fixtures/contracts/simple_contract.json' }
+  let(:strict_contract_path) { 'spec/fixtures/contracts/strict_contract.json' }
 
-  before :all do
-    WebMock.allow_net_connect!
-    @server = Pacto::Server::Dummy.new 8000, '/hello', '{"message": "Hello World!"}'
-    @server.start
-  end
-
-  after :all do
-    @server.terminate
+  around :each do |example|
+    run_pacto do
+      example.run
+    end
   end
 
   def expect_to_raise(message_pattern = nil, &blk)
@@ -20,21 +17,21 @@ describe 'pacto/rspec' do
 
   def json_response(url)
     response = Faraday.get(url) do |req|
-      req.headers = {'Accept' => 'application/json' }
+      req.headers = { 'Accept' => 'application/json' }
     end
     MultiJson.load(response.body)
   end
 
   def play_bad_response
-    contracts.stub_all(:device_id => 1.5)
+    contracts.stub_providers(device_id: 1.5)
     Faraday.get('http://dummyprovider.com/strict') do |req|
-      req.headers = {'Accept' => 'application/json' }
+      req.headers = { 'Accept' => 'application/json' }
     end
   end
 
-  context 'successful validations' do
+  context 'successful investigations' do
     let(:contracts) do
-      Pacto.load_contracts 'spec/integration/data/', 'http://dummyprovider.com'
+      Pacto.load_contracts 'spec/fixtures/contracts/', 'http://dummyprovider.com'
     end
 
     before(:each) do
@@ -43,29 +40,29 @@ describe 'pacto/rspec' do
         c.register_hook Pacto::Hooks::ERBHook.new
       end
 
-      contracts.stub_all(:device_id => 42)
+      contracts.stub_providers(device_id: 42)
       Pacto.validate!
 
       Faraday.get('http://dummyprovider.com/hello') do |req|
-        req.headers = {'Accept' => 'application/json' }
+        req.headers = { 'Accept' => 'application/json' }
       end
     end
 
     it 'performs successful assertions' do
       # High level assertions
       expect(Pacto).to_not have_unmatched_requests
-      expect(Pacto).to_not have_failed_validations
+      expect(Pacto).to_not have_failed_investigations
 
       # Increasingly strict assertions
       expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello')
-      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').with(:headers => {'Accept' => 'application/json'})
+      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').with(headers: { 'Accept' => 'application/json' })
       expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').against_contract(/simple_contract.json/)
     end
 
     it 'supports negative assertions' do
       expect(Pacto).to_not have_validated(:get, 'http://dummyprovider.com/strict')
       Faraday.get('http://dummyprovider.com/strict') do |req|
-        req.headers = {'Accept' => 'application/json' }
+        req.headers = { 'Accept' => 'application/json' }
       end
       expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/strict')
     end
@@ -73,14 +70,14 @@ describe 'pacto/rspec' do
     it 'raises useful error messages' do
       # High level error messages
       expect_to_raise(/Expected Pacto to have not matched all requests to a Contract, but all requests were matched/) { expect(Pacto).to have_unmatched_requests }
-      expect_to_raise(/Expected Pacto to have found validation problems, but none were found/) { expect(Pacto).to have_failed_validations }
+      expect_to_raise(/Expected Pacto to have found investigation problems, but none were found/) { expect(Pacto).to have_failed_investigations }
 
       unmatched_url = 'http://localhost:8000/404'
       Faraday.get unmatched_url
       expect_to_raise(/the following requests were not matched.*#{Regexp.quote unmatched_url}/m) { expect(Pacto).to_not have_unmatched_requests }
 
       # Expected failures
-      expect_to_raise(/no matching request was received/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').with(:headers => {'Accept' => 'text/plain'}) }
+      expect_to_raise(/no matching request was received/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').with(headers: { 'Accept' => 'text/plain' }) }
       # No support for with accepting a block
       # expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').with { |req| req.body == "abc" }
       expect_to_raise(/but it was validated against/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').against_contract(/strict_contract.json/) }
@@ -88,10 +85,10 @@ describe 'pacto/rspec' do
       expect_to_raise(/but no matching request was received/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/strict') }
     end
 
-    it 'displays Contract validation problems' do
+    it 'displays Contract investigation problems' do
       play_bad_response
-      expect_to_raise(/validation errors were found:/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/strict') }
-      expect_to_raise(/but the following issues were found:/) { expect(Pacto).to_not have_failed_validations }
+      expect_to_raise(/investigation errors were found:/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/strict') }
+      expect_to_raise(/but the following issues were found:/) { expect(Pacto).to_not have_failed_investigations }
     end
 
     it 'displays the Contract file' do

data/spec/integration/templating_spec.rb

@@ -1,20 +1,21 @@
+# -*- encoding : utf-8 -*-
 require 'securerandom'
 
 describe 'Templating' do
-  let(:contract_path) { 'spec/integration/data/templating_contract.json' }
+  let(:contract_path) { 'spec/fixtures/contracts/templating_contract.json' }
   let(:contracts) {  Pacto.load_contracts(contract_path, 'http://dummyprovider.com') }
 
   let(:key) { SecureRandom.hex }
   let(:auth_token) { SecureRandom.hex }
 
   let :response do
-    contracts.stub_all(:key => key, :auth_token => auth_token)
+    contracts.stub_providers(key: key, auth_token: auth_token)
 
     raw_response = Faraday.get('http://dummyprovider.com/echo') do |req|
       req.headers = {
-      'Accept' => 'application/json',
-      'Custom-Auth-Token' => "#{auth_token}",
-      'X-Message' => "#{key}"
+        'Accept' => 'application/json',
+        'Custom-Auth-Token' => "#{auth_token}",
+        'X-Message' => "#{key}"
       }
     end
     MultiJson.load(raw_response.body)
@@ -28,7 +29,7 @@ describe 'Templating' do
     it 'does not proccess erb tag' do
       Pacto.configure do |c|
         c.strict_matchers = false
-        c.register_hook do |contracts, req, res|
+        c.register_hook do |_contracts, _req, res|
           res
         end
       end

data/spec/pacto/dummy_server.rb

@@ -0,0 +1,4 @@
+# -*- encoding : utf-8 -*-
+require_relative 'dummy_server/dummy'
+require_relative 'dummy_server/playback_servlet'
+require_relative 'dummy_server/jruby_workaround_helper'

data/spec/pacto/{server → dummy_server}/dummy.rb

@@ -1,9 +1,10 @@
+# -*- encoding : utf-8 -*-
 require 'webrick'
 require 'forwardable'
 require 'tempfile'
 
 module Pacto
-  module Server
+  module DummyServer
     class Servlet < WEBrick::HTTPServlet::AbstractServlet
       extend Forwardable
 
@@ -12,7 +13,7 @@ module Pacto
 
         @doer = PlaybackServlet.new(
           status: 200,
-          headers: {'Content-Type' => 'application/json', 'Vary' => 'Accept'},
+          headers: { 'Content-Type' => 'application/json', 'Vary' => 'Accept' },
           body: json
         )
       end
@@ -22,11 +23,11 @@ module Pacto
 
     class Dummy
       def initialize(port, path, response)
-        log_file = File.exists?('/dev/null') ? '/dev/null' : Tempfile.new('log') # So tests run on Windows
+        log_file = File.exist?('/dev/null') ? '/dev/null' : Tempfile.new('log') # So tests run on Windows
         params = {
-          :Port => port,
-          :AccessLog => [],
-          :Logger => WEBrick::Log.new(log_file, 7)
+          Port: port,
+          AccessLog: [],
+          Logger: WEBrick::Log.new(log_file, 7)
         }
         @server = WEBrick::HTTPServer.new params
         @server.mount path, Servlet, response

data/spec/pacto/dummy_server/jruby_workaround_helper.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module DummyServer
+    module JRubyWorkaroundHelper
+      include Pacto::TestHelper
+
+      def run_pacto
+        WebMock.allow_net_connect!
+        # There are issues with EventMachine on JRuby, so it can't currently us with_pacto
+        if RUBY_PLATFORM == 'java'
+          @server = Pacto::DummyServer::Dummy.new 8000, '/hello', '{"message": "Hello World!"}'
+          @server.start
+          yield
+          @server.terminate
+        else
+          with_pacto(port: 8000, strip_port: true) do
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/spec/pacto/{server → dummy_server}/playback_servlet.rb

@@ -1,5 +1,6 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  module Server
+  module DummyServer
     class PlaybackServlet
       attr_reader :status, :headers, :body
 
@@ -9,7 +10,7 @@ module Pacto
         @body = attributes.fetch(:body, nil)
       end
 
-      def do_GET(request, response) # rubocop:disable MethodName
+      def do_GET(_request, response) # rubocop:disable MethodName
         response.status = status
         headers.each do |key, value|
           response[key] = value

data/spec/spec_helper.rb

@@ -1,20 +1,29 @@
+# -*- encoding : utf-8 -*-
 require 'coveralls_helper'
 require 'webmock/rspec'
 require 'pacto'
-require 'pacto/server'
+require 'pacto/test_helper'
+require 'pacto/dummy_server'
+require 'fabrication'
 require 'stringio'
 require 'rspec'
-require 'should_not/rspec'
+
+# Pre-load shared examples
+require_relative 'unit/pacto/actor_spec.rb'
 
 RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+  config.include Pacto::TestHelper
+  config.include Pacto::DummyServer::JRubyWorkaroundHelper
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
-  config.before(:each) do
-    provider = Pacto.configuration.provider
-    unless provider.respond_to? :reset!
-      provider.stub(:reset!)
-    end
+  config.after(:each) do
     Pacto.clear!
   end
 end
+
+def sample_contract
+  # Memoized for test speed
+  @sample_contract ||= Fabricate(:contract)
+end

data/spec/unit/actors/from_examples_spec.rb

@@ -0,0 +1,70 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Actors
+    describe FromExamples do
+
+      let(:fallback) { double('fallback') }
+      subject(:generator) { described_class.new fallback }
+
+      context 'a contract without examples' do
+        let(:contract) { Fabricate(:contract) }
+
+        it_behaves_like 'an actor' do
+          before(:each) do
+            allow(fallback).to receive(:build_request).with(contract, {}).and_return(Fabricate(:pacto_request))
+            allow(fallback).to receive(:build_response).with(contract, {}).and_return(Fabricate(:pacto_response))
+          end
+          let(:contract) { Fabricate(:contract) }
+        end
+
+        it 'uses the fallback actor' do
+          expect(fallback).to receive(:build_request).with(contract, {})
+          expect(fallback).to receive(:build_response).with(contract, {})
+          generator.build_request contract
+          generator.build_response contract
+        end
+      end
+
+      context 'a contract with examples' do
+        let(:contract) { Fabricate(:contract, example_count: 3) }
+        let(:request) { generator.build_request contract }
+        let(:response) { generator.build_response contract }
+
+        it_behaves_like 'an actor' do
+          let(:contract) { Fabricate(:contract, example_count: 3) }
+        end
+
+        context 'no example specified' do
+          it 'uses the first example' do
+            expect(request.body).to eq(contract.examples.values.first.request.body)
+            expect(response.body).to eq(contract.examples.values.first.response.body)
+          end
+        end
+
+        context 'example specified' do
+          let(:name) { '1' }
+          subject(:generator) { described_class.new fallback, Pacto::Actors::NamedExampleSelector }
+          let(:request) { generator.build_request contract, example_name: name }
+          let(:response) { generator.build_response contract, example_name: name }
+
+          it 'uses the named example' do
+            expect(request.body).to eq(contract.examples[name].request.body)
+            expect(response.body).to eq(contract.examples[name].response.body)
+          end
+        end
+
+        context 'with randomized behavior' do
+          subject(:generator) { described_class.new fallback, Pacto::Actors::RandomExampleSelector }
+          it 'returns a randomly selected example' do
+            examples_requests = contract.examples.values.map(&:request)
+            examples_responses = contract.examples.values.map(&:response)
+            request_bodies = examples_requests.map(&:body)
+            response_bodies = examples_responses.map(&:body)
+            expect(request_bodies).to include request.body
+            expect(response_bodies).to include response.body
+          end
+        end
+      end
+    end
+  end
+end