pacto 0.3.1 → 0.4.0.rc1

data/spec/unit/actors/json_generator_spec.rb

@@ -0,0 +1,105 @@
+# -*- encoding : utf-8 -*-
+RSpec.shared_examples 'uses defaults' do
+  it 'uses the default values for the request' do
+    expect(request.body['foo']).to eq 'custom default value'
+  end
+
+  it 'uses the default values for the response' do
+    response = generator.build_response contract # , request
+    expect(response.body['foo']).to eq 'custom default value'
+  end
+end
+
+RSpec.shared_examples 'uses dumb values' do
+  it 'uses dumb values (request)' do
+    expect(request.body['foo']).to eq 'bar'
+  end
+
+  it 'uses dumb values (response)' do
+    response = generator.build_response contract # , request
+    expect(response.body['foo']).to eq 'bar'
+  end
+end
+
+module Pacto
+  module Actors
+    describe JSONGenerator do
+      subject(:generator) { described_class.new }
+      let(:request_clause) { Fabricate(:request_clause, schema: schema) }
+      let(:response_clause) { Fabricate(:response_clause, schema: schema) }
+      let(:contract) { Fabricate(:contract, request: request_clause, response: response_clause) }
+      let(:request) { generator.build_request contract }
+
+      context 'using default values from schema' do
+        context 'draft3' do
+          let(:schema) do
+            {
+              '$schema'  => 'http://json-schema.org/draft-03/schema#',
+              'type'     => 'object',
+              'required' => true,
+              'properties' => {
+                'foo' => {
+                  'type'     => 'string',
+                  'required' => true,
+                  'default'  => 'custom default value'
+                }
+              }
+            }
+          end
+          include_examples 'uses defaults'
+        end
+        context 'draft4' do
+          let(:schema) do
+            {
+              '$schema'  => 'http://json-schema.org/draft-04/schema#',
+              'type'     => 'object',
+              'required' => ['foo'],
+              'properties' => {
+                'foo' => {
+                  'type'     => 'string',
+                  'default'  => 'custom default value'
+                }
+              }
+            }
+          end
+          skip 'draft4 is not supported by JSONGenerator'
+          # include_examples 'uses defaults'
+        end
+      end
+      context 'using dumb values (no defaults)' do
+        context 'draft3' do
+          let(:schema) do
+            {
+              '$schema'  => 'http://json-schema.org/draft-03/schema#',
+              'type'     => 'object',
+              'required' => true,
+              'properties' => {
+                'foo' => {
+                  'type'     => 'string',
+                  'required' => true
+                }
+              }
+            }
+          end
+          include_examples 'uses dumb values'
+        end
+        context 'draft4' do
+          let(:schema) do
+            {
+              '$schema'  => 'http://json-schema.org/draft-04/schema#',
+              'type'     => 'object',
+              'required' => ['foo'],
+              'properties' => {
+                'foo' => {
+                  'type'     => 'string'
+                }
+              }
+            }
+          end
+          skip 'draft4 is not supported by JSONGenerator'
+          # include_examples 'uses dumb values'
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/actor_spec.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+RSpec.shared_examples 'an actor' do
+  # let(:contract) { Fabricate(:contract) }
+  let(:data) do
+    {}
+  end
+
+  describe '#build_request' do
+    let(:request) { subject.build_request contract, data }
+    it 'creates a PactoRequest' do
+      expect(request).to be_an_instance_of Pacto::PactoRequest
+    end
+  end
+
+  describe '#build_response' do
+    # Shouldn't build response be building a response for a request?
+    # let(:request) { Fabricate :pacto_request }
+    let(:response) { subject.build_response contract, data }
+    it 'creates a PactoResponse' do
+      expect(response).to be_an_instance_of Pacto::PactoResponse
+    end
+  end
+end

data/spec/unit/pacto/configuration_spec.rb

@@ -1,18 +1,19 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   describe Configuration do
-    subject(:configuration) { Configuration.new }
+    subject(:configuration) { described_class.new }
     let(:contracts_path) { 'path_to_contracts' }
 
-    it 'sets the stub provider by default to WebMockAdapter' do
-      expect(configuration.provider).to be_kind_of Stubs::WebMockAdapter
+    it 'sets the http adapter by default to WebMockAdapter' do
+      expect(configuration.adapter).to be_kind_of Stubs::WebMockAdapter
     end
 
     it 'sets strict matchers by default to true' do
