pacto 0.4.0.rc1 → 0.4.0.rc2

data/spec/integration/rspec_spec.rb

@@ -2,11 +2,11 @@
 require 'pacto/rspec'
 
 describe 'pacto/rspec' do
-  let(:contract_path) { 'spec/fixtures/contracts/simple_contract.json' }
-  let(:strict_contract_path) { 'spec/fixtures/contracts/strict_contract.json' }
+  let(:contract_path) { contract_file 'simple_contract' }
+  let(:strict_contract_path) { contract_file 'strict_contract' }
 
   around :each do |example|
-    run_pacto do
+    with_pacto(port: 8000) do
       example.run
     end
   end
@@ -31,7 +31,7 @@ describe 'pacto/rspec' do
 
   context 'successful investigations' do
     let(:contracts) do
-      Pacto.load_contracts 'spec/fixtures/contracts/', 'http://dummyprovider.com'
+      Pacto.load_contracts contracts_folder, 'http://dummyprovider.com'
     end
 
     before(:each) do
@@ -43,7 +43,7 @@ describe 'pacto/rspec' do
       contracts.stub_providers(device_id: 42)
       Pacto.validate!
 
-      Faraday.get('http://dummyprovider.com/hello') do |req|
+      Faraday.get('http://dummyprovider.com/api/hello') do |req|
         req.headers = { 'Accept' => 'application/json' }
       end
     end
@@ -54,9 +54,9 @@ describe 'pacto/rspec' do
       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').against_contract(/simple_contract.json/)
+      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/api/hello')
+      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/api/hello').with(headers: { 'Accept' => 'application/json' })
+      expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/api/hello').against_contract(/simple_contract.json/)
     end
 
     it 'supports negative assertions' do
@@ -77,11 +77,11 @@ describe 'pacto/rspec' do
       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/api/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/) }
