pacto 0.3.0.pre → 0.3.0

data/lib/pacto/request_clause.rb

@@ -0,0 +1,43 @@
+module Pacto
+  class RequestClause
+    attr_reader :host, :method, :schema
+    attr_accessor :body
+
+    def initialize(host, definition)
+      @host = host
+      @definition = definition
+      @method = definition['method'].to_s.downcase.to_sym
+      @schema = definition['body'] || {}
+    end
+
+    def uri
+      @uri ||= Pacto::URI.for(host, path, params)
+    end
+
+    def body
+      JSON::Generator.generate(@definition['body']) if @definition['body']
+    end
+
+    def path
+      @definition['path']
+    end
+
+    def headers
+      @definition['headers']
+    end
+
+    def params
+      @definition['params'] || {}
+    end
+
+    def execute
+      conn = Faraday.new(:url => uri.to_s) do |faraday|
+        faraday.response :logger if Pacto.configuration.logger.level == :debug
+        faraday.adapter  Faraday.default_adapter
+      end
+      conn.send(method) do |req|
+        req.headers = headers
+      end
+    end
+  end
+end

data/lib/pacto/request_pattern.rb

@@ -0,0 +1,8 @@
+module Pacto
+  class RequestPattern
+    def self.for(base_request)
+      uri_pattern = UriPattern.for(base_request)
+      WebMock::RequestPattern.new(base_request.method, uri_pattern)
+    end
+  end
+end

data/lib/pacto/response_clause.rb

@@ -0,0 +1,15 @@
+module Pacto
+  class ResponseClause
+    attr_reader :status, :headers, :schema
+
+    def initialize(definition)
+      @status = definition['status']
+      @headers = definition['headers']
+      @schema = definition['body'] || {}
+    end
+
+    def body
+      @body ||= JSON::Generator.generate(schema)
+    end
+  end
+end

data/lib/pacto/rspec.rb

@@ -0,0 +1,102 @@
+require 'pacto'
+
+begin
+  require 'rspec/core'
+  require 'rspec/expectations'
+rescue LoadError
+  raise 'pacto/rspec requires rspec 2 or later'
+end
+
+RSpec::Matchers.define :have_unmatched_requests do |method, uri|
+  @unmatched_validations = Pacto::ValidationRegistry.instance.unmatched_validations
+  match do
+    !@unmatched_validations.empty?
+  end
+
+  failure_message_for_should do
+    'Expected Pacto to have not matched all requests to a Contract, but all requests were matched.'
+  end
+
+  failure_message_for_should_not do
+    unmatched_requests = @unmatched_validations.map(&:request).join("\n  ")
+    "Expected Pacto to have matched all requests to a Contract, but the following requests were not matched: \n  #{unmatched_requests}"
+  end
+end
+
+RSpec::Matchers.define :have_failed_validations do |method, uri|
+  @failed_validations = Pacto::ValidationRegistry.instance.failed_validations
+  match do
+    !@failed_validations.empty?
+  end
+
+  failure_message_for_should do
+    'Expected Pacto to have found validation problems, but none were found.'
+  end
+
+  failure_message_for_should_not do
+    "Expected Pacto to have successfully validated all requests, but the following issues were found: #{@failed_validations}"
+  end
+end
+
+RSpec::Matchers.define :have_validated do |method, uri|
+  @request_pattern = WebMock::RequestPattern.new(method, uri)
+  match do
+    validated? @request_pattern
+  end
+
+  chain :against_contract do |contract|
+    @contract = contract
+  end
+
+  chain :with do |options|
+    @request_pattern.with options
+  end
+
+  def validated?(request_pattern)
+    @matching_validations = Pacto::ValidationRegistry.instance.validated? @request_pattern
+    validated = !@matching_validations.nil?
+    validated && successfully? && contract_matches?
+  end
+
+  def validation_results
+    @validation_results ||= @matching_validations.map(&:results).flatten.compact
+  end
+
+  def successfully?
+    @matching_validations.map(&:successful?).uniq.eql? [true]
+  end
+
+  def contract_matches?
+    if @contract
+      validated_contracts = @matching_validations.map(&:contract)
+      # Is there a better option than case equality for string & regex support?
+      validated_contracts.map(&:file).index { |file| @contract === file } # rubocop:disable CaseEquality
+    else
+      true
+    end
+  end
+
+  failure_message_for_should do
+    buffer = StringIO.new
+    buffer.puts "expected Pacto to have validated #{@request_pattern}"
+    if @matching_validations.nil? || @matching_validations.empty?
+      buffer.puts '  but no matching request was received'
+      buffer.puts '    received:'
+      buffer.puts "#{WebMock::RequestRegistry.instance}"
+    elsif @matching_validations.map(&:contract).compact.empty?
+      buffer.puts '  but a matching Contract was not found'
+    elsif !successfully?
+      buffer.puts '  but validation errors were found:'
+      buffer.print '    '
+      buffer.puts validation_results.join "\n    "
+      # validation_results.each do |validation_result|
+      #   buffer.puts "    #{validation_result}"
+      # end
+    elsif @contract
+      validated_against = @matching_validations.map { |v| v.against_contract?  @contract }.compact.join ','
+      buffer.puts "  against Contract #{@contract}"
+      buffer.puts "    but it was validated against #{validated_against}"
+    end
+    buffer.string
+  end
+end