-      expect(configuration.strict_matchers).to be_true
+      expect(configuration.strict_matchers).to be true
     end
 
-    it 'sets contracts path by default to nil' do
-      expect(configuration.contracts_path).to be_nil
+    it 'sets contracts path by default to .' do
+      expect(configuration.contracts_path).to eq('.')
     end
 
     it 'sets logger by default to Logger' do

data/spec/unit/pacto/consumer/faraday_driver_spec.rb

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  class Consumer
+    describe FaradayDriver do
+      subject(:strategy) { described_class.new }
+      let(:get_request)  { Fabricate(:pacto_request, method: :get,  host: 'http://localhost/', path: 'hello_world', params: { 'foo' => 'bar' }) }
+      let(:post_request) { Fabricate(:pacto_request, method: :post, host: 'http://localhost/', path: 'hello_world', params: { 'foo' => 'bar' }) }
+
+      describe '#execute' do
+
+        before do
+          WebMock.stub_request(:get, 'http://localhost/hello_world?foo=bar').
+            to_return(status: 200, body: '', headers: {})
+          WebMock.stub_request(:post, 'http://localhost/hello_world?foo=bar').
+            to_return(status: 200, body: '', headers: {})
+        end
+
+        context 'for any request' do
+          it 'returns the a Pacto::PactoResponse' do
+            expect(strategy.execute get_request).to be_a Pacto::PactoResponse
+          end
+        end
+
+        context 'for a GET request' do
+          it 'makes the request thru the http client' do
+            strategy.execute get_request
+            expect(WebMock).to have_requested(:get, 'http://localhost/hello_world?foo=bar')
+          end
+        end
+
+        context 'for a POST request' do
+          it 'makes the request thru the http client' do
+            strategy.execute post_request
+            expect(WebMock).to have_requested(:post, 'http://localhost/hello_world?foo=bar')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/contract_builder_spec.rb

@@ -0,0 +1,89 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  describe ContractBuilder do
+    let(:data) { subject.build_hash }
+    describe '#name' do
+      it 'sets the contract name' do
+        subject.name = 'foo'
+        expect(data).to include(name: 'foo')
+      end
+    end
+
+    describe '#add_example' do
+      let(:examples) { subject.build_hash[:examples] }
+      it 'adds named examples to the contract' do
+        subject.add_example 'foo', Fabricate(:pacto_request), Fabricate(:pacto_response)
+        subject.add_example 'bar', Fabricate(:pacto_request), Fabricate(:pacto_response)
+        expect(examples).to be_a(Hash)
+        expect(examples.keys).to include('foo', 'bar')
+        expect(examples['foo'][:response]).to include(status: 200)
+        expect(data)
+      end
+    end
+
+    context 'without examples' do
+      describe '#infer_schemas' do
+        it 'does not add schemas' do
+          subject.name = 'test'
+          subject.infer_schemas
+          expect(data[:request][:schema]).to be_nil
+          expect(data[:response][:schema]).to be_nil
+        end
+      end
+    end
+
+    context 'with examples' do
+      before(:each) do
+        subject.add_example 'success', Fabricate(:pacto_request), Fabricate(:pacto_response)
+        subject.add_example 'not found', Fabricate(:pacto_request), Fabricate(:pacto_response)
+      end
+
+      describe '#without_examples' do
+        it 'stops the builder from including examples in the final data' do
+          expect(subject.build_hash.keys).to include(:examples)
+          expect(subject.without_examples.build_hash.keys).to_not include(:examples)
+        end
+      end
+
+      describe '#infer_schemas' do
+        it 'adds schemas' do
+          subject.name = 'test'
+          subject.infer_schemas
+          contract = subject.build
+          expect(contract.request.schema).to_not be_nil
+          expect(contract.request.schema).to_not be_nil
+        end
+      end
+    end
+
+    context 'generating from interactions' do
+      let(:request) { Fabricate(:pacto_request) }
+      let(:response) { Fabricate(:pacto_response) }
+      let(:data) { subject.generate_response(request, response).build_hash }
+      let(:contract) { subject.generate_contract(request, response).build }
+
+      describe '#generate_response' do
+        it 'sets the response status' do
+          expect(data[:response]).to include(
+                                               status: 200
+                                             )
+        end
+
+        it 'sets response headers' do
+          expect(data[:response][:headers]).to be_a(Hash)
+        end
+      end
+
+      describe '#infer_schemas' do
+        it 'sets the schemas based on the examples' do
+          expect(contract.request.schema).to_not be_nil
+          expect(contract.request.schema).to_not be_nil
+        end
+      end
+    end
+
+    skip '#add_request_header'
+    skip '#add_response_header'
+    skip '#filter'
+  end
+end