-      expect_to_raise(/but it was validated against/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/hello').against_contract('simple_contract.json') }
+      # expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/api/hello').with { |req| req.body == "abc" }
+      expect_to_raise(/but it was validated against/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/api/hello').against_contract(/strict_contract.json/) }
+      expect_to_raise(/but it was validated against/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/api/hello').against_contract('simple_contract.json') }
       expect_to_raise(/but no matching request was received/) { expect(Pacto).to have_validated(:get, 'http://dummyprovider.com/strict') }
     end
 

data/spec/integration/templating_spec.rb

@@ -2,7 +2,7 @@
 require 'securerandom'
 
 describe 'Templating' do
-  let(:contract_path) { 'spec/fixtures/contracts/templating_contract.json' }
+  let(:contract_path) { contract_file 'templating_contract' }
   let(:contracts) {  Pacto.load_contracts(contract_path, 'http://dummyprovider.com') }
 
   let(:key) { SecureRandom.hex }

data/spec/spec_helper.rb

@@ -3,7 +3,6 @@ require 'coveralls_helper'
 require 'webmock/rspec'
 require 'pacto'
 require 'pacto/test_helper'
-require 'pacto/dummy_server'
 require 'fabrication'
 require 'stringio'
 require 'rspec'
@@ -14,7 +13,6 @@ 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
@@ -23,6 +21,20 @@ RSpec.configure do |config|
   end
 end
 
+def default_pacto_format
+  ENV['PACTO_DEFAULT_FORMAT'] || 'legacy'
+end
+
+def contracts_folder(format = default_pacto_format)
+  "spec/fixtures/contracts/#{format}"
+end
+
+def contract_file(name, format = default_pacto_format)
+  file = Dir.glob("#{contracts_folder(format)}/#{name}.*").first
+  fail "Could not find a #{format} contract for #{name}" if file.nil?
+  file
+end
+
 def sample_contract
   # Memoized for test speed
   @sample_contract ||= Fabricate(:contract)

data/spec/unit/pacto/contract_factory_spec.rb

@@ -5,8 +5,7 @@ module Pacto
   describe ContractFactory do
     let(:host)                 { 'http://localhost' }
     let(:contract_name)        { 'contract' }
-    let(:contracts_path)       { %w(spec fixtures contracts) }
-    let(:contract_path)        { File.join(contracts_path, "#{contract_name}.json") }
+    let(:contract_path)        { File.join(contracts_folder, "#{contract_name}.json") }
     let(:contract_files)       { [contract_path, contract_path] }
     subject(:contract_factory) { described_class }
 

data/spec/unit/pacto/contract_spec.rb

@@ -1,89 +1,63 @@
 # -*- encoding : utf-8 -*-
-module Pacto
-  describe Contract do
-    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 }
+RSpec.shared_examples 'a contract' do
+  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
 
-    subject(:contract) do
-      described_class.new(
-        request: request_clause,
-        response: response_clause,
-        file: file,
-        name: 'sample'
-      )
-    end
+  it 'is a type of Contract' do
+    expect(subject).to be_a_kind_of(Pacto::Contract)
+  end
 
-    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
+  describe '#stub_contract!' do
+    it 'register a stub for the contract' do
+      expect(adapter).to receive(:stub_request!).with(contract)
+      contract.stub_contract!
     end
+  end
 
-    describe '#stub_contract!' do
-      it 'register a stub for the contract' do
-        expect(adapter).to receive(:stub_request!).with(contract)
-        contract.stub_contract!
-      end
-    end
+  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')] }
 
-    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
+      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 '#simulate_request' do
       before do
-        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
+        allow(consumer_driver).to receive(:execute).with(an_instance_of(Pacto::PactoRequest)).and_return fake_response
       end
 
-      describe '#simulate_request' do
-        before do
-          allow(consumer_driver).to receive(:execute).with(an_instance_of(Pacto::PactoRequest)).and_return fake_response
-        end
-
-        it 'generates the response' do
-          expect(consumer_driver).to receive(:execute).with(an_instance_of(Pacto::PactoRequest))
-          contract.simulate_request
-        end
+      it 'generates the response' do
+        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(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
+      it 'returns the result of the validating the generated response' do
+        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('request_pattern') }
-      let(:request_signature)  { double('request_signature') }
+  describe '#matches?' do
+    let(:request_pattern)  { double('request_pattern') }
+    let(:request_signature)  { double('request_signature') }
 
-      it 'delegates to the request pattern' do
-        expect(Pacto::RequestPattern).to receive(:for).and_return(request_pattern)
-        expect(request_pattern).to receive(:matches?).with(request_signature)
+    it 'delegates to the request pattern' do
+      expect(Pacto::RequestPattern).to receive(:for).and_return(request_pattern)
+      expect(request_pattern).to receive(:matches?).with(request_signature)
 
-        contract.matches?(request_signature)
-      end
+      contract.matches?(request_signature)
     end
   end
 end

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

@@ -3,7 +3,8 @@ module Pacto
   describe Investigation do
     let(:request) { double('request') }
     let(:response) { double('response') }
-    let(:contract) { Fabricate(:contract) }
+    let(:file) { 'foobar' }
+    let(:contract) { Fabricate(:contract, file: file) }
     let(:investigation_citations) { [] }
     let(:investigation_citations_with_errors) { ['an error occurred'] }
 
@@ -44,9 +45,9 @@ module Pacto
       end
 
       it 'returns the contract with an exact string name match' do
-        allow(contract).to receive(:file).and_return('foo')
         investigation = Pacto::Investigation.new request, response, contract, investigation_citations
-        expect(investigation.against_contract? 'foo').to eq(contract)
+        expect(investigation.against_contract? 'foobar').to eq(contract)
+        expect(investigation.against_contract? 'foo').to be_nil
         expect(investigation.against_contract? 'bar').to be_nil
       end
 

data/spec/unit/pacto/formats/legacy/contract_builder_spec.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      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
+  end
+end

data/spec/unit/pacto/formats/legacy/contract_factory_spec.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+module Pacto
+  module Formats
+    module Legacy
+      describe ContractFactory do
+        let(:host)                 { 'http://localhost' }
+        let(:contract_format)      { 'legacy' }
+        let(:contract_name)        { 'contract' }
+        let(:contract_path)        { contract_file(contract_name, contract_format) }
+        subject(:contract_factory) { described_class.new }
+
+        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(Pacto::Formats::Legacy::Contract)
+        end
+
+        context 'deprecated contracts' do
+          let(:contract_format)      { 'deprecated' }
+          let(:contract_name)        { 'deprecated_contract' }
+          it 'can no longer be loaded' do
+            expect { contract_factory.build_from_file(contract_path, host) }.to raise_error(/old syntax no longer supported/)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/formats/legacy/contract_generator_spec.rb

@@ -0,0 +1,173 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      describe ContractGenerator do
+        let(:record_host) do
+          'http://example.com'
+        end
+        let(:request_clause) { Fabricate(:request_clause, params: { 'api_key' => "<%= ENV['MY_API_KEY'] %>" }) }
+        let(:response_adapter) do
+          Faraday::Response.new(
+            status: 200,
+            response_headers: {
+              'Date' => [Time.now],
+              'Server' => ['Fake Server'],
+              'Content-Type' => ['application/json'],
+              'Vary' => ['User-Agent']
+            },
+            body: 'dummy body' # body is just a string
+          )
+        end
+        let(:filtered_request_headers) { double('filtered_response_headers') }
+        let(:filtered_response_headers) { double('filtered_response_headers') }
+        let(:response_body_schema) { '{"message": "dummy generated schema"}' }
+        let(:version) { 'draft3' }
+        let(:schema_generator) { double('schema_generator') }
+        let(:validator) { double('validator') }
+        let(:filters) { double :filters }
+        let(:consumer) { double 'consumer' }
+        let(:request_file) { 'request.json' }
+        let(:generator) { described_class.new version, schema_generator, validator, filters, consumer }
+        let(:request_contract) do
+          Fabricate(:partial_contract, request: request_clause, file: request_file)
+        end
+        let(:request) do
+          Pacto.configuration.default_consumer.build_request request_contract
+        end
+
+        def pretty(obj)
+          MultiJson.encode(obj, pretty: true).gsub(/^$\n/, '')
+        end
+
+        describe '#generate_from_partial_contract' do
+          # TODO: Deprecate partial contracts?
+          let(:generated_contract) { Fabricate(:contract) }
+          before do
+            expect(Pacto).to receive(:load_contract).with(request_file, record_host).and_return request_contract
+            expect(consumer).to receive(:request).with(request_contract).and_return([request, response_adapter])
+          end
+
+          it 'parses the request' do
+            expect(generator).to receive(:save).with(request_file, request, anything)
+            generator.generate_from_partial_contract request_file, record_host
+          end
+
+          it 'fetches a response' do
+            expect(generator).to receive(:save).with(request_file, anything, response_adapter)
+            generator.generate_from_partial_contract request_file, record_host
+          end
+
+          it 'saves the result' do
+            expect(generator).to receive(:save).with(request_file, request, response_adapter).and_return generated_contract
+            expect(generator.generate_from_partial_contract request_file, record_host).to eq(generated_contract)
+          end
+        end
+
+        describe '#save' do
+          before do
+            allow(filters).to receive(:filter_request_headers).with(request, response_adapter).and_return filtered_request_headers
+            allow(filters).to receive(:filter_response_headers).with(request, response_adapter).and_return filtered_response_headers
+          end
+          context 'invalid schema' do
+            it 'raises an error if schema generation fails' do
+              expect(schema_generator).to receive(:generate).and_raise ArgumentError.new('Could not generate schema')
+              expect { generator.save request_file, request, response_adapter }.to raise_error
+            end
+
+            it 'raises an error if the generated contract is invalid' do
+              expect(schema_generator).to receive(:generate).and_return response_body_schema
+              expect(validator).to receive(:validate).and_raise InvalidContract.new('dummy error')
+              expect { generator.save request_file, request, response_adapter }.to raise_error
+            end
+          end
+
+          context 'valid schema' do
+            let(:raw_contract) do
+              expect(schema_generator).to receive(:generate).with(request_file, response_adapter.body, Pacto.configuration.generator_options).and_return response_body_schema
+              expect(validator).to receive(:validate).and_return true
+              generator.save request_file, request, response_adapter
+            end
+            subject(:generated_contract) { JSON.parse raw_contract }
+
+            it 'sets the schema to the generated json-schema' do
+              expect(subject['response']['schema']).to eq(JSON.parse response_body_schema)
+            end
+
+            it 'sets the request attributes' do
+              generated_request = subject['request']
+              expect(generated_request['params']).to eq(request.uri.query_values)
+              expect(generated_request['path']).to eq(request.uri.path)
+            end
+
+            it 'preserves ERB in the request params' do
+              generated_request = subject['request']
+              expect(generated_request['params']).to eq('api_key' => "<%= ENV['MY_API_KEY'] %>")
+            end
+
+            it 'normalizes the request method' do
+              generated_request = subject['request']
+              expect(generated_request['http_method']).to eq(request.method.downcase.to_s)
+            end
+
+            it 'sets the response attributes' do
+              generated_response = subject['response']
+              expect(generated_response['status']).to eq(response_adapter.status)
+            end
+
+            it 'generates pretty JSON' do
+              expect(raw_contract).to eq(pretty(subject))
+            end
+          end
+
+          context 'with hints' do
+            let(:request1) { Fabricate(:pacto_request, host: 'example.com', path: '/album/5/cover') }
+            let(:request2) { Fabricate(:pacto_request, host: 'example.com', path: '/album/7/cover') }
+            let(:response1) { Fabricate(:pacto_response) }
+            let(:response2) { Fabricate(:pacto_response) }
+            let(:contracts_path) { Dir.mktmpdir }
+
+            before(:each) do
+              allow(filters).to receive(:filter_request_headers).with(request1, response1).and_return request1.headers
+              allow(filters).to receive(:filter_response_headers).with(request1, response1).and_return response1.headers
+              allow(filters).to receive(:filter_request_headers).with(request2, response2).and_return request2.headers
+              allow(filters).to receive(:filter_response_headers).with(request2, response2).and_return response2.headers
+              allow(schema_generator).to receive(:generate).with(request_file, response1.body, Pacto.configuration.generator_options).and_return response_body_schema
+              allow(schema_generator).to receive(:generate).with(request_file, response2.body, Pacto.configuration.generator_options).and_return response_body_schema
+              allow(validator).to receive(:validate).twice.and_return true
+              Pacto.configuration.contracts_path = contracts_path
+              Pacto::Generator.configure do |c|
+                c.hint 'Get Album Cover', http_method: :get, host: 'http://example.com', path: '/album/{id}/cover', target_file: 'album_services/get_album_cover.json'
+              end
+              Pacto.generate!
+            end
+
+            it 'names the contract based on the hint' do
+              contract1 = generator.generate request1, response1
+              expect(contract1.name).to eq('Get Album Cover')
+            end
+
+            it 'sets the path to match the hint' do
+              contract1 = generator.generate request1, response1
+              expect(contract1.request.path).to eq('/album/{id}/cover')
+            end
+
+            it 'sets the target file based on the hint' do
+              contract1 = generator.generate request1, response1
+              expected_path = File.expand_path('album_services/get_album_cover.json', contracts_path)
+              real_expected_path =  Pathname.new(expected_path).realpath.to_s
+              expected_file_uri = Addressable::URI.convert_path(real_expected_path).to_s
+              expect(contract1.file).to eq(expected_file_uri)
+            end
+
+            xit 'does not create duplicate contracts' do
+              contract1 = generator.generate request1, response1
+              contract2 = generator.generate request2, response2
+              expect(contract1).to eq(contract2)
+            end
+          end
+        end
+      end
+    end
+  end
+end