data/lib/pacto/stubs/uri_pattern.rb

@@ -0,0 +1,23 @@
+module Pacto
+  class UriPattern
+    class << self
+      def for(request)
+        if Pacto.configuration.strict_matchers
+          build_strict_uri_pattern(request)
+        else
+          build_relaxed_uri_pattern(request)
+        end
+      end
+
+      def build_strict_uri_pattern(request)
+        "#{request.host}#{request.path}"
+      end
+
+      def build_relaxed_uri_pattern(request)
+        path_pattern = request.path.gsub(/\/:\w+/, '/[^\/\?#]+')
+        host_pattern = Regexp.quote(request.host)
+        /#{host_pattern}#{path_pattern}/
+      end
+    end
+  end
+end

data/lib/pacto/stubs/webmock_adapter.rb

@@ -0,0 +1,69 @@
+require 'pacto/stubs/webmock_helper'
+
+module Pacto
+  module Stubs
+    class WebMockAdapter
+      def initialize
+        register_hooks
+      end
+
+      def stub_request!(request, response)
+        uri_pattern = UriPattern.for(request)
+        stub = WebMock.stub_request(request.method, uri_pattern)
+
+        stub.request_pattern.with(strict_details(request)) if Pacto.configuration.strict_matchers
+
+        stub.to_return(
+          :status => response.status,
+          :headers => response.headers,
+          :body => format_body(response.body)
+        )
+      end
+
+      def reset!
+        WebMock.reset!
+        WebMock.reset_callbacks
+      end
+
+      def process_hooks(request_signature, response)
+        WebMockHelper.generate(request_signature, response) if Pacto.generating?
+
+        contracts = Pacto.contracts_for request_signature
+        Pacto.configuration.hook.process contracts, request_signature, response
+
+        WebMockHelper.validate(request_signature, response) if Pacto.validating?
+      end
+
+      private
+
+      def register_hooks
+        WebMock.after_request do |request_signature, response|
+          process_hooks request_signature, response
+        end
+      end
+
+      def format_body(body)
+        if body.is_a?(Hash) || body.is_a?(Array)
+          body.to_json
+        else
+          body
+        end
+      end
+
+      def strict_details(request)
+        {}.tap do |details|
+          unless request.params.empty?
+            details[webmock_params_key(request)] = request.params
+          end
+          unless request.headers.empty?
+            details[:headers] = request.headers
+          end
+        end
+      end
+
+      def webmock_params_key(request)
+        request.method == :get ? :query : :body
+      end
+    end
+  end
+end

data/lib/pacto/stubs/webmock_helper.rb

@@ -0,0 +1,71 @@
+module Pacto
+  module Stubs
+    class WebMockHelper
+      class << self
+        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 logger
+          @logger ||= Logger.instance
+        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/ui.rb

@@ -0,0 +1,7 @@
+require 'term/ansicolor'
+
+module Pacto
+  module UI
+    extend Term::ANSIColor
+  end
+end

data/lib/pacto/uri.rb

@@ -0,0 +1,9 @@
+module Pacto
+  class URI
+    def self.for(host, path, params = {})
+      Addressable::URI.heuristic_parse("#{host}#{path}").tap do |uri|
+        uri.query_values = params unless params.empty?
+      end
+    end
+  end
+end

data/lib/pacto/validation.rb

@@ -0,0 +1,57 @@
+module Pacto
+  class Validation
+    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 logger
+      @logger ||= Logger.instance
+    end
+
+    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

@@ -0,0 +1,41 @@
+module Pacto
+  module Validators
+    class BodyValidator
+      def self.section_name
+        fail 'section name should be provided by subclass'
+      end
+
+      def self.validate(schema, body)
+        if schema
+          if schema['type'] && schema['type'] == 'string'
+            validate_as_pure_string schema, body.body
+          else
+            body.respond_to?(:body) ? validate_as_json(schema, body.body) : validate_as_json(schema, body)
+          end
+        else
+          []
+        end
+      end
+
+      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)
+        JSON::Validator.fully_validate(schema, body, :version => :draft3)
+      end
+    end
+  end
+end