data/spec/unit/pacto/contract_factory_spec.rb

@@ -1,23 +1,74 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 
 module Pacto
   describe ContractFactory do
     let(:host)                 { 'http://localhost' }
     let(:contract_name)        { 'contract' }
-    let(:contracts_path)       { %w(spec unit data) }
+    let(:contracts_path)       { %w(spec fixtures contracts) }
     let(:contract_path)        { File.join(contracts_path, "#{contract_name}.json") }
-    subject(:contract_factory) { ContractFactory.new }
+    let(:contract_files)       { [contract_path, contract_path] }
+    subject(:contract_factory) { described_class }
 
-    it 'builds a contract given a JSON file path and a host' do
-      contract = contract_factory.build_from_file(contract_path, host)
-      expect(contract).to be_a(Contract)
-    end
+    describe '#build' do
+      context 'default contract format' do
+        it 'builds contracts from a list of file paths and a host' do
+          contracts = contract_factory.build(contract_files, host)
+          contracts.each do |contract|
+            expect(contract).to be_a(Contract)
+          end
+        end
+      end
+
+      context 'custom format' do
+        let(:dummy_contract) { double }
+
+        class CustomContractFactory
+          def initialize(dummy_contract)
+            @dummy_contract = dummy_contract # rubocop:disable RSpec/InstanceVariable
+          end
+
+          def build_from_file(_contract_path, _host)
+            @dummy_contract # rubocop:disable RSpec/InstanceVariable
+          end
+        end
+
+        before do
+          subject.add_factory :custom, CustomContractFactory.new(dummy_contract)
+        end
+
+        it 'delegates to the registered factory' do
+          expect(contract_factory.build(contract_files, host, :custom)).to eq([dummy_contract, dummy_contract])
+        end
+      end
+
+      context 'flattening' do
+        let(:contracts_per_file) { 4 }
+
+        class MultiContractFactory
+          def initialize(contracts)
+            @contracts = contracts # rubocop:disable RSpec/InstanceVariable
+          end
+
+          def build_from_file(_contract_path, _host)
+            @contracts # rubocop:disable RSpec/InstanceVariable
+          end
+        end
+
+        before do
+          contracts = contracts_per_file.times.map do
+            double
+          end
+          subject.add_factory :multi, MultiContractFactory.new(contracts)
+        end
 
-    it 'builds contracts from a list of file paths and a host' do
-      contract_files = [contract_path, contract_path]
-      contracts = contract_factory.build(contract_files, host)
-      contracts.each do |contract|
-        expect(contract).to be_a(Contract)
+        it 'delegates to the registered factory' do
+          loaded_contracts = contract_factory.build(contract_files, host, :multi)
+          expected_size = contracts_per_file * contract_files.size
+          # If the ContractFactory doesn't flatten returned contracts the size will be off. It needs
+          # to flatten because some factories load a single contract per file, others load multiple.
+          expect(loaded_contracts.size).to eq(expected_size)
+        end
       end
     end
   end

data/spec/unit/pacto/contract_files_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'spec_helper'
 require 'fileutils'
 

data/spec/unit/pacto/contract_set_spec.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+module Pacto
+  describe ContractSet do
+    let(:contract1) { Fabricate(:contract) }
+    let(:contract2) { Fabricate(:contract, request: Fabricate(:request_clause, host: 'www2.example.com')) }
+
+    it 'holds a list of contracts' do
+      list = ContractSet.new([contract1, contract2])
+      expect(list).to eq(Set.new([contract1, contract2]))
+    end
+
+    context 'when validating' do
+      it 'validates every contract on the list' do
+        expect(contract1).to receive(:simulate_request)
+        expect(contract2).to receive(:simulate_request)
+
+        list = ContractSet.new([contract1, contract2])
+        list.simulate_consumers
+      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 = ContractSet.new([contract1, contract2])
+        list.stub_providers(values)
+      end
+    end
+  end
+end

