pacto 0.3.0.pre → 0.3.0

data/spec/unit/pacto/contract_list_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Pacto
+  describe ContractList do
+    let(:contract1) { double(:contract_1) }
+    let(:contract2) { double(:contract_2) }
+
+    it 'holds a list of contracts' do
+      list = ContractList.new([contract1, contract2])
+      expect(list.contracts).to eq([contract1, contract2])
+    end
+
+    context 'when validating' do
+      it 'validates every contract on the list' do
+        expect(contract1).to receive(:validate_provider)
+        expect(contract2).to receive(:validate_provider)
+
+        list = ContractList.new([contract1, contract2])
+        list.validate_all
+      end
+    end
+
+    context 'when stubbing' do
+      let(:values) { Hash.new }
+
+      it 'stubs every contract on the list' do
+        expect(contract1).to receive(:stub_contract!).with(values)
+        expect(contract2).to receive(:stub_contract!).with(values)
+
+        list = ContractList.new([contract1, contract2])
+        list.stub_all(values)
+      end
+    end
+  end
+end

data/spec/unit/pacto/contract_spec.rb

@@ -1,77 +1,76 @@
 module Pacto
   describe Contract do
     let(:request)  { double 'request' }
-    let(:request_signature)  { double 'request_signature' }
-    let(:response) { double 'response' }
+    let(:response) { double 'response definition' }
     let(:provider) { double 'provider' }
-    let(:instantiated_response) { double 'instantiated response' }
+    let(:file) { 'contranct.json' }
+    let(:request_pattern_provider) { double(for: nil) }
 
-    subject(:contract) { described_class.new request, response }
+    subject(:contract) { Contract.new(request, response, file, 'sample', request_pattern_provider) }
 
     before do
-      response.stub(:instantiate => instantiated_response)
       Pacto.configuration.provider = provider
     end
 
+    it 'has a request pattern' do
+      pattern = double
+      expect(request_pattern_provider).to receive(:for).and_return(pattern)
+      expect(contract.request_pattern).to eq pattern
+    end
+
     describe '#stub_contract!' do
-      it 'instantiates the response and registers a stub' do
-        response.should_receive :instantiate
-        provider.should_receive(:stub_request!).with request, instantiated_response
+      it 'register a stub for the contract' do
+        provider.should_receive(:stub_request!).with(request, response)
         contract.stub_contract!
       end
     end
 
-    describe '#validate' do
+    context 'validations' do
+      let(:fake_response) { double('fake response') }
+      let(:validation_result) { double 'validation result' }
+
       before do
-        response.stub(:validate => validation_result)
-        request.stub(:execute => fake_response)
+        allow(Pacto::ContractValidator).to receive(:validate).with(contract, request, fake_response, {}).and_return validation_result
       end
 
-      let(:validation_result) { double 'validation result' }
-      let(:fake_response)     { double 'fake response' }
+      describe '#validate_consumer' do
+        it 'returns the result of the validation' do
+          expect(Pacto::ContractValidator).to receive(:validate).with(contract, request, fake_response, {})
+          expect(contract.validate_consumer request, fake_response).to eq validation_result
+        end
 
-      it 'validates the generated response' do
-        response.should_receive(:validate).with(fake_response, {})
-        expect(contract.validate).to eq validation_result
+        it 'does not generate another response' do
+          request.should_not_receive :execute
+          contract.validate_consumer request, fake_response
+        end
       end
 
-      it 'returns the result of the validation' do
-        expect(contract.validate).to eq validation_result
-      end
+      describe '#validate_provider' do
+        before do
+          allow(request).to receive(:execute).and_return fake_response
+        end
 
-      it 'generates the response' do
-        request.should_receive :execute
-        contract.validate
-      end
+        it 'generates the response' do
+          request.should_receive :execute
+          contract.validate_provider
+        end
 
-      context 'when response gotten is provided' do
-        it 'does not generate the response' do
-          request.should_not_receive :execute
-          contract.validate fake_response
+        it 'returns the result of the validating the generated response' do
+          expect(Pacto::ContractValidator).to receive(:validate).with(contract, request, fake_response, {})
+          expect(contract.validate_provider).to eq validation_result
         end
       end
     end
 
     describe '#matches?' do
-      let(:request_matcher) do
-        double('fake request matcher').tap do |matcher|
-          matcher.stub(:matches?) { |r| r == request_signature }
-        end
-      end
+      let(:request_pattern) { double(matches?: true) }
+      let(:request_signature)  { double }
 
-      context 'when the contract is not stubbed' do
-        it 'returns false' do
-          expect(contract.matches? request_signature).to be_false
-        end
-      end
+      it 'delegates to the request pattern' do
+        expect(request_pattern_provider).to receive(:for).and_return(request_pattern)
+        expect(request_pattern).to receive(:matches?).with(request_signature)
 
