pacto 0.3.1 → 0.4.0.rc1

data/lib/pacto/validators/response_status_validator.rb

@@ -1,24 +0,0 @@
-module Pacto
-  module Validators
-    class ResponseStatusValidator
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        expected_status = env[:contract].response.status
-        actual_status = env[:actual_response].status
-        env[:validation_results].concat self.class.validate(expected_status, actual_status)
-        @app.call env
-      end
-
-      def self.validate(expected_status, actual_status)
-        errors = []
-        if expected_status != actual_status
-          errors << "Invalid status: expected #{expected_status} but got #{actual_status}"
-        end
-        errors
-      end
-    end
-  end
-end

data/spec/pacto/server.rb

@@ -1,2 +0,0 @@
-require_relative 'server/dummy'
-require_relative 'server/playback_servlet'

data/spec/unit/pacto/contract_list_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-module Pacto
-  describe ContractList do
-    let(:contract1) { double(:contract_1) }
-    let(:contract2) { double(:contract_2) }
-
-    it 'holds a list of contracts' do
-      list = ContractList.new([contract1, contract2])
-      expect(list.contracts).to eq([contract1, contract2])
-    end
-
-    context 'when validating' do
-      it 'validates every contract on the list' do
-        expect(contract1).to receive(:validate_provider)
-        expect(contract2).to receive(:validate_provider)
-
-        list = ContractList.new([contract1, contract2])
-        list.validate_all
-      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 = ContractList.new([contract1, contract2])
-        list.stub_all(values)
-      end
-    end
-  end
-end

data/spec/unit/pacto/contract_validator_spec.rb

