pacto 0.3.1 → 0.4.0.rc1

data/.rubocop-todo.yml

@@ -1,24 +0,0 @@
-# This configuration was generated by `rubocop --auto-gen-config`.
-# The point is for the user to remove these configuration records
-# one by one as the offences are removed from the code base.
-
-Documentation:
-  Enabled: false
-
-DotPosition:
-  Enabled: false
-
-Encoding:
-  Enabled: false
-
-HashSyntax:
-  Enabled: false
-
-IfUnlessModifier:
-  Enabled: false
-
-LineLength:
-  Enabled: false
-
-SpaceInsideHashLiteralBraces:
-  Enabled: false

data/.ruby-gemset

@@ -1 +0,0 @@
-pacto

data/.ruby-version

@@ -1 +0,0 @@
-2.1.0

data/CHANGELOG

@@ -1,12 +0,0 @@
-0.3.1
-
-  Enhancements:
-    * #103 - Display file URI instead of meaningless schema identifier in messages
-
-  Bug Fixes:
-    * #102 - Fix rake pacto:generate task
-
-
-0.3.0
-
-  First stable release

data/features/validate/body_only.feature

@@ -1,85 +0,0 @@
-Feature: Validation
-
-  You can validate just the body of the contract. This may be useful if you want to validate a stubbing system that does not stub the fully connection, or if Pacto is currently unable to validate your headers.
-
-  Background:
-    Given a file named "Gemfile" with:
-    """ruby
-    source 'https://rubygems.org'
-
-    gem 'pacto', :path => '../..'
-    gem 'excon'
-    """
-    Given a file named "validate.rb" with:
-      """ruby
-      require 'pacto'
-      require_relative 'my_service'
-
-      contract_list = Pacto.load_contracts('contracts', 'http://example.com')
-      contract_list.stub_all
-
-      contract = contract_list.contracts.first
-      service = MyService.new
-      response = service.hello
-      successful = contract.validate_consumer nil, response, :body_only => true
-      puts "Validated successfully!" if successful
-      """
-    Given a file named "contracts/template.json" with:
-      """json
-      {
-        "request": {
-          "method": "GET",
-          "path": "/hello",
-          "headers": {
-            "Accept": "application/json"
-          },
-          "params": {}
-        },
-
-        "response": {
-          "status": 200,
-          "headers": { "Content-Type": "application/json" },
-          "body": {
-            "type": "object",
-            "required": true,
-            "properties": {
-              "message": { "type": "string", "required": true
-              }
-            }
-          }
-        }
-      }
-      """
-
-  Scenario: Validate the response body only
-    # This should be in the Before block, but https://github.com/cucumber/cucumber/issues/52
-    Given I successfully run `bundle install --local`
-    Given a file named "my_service.rb" with:
-    """ruby
-    require 'excon'
-    class MyService
-      def response(params={})
-        body    = params[:body] || {}
-        status  = params[:status] || 200
-        headers = params[:headers] || {}
-
-        response = Excon::Response.new(:body => body, :headers => headers, :status => status)
-        if params.has_key?(:expects) && ![*params[:expects]].include?(response.status)
-          raise(Excon::Errors.status_error(params, response))
-        else response
-        end
-      end
-
-      def hello
-        body = {
-          'message' => 'Hi!'
-        }
-        response({:body => body})
-      end
-    end
-    """
-    When I run `bundle exec ruby validate.rb`
-    Then the output should contain:
-      """
-      Validated successfully!
-      """

data/lib/pacto/contract_list.rb

@@ -1,17 +0,0 @@
-module Pacto
-  class ContractList
-    attr_reader :contracts
-
-    def initialize(contracts)
-      @contracts = contracts
-    end
-
-    def stub_all(values = {})
-      contracts.each { |contract| contract.stub_contract!(values) }
-    end
-
-    def validate_all
-      contracts.map { |contract| contract.validate_provider }
-    end
-  end
-end

data/lib/pacto/contract_validator.rb

