pacto 0.4.0.rc1 → 0.4.0.rc2

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

@@ -0,0 +1,41 @@
+# -*- encoding : utf-8 -*-
+require 'unit/pacto/contract_spec'
+
+module Pacto
+  module Formats
+    module Legacy
+      describe Contract do
+        let(:request_clause) do
+          Pacto::Formats::Legacy::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
+          ResponseClause.new(status: 200)
+        end
+        let(:adapter) { double 'provider' }
+        let(:file) { contract_file 'contract', 'legacy' }
+        let(:consumer_driver) { double }
+        let(:provider_actor) { double }
+
+        subject(:contract) do
+          described_class.new(
+            request: request_clause,
+            response: response_clause,
+            file: file,
+            name: 'sample'
+          )
+        end
+
+        it_behaves_like 'a contract'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      module Generator
+        describe Filters do
+          let(:record_host) do
+            'http://example.com'
+          end
+          let(:request) do
+            RequestClause.new(
+              host: record_host,
+              http_method: 'GET',
+              path: '/abcd',
+              headers: {
+                'Server' => ['example.com'],
+                'Connection' => ['Close'],
+                'Content-Length' => [1234],
+                'Via' => ['Some Proxy'],
+                'User-Agent' => ['rspec']
+              },
+              params: {
+                'apikey' => "<%= ENV['MY_API_KEY'] %>"
+              }
+            )
+          end
+          let(:varies) { ['User-Agent'] }
+          let(:response) do
+            Faraday::Response.new(
+              status: 200,
+              response_headers: {
+                'Date' => Time.now.rfc2822,
+                'Last-Modified' => Time.now.rfc2822,
+                'ETag' => 'abc123',
+                'Server' => ['Fake Server'],
+                'Content-Type' => ['application/json'],
+                'Vary' => varies
+              },
+              body: double('dummy body')
+            )
+          end
+
+          describe '#filter_request_headers' do
+            subject(:filtered_request_headers) { described_class.new.filter_request_headers(request, response).keys.map(&:downcase) }
+            it 'keeps important request headers' do
+              expect(filtered_request_headers).to include 'user-agent'
+            end
+
+            it 'filters informational request headers' do
+              expect(filtered_request_headers).not_to include 'via'
+              expect(filtered_request_headers).not_to include 'date'
+              expect(filtered_request_headers).not_to include 'server'
+              expect(filtered_request_headers).not_to include 'content-length'
+              expect(filtered_request_headers).not_to include 'connection'
+            end
+
+            context 'multiple Vary elements' do
+              context 'as a single string' do
+                let(:varies) do
+                  ['User-Agent,Via']
+                end
+                it 'keeps each header' do
+                  expect(filtered_request_headers).to include 'user-agent'
+                  expect(filtered_request_headers).to include 'via'
+                end
+              end
+              context 'as multiple items' do
+                let(:varies) do
+                  %w(User-Agent Via)
+                end
+                it 'keeps each header' do
+                  expect(filtered_request_headers).to include 'user-agent'
+                  expect(filtered_request_headers).to include 'via'
+                end
+              end
+            end
+          end
+
+          describe '#filter_response_headers' do
+            subject(:filtered_response_headers) { described_class.new.filter_response_headers(request, response).keys.map(&:downcase) }
+            it 'keeps important response headers' do
+              expect(filtered_response_headers).to include 'content-type'
+            end
+
+            it 'filters connection control headers' do
+              expect(filtered_response_headers).not_to include 'content-length'
+              expect(filtered_response_headers).not_to include 'via'
+            end
+
+            it 'filters freshness headers' do
+              expect(filtered_response_headers).not_to include 'date'
+              expect(filtered_response_headers).not_to include 'last-modified'
+              expect(filtered_response_headers).not_to include 'eTag'
+            end
+
+            it 'filters x-* headers' do
+              expect(filtered_response_headers).not_to include 'x-men'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      describe RequestClause do
+        let(:host)           { 'http://localhost' }
+        let(:method)         { 'GET' }
+        let(:path)           { '/hello_world' }
+        let(:headers)        { { 'accept' => 'application/json' } }
+        let(:params)         { { 'foo' => 'bar' } }
+        let(:body)           { double :body }
+        let(:params_as_json) { "{\"foo\":\"bar\"}" }
+        let(:absolute_uri)   { "#{host}#{path}" }
+        subject(:request) do
+          req_hash = {
+            host: host,
+            'http_method'  => method,
+            'path'    => path,
+            'headers' => headers,
+            'params'  => params
+          }
+          # The default test is for missing keys, not explicitly nil keys
+          req_hash.merge!('schema' => body) if body
+          described_class.new(req_hash)
+        end
+
+        it 'has a host' do
+          expect(request.host).to eq host
+        end
+
+        describe '#http_method' do
+          it 'delegates to definition' do
+            expect(request.http_method).to eq :get
+          end
+
+          it 'downcases the method' do
+            expect(request.http_method).to eq request.http_method.downcase
+          end
+
+          it 'returns a symbol' do
+            expect(request.http_method).to be_kind_of Symbol
+          end
+        end
+
+        describe '#schema' do
+          it 'delegates to definition\'s body' do
+            expect(request.schema).to eq body
+          end
+
+          describe 'when definition does not have a schema' do
+            let(:body) { nil }
+
+            it 'returns an empty empty hash' do
+              expect(request.schema).to eq({})
+            end
+          end
+        end
+
+        describe '#path' do
+          it 'delegates to definition' do
+            expect(request.path).to eq path
+          end
+        end
+
+        describe '#headers' do
+          it 'delegates to definition' do
+            expect(request.headers).to eq headers
+          end
+        end
+
+        describe '#params' do
+          it 'delegates to definition' do
+            expect(request.params).to eq params
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      describe ResponseClause do
+        let(:body_definition) do
+          Fabricate(:schema)
+        end
+
+        let(:definition) do
+          {
+            'status' => 200,
+            'headers' => {
+              'Content-Type' => 'application/json'
+            },
+            'schema' => body_definition
+          }
+        end
+
+        subject(:response) { described_class.new(definition) }
+
+        it 'has a status' do
+          expect(response.status).to eq(200)
+        end
+
+        it 'has a headers hash' do
+          expect(response.headers).to eq(
+            'Content-Type' => 'application/json'
+          )
+        end
+
+        it 'has a schema' do
+          expect(response.schema).to eq(body_definition)
+        end
+
+        it 'has a default value for the schema' do
+          definition.delete 'schema'
+          response = described_class.new(definition)
+          expect(response.schema).to eq(Hash.new)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Swagger
+      describe ContractFactory do
+        let(:swagger_file) { contract_file('petstore', 'swagger') }
+        let(:expected_schema) do
+          {
+            'type' => 'array',
+            'items' => {
+              'required' => %w(id name),
+              'properties' => {
+                'id' => { 'type' => 'integer', 'format' => 'int64' },
+                'name' => { 'type' => 'string' },
+                'tag' => { 'type' => 'string' }
+              }
+            }
+          }
+        end
+        describe '#load_hints' do
+          pending 'loads hints from Swagger' do
+            hints = subject.load_hints(swagger_file)
+            expect(hints.size).to eq(3) # number of API operations
+            hints.each do | hint |
+              expect(hint).to be_a_kind_of(Pacto::Generator::Hint)
+              expect(hint.host).to eq('petstore.swagger.wordnik.com')
+              expect([:get, :post]).to include(hint.http_method)
+              expect(hint.path).to match(/\/pets/)
+            end
+          end
+        end
+
+        describe '#build_from_file' do
+          it 'loads Contracts from Swagger' do
+            contracts = subject.build_from_file(swagger_file)
+            expect(contracts.size).to eq(3) # number of API operations
+            contracts.each do | contract |
+              expect(contract).to be_a(Pacto::Formats::Swagger::Contract)
+
+              request_clause = contract.request
+              expect(request_clause.host).to eq('petstore.swagger.wordnik.com')
+              expect([:get, :post]).to include(request_clause.http_method)
+              expect(request_clause.path).to match(/\/pets/)
+
+              response_clause = contract.response
+              if request_clause.http_method == :get
+                expect(response_clause.status).to eq(200)
+              else
+                expect(response_clause.status).to eq(201)
+              end
+              expect(response_clause.schema).to eq(expected_schema) if response_clause.status == 200
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/formats/swagger/contract_spec.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+require 'unit/pacto/contract_spec'
+
+module Pacto
+  module Formats
+    module Swagger
+      describe Contract do
+        let(:swagger_yaml) do
+          ''"
+          swagger: '2.0'
+          info:
+            title: Sample API
+            version: N/A
+          consumes:
+          - application/json
+          produces:
+          - application/json
+          paths:
+            /:
+              get:
+                operationId: sample
+                responses:
+                  200:
+                    description: |-
+                      Success.
+          "''
+        end
+        let(:swagger_definition) do
+          ::Swagger.build(swagger_yaml, format: :yaml)
+        end
+        let(:api_operation) do
+          swagger_definition.operations.first
+        end
+        let(:adapter) { double 'provider' }
+        let(:file) { Tempfile.new(['swagger', '.yaml']).path }
+        let(:consumer_driver) { double }
+        let(:provider_actor) { double }
+
+        subject(:contract) do
+          described_class.new(api_operation, file: file)
+        end
+
+        it_behaves_like 'a contract'
+      end
+    end
+  end
+end