-      context 'when the contract is stubbed' do
-        it 'returns true if it matches the request' do
-          provider.should_receive(:stub_request!).with(request, instantiated_response).and_return(request_matcher)
-          contract.stub_contract!
-          expect(contract.matches? request_signature).to be_true
-          expect(contract.matches? :anything).to be_false
-        end
+        contract.matches?(request_signature)
       end
     end
   end

data/spec/unit/pacto/contract_validator_spec.rb

@@ -0,0 +1,85 @@
+module Pacto
+  describe ContractValidator do
+    let(:validation_errors) { ['some error', 'another error'] }
+
+    let(:expected_response) do
+      ResponseClause.new(
+        'status' => 200,
+        'headers' => {
+          'Content-Type' => 'application/json'
+        },
+        'body' =>  {:type => 'object', :required => true, :properties => double('body definition properties')}
+      )
+    end
+
+    let(:actual_response) do
+      double(
+        :status => 200,
+        :headers => {'Content-Type' => 'application/json', 'Age' => '60'},
+        :body => { 'message' => 'response' }
+      )
+    end
+
+    let(:actual_request) { double :actual_request }
+
+    let(:expected_request) do
+      RequestClause.new(
+        'http://example.com',
+        'body' =>  {
+          :type => 'object',
+          :required => true,
+          :properties => double('body definition properties')
+        }
+      )
+    end
+
+    let(:contract) do
+      request_pattern_provider = double(for: nil)
+      Contract.new(expected_request, expected_response, 'some_file.json', 'sample', request_pattern_provider)
+    end
+
+    let(:opts) { {} }
+
+    describe '.validate' do
+      before do
+        allow(Pacto::Validators::RequestBodyValidator).to receive(:validate).with(expected_request.schema, actual_request).and_return([])
+        allow(Pacto::Validators::ResponseBodyValidator).to receive(:validate).with(expected_response.schema, actual_response).and_return([])
+      end
+
+      context 'default validator stack' do
+        it 'calls the RequestBodyValidator' do
+          expect(Pacto::Validators::RequestBodyValidator).to receive(:validate).with(expected_request.schema, actual_request).and_return(validation_errors)
+          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to eq(validation_errors)
+        end
+
+        it 'calls the ResponseStatusValidator' do
+          expect(Pacto::Validators::ResponseStatusValidator).to receive(:validate).with(expected_response.status, actual_response.status).and_return(validation_errors)
+          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to eq(validation_errors)
+        end
+
+        it 'calls the ResponseHeaderValidator' do
+          expect(Pacto::Validators::ResponseHeaderValidator).to receive(:validate).with(expected_response.headers, actual_response.headers).and_return(validation_errors)
+          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to eq(validation_errors)
+        end
+
+        it 'calls the ResponseBodyValidator' do
+          expect(Pacto::Validators::ResponseBodyValidator).to receive(:validate).with(expected_response.schema, actual_response).and_return(validation_errors)
+          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to eq(validation_errors)
+        end
+      end
+
+      context 'when headers and body match and the ResponseStatusValidator reports no errors' do
+        it 'does not return any errors' do
+          # JSON::Validator.should_receive(:fully_validate).
+          #   with(definition['body'], fake_response.body, :version => :draft3).
+          #   and_return([])
+          expect(Pacto::Validators::RequestBodyValidator).to receive(:validate).with(expected_request.schema, actual_request).and_return([])
+          expect(Pacto::Validators::ResponseStatusValidator).to receive(:validate).with(expected_response.status, actual_response.status).and_return([])
+          expect(Pacto::Validators::ResponseHeaderValidator).to receive(:validate).with(expected_response.headers, actual_response.headers).and_return([])
+          expect(Pacto::Validators::ResponseBodyValidator).to receive(:validate).with(expected_response.schema, actual_response).and_return([])
+          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -1,13 +1,6 @@
 describe Pacto do
   describe '.configure' do
     let(:contracts_path) { 'path_to_contracts' }
-    it 'allows preprocessor manual configuration' do
-      expect(Pacto.configuration.preprocessor).to_not be_nil
-      Pacto.configure do |c|
-        c.preprocessor = nil
-      end
-      expect(Pacto.configuration.preprocessor).to be_nil
-    end
 
     it 'allows contracts_path manual configuration' do
       expect(Pacto.configuration.contracts_path).to be_nil
@@ -17,12 +10,12 @@ describe Pacto do
       expect(Pacto.configuration.contracts_path).to eq(contracts_path)
     end
 
-    it 'register a Pacto Callback' do
-      callback_block = Pacto::Callback.new { }
+    it 'register a Pacto Hook' do
+      hook_block = Pacto::Hook.new {}
       Pacto.configure do |c|
