pacto 0.2.5 → 0.3.0.pre

data/spec/spec_helper.rb

@@ -1 +1,18 @@
+require 'coveralls_helper'
 require 'pacto'
+require 'pacto/server'
+require 'stringio'
+require 'should_not/rspec'
+
+RSpec.configure do |config|
+  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
+    Pacto.clear!
+  end
+end

data/spec/unit/data/simple_contract.json

@@ -0,0 +1,22 @@
+{
+  "request": {
+    "method": "GET",
+    "path": "/hello",
+    "headers": {
+      "Accept": "application/json"
+    },
+    "params": {}
+  },
+
+  "response": {
+    "status": 200,
+    "headers": { "Content-Type": "application/json" },
+    "body": {
+      "type": "object",
+      "required": true,
+      "properties": {
+        "message": { "type": "string", "required": true }
+      }
+    }
+  }
+}

data/spec/unit/hooks/erb_hook_spec.rb

@@ -0,0 +1,51 @@
+describe Pacto::Hooks::ERBHook do
+  describe '#process' do
+    let(:req) {
+      OpenStruct.new({:headers => {'User-Agent' => 'abcd'}})
+    }
+    let(:converted_req) {
+      {'HEADERS' => {'User-Agent' => 'abcd'}}
+    }
+    let(:res) {
+      OpenStruct.new({:body => 'before'})
+    }
+
+    before do
+    end
+
+    context 'no matching contracts' do
+      it 'binds the request' do
+        contracts = Set.new
+        mock_erb({ :req => converted_req })
+        described_class.new.process contracts, req, res
+        expect(res.body).to eq('after')
+      end
+    end
+
+    context 'one matching contract' do
+      it 'binds the request and the contract\'s values' do
+        contract = OpenStruct.new({:values => {:max => 'test'}})
+        contracts = Set.new([contract])
+        mock_erb({ :req => converted_req, :max => 'test'})
+        described_class.new.process contracts, req, res
+        expect(res.body).to eq('after')
+      end
+    end
+
+    context 'multiple matching contracts' do
+      it 'binds the request and the first contract\'s values' do
+        contract1 = OpenStruct.new({:values => {:max => 'test'}})
+        contract2 = OpenStruct.new({:values => {:mob => 'team'}})
+        res = OpenStruct.new({:body => 'before'})
+        mock_erb({ :req => converted_req, :max => 'test'})
+        contracts = Set.new([contract1, contract2])
+        described_class.new.process contracts, req, res
+        expect(res.body).to eq('after')
+      end
+    end
+  end
+
+  def mock_erb(hash)
+    Pacto::ERBProcessor.any_instance.should_receive(:process).with('before', hash).and_return('after')
+  end
+end

data/spec/unit/pacto/configuration_spec.rb

@@ -0,0 +1,51 @@
+module Pacto
+  describe Configuration do
+    subject(:configuration) { Configuration.new }
+    let(:contracts_path) { 'path_to_contracts' }
+
+    it 'sets the preprocessor by default to ERBProcessor' do
+      expect(configuration.preprocessor).to be_kind_of ERBProcessor
+    end
+
+    it 'sets the postprocessor by default to HashMergeProcessor' do
+      expect(configuration.postprocessor).to be_kind_of HashMergeProcessor
+    end
+
+    it 'sets the stub provider by default to BuiltIn' do
+      expect(configuration.provider).to be_kind_of Stubs::BuiltIn
+    end
+
+    it 'sets strict matchers by default to true' do
+      expect(configuration.strict_matchers).to be_true
+    end
+
+    it 'sets contracts path by default to nil' do
+      expect(configuration.contracts_path).to be_nil
+    end
+
+    it 'sets logger by default to Logger' do
+      expect(configuration.logger).to be_kind_of Logger
+    end
+
+    context 'about logging' do
+
+      context 'when PACTO_DEBUG is enabled' do
+        around do |example|
+          ENV['PACTO_DEBUG'] = 'true'
+          example.run
+          ENV.delete 'PACTO_DEBUG'
+        end
+
+        it 'sets the log level to debug' do
+          expect(configuration.logger.level).to eq :debug
+        end
+      end
+
+      context 'when PACTO_DEBUG is disabled' do
+        it 'sets the log level to default' do
+          expect(configuration.logger.level).to eq :error
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/contract_factory_spec.rb

@@ -4,49 +4,18 @@ module Pacto
     let(:contract_name)      { 'contract' }
     let(:contract_path)      { File.join('spec', 'unit', 'data', "#{contract_name}.json") }
     let(:file_pre_processor) { double('file_pre_processor') }