data/spec/unit/pacto/contract_spec.rb

@@ -1,73 +1,85 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   describe Contract do
-    let(:request)  { double 'request' }
-    let(:response) { double 'response definition' }
-    let(:provider) { double 'provider' }
-    let(:file) { 'contranct.json' }
-    let(:request_pattern_provider) { double(for: nil) }
-
-    subject(:contract) { Contract.new(request, response, file, 'sample', request_pattern_provider) }
+    let(:request_clause) do
+      Pacto::RequestClause.new(
+        http_method: 'GET',
+        host: 'http://example.com',
+        path: '/',
+        schema:  {
+          type: 'object',
+          required: true # , :properties => double('body definition properties')
+        }
+      )
+    end
+    let(:response_clause) do
+      Pacto::ResponseClause.new(status: 200)
+    end
+    let(:adapter) { double 'provider' }
+    let(:file) { 'contract.json' }
+    let(:consumer_driver) { double }
+    let(:provider_actor) { double }
 
-    before do
-      Pacto.configuration.provider = provider
+    subject(:contract) do
+      described_class.new(
+        request: request_clause,
+        response: response_clause,
+        file: file,
+        name: 'sample'
+      )
     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
+    before do
+      Pacto.configuration.adapter = adapter
+      allow(consumer_driver).to receive(:respond_to?).with(:execute).and_return true
+      allow(provider_actor).to receive(:respond_to?).with(:build_response).and_return true
+      Pacto.configuration.default_consumer.driver = consumer_driver
+      Pacto.configuration.default_provider.actor = provider_actor
     end
 
     describe '#stub_contract!' do
       it 'register a stub for the contract' do
-        provider.should_receive(:stub_request!).with(request, response)
+        expect(adapter).to receive(:stub_request!).with(contract)
         contract.stub_contract!
       end
     end
 
-    context 'validations' do
-      let(:fake_response) { double('fake response') }
-      let(:validation_result) { double 'validation result' }
+    context 'investigations' do
+      let(:request) { Pacto.configuration.default_consumer.build_request contract }
+      let(:fake_response) { Fabricate(:pacto_response) } # double('fake response') }
+      let(:cop) { double 'cop' }
+      let(:investigation_citations) { [double('investigation result')] }
 
       before do
-        allow(Pacto::ContractValidator).to receive(:validate).with(contract, request, fake_response, {}).and_return validation_result
-      end
-
-      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 'does not generate another response' do
-          request.should_not_receive :execute
-          contract.validate_consumer request, fake_response
-        end
+        Pacto::Cops.active_cops.clear
+        Pacto::Cops.active_cops << cop
+        allow(cop).to receive(:investigate).with(an_instance_of(Pacto::PactoRequest), fake_response, contract).and_return investigation_citations
       end
 
-      describe '#validate_provider' do
+      describe '#simulate_request' do
         before do
-          allow(request).to receive(:execute).and_return fake_response
+          allow(consumer_driver).to receive(:execute).with(an_instance_of(Pacto::PactoRequest)).and_return fake_response
         end
 
         it 'generates the response' do
-          request.should_receive :execute
-          contract.validate_provider
+          expect(consumer_driver).to receive(:execute).with(an_instance_of(Pacto::PactoRequest))
+          contract.simulate_request
         end
 
         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
+          expect(cop).to receive(:investigate).with(an_instance_of(Pacto::PactoRequest), fake_response, contract)
+          investigation = contract.simulate_request
+          expect(investigation.citations).to eq investigation_citations
         end
       end
     end
 
     describe '#matches?' do
-      let(:request_pattern) { double(matches?: true) }
-      let(:request_signature)  { double }
+      let(:request_pattern)  { double('request_pattern') }
+      let(:request_signature)  { double('request_signature') }
 
       it 'delegates to the request pattern' do
-        expect(request_pattern_provider).to receive(:for).and_return(request_pattern)
+        expect(Pacto::RequestPattern).to receive(:for).and_return(request_pattern)
         expect(request_pattern).to receive(:matches?).with(request_signature)
 
         contract.matches?(request_signature)