@@ -1,85 +0,0 @@
-module Pacto
-  describe ContractValidator do
-    let(:validation_errors) { ['some error', 'another error'] }
-
-    let(:expected_response) do
-      ResponseClause.new(
-        'status' => 200,
-        'headers' => {
-          'Content-Type' => 'application/json'
-        },
-        'body' =>  {:type => 'object', :required => true, :properties => double('body definition properties')}
-      )
-    end
-
-    let(:actual_response) do
-      double(
-        :status => 200,
-        :headers => {'Content-Type' => 'application/json', 'Age' => '60'},
-        :body => { 'message' => 'response' }
-      )
-    end
-
-    let(:actual_request) { double :actual_request }
-
-    let(:expected_request) do
-      RequestClause.new(
-        'http://example.com',
-        'body' =>  {
-          :type => 'object',
-          :required => true,
-          :properties => double('body definition properties')
-        }
-      )
-    end
-
-    let(:contract) do
-      request_pattern_provider = double(for: nil)
-      Contract.new(expected_request, expected_response, 'some_file.json', 'sample', request_pattern_provider)
-    end
-
-    let(:opts) { {} }
-
-    describe '.validate' do
-      before do
-        allow(Pacto::Validators::RequestBodyValidator).to receive(:validate).with(contract, actual_request).and_return([])
-        allow(Pacto::Validators::ResponseBodyValidator).to receive(:validate).with(contract, actual_response).and_return([])
-      end
-
-      context 'default validator stack' do
-        it 'calls the RequestBodyValidator' do
-          expect(Pacto::Validators::RequestBodyValidator).to receive(:validate).with(contract, actual_request).and_return(validation_errors)
-          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to eq(validation_errors)
-        end
-
-        it 'calls the ResponseStatusValidator' do
-          expect(Pacto::Validators::ResponseStatusValidator).to receive(:validate).with(expected_response.status, actual_response.status).and_return(validation_errors)
-          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to eq(validation_errors)
-        end
-
-        it 'calls the ResponseHeaderValidator' do
-          expect(Pacto::Validators::ResponseHeaderValidator).to receive(:validate).with(expected_response.headers, actual_response.headers).and_return(validation_errors)
-          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to eq(validation_errors)
-        end
-
-        it 'calls the ResponseBodyValidator' do
-          expect(Pacto::Validators::ResponseBodyValidator).to receive(:validate).with(contract, actual_response).and_return(validation_errors)
-          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to eq(validation_errors)
-        end
-      end
-
-      context 'when headers and body match and the ResponseStatusValidator reports no errors' do
-        it 'does not return any errors' do
-          # JSON::Validator.should_receive(:fully_validate).
-          #   with(definition['body'], fake_response.body, :version => :draft3).
-          #   and_return([])
-          expect(Pacto::Validators::RequestBodyValidator).to receive(:validate).with(contract, actual_request).and_return([])
-          expect(Pacto::Validators::ResponseStatusValidator).to receive(:validate).with(expected_response.status, actual_response.status).and_return([])
-          expect(Pacto::Validators::ResponseHeaderValidator).to receive(:validate).with(expected_response.headers, actual_response.headers).and_return([])
-          expect(Pacto::Validators::ResponseBodyValidator).to receive(:validate).with(contract, actual_response).and_return([])
-          expect(ContractValidator.validate contract, actual_request, actual_response, opts).to be_empty
-        end
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-describe Pacto::ValidationRegistry do
-  subject(:registry) { Pacto::ValidationRegistry.instance }
-  let(:request_pattern) { WebMock::RequestPattern.new(:get, 'www.example.com') }
-  let(:request_signature) { WebMock::RequestSignature.new(:get, 'www.example.com') }
-  let(:different_request_signature) { WebMock::RequestSignature.new(:get, 'www.thoughtworks.com') }
-  let(:validation) { Pacto::Validation.new(request_signature, double, nil) }
-  let(:validation_for_a_similar_request) { Pacto::Validation.new(request_signature, double, nil) }
-  let(:validation_for_a_different_request) { Pacto::Validation.new(different_request_signature, double, nil) }
-
-  before(:each) do
-    registry.reset!
-  end
-
-  describe 'reset!' do
-    before(:each) do
-      registry.register_validation(validation)
-    end
-
-    it 'cleans validations' do
-      expect { registry.reset! }.to change { registry.validated? request_pattern }.from([validation]).to(nil)
-    end
-  end
-
-  describe 'registering and reporting registered validations' do
-    it 'returns registered validation' do
-      expect(registry.register_validation validation).to eq(validation)
-    end
-
-    it 'reports if validation is not registered' do
-      expect(registry.validated? request_pattern).to be_false
-    end
-
-    it 'registers and returns matching validations' do
-      registry.register_validation(validation)
-      registry.register_validation(validation_for_a_similar_request)
-      registry.register_validation(validation_for_a_different_request)
-      expect(registry.validated? request_pattern).to eq([validation, validation_for_a_similar_request])
-    end
-  end
-
-  describe '.unmatched_validations' do
-    let(:contract) { double('contract', :name => 'test') }
-
-    it 'returns validations with no contract' do
-      allow(contract).to receive(:validate_consumer).with(different_request_signature, anything).and_return(double('results', :empty? => true))
-      validation_with_results = Pacto::Validation.new(different_request_signature, double, contract)
-      registry.register_validation(validation)
-      registry.register_validation(validation_for_a_similar_request)
-      registry.register_validation(validation_for_a_different_request)
-      registry.register_validation(validation_with_results)
-
-      expect(registry.unmatched_validations).to match_array([validation, validation_for_a_similar_request, validation_for_a_different_request])
-    end
-  end
-
-  describe '.failed_validations' do
-    let(:contract) { double('contract', :name => 'test') }
-    let(:results2) { double('results2', :empty? => false, :join => 'wtf') }
-
-    it 'returns validations with unsuccessful results' do
-      allow(contract).to receive(:name).and_return 'test'
-      allow(contract).to receive(:validate_consumer).with(request_signature, anything).and_return(results2)
-      validation_with_successful_results = Pacto::Validation.new(request_signature, double, contract)
-      validation_with_unsuccessful_results = Pacto::Validation.new(request_signature, double, contract)
-
-      expect(validation_with_successful_results).to receive(:successful?).twice.and_return true
-      expect(validation_with_unsuccessful_results).to receive(:successful?).twice.and_return false
-
-      registry.register_validation(validation)
-      registry.register_validation(validation_with_successful_results)
-      registry.register_validation(validation_with_unsuccessful_results)
-
-      expect(registry.failed_validations).to match_array([validation_with_unsuccessful_results])
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-module Pacto
-  describe Validation do
-    let(:request) { double('request') }
-    let(:response) { double('response') }
-    let(:contract) { double('contract') }
-    let(:validation_results) { double('validation_results') }
-
-    before(:each) do
-      allow(contract).to receive(:validate_consumer)
-    end
-
-    it 'stores the request, response and contract' do
-      validation = Pacto::Validation.new request, response, contract
-      expect(validation.request).to eq request
-      expect(validation.response).to eq response
-    end
-
-    it 'generates and stores the results' do
-      expect(contract).to receive(:validate_consumer).with(request, response).and_return(validation_results)
-      validation = Pacto::Validation.new request, response, contract
-      expect(validation.results).to eq validation_results
-    end
-
-    describe '#successful?' do
-      subject(:validation) do
-        Pacto::Validation.new request, response, contract
-      end
-
-      it 'returns true if there were no validation errors' do
-        expect(validation.successful?).to be_true
-      end
-
-      it 'returns false if there were validation errors' do
-        expect(validation.successful?).to be_true
-      end
-    end
-
-    describe '#against_contract?' do
-      it 'returns nil if there was no contract' do
-        validation = Pacto::Validation.new request, response, nil
-        expect(validation.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')
-        validation = Pacto::Validation.new request, response, contract
-        expect(validation.against_contract? 'foo').to eq(contract)
-        expect(validation.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'
-        validation = Pacto::Validation.new request, response, contract
-        expect(validation.against_contract?(/foo/)).to eq(contract)
-        expect(validation.against_contract?(/bar/)).to eq(contract)
-        expect(validation.against_contract?(/baz/)).to be_nil
-      end
-    end
-  end
-end

data/spec/unit/pacto/generator_spec.rb

@@ -1,132 +0,0 @@
-module Pacto
-  describe Generator do
-    let(:record_host) do
-      'http://example.com'
-    end
-    let(:request) do
-      Pacto::RequestClause.new(record_host,
-                               'method' => 'GET',
-                               'path' => '/abcd',
-                               'headers' => {
-                                 'Content-Length' => [1234],
-                                 'Via' => ['Some Proxy'],
-                                 'User-Agent' => ['rspec']
-                               },
-                               'params' => {
-                                 'apikey' => "<%= ENV['MY_API_KEY'] %>"
-                               }
-                              )
-    end
-    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(:request_file) { 'request.json' }
-    let(:options) { Pacto.configuration.generator_options }
-    let(:generator) { described_class.new version, schema_generator, validator, options, filters }
-
-    def pretty(obj)
-      MultiJson.encode(obj, :pretty => true).gsub(/^$\n/, '')
-    end
-
-    describe '#generate' do
-      let(:request_contract) do
-        double(
-          :request => request
-        )
-      end
-      let(:generated_contract) { double('generated contract') }
-      before do
-        Pacto.should_receive(:load_contract).with(request_file, record_host).and_return request_contract
-        request.should_receive(:execute).and_return response_adapter
-      end
-
-      it 'parses the request' do
-        generator.should_receive(:save).with(request_file, request, anything)
-        generator.generate request_file, record_host
-      end
-
-      it 'fetches a response' do
-        generator.should_receive(:save).with(request_file, anything, response_adapter)
-        generator.generate request_file, record_host
-      end
-
-      it 'saves the result' do
-        generator.should_receive(:save).with(request_file, request, response_adapter).and_return generated_contract
-        expect(generator.generate request_file, record_host).to eq(generated_contract)
-      end
-    end
-
-    describe '#save' do
-      before do
-        filters.should_receive(:filter_request_headers).with(request, response_adapter).and_return filtered_request_headers
-        filters.should_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
-          JSON::SchemaGenerator.should_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
-          JSON::SchemaGenerator.should_receive(:generate).and_return response_body_schema
-          validator.should_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
-          JSON::SchemaGenerator.should_receive(:generate).with(request_file, response_adapter.body, Pacto.configuration.generator_options).and_return response_body_schema
-          validator.should_receive(:validate).and_return true
-          generator.save request_file, request, response_adapter
-        end
-        subject(:generated_contract) { JSON.parse raw_contract }
-
-        it 'sets the body to the generated json-schema' do
-          expect(subject['response']['body']).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.params)
-          expect(generated_request['path']).to eq(request.path)
-        end
-
-        it 'preserves ERB in the request params' do
-          generated_request = subject['request']
-          expect(generated_request['params']['apikey']).to eq("<%= ENV['MY_API_KEY'] %>")
-        end
-
-        it 'normalizes the request method' do
-          generated_request = subject['request']
-          expect(generated_request['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
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Pacto
-  module Stubs
-    describe WebMockHelper do
-      before do
-        WebMock.stub_request(:get, 'www.example.com').to_return(:body => 'pacto')
-        WebMock.after_request do |request_signature, response|
-          @request_signature = request_signature
-          @response = response
-        end
-        Faraday.get 'http://www.example.com'
-      end
-
-      describe '#validate' do
-        it 'validates a WebMock request/response pair' do
-          described_class.validate @request_signature, @response
-        end
-      end
-    end
-  end
-end

data/spec/unit/pacto/validators/body_validator_spec.rb

@@ -1,118 +0,0 @@
-module Pacto
-  module Validators
-    describe BodyValidator do
-      class MyBodyValidator < BodyValidator
-        class << self
-          attr_writer :subschema
-
-          def section_name
-            'my_section'
-          end
-
-          def subschema(contract)
-            @subschema
-          end
-        end
-      end
-
-      subject(:validator)    { MyBodyValidator }
-      let(:string_required)  { true }
-      let(:contract)         { double('contract', :file => 'file:///a.json') }
-      let(:body)             { 'a simple string' }
-      let(:fake_interaction) { double(:fake_interaction, body: body) }
-
-      before(:each) do
-        MyBodyValidator.subschema = schema
-      end
-
-      describe '#validate' do
-        context 'when schema is not specified' do
-          let(:schema) { nil }
-
-          it 'gives no errors without validating body' do
-            JSON::Validator.should_not_receive(:fully_validate)
-            expect(validator.validate(contract, fake_interaction)).to be_empty
-          end
-        end
-
-        context 'when the body is a string' do
-          # TODO: Apparently a schema has string as keys. Probably we could
-          # make convert it into a symbol based key.
-          let(:schema) { { 'type' => 'string', 'required' => string_required } }
-
-          it 'does not validate using JSON Schema' do
-            # FIXME: This seems like a design flaw. We're partially reproducing json-schema behavior
-            # instead of finding a way to use it.
-            JSON::Validator.should_not_receive(:fully_validate)
-            validator.validate(contract, fake_interaction)
-          end
-
-          context 'if required' do
-            it 'does not return an error when body is a string' do
-              expect(validator.validate(contract, fake_interaction)).to be_empty
-            end
-
-            it 'returns an error when body is nil' do
-              expect(fake_interaction).to receive(:body).and_return nil
-              expect(validator.validate(contract, fake_interaction).size).to eq 1
-            end
-          end
-
-          context 'if not required' do
-            let(:string_required) { false }
-
-            it 'does not return an error when body is a string' do
-              expect(validator.validate(contract, fake_interaction)).to be_empty
-            end
-
-            it 'does not return an error when body is nil' do
-              expect(fake_interaction).to receive(:body).and_return nil
-              expect(validator.validate(contract, fake_interaction)).to be_empty
-            end
-          end
-
-          context 'if contains pattern' do
-            let(:schema) do
-              { type: 'string', required: string_required, pattern: 'a.c' }
-            end
-
-            context 'body matches pattern' do
-              let(:body) { 'abc' } # This matches the pattern /a.c/
-
-              it 'does not return an error' do
-                expect(validator.validate(contract, fake_interaction)).to be_empty
-              end
-            end
-
-            context 'body does not match pattern' do
-              let(:body) { 'acb' } # This does not matches the pattern /a.c/
-
-              it 'returns an error' do
-                expect(validator.validate(contract, fake_interaction).size).to eq 1
-              end
-            end
-          end
-        end
-
-        context 'when the body is json' do
-          let(:schema) { { type: 'object' } }
-
-          context 'when body matches' do
-            it 'does not return any errors' do
-              expect(JSON::Validator).to receive(:fully_validate).and_return([])
-              expect(validator.validate(contract, fake_interaction)).to be_empty
-            end
-          end
-
-          context 'when body does not match' do
-            it 'returns a list of errors' do
-              errors = double 'some errors'
-              expect(JSON::Validator).to receive(:fully_validate).and_return(errors)
-              expect(validator.validate(contract, fake_interaction)).to eq(errors)
-            end
-          end
-        end
-      end
-    end
-  end
-end