-    let(:file_content)       { File.read(contract_path)}
+    let(:file_content)       { File.read(contract_path) }
 
     describe '.build_from_file' do
-      it 'should build a contract given a JSON file path and a host' do
+      it 'builds a contract given a JSON file path and a host' do
         file_pre_processor.stub(:process).and_return(file_content)
-        described_class.build_from_file(contract_path, host, file_pre_processor).
-          should be_a_kind_of(Pacto::Contract)
+        expect(described_class.build_from_file(contract_path, host, file_pre_processor)).to be_a_kind_of(Pacto::Contract)
       end
 
-      it 'should process files using File Pre Processor module' do
+      it 'processes files using File Pre Processor module' do
         file_pre_processor.should_receive(:process).with(file_content).and_return(file_content)
         described_class.build_from_file(contract_path, host, file_pre_processor)
       end
     end
-
-    describe '.validate_contract' do
-      it 'should not raise error if contract is correct' do
-        expect {
-          definition = {
-            'request' => {
-              'method' => 'GET',
-              'path' => '/a/path',
-              'params' => {},
-              'headers' => {}
-            },
-            'response' => {
-              'status' => 200,
-              'headers' => {},
-              'body' => {
-                'type' => 'string',
-                'required' => true
-              }
-            }
-          }
-          described_class.validate_contract(definition, contract_path)
-        }.not_to raise_error
-      end
-      
-      it 'should raise InvalidContract if contract do not contain a Request' do
-        expect {
-          described_class.validate_contract({}, contract_path)
-        }.to raise_error(InvalidContract)
-      end
-    end
   end
 end

data/spec/unit/pacto/contract_spec.rb

@@ -1,49 +1,77 @@
 module Pacto
   describe Contract do
-    let(:request) { double('request') }
-    let(:response) { double('response') }
+    let(:request)  { double 'request' }
+    let(:request_signature)  { double 'request_signature' }
+    let(:response) { double 'response' }
+    let(:provider) { double 'provider' }
+    let(:instantiated_response) { double 'instantiated response' }
 
-    let(:contract) { described_class.new(request, response) }
+    subject(:contract) { described_class.new request, response }
 
-    describe '#instantiate' do
-      let(:instantiated_response) { double('instantiated response') }
-      let(:instantiated_contract) { double('instantiated contract') }
+    before do
+      response.stub(:instantiate => instantiated_response)
+      Pacto.configuration.provider = provider
+    end
 
-      context 'by default' do
-        it 'should instantiate a contract with default attributes' do
-          response.should_receive(:instantiate).and_return(instantiated_response)
-          InstantiatedContract.should_receive(:new).
-            with(request, instantiated_response).
-            and_return(instantiated_contract)
-          instantiated_contract.should_not_receive(:replace!)
+    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
+        contract.stub_contract!
+      end
+    end
 
-          contract.instantiate.should == instantiated_contract
-        end
+    describe '#validate' do
+      before do
+        response.stub(:validate => validation_result)
+        request.stub(:execute => fake_response)
       end
 
-      context 'with extra attributes' do
-        let(:attributes) { {:foo => 'bar'} }
+      let(:validation_result) { double 'validation result' }
+      let(:fake_response)     { double 'fake response' }
 
-        it 'should instantiate a contract and overwrite default attributes' do
-          response.should_receive(:instantiate).and_return(instantiated_response)
-          InstantiatedContract.should_receive(:new).
-            with(request, instantiated_response).
-            and_return(instantiated_contract)
-          instantiated_contract.should_receive(:replace!).with(attributes)
+      it 'validates the generated response' do
+        response.should_receive(:validate).with(fake_response, {})
+        expect(contract.validate).to eq validation_result
+      end
+
+      it 'returns the result of the validation' do
+        expect(contract.validate).to eq validation_result
+      end
 
-          contract.instantiate(attributes).should == instantiated_contract
+      it 'generates the response' do
+        request.should_receive :execute
+        contract.validate
+      end
+
+      context 'when response gotten is provided' do
+        it 'does not generate the response' do
+          request.should_not_receive :execute
+          contract.validate fake_response
         end
       end
     end
 
-    describe '#validate' do
-      let(:fake_response) { double('fake response') }
-      let(:validation_result) { double('validation result') }
+    describe '#matches?' do
+      let(:request_matcher) do
+        double('fake request matcher').tap do |matcher|
+          matcher.stub(:matches?) { |r| r == request_signature }
+        end
+      end
 
