pacto 0.3.1 → 0.4.0.rc1

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

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Core
+    describe HTTPMiddleware do
+      subject(:middleware) { Pacto::Core::HTTPMiddleware.new }
+      let(:request) { double }
+      let(:response) { double }
+
+      class FailingObserver
+        def raise_error(_pacto_request, _pacto_response)
+          fail InvalidContract, ['The contract was missing things', 'and stuff']
+        end
+      end
+
+      describe '#process' do
+        it 'calls registered HTTP observers' do
+          observer1, observer2 = double, double
+          expect(observer1).to receive(:respond_to?).with(:do_something).and_return true
+          expect(observer2).to receive(:respond_to?).with(:do_something_else).and_return true
+          middleware.add_observer(observer1, :do_something)
+          middleware.add_observer(observer2, :do_something_else)
+          expect(observer1).to receive(:do_something).with(request, response)
+          expect(observer2).to receive(:do_something_else).with(request, response)
+          middleware.process request, response
+        end
+
+        pending 'logs rescues and logs failures'
+        pending 'calls the HTTP middleware'
+        pending 'calls the registered hook'
+        pending 'calls generate when generate is enabled'
+        pending 'calls validate when validate mode is enabled'
+        pending 'validates a WebMock request/response pair'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  describe Investigation do
+    let(:request) { double('request') }
+    let(:response) { double('response') }
+    let(:contract) { Fabricate(:contract) }
+    let(:investigation_citations) { [] }
+    let(:investigation_citations_with_errors) { ['an error occurred'] }
+
+    it 'stores the request, response, contract and citations' do
+      investigation = Pacto::Investigation.new request, response, contract, investigation_citations
+      expect(investigation.request).to eq request
+      expect(investigation.response).to eq response
+      expect(investigation.contract).to eq contract
+      expect(investigation.citations).to eq investigation_citations
+    end
+
+    context 'if there were investigation errors' do
+      subject(:investigation) do
+        Pacto::Investigation.new request, response, contract, investigation_citations_with_errors
+      end
+
+      describe '#successful?' do
+        it 'returns false' do
+          expect(investigation.successful?).to be_falsey
+        end
+      end
+    end
+
+    context 'if there were no investigation errors' do
+      subject(:investigation) do
+        Pacto::Investigation.new request, response, contract, investigation_citations
+      end
+
+      it 'returns false' do
+        expect(investigation.successful?).to be true
+      end
+    end
+
+    describe '#against_contract?' do
+      it 'returns nil if there was no contract' do
+        investigation = Pacto::Investigation.new request, response, nil, investigation_citations
+        expect(investigation.against_contract? 'a').to be_nil
+      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? 'bar').to be_nil
+      end
+
+      it 'returns the contract if there is a regex match' do
+        allow(contract).to receive(:file).and_return 'foobar'
+        investigation = Pacto::Investigation.new request, response, contract, investigation_citations
+        expect(investigation.against_contract?(/foo/)).to eq(contract)
+        expect(investigation.against_contract?(/bar/)).to eq(contract)
+        expect(investigation.against_contract?(/baz/)).to be_nil
+      end
+    end
+  end
+end

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

@@ -1,17 +1,18 @@
+# -*- encoding : utf-8 -*-
 describe Pacto do
-  modes = %w{generate validate}
+  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
+        expect(subject.send query_method).to be_falsey
         subject.send enable_method
-        expect(subject.send query_method).to be_true
+        expect(subject.send query_method).to be true
 
         subject.send disable_method
-        expect(subject.send query_method).to be_false
+        expect(subject.send query_method).to be_falsey
       end
     end
   end

data/spec/unit/pacto/erb_processor_spec.rb

@@ -1,6 +1,7 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   describe ERBProcessor do
-    subject(:processor) { ERBProcessor.new }
+    subject(:processor) { described_class.new }
 
     describe '#process' do
       let(:erb) { '2 + 2 = <%= 2 + 2 %>' }
@@ -11,7 +12,7 @@ module Pacto
       end
 
       it 'logs the erb processed' do
-        Pacto.configuration.logger.should_receive(:debug).with("Processed contract: \"#{result}\"")
+        expect(Pacto.configuration.logger).to receive(:debug).with("Processed contract: \"#{result}\"")
         processor.process erb
       end
 

data/spec/unit/pacto/extensions_spec.rb