data/spec/unit/pacto/investigation_registry_spec.rb

@@ -55,11 +55,10 @@ describe Pacto::InvestigationRegistry do
   end
 
   describe '.failed_investigations' do
-    let(:contract) { Fabricate(:contract) }
+    let(:contract) { Fabricate(:contract, name: 'test') }
     let(:citations2) { ['a sample citation'] }
 
     it 'returns investigations with unsuccessful citations' do
-      allow(contract).to receive(:name).and_return 'test'
       investigation_with_successful_citations = Pacto::Investigation.new(request_signature, pacto_response, nil, ['error'])
       investigation_with_unsuccessful_citations = Pacto::Investigation.new(request_signature, pacto_response, nil, %w(error2 error3))
 

data/spec/unit/pacto/pacto_spec.rb

@@ -17,10 +17,12 @@ describe Pacto do
   end
 
   describe '.validate_contract' do
+    let(:contract_path) { contract_file 'contract' }
+
     context 'valid' do
       it 'returns true' do
         mock_investigation []
-        success = described_class.validate_contract 'my_contract.json'
+        success = described_class.validate_contract contract_path
         expect(success).to be true
       end
     end
@@ -28,20 +30,20 @@ describe Pacto do
     context 'invalid' do
       it 'raises an InvalidContract error' do
         mock_investigation ['Error 1']