-        c.register_callback(callback_block)
+        c.register_hook(hook_block)
       end
-      expect(Pacto.configuration.callback).to eq(callback_block)
+      expect(Pacto.configuration.hook).to eq(hook_block)
     end
   end
 end

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

@@ -0,0 +1,119 @@
+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 }
+
+    subject(:contract_list) 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
+
+      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
+      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
+        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)
+        end
+      end
+    end
+
+    def create_contracts(total, matches)
+      total.times.map do
+        double('contract',
+               :stub_contract! => double('request matcher'),
+               :matches? => matches)
+      end
+    end
+
+    def register_and_use(contracts)
+      contracts.each { |contract| contract_list.register contract }
+      contract_list.use :default
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+describe Pacto do
+  modes = %w{generate validate}
+  modes.each do |mode|
+    enable_method = "#{mode}!".to_sym # generate!
+    query_method = "#{mode[0..-2]}ing?".to_sym # generating?
+    disable_method = "stop_#{mode[0..-2]}ing!".to_sym # stop_generating!
+    describe ".#{mode}!" do
+      it "tells the provider to enable #{mode} mode" do
+        expect(subject.send query_method).to be_false
+        subject.send enable_method
+        expect(subject.send query_method).to be_true
+
+        subject.send disable_method
+        expect(subject.send query_method).to be_false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+describe Pacto::ValidationRegistry do
+  subject(:registry) { Pacto::ValidationRegistry.instance }
+  let(:request_pattern) { WebMock::RequestPattern.new(:get, 'www.example.com') }
+  let(:request_signature) { WebMock::RequestSignature.new(:get, 'www.example.com') }
+  let(:different_request_signature) { WebMock::RequestSignature.new(:get, 'www.thoughtworks.com') }
+  let(:validation) { Pacto::Validation.new(request_signature, double, nil) }
+  let(:validation_for_a_similar_request) { Pacto::Validation.new(request_signature, double, nil) }
+  let(:validation_for_a_different_request) { Pacto::Validation.new(different_request_signature, double, nil) }
+
+  before(:each) do
+    registry.reset!
+  end
+
+  describe 'reset!' do
+    before(:each) do
+      registry.register_validation(validation)
+    end
+
+    it 'cleans validations' do
+      expect { registry.reset! }.to change { registry.validated? request_pattern }.from([validation]).to(nil)
+    end
+  end
+
+  describe 'registering and reporting registered validations' do
+    it 'returns registered validation' do
+      expect(registry.register_validation validation).to eq(validation)
+    end
+
+    it 'reports if validation is not registered' do
+      expect(registry.validated? request_pattern).to be_false
+    end
+
+    it 'registers and returns matching validations' do
+      registry.register_validation(validation)
+      registry.register_validation(validation_for_a_similar_request)
+      registry.register_validation(validation_for_a_different_request)
+      expect(registry.validated? request_pattern).to eq([validation, validation_for_a_similar_request])
+    end
+  end
+
+  describe '.unmatched_validations' do
+    let(:contract) { double('contract', :name => 'test') }
+
+    it 'returns validations with no contract' do
+      allow(contract).to receive(:validate_consumer).with(different_request_signature, anything).and_return(double('results', :empty? => true))
+      validation_with_results = Pacto::Validation.new(different_request_signature, double, contract)
+      registry.register_validation(validation)
+      registry.register_validation(validation_for_a_similar_request)
+      registry.register_validation(validation_for_a_different_request)
+      registry.register_validation(validation_with_results)
+
+      expect(registry.unmatched_validations).to match_array([validation, validation_for_a_similar_request, validation_for_a_different_request])
+    end
+  end
+
+  describe '.failed_validations' do
+    let(:contract) { double('contract', :name => 'test') }
+    let(:results2) { double('results2', :empty? => false, :join => 'wtf') }
+
+    it 'returns validations with unsuccessful results' do
+      allow(contract).to receive(:name).and_return 'test'
+      allow(contract).to receive(:validate_consumer).with(request_signature, anything).and_return(results2)
+      validation_with_successful_results = Pacto::Validation.new(request_signature, double, contract)
+      validation_with_unsuccessful_results = Pacto::Validation.new(request_signature, double, contract)
+
+      expect(validation_with_successful_results).to receive(:successful?).twice.and_return true
+      expect(validation_with_unsuccessful_results).to receive(:successful?).twice.and_return false
+
+      registry.register_validation(validation)
+      registry.register_validation(validation_with_successful_results)
+      registry.register_validation(validation_with_unsuccessful_results)
+
+      expect(registry.failed_validations).to match_array([validation_with_unsuccessful_results])
+    end
+  end
+end