@@ -1,29 +0,0 @@
-module Pacto
-  class ContractValidator
-    class << self
-      def validate(contract, request, response, opts)
-        env = {
-          :contract => contract,
-          :actual_request => request,
-          :actual_response => response,
-          :validation_results => []
-        }
-        validation_stack(opts).call env
-        env[:validation_results].compact
-      end
-
-      private
-
-      def validation_stack(opts)
-        Middleware::Builder.new do
-          use Pacto::Validators::RequestBodyValidator
-          unless opts[:body_only]
-            use Pacto::Validators::ResponseStatusValidator
-            use Pacto::Validators::ResponseHeaderValidator
-          end
-          use Pacto::Validators::ResponseBodyValidator
-        end
-      end
-    end
-  end
-end

data/lib/pacto/core/validation_registry.rb

@@ -1,40 +0,0 @@
-module Pacto
-  class ValidationRegistry
-    include Singleton
-    include Logger
-    attr_reader :validations
-
-    def initialize
-      @validations = []
-    end
-
-    def reset!
-      @validations.clear
-    end
-
-    def validated?(request_pattern)
-      matched_validations = @validations.select do |validation|
-        request_pattern.matches? validation.request
-      end
-      matched_validations unless matched_validations.empty?
-    end
-
-    def register_validation(validation)
-      @validations << validation
-      logger.info "Detected #{validation.summary}"
-      validation
-    end
-
-    def unmatched_validations
-      @validations.select do |validation|
-        validation.contract.nil?
-      end
-    end
-
-    def failed_validations
-      @validations.select do |validation|
-        !validation.successful?
-      end
-    end
-  end
-end

data/lib/pacto/stubs/webmock_helper.rb

@@ -1,69 +0,0 @@
-module Pacto
-  module Stubs
-    class WebMockHelper
-      class << self
-        include Logger
-
-        def validate(request_signature, response)
-          pacto_response = webmock_to_pacto_response(response)
-          contract = Pacto.contracts_for(request_signature).first
-          validation = Validation.new request_signature, pacto_response, contract
-          Pacto::ValidationRegistry.instance.register_validation validation
-        end
-
-        def generate(request_signature, response)
-          logger.debug("Generating Contract for #{request_signature}, #{response}")
-          begin
-            contract_file = load_contract_file(request_signature)
-
-            unless File.exists? contract_file
-              generate_contract(request_signature, response, contract_file)
-            end
-          rescue => e
-            logger.error("Error while generating Contract #{contract_file}: #{e.message}")
-            logger.error("Backtrace: #{e.backtrace}")
-          end
-        end
-
-        private
-
-        def generate_contract(request_signature, response, contract_file)
-          uri = URI(request_signature.uri)
-          pacto_request = webmock_to_pacto_request(request_signature)
-          pacto_response = webmock_to_pacto_response(response)
-          generator = Pacto::Generator.new
-          FileUtils.mkdir_p(File.dirname contract_file)
-          File.write(contract_file, generator.save(uri, pacto_request, pacto_response))
-          logger.debug("Generating #{contract_file}")
-
-          Pacto.load_contract contract_file, uri.host
-        end
-
-        def load_contract_file(request_signature)
-          uri = URI(request_signature.uri)
-          basename = File.basename(uri.path, '.json') + '.json'
-          File.join(Pacto.configuration.contracts_path, uri.host, File.dirname(uri.path), basename)
-        end
-
-        def webmock_to_pacto_request(webmock_request)
-          uri = webmock_request.uri
-          Faraday::Request.create webmock_request.method do |req|
-            req.path = uri.path
-            req.params = uri.query_values
-            req.headers = webmock_request.headers
-            req.body = webmock_request.body
-          end
-        end
-
-        def webmock_to_pacto_response(webmock_response)
-          status, _description = webmock_response.status
-          Faraday::Response.new(
-            :status => status,
-            :response_headers => webmock_response.headers || {},
-            :body => webmock_response.body
-          )
-        end
-      end
-    end
-  end
-end

data/lib/pacto/validation.rb