-        expect { described_class.validate_contract 'my_contract.json' }.to raise_error(InvalidContract)
+        expect { described_class.validate_contract contract_path }.to raise_error(Pacto::InvalidContract)
       end
     end
   end
 
   describe 'loading contracts' do
-    let(:contracts_path) { 'path/to/dir' }
+    let(:contracts_path) { contracts_folder }
     let(:host) { 'localhost' }
 
     it 'instantiates a contract list' do
       expect(Pacto::ContractSet).to receive(:new) do |contracts|
         contracts.each { |contract| expect(contract).to be_a_kind_of(Pacto::Contract) }
       end
-      described_class.load_contracts('spec/fixtures/contracts/', host)
+      described_class.load_contracts(contracts_path, host)
     end
   end
 end

data/spec/unit/pacto/stubs/uri_pattern_spec.rb

@@ -21,22 +21,21 @@ module Pacto
         expect(uri_pattern.pattern).to eql('{scheme}://myhost.com/stuff{?anyvars*}')
       end
 
-      it 'convers segments preceded by : into variables', :deprecated do
-        request = Fabricate(:request_clause, host: 'myhost.com', path: '/:id')
-        uri_pattern = UriPattern.for(request)
-        expect(uri_pattern.keys).to include('id')
-        expect(uri_pattern.pattern).to_not include(':id')
+      it 'fails if segment uses : syntax' do
+        expect do
+          Fabricate(:request_clause, host: 'myhost.com', path: '/:id')
+        end.to raise_error(/old syntax no longer supported/)
       end
 
       it 'creates a regex that does not allow additional path elements' do
-        request = Fabricate(:request_clause, host: 'myhost.com', path: '/:id')
+        request = Fabricate(:request_clause, host: 'myhost.com', path: '/{id}')
         pattern = UriPattern.for(request)
         expect(pattern).to match('http://myhost.com/foo')
         expect(pattern).to_not match('http://myhost.com/foo/bar')
       end
 
-      it 'creates a regex that does allow query parameters', :deprecated do
-        request = Fabricate(:request_clause, host: 'myhost.com', path: '/:id')
+      it 'creates a regex that does allow query parameters' do
+        request = Fabricate(:request_clause, host: 'myhost.com', path: '/{id}')
         pattern = UriPattern.for(request)
         expect(pattern.match('http://myhost.com/foo?a=b')). to be_truthy
         expect(pattern.match('http://myhost.com/foo?a=b&c=d')).to be_truthy