pacto 0.3.1 → 0.4.0.rc1

data/spec/unit/pacto/cops/body_cop_spec.rb

@@ -0,0 +1,107 @@
+# -*- encoding : utf-8 -*-
+RSpec.shared_examples 'a body cop' do | section_to_validate |
+  subject(:cop) { described_class }
+  let(:request_clause)  { Fabricate(:request_clause, schema: schema) }
+  let(:response_clause) { Fabricate(:response_clause, schema: schema) }
+  let(:contract)         do
+    Fabricate(:contract, file: 'file:///a.json', request: request_clause, response: response_clause)
+  end
+  let(:string_required)  { %w(#) }
+  let(:request)          { Fabricate(:pacto_request) }
+  let(:response)         { Fabricate(:pacto_response) }
+  let(:clause_to_validate) { contract.send section_to_validate }
+  let(:object_to_validate) { send section_to_validate }
+
+  describe '#validate' do
+    context 'when schema is not specified' do
+      let(:schema) { nil }
+
+      it 'gives no errors without validating body' do
+        expect(JSON::Validator).not_to receive(:fully_validate)
+        expect(cop.investigate(request, response, contract)).to be_empty
+      end
+    end
+
+    context 'when the expected body is a string' do
+      let(:schema) { { 'type' => 'string', 'required' => string_required } }
+
+      context 'if required' do
+        it 'does not return an error when body is a string' do
+          object_to_validate.body = 'asdf'
+          expect(cop.investigate(request, response, contract)).to eq([])
+        end
+
+        it 'returns an error when body is nil' do
+          object_to_validate.body = nil
+          expect(cop.investigate(request, response, contract).size).to eq 1
+        end
+      end
+
+      context 'if not required' do
+        let(:string_required) { %w() }
+
+        # Body can be empty but not nil if not required
+        # Not sure if this is an issue or not
+        skip 'does not return an error when body is a string' do
+          expect(cop.investigate(request, response, contract)).to be_empty
+        end
+
+        it 'does not return an error when body is empty' do
+          object_to_validate.body = ''
+          expect(cop.investigate(request, response, contract)).to be_empty
+        end
+      end
+
+      context 'if contains pattern' do
+        let(:schema) do
+          { type: 'string', required: string_required, pattern: 'a.c' }
+        end
+
+        context 'body matches pattern' do
+          it 'does not return an error' do
+            object_to_validate.body = 'abc'
+            expect(cop.investigate(request, response, contract)).to be_empty
+          end
+        end
+
+        context 'body does not match pattern' do
+          it 'returns an error' do
+            object_to_validate.body = 'acb' # This does not matches the pattern /a.c/
+            expect(cop.investigate(request, response, contract).size).to eq 1
+          end
+        end
+      end
+    end
+
+    context 'when the body is json' do
+      let(:schema) { { type: 'object' } }
+
+      context 'when body matches' do
+        it 'does not return any errors' do
+          expect(JSON::Validator).to receive(:fully_validate).and_return([])
+          expect(cop.investigate(request, response, contract)).to be_empty
+        end
+      end
+
+      context 'when body does not match' do
+        it 'returns a list of errors' do
+          errors = double 'some errors'
+          expect(JSON::Validator).to receive(:fully_validate).and_return(errors)
+          expect(cop.investigate(request, response, contract)).to eq(errors)
+        end
+      end
+    end
+  end
+end
+
+module Pacto
+  module Cops
+    describe RequestBodyCop do
+      it_behaves_like 'a body cop', :request
+    end
+
+    describe ResponseBodyCop do
+      it_behaves_like 'a body cop', :response
+    end
+  end
+end

data/spec/unit/pacto/{validators/response_header_validator_spec.rb → cops/response_header_cop_spec.rb}

@@ -1,24 +1,34 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  module Validators
-    describe ResponseHeaderValidator do
-      subject(:validator) { described_class }
+  module Cops
+    describe ResponseHeaderCop do
+      subject(:cop) { described_class }
+      let(:contract)         do
+        response_clause = Fabricate(:response_clause, headers: expected_headers)
+        Fabricate(:contract, response: response_clause)
+      end
+      let(:request)          { Fabricate(:pacto_request) }
+      let(:response)         { Fabricate(:pacto_response, headers: actual_headers) }
       let(:expected_headers) do
         {
           'Content-Type' => 'application/json'
         }
       end
-      describe '#validate' do
+      describe '#investigate' do
         context 'when headers do not match' do
-          let(:actual_headers) { {'Content-Type' => 'text/html'} }
-
+          let(:actual_headers) do
+            { 'Content-Type' => 'text/html' }
+          end
           it 'indicates the exact mismatches' do
-            expect(validator.validate(expected_headers, actual_headers)).
+            expect(cop.investigate(request, response, contract)).
               to eq ['Invalid response header Content-Type: expected "application/json" but received "text/html"']
           end
         end
 
         context 'when headers are missing' do
-          let(:actual_headers) { {} }
+          let(:actual_headers) do
+            {}
+          end
           let(:expected_headers) do
             {
               'Content-Type' => 'application/json',
@@ -26,7 +36,7 @@ module Pacto
             }
           end
           it 'lists the missing headers' do
-            expect(validator.validate(expected_headers, actual_headers)).
+            expect(cop.investigate(request, response, contract)).
               to eq [
                 'Missing expected response header: Content-Type',
                 'Missing expected response header: My-Cool-Header'
@@ -40,9 +50,9 @@ module Pacto
           end
 
           context 'and no Location header is sent' do
-            let(:actual_headers) { {'Content-Type' => 'application/json'} }
+            let(:actual_headers) { { 'Content-Type' => 'application/json' } }
             it 'returns a header error when no Location header is sent' do
-              expect(validator.validate(expected_headers, actual_headers)).to eq ['Missing expected response header: Location']
+              expect(cop.investigate(request, response, contract)).to eq ['Missing expected response header: Location']
             end
           end
 
@@ -54,8 +64,9 @@ module Pacto
               }
             end
 
-            it 'returns a validation error' do
-              expect(validator.validate(expected_headers, actual_headers)).to eq ["Invalid response header Location: expected URI #{actual_headers['Location']} to match URI Template #{expected_headers['Location']}"]
+            it 'returns a investigation error' do
+              response.headers = actual_headers
+              expect(cop.investigate(request, response, contract)).to eq ["Invalid response header Location: expected URI #{actual_headers['Location']} to match URI Template #{expected_headers['Location']}"]
             end
           end
 
@@ -67,25 +78,25 @@ module Pacto
               }
             end
 
-            it 'validates successfully' do
-              expect(validator.validate(expected_headers, actual_headers)).to be_empty
+            it 'investigates successfully' do
+              expect(cop.investigate(request, response, contract)).to be_empty
             end
           end
         end
 
         context 'when headers are a subset of expected headers' do
-          let(:actual_headers) { {'Content-Type' => 'application/json'} }
+          let(:actual_headers) { { 'Content-Type' => 'application/json' } }
 
           it 'does not return any errors' do
-            expect(validator.validate(expected_headers, actual_headers)).to be_empty
+            expect(cop.investigate(request, response, contract)).to be_empty
           end
         end
 
         context 'when headers values match but keys have different case' do
-          let(:actual_headers) { {'content-type' => 'application/json'} }
+          let(:actual_headers) { { 'content-type' => 'application/json' } }
 
           it 'does not return any errors' do
-            expect(validator.validate(expected_headers, actual_headers)).to be_empty
+            expect(cop.investigate(request, response, contract)).to be_empty
           end
         end
       end

data/spec/unit/pacto/cops/response_status_cop_spec.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Cops
+    describe ResponseStatusCop do
+      subject(:cop) { described_class }
+      let(:contract) { Fabricate(:contract) }
+      let(:request) { Fabricate(:pacto_request) }
+
+      describe '#investigate' do
+        context 'when status does not match' do
+          let(:response) { Fabricate(:pacto_response, status: 500) }
+          it 'returns a status error' do
+            expect(cop.investigate(request, response, contract)).to eq ['Invalid status: expected 200 but got 500']
+          end
+        end
+
+        context 'when the status matches' do
+          let(:response) { Fabricate(:pacto_response, status: 200) }
+          it 'returns nil' do
+            expect(cop.investigate(request, response, contract)).to be_empty
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/cops_spec.rb

@@ -0,0 +1,75 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  describe Cops do
+    let(:investigation_errors) { ['some error', 'another error'] }
+
+    let(:expected_response) do
+      Fabricate(:response_clause)
+    end
+
+    let(:actual_response) do
+      # TODO: Replace this with a Fabrication for Pacto::PactoResponse (perhaps backed by WebMock)
+      Fabricate(:pacto_response)
+      # double(
+      #   status: 200,
+      #   headers: { 'Content-Type' => 'application/json', 'Age' => '60' },
+      #   body: { 'message' => 'response' }
+      # )
+    end
+
+    let(:actual_request) { Fabricate(:pacto_request) }
+
+    let(:expected_request) do
+      Fabricate(:request_clause)
+    end
+
+    let(:contract) do
+      Fabricate(
+        :contract,
+        request: expected_request,
+        response: expected_response
+      )
+    end
+
+    describe '#validate_contract' do
+      before do
+        allow(Pacto::Cops::RequestBodyCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return([])
+        allow(Pacto::Cops::ResponseBodyCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return([])
+      end
+
+      context 'default cops' do
+        let(:investigation) { described_class.perform_investigation actual_request, actual_response, contract }
+
+        it 'calls the RequestBodyCop' do
+          expect(Pacto::Cops::RequestBodyCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return(investigation_errors)
+          expect(investigation.citations).to eq(investigation_errors)
+        end
+
+        it 'calls the ResponseStatusCop' do
+          expect(Pacto::Cops::ResponseStatusCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return(investigation_errors)
+          expect(investigation.citations).to eq(investigation_errors)
+        end
+
+        it 'calls the ResponseHeaderCop' do
+          expect(Pacto::Cops::ResponseHeaderCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return(investigation_errors)
+          expect(investigation.citations).to eq(investigation_errors)
+        end
+
+        it 'calls the ResponseBodyCop' do
+          expect(Pacto::Cops::ResponseBodyCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return(investigation_errors)
+          expect(investigation.citations).to eq(investigation_errors)
+        end
+      end
+
+      context 'when headers and body match and the ResponseStatusCop reports no errors' do
+        it 'does not return any errors' do
+          expect(Pacto::Cops::RequestBodyCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return([])
+          expect(Pacto::Cops::ResponseStatusCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return([])
+          expect(Pacto::Cops::ResponseHeaderCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return([])
+          expect(Pacto::Cops::ResponseBodyCop).to receive(:investigate).with(actual_request, actual_response, contract).and_return([])
+          expect(described_class.perform_investigation actual_request, actual_response, contract).to be_successful
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/core/configuration_spec.rb

@@ -1,21 +1,22 @@
+# -*- encoding : utf-8 -*-
 describe Pacto do
   describe '.configure' do
     let(:contracts_path) { 'path_to_contracts' }
 
     it 'allows contracts_path manual configuration' do
-      expect(Pacto.configuration.contracts_path).to be_nil
-      Pacto.configure do |c|
+      expect(described_class.configuration.contracts_path).to eq('.')
+      described_class.configure do |c|
         c.contracts_path = contracts_path
       end
-      expect(Pacto.configuration.contracts_path).to eq(contracts_path)
+      expect(described_class.configuration.contracts_path).to eq(contracts_path)
     end
 
     it 'register a Pacto Hook' do
       hook_block = Pacto::Hook.new {}
-      Pacto.configure do |c|
+      described_class.configure do |c|
         c.register_hook(hook_block)
       end
-      expect(Pacto.configuration.hook).to eq(hook_block)
+      expect(described_class.configuration.hook).to eq(hook_block)
     end
   end
 end

data/spec/unit/pacto/core/contract_registry_spec.rb

@@ -1,104 +1,38 @@
+# -*- encoding : utf-8 -*-
 require_relative '../../../../lib/pacto/core/contract_registry'
 
 module Pacto
   describe ContractRegistry do
-    let(:tag) { 'contract_tag' }
-    let(:another_tag) { 'another_tag' }
-    let(:contract) { double('contract') }
-    let(:contract_factory)  { double }
-    let(:another_contract) { double('another_contract') }
-    let(:request_signature) { double('request signature') }
-    let(:contracts_that_match)      { create_contracts 2, true }
-    let(:contracts_that_dont_match) { create_contracts 3, false }
-    let(:all_contracts)             { contracts_that_match + contracts_that_dont_match }
+    let(:contract) { Fabricate(:contract) }
+    let(:request_signature) { Fabricate(:webmock_request_signature) }
 
-    subject(:contract_list) do
+    subject(:contract_registry) do
       ContractRegistry.new
     end
 
     describe '.register' do
-      context 'no tag' do
-        it 'registers the contract with the default tag' do
-          contract_list.register contract
-          expect(contract_list[:default]).to include(contract)
-        end
-      end
-
-      context 'one tag' do
-        it 'registers a contract under a given tag' do
-          contract_list.register(contract, tag)
-          expect(contract_list[tag]).to include(contract)
-        end
-
-        it 'does not duplicate a contract when it has already been registered with the same tag' do
-          contract_list
-            .register(contract, tag)
-            .register(contract, tag)
-
-          expect(contract_list[tag]).to include(contract)
-          expect(contract_list[tag]).to have(1).items
-        end
-      end
-
-      context 'multiple tags' do
-        it 'registers a contract using different tags' do
-          contract_list.register(contract, tag, another_tag)
-          expect(contract_list[tag]).to include(contract)
-          expect(contract_list[another_tag]).to include(contract)
-        end
-
-        it 'registers a tag with different contracts ' do
-          contract_list
-            .register(contract, tag)
-            .register(another_contract, tag)
-
-          expect(contract_list[tag]).to include(contract, another_contract)
-        end
-
+      it 'registers the contract' do
+        contract_registry.register contract
+        expect(contract_registry).to include(contract)
       end
     end
 
-    describe '.use' do
-      before do
-        contract_list
-          .register(contract, tag)
-          .register(another_contract, :default)
-      end
-
-      context 'when a contract has been registry' do
-        let(:response_body) { double('response_body') }
-
-        it 'stubs a contract with default values' do
-          contract.should_receive(:stub_contract!)
-          another_contract.should_receive(:stub_contract!)
-          contract_list.use(tag)
-        end
-
-        it 'stubs default contract if unused tag' do
-          another_contract.should_receive(:stub_contract!)
-          contract_list.use(another_tag)
-        end
-      end
-
-      context 'when contract has not been registry' do
-        it 'raises an argument error' do
-          contract_list = ContractRegistry.new
-          expect { contract_list.use('unregistry') }.to raise_error ArgumentError
-        end
+    describe '.contracts_for' do
+      before(:each) do
+        contract_registry.register contract
       end
-    end
 
-    describe '.contracts_for' do
       context 'when no contracts are found for a request' do
         it 'returns an empty list' do
-          expect(contract_list.contracts_for request_signature).to be_empty
+          expect(contract).to receive(:matches?).with(request_signature).and_return false
+          expect(contract_registry.contracts_for request_signature).to be_empty
         end
       end
 
       context 'when contracts are found for a request' do
         it 'returns the matching contracts' do
-          register_and_use all_contracts
-          expect(contract_list.contracts_for request_signature).to eq(contracts_that_match)
+          expect(contract).to receive(:matches?).with(request_signature).and_return true
+          expect(contract_registry.contracts_for request_signature).to eq([contract])
         end
       end
     end
@@ -111,9 +45,8 @@ module Pacto
       end
     end
 
-    def register_and_use(contracts)
-      contracts.each { |contract| contract_list.register contract }
-      contract_list.use :default
+    def register_contracts(contracts)
+      contracts.each { |contract| contract_registry.register contract }
     end
   end
 end