-      it 'should execute the request and match it against the expected response' do
-        request.should_receive(:execute).and_return(fake_response)
-        response.should_receive(:validate).with(fake_response).and_return(validation_result)
-        contract.validate.should == validation_result
+      context 'when the contract is not stubbed' do
+        it 'returns false' do
+          expect(contract.matches? request_signature).to be_false
+        end
+      end
+
+      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
       end
     end
   end

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

@@ -0,0 +1,28 @@
+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
+      Pacto.configure do |c|
+        c.contracts_path = contracts_path
+      end
+      expect(Pacto.configuration.contracts_path).to eq(contracts_path)
+    end
+
+    it 'register a Pacto Callback' do
+      callback_block = Pacto::Callback.new { }
+      Pacto.configure do |c|
+        c.register_callback(callback_block)
+      end
+      expect(Pacto.configuration.callback).to eq(callback_block)
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+describe Pacto do
+  let(:tag) { 'contract_tag' }
+  let(:another_tag) { 'another_tag' }
+  let(:contract) { double('contract') }
+  let(:another_contract) { double('another_contract') }
+
+  after do
+    described_class.unregister_all!
+  end
+
+  describe '.register' do
+    context 'no tag' do
+      it 'registers the contract with the default tag' do
+        described_class.register_contract contract
+        expect(described_class.registered[:default]).to include(contract)
+      end
+    end
+
+    context 'one tag' do
+      it 'registers a contract under a given tag' do
+        described_class.register_contract(contract, tag)
+        expect(described_class.registered[tag]).to include(contract)
+      end
+
+      it 'does not duplicate a contract when it has already been registered with the same tag' do
+        described_class.register_contract(contract, tag)
+        described_class.register_contract(contract, tag)
+        expect(described_class.registered[tag]).to include(contract)
+        expect(described_class.registered[tag]).to have(1).items
+      end
+    end
+
+    context 'multiple tags' do
+      it 'registers a contract using different tags' do
+        described_class.register_contract(contract, tag, another_tag)
+        expect(described_class.registered[tag]).to include(contract)
+        expect(described_class.registered[another_tag]).to include(contract)
+      end
+
+      it 'registers a tag with different contracts ' do
+        described_class.register_contract(contract, tag)
+        described_class.register_contract(another_contract, tag)
+        expect(described_class.registered[tag]).to include(contract, another_contract)
+      end
+
+    end
+
+    context 'with a block' do
+      it 'has a compact syntax for registering multiple contracts' do
+        described_class.configure do |c|
+          c.register_contract 'new_api/create_item_v2', :item, :new
+          c.register_contract 'authentication', :default
+          c.register_contract 'list_items_legacy', :legacy
+          c.register_contract 'get_item_legacy', :legacy
+        end
+        expect(described_class.registered[:new]).to include('new_api/create_item_v2')
+        expect(described_class.registered[:default]).to include('authentication')
+        expect(described_class.registered[:legacy]).to include('list_items_legacy', 'get_item_legacy')
+      end
+    end
+  end
+
+  describe '.use' do
+    before do
+      described_class.register_contract(contract, tag)
+      described_class.register_contract(another_contract, :default)
+    end
+
+    context 'when a contract has been registered' 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!)
+        expect(described_class.use(tag)).to eq 2
+      end
+
+      it 'stubs default contract if unused tag' do
+        another_contract.should_receive(:stub_contract!)
+        expect(described_class.use(another_tag)).to eq 1
+      end
+    end
+
+    context 'when contract has not been registered' do
+      it 'raises an argument error' do
+        described_class.unregister_all!
+        expect { described_class.use('unregistered') }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '.unregister_all!' do
+    it 'unregisters all previously registered contracts' do
+      described_class.register_contract(contract, tag)
+      described_class.unregister_all!
+      expect(described_class.registered).to be_empty
+    end
+  end
+
+  describe '.contract_for' do
+    let(:request_signature) { double('request signature') }
+
+    context 'when no contracts are found for a request' do
+      it 'returns an empty list' do
+        expect(described_class.contract_for request_signature).to be_empty
+      end
+    end
+
+    context 'when contracts are found for a request' do
+      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 }
+
+      it 'returns the matching contracts' do
+        register_and_use all_contracts
+        expect(described_class.contract_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.to_set
+  end
+
+  def register_and_use contracts
+    contracts.each { |contract| described_class.register_contract contract }
+    Pacto.use :default
+  end
+end