@@ -1,54 +0,0 @@
-module Pacto
-  class Validation
-    include Logger
-    attr_reader :request, :response, :contract, :results
-
-    def initialize(request, response, contract)
-      @request = request
-      @response = response
-      @contract = contract
-      validate unless contract.nil?
-    end
-
-    def successful?
-      @results.nil? || @results.empty?
-    end
-
-    def against_contract?(contract_pattern)
-      unless @contract.nil?
-        case contract_pattern
-        when String
-          @contract if @contract.file.eql? contract_pattern
-        when Regexp
-          @contract if @contract.file =~ contract_pattern
-        end
-      end
-    end
-
-    def to_s
-      contract_name = @contract.nil? ? 'nil' : contract.name
-      """
-      Validation:
-      \tRequest: #{@request}
-      \tContract: #{contract_name}
-      \tResults: \n\t\t#{@results.join "\n\t\t"}
-      """
-    end
-
-    def summary
-      if @contract.nil?
-        "Missing contract for services provided by #{@request.uri.host}"
-      else
-        status = successful? ? 'successful' : 'unsuccessful'
-        "#{status} validation of #{@contract.name}"
-      end
-    end
-
-    private
-
-    def validate
-      logger.debug("Validating #{@request}, #{@response} against #{@contract}")
-      @results = contract.validate_consumer(@request, @response)
-    end
-  end
-end

data/lib/pacto/validators/body_validator.rb

@@ -1,49 +0,0 @@
-module Pacto
-  module Validators
-    class BodyValidator
-      def self.section_name
-        fail 'section name should be provided by subclass'
-      end
-
-      def self.subschema(contract)
-        fail 'override to return the proper subschema the contract'
-      end
-
-      # FIXME: https://github.com/thoughtworks/pacto/issues/10#issuecomment-31281238
-      # rubocop:disable MethodLenth
-      def self.validate(contract, body)
-        schema = subschema(contract)
-        if schema
-          schema['id'] = contract.file unless schema.key? 'id'
-          if schema['type'] && schema['type'] == 'string'
-            validate_as_pure_string schema, body.body
-          else
-            validate_as_json(schema, body)
-          end
-        end || []
-      end
-      # rubocop:enable MethodLenth
-
-      private
-
-      def self.validate_as_pure_string(schema, body)
-        errors = []
-        if schema['required'] && body.nil?
-          errors << "The #{section_name} does not contain a body"
-        end
-
-        pattern = schema['pattern']
-        if pattern && !(body =~ Regexp.new(pattern))
-          errors << "The #{section_name} does not match the pattern #{pattern}"
-        end
-
-        errors
-      end
-
-      def self.validate_as_json(schema, body)
-        body = body.body if body.respond_to? :body
-        JSON::Validator.fully_validate(schema, body, :version => :draft3)
-      end
-    end
-  end
-end

data/lib/pacto/validators/request_body_validator.rb

@@ -1,26 +0,0 @@
-module Pacto
-  module Validators
-    class RequestBodyValidator < BodyValidator
-      def initialize(app)
-        @app = app
-      end
-
-      def self.section_name
-        'request'
-      end
-
-      def self.subschema(contract)
-        contract.request.schema
-      end
-
-      def call(env)
-        if env[:validation_results].empty? # skip body validation if we already have other errors
-          actual_body = env[:actual_request]
-          errors = self.class.validate(env[:contract], actual_body)
-          env[:validation_results].concat errors.compact
-        end
-        @app.call env
-      end
-    end
-  end
-end

data/lib/pacto/validators/response_body_validator.rb

@@ -1,26 +0,0 @@
-module Pacto
-  module Validators
-    class ResponseBodyValidator < BodyValidator
-      def initialize(app)
-        @app = app
-      end
-
-      def self.section_name
-        'response'
-      end
-
-      def self.subschema(contract)
-        contract.response.schema
-      end
-
-      def call(env)
-        if env[:validation_results].empty? # skip body validation if we already have other errors
-          actual_body = env[:actual_response]
-          errors = self.class.validate(env[:contract], actual_body)
-          env[:validation_results].concat errors.compact
-        end
-        @app.call env
-      end
-    end
-  end
-end