pacto 0.4.0.rc1 → 0.4.0.rc2

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

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

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

@@ -1,171 +0,0 @@
-# -*- 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/pacto/native_contract_factory_spec.rb

@@ -1,26 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'spec_helper'
-
-module Pacto
-  describe NativeContractFactory 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") }
-    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(Contract)
-    end
-
-    context 'deprecated contracts' do
-      let(:contracts_path)       { %w(spec fixtures deprecated_contracts) }
-      let(:contract_name)        { 'deprecated_contract' }
-      it 'can still be loaded' do
-        contract = contract_factory.build_from_file(contract_path, host)
-        expect(contract).to be_a(Contract)
-      end
-    end
-  end
-end

data/spec/unit/pacto/request_clause_spec.rb

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

data/spec/unit/pacto/response_clause_spec.rb

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

data/spec/unit/pacto/server/playback_servlet_spec.rb

@@ -1,27 +0,0 @@
-# -*- encoding : utf-8 -*-
-module Pacto
-  module DummyServer
-    describe PlaybackServlet do
-      let(:request) { double }
-      let(:response) { double('response', :status= => '', :[]= => '', :body= => '') }
-
-      it 'alters response data with recorded status' do
-        servlet = PlaybackServlet.new status: 200
-        servlet.do_GET(request, response)
-        expect(response).to have_received(:status=).with(200)
-      end
-
-      it 'alters reponse data with recorded headers' do
-        servlet = PlaybackServlet.new headers: { 'Content-Type' => 'application/json' }
-        servlet.do_GET(request, response)
-        expect(response).to have_received(:[]=).with('Content-Type', 'application/json')
-      end
-
-      it 'alters reponse data with recorded ' do
-        servlet = PlaybackServlet.new body: 'recorded'
-        servlet.do_GET(request, response)
-        expect(response).to have_received(:body=).with('recorded')
-      end
-    end
-  end
-end

data/spec/unit/pacto/swagger_contract_factory_spec.rb

@@ -1,56 +0,0 @@
-# -*- encoding : utf-8 -*-
-module Pacto
-  module Generator
-    describe SwaggerContractFactory do
-      let(:swagger_file) { 'spec/fixtures/swagger/petstore.yaml' }
-      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
-        it '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_kind_of(Pacto::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