@@ -1,24 +1,14 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  module Extensions
-    describe HashSubsetOf do
-      describe '#normalize_keys' do
-        it 'turns keys into downcased strings' do
-          expect({:A => 'a'}.normalize_keys).to eq('a' => 'a')
-          expect({:a => 'a'}.normalize_keys).to eq('a' => 'a')
-          expect({'A' => 'a'}.normalize_keys).to eq('a' => 'a')
-          expect({'a' => 'a'}.normalize_keys).to eq('a' => 'a')
-        end
-      end
-
-      describe '#normalize_header_keys' do
-        it 'matches headers to the style in the RFC documentation' do
-          expect(Pacto::Extensions.normalize_header_keys(:'user-agent' => 'a')).to eq('User-Agent' => 'a') # rubocop:disable SymbolName
-          expect(Pacto::Extensions.normalize_header_keys(:user_agent => 'a')).to eq('User-Agent' => 'a')
-          expect(Pacto::Extensions.normalize_header_keys('User-Agent' => 'a')).to eq('User-Agent' => 'a')
-          expect(Pacto::Extensions.normalize_header_keys('user-agent' => 'a')).to eq('User-Agent' => 'a')
-          expect(Pacto::Extensions.normalize_header_keys('user_agent' => 'a')).to eq('User-Agent' => 'a')
-          expect(Pacto::Extensions.normalize_header_keys('USER_AGENT' => 'a')).to eq('User-Agent' => 'a')
-        end
+  describe Extensions do
+    describe '#normalize_header_keys' do
+      it 'matches headers to the style in the RFC documentation' do
+        expect(Pacto::Extensions.normalize_header_keys(:'user-agent' => 'a')).to eq('User-Agent' => 'a') # rubocop:disable SymbolName
+        expect(Pacto::Extensions.normalize_header_keys(user_agent: 'a')).to eq('User-Agent' => 'a')
+        expect(Pacto::Extensions.normalize_header_keys('User-Agent' => 'a')).to eq('User-Agent' => 'a')
+        expect(Pacto::Extensions.normalize_header_keys('user-agent' => 'a')).to eq('User-Agent' => 'a')
+        expect(Pacto::Extensions.normalize_header_keys('user_agent' => 'a')).to eq('User-Agent' => 'a')
+        expect(Pacto::Extensions.normalize_header_keys('USER_AGENT' => 'a')).to eq('User-Agent' => 'a')
       end
     end
   end

data/spec/unit/pacto/generator/filters_spec.rb

@@ -1,22 +1,23 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  class Generator
+  module Generator
     describe Filters do
       let(:record_host) do
         'http://example.com'
       end
       let(:request) do
         RequestClause.new(
-          record_host,
-          'method' => 'GET',
-          'path' => '/abcd',
-          'headers' => {
+          host: record_host,
+          http_method: 'GET',
+          path: '/abcd',
+          headers: {
             'Server' => ['example.com'],
             'Connection' => ['Close'],
             'Content-Length' => [1234],
             'Via' => ['Some Proxy'],
             'User-Agent' => ['rspec']
           },
-          'params' => {
+          params: {
             'apikey' => "<%= ENV['MY_API_KEY'] %>"
           }
         )
@@ -24,8 +25,8 @@ module Pacto
       let(:varies) { ['User-Agent'] }
       let(:response) do
         Faraday::Response.new(
-          :status => 200,
-          :response_headers => {
+          status: 200,
+          response_headers: {
             'Date' => Time.now.rfc2822,
             'Last-Modified' => Time.now.rfc2822,
             'ETag' => 'abc123',
@@ -33,7 +34,7 @@ module Pacto
             'Content-Type' => ['application/json'],
             'Vary' => varies
           },
-          :body => double('dummy body')
+          body: double('dummy body')
         )
       end
 
@@ -63,7 +64,7 @@ module Pacto
           end
           context 'as multiple items' do
             let(:varies) do
-              %w{User-Agent Via}
+              %w(User-Agent Via)
             end
             it 'keeps each header' do
               expect(filtered_request_headers).to include 'user-agent'

data/spec/unit/pacto/generator/native_contract_generator_spec.rb

@@ -0,0 +1,171 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Generator
+    describe NativeContractGenerator 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

data/spec/unit/{hooks → pacto/hooks}/erb_hook_spec.rb

@@ -1,13 +1,17 @@
+# -*- encoding : utf-8 -*-
 describe Pacto::Hooks::ERBHook do
   describe '#process' do
     let(:req) do
-      OpenStruct.new(:headers => {'User-Agent' => 'abcd'})
+      OpenStruct.new(headers: { 'User-Agent' => 'abcd' })
     end
     let(:converted_req) do
-      {'HEADERS' => {'User-Agent' => 'abcd'}}
+      { 'HEADERS' => { 'User-Agent' => 'abcd' } }
     end
     let(:res) do
-      OpenStruct.new(:body => 'before')
+      Pacto::PactoResponse.new(
+        status: 200,
+        body: 'before'
+      )
     end
 
     before do
@@ -16,7 +20,7 @@ describe Pacto::Hooks::ERBHook do
     context 'no matching contracts' do
       it 'binds the request' do
         contracts = Set.new
-        mock_erb(:req => converted_req)
+        mock_erb(req: converted_req)
         described_class.new.process contracts, req, res
         expect(res.body).to eq('after')
       end
@@ -24,9 +28,9 @@ describe Pacto::Hooks::ERBHook do
 
     context 'one matching contract' do
       it 'binds the request and the contract\'s values' do
-        contract = OpenStruct.new(:values => {:max => 'test'})
+        contract = OpenStruct.new(values: { max: 'test' })
         contracts = Set.new([contract])
-        mock_erb(:req => converted_req, :max => 'test')
+        mock_erb(req: converted_req, max: 'test')
         described_class.new.process contracts, req, res
         expect(res.body).to eq('after')
       end
@@ -34,10 +38,13 @@ describe Pacto::Hooks::ERBHook do
 
     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')
+        contract1 = OpenStruct.new(values: { max: 'test' })
+        contract2 = OpenStruct.new(values: { mob: 'team' })
+        res = Pacto::PactoResponse.new(
+          status: 200,
+          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')
@@ -46,6 +53,6 @@ describe Pacto::Hooks::ERBHook do
   end
 
   def mock_erb(hash)
-    Pacto::ERBProcessor.any_instance.should_receive(:process).with('before', hash).and_return('after')
+    expect_any_instance_of(Pacto::ERBProcessor).to receive(:process).with('before', hash).and_return('after')
   end
 end