pacto 0.3.1 → 0.4.0.rc1

data/lib/pacto/contract.rb

@@ -1,39 +1,67 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  class Contract
-    attr_reader :name, :values, :request, :response, :file, :request_pattern
+  class Contract < Pacto::Dash
+    property :id
+    property :file
+    property :request,  required: true
+    # Although I'd like response to be required, it complicates
+    # the partial contracts used the rake generation task...
+    # yet another reason I'd like to deprecate that feature
+    property :response # , required: true
+    property :values, default: {}
+    # Gotta figure out how to use test doubles w/ coercion
+    coerce_key :request,  RequestClause
+    coerce_key :response, ResponseClause
+    property :examples
+    property :name, required: true
+    property :adapter, default: proc { Pacto.configuration.adapter }
+    property :consumer, default: proc { Pacto.configuration.default_consumer }
+    property :provider, default: proc { Pacto.configuration.default_provider }
 
-    def initialize(request, response, file, name = nil, request_pattern_provider = RequestPattern)
-      @request = request
-      @response = response
-      @file = Addressable::URI.convert_path(file.to_s).to_s
-      @name = name || @file
-      @request_pattern = request_pattern_provider.for(request)
-      @values = {}
+    def initialize(opts)
+      if opts[:file]
+        opts[:file] = Addressable::URI.convert_path(File.expand_path(opts[:file])).to_s
+        opts[:name] ||= opts[:file]
+      end
+      opts[:id] ||= (opts[:summary] || opts[:file])
+      super
+    end
+
+    def examples?
+      examples && !examples.empty?
     end
 
     def stub_contract!(values = {})
-      @values = values
-      Pacto.configuration.provider.stub_request!(request, response)
+      self.values = values
+      adapter.stub_request!(self)
     end
 
-    def validate_provider(opts = {})
-      request = @request
-      response = provider_response
-      validate_consumer request, response, opts
+    def simulate_request
+      pacto_request, pacto_response = execute
+      validate_response pacto_request, pacto_response
     end
 
-    def validate_consumer(request, response, opts = {})
-      Pacto::ContractValidator.validate self, request, response, opts
+    # Should this be deprecated?
+    def validate_response(request, response)
+      Pacto::Cops.perform_investigation request, response, self
     end
 
     def matches?(request_signature)
       request_pattern.matches? request_signature
     end
 
-    private
+    def request_pattern
+      request.pattern
+    end
+
+    def response_for(pacto_request)
+      provider.response_for self, pacto_request
+    end
 
-    def provider_response
-      @request.execute
+    def execute(additional_values = {})
+      # FIXME: Do we really need to store on the Contract, or just as a param for #stub_contact! and #execute?
+      full_values = values.merge(additional_values)
+      consumer.reenact(self, full_values)
     end
   end
 end

data/lib/pacto/contract_builder.rb

@@ -0,0 +1,125 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  class ContractBuilder < Hashie::Dash # rubocop:disable Metrics/ClassLength
+    extend Forwardable
+    attr_accessor :source
+
+    def initialize(options = {})
+      @schema_generator = options[:schema_generator] ||= JSON::SchemaGenerator
+      @filters = options[:filters] ||= Pacto::Generator::Filters.new
+      @data = { request: {}, response: {}, examples: {} }
+      @source = 'Pacto' # Currently used by JSONSchemaGeneator, but not really useful
+    end
+
+    def name=(name)
+      @data[:name] = name
+    end
+
+    def add_example(name, pacto_request, pacto_response)
+      @data[:examples][name] ||= {}
+      @data[:examples][name][:request] = clean(pacto_request.to_hash)
+      @data[:examples][name][:response] = clean(pacto_response.to_hash)
+      self
+    end
+
+    def infer_all
+      # infer_file # The target file is being chosen inferred by the Generator
+      infer_name
+      infer_schemas
+    end
+
+    def infer_name
+      if @data[:examples].empty?
+        @data[:name] = @data[:request][:path] if @data[:request]
+        return self
+      end
+
+      example, hint = example_and_hint
+      @data[:name] = hint.nil? ? PactoRequest.new(example[:request]).uri.path : hint.service_name
+      self
+    end
+
+    def infer_schemas
+      return self if @data[:examples].empty?
+
+      # TODO: It'd be awesome if we could infer across all examples
+      example, _hint = example_and_hint
+      sample_request_body = example[:request][:body]
+      sample_response_body = example[:response][:body]
+      @data[:request][:schema] = generate_schema(sample_request_body) if sample_request_body && !sample_request_body.empty?
+      @data[:response][:schema] = generate_schema(sample_response_body) if sample_response_body && !sample_response_body.empty?
+      self
+    end
+
+    def without_examples
+      @export_examples = false
+      self
+    end
+
+    def generate_contract(request, response)
+      generate_request(request, response)
+      generate_response(request, response)
+      infer_all
+      self
+    end
+
+    def generate_request(request, response)
+      hint = hint_for(request)
+      request = clean(
+                        headers: @filters.filter_request_headers(request, response),
+                        http_method: request.method,
+                        params: request.uri.query_values,
+                        path: hint.nil? ? request.uri.path : hint.path
+                      )
+      @data[:request] = request
+      self
+    end
+
+    def generate_response(request, response)
+      response = clean(
+                         headers: @filters.filter_response_headers(request, response),
+                         status: response.status
+                       )
+      @data[:response] = response
+      self
+    end
+
+    def build_hash
+      instance_eval(&block) if block_given?
+      @final_data = @data.dup
+      @final_data.delete(:examples) if exclude_examples?
+      clean(@final_data)
+    end
+
+    def build(&block)
+      Contract.new build_hash(&block)
+    end
+
+    protected
+
+    def example_and_hint
+      example = @data[:examples].values.first
+      example_request = PactoRequest.new example[:request]
+      [example, Pacto::Generator.hint_for(example_request)]
+    end
+
+    def exclude_examples?
+      @export_examples == false
+    end
+
+    def generate_schema(body, generator_options = Pacto.configuration.generator_options)
+      return if body.nil? || body.empty?
+
+      body_schema = @schema_generator.generate @source, body, generator_options
+      MultiJson.load(body_schema)
+    end
+
+    def clean(data)
+      data.delete_if { |_k, v| v.nil? }
+    end
+
+    def hint_for(pacto_request)
+      Pacto::Generator.hint_for(pacto_request)
+    end
+  end
+end

data/lib/pacto/contract_factory.rb

@@ -1,22 +1,41 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   class ContractFactory
-    attr_reader :schema
+    include Singleton
+    include Logger
 
-    def initialize(options = {})
-      @schema = options[:schema] || MetaSchema.new
+    def initialize
+      @factories = {}
     end
 
-    def build(contract_files, host)
-      contract_files.map { |file| build_from_file(file, host) }
+    def add_factory(format, factory)
+      @factories[format.to_sym] = factory
     end
 
-    def build_from_file(contract_path, host)
-      contract_definition = File.read(contract_path)
-      definition = JSON.parse(contract_definition)
-      schema.validate definition
-      request = RequestClause.new(host, definition['request'])
-      response = ResponseClause.new(definition['response'])
-      Contract.new(request, response, contract_path, definition['name'])
+    def remove_factory(format)
+      @factories.delete format
+    end
+
+    def build(contract_files, host, format = :default)
+      factory = @factories[format.to_sym]
+      fail "No Contract factory registered for #{format}" if factory.nil?
+
+      contract_files.map { |file| factory.build_from_file(file, host) }.flatten
+    end
+
+    def load_contracts(contracts_path, host, format = :default)
+      factory = @factories[format.to_sym]
+      files = factory.files_for(contracts_path)
+      contracts = ContractFactory.build(files, host, format)
+      contracts
+    end
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, *ContractFactory.instance_methods(false)
     end
   end
 end
+
+require 'pacto/native_contract_factory'
+require 'pacto/swagger_contract_factory'

data/lib/pacto/contract_files.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'pathname'
 module Pacto
   class ContractFiles

data/lib/pacto/contract_set.rb

@@ -0,0 +1,12 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  class ContractSet < Set
+    def stub_providers(values = {})
+      each { |contract| contract.stub_contract!(values) }
+    end
+
+    def simulate_consumers
+      map(&:simulate_request)
+    end
+  end
+end

data/lib/pacto/cops.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Cops
+    extend Pacto::Resettable
+
+    class << self
+      def reset!
+        @active_cops = nil
+      end
+
+      def register_cop(cop)
+        fail TypeError "#{cop} does not respond to investigate" unless cop.respond_to? :investigate
+        registered_cops << cop
+      end
+
+      def registered_cops
+        @registered_cops ||= Set.new
+      end
+
+      def active_cops
+        @active_cops ||= registered_cops.dup
+      end
+
+      def investigate(request_signature, pacto_response)
+        return unless Pacto.validating?
+
+        contract = Pacto.contracts_for(request_signature).first
+        if contract
+          investigation = perform_investigation request_signature, pacto_response, contract
+        else
+          investigation = Investigation.new request_signature, pacto_response
+        end
+
+        Pacto::InvestigationRegistry.instance.register_investigation investigation
+      end
+
+      def perform_investigation(request, response, contract)
+        citations = []
+        active_cops.map do | cop |
+          citations.concat cop.investigate(request, response, contract)
+        end
+        Investigation.new(request, response, contract, citations.compact)
+      end
+    end
+  end
+end

data/lib/pacto/cops/body_cop.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Cops
+    class BodyCop
+      KNOWN_CLAUSES = [:request, :response]
+
+      def self.validates(clause)
+        fail ArgumentError, "Unknown clause: #{clause}" unless KNOWN_CLAUSES.include? clause
+        @clause = clause
+      end
+
+      def self.investigate(request, response, contract)
+        # eval "is a security risk" and local_variable_get is ruby 2.1+ only, so...
+        body = { request: request, response: response }[@clause].body
+        schema = contract.send(@clause).schema
+        if schema && !schema.empty?
+          schema['id'] = contract.file unless schema.key? 'id'
+          JSON::Validator.fully_validate(schema, body, version: :draft3)
+        end || []
+      end
+    end
+  end
+end

data/lib/pacto/cops/request_body_cop.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Cops
+    class RequestBodyCop < BodyCop
+      validates :request
+    end
+  end
+end
+
+Pacto::Cops.register_cop Pacto::Cops::RequestBodyCop

data/lib/pacto/cops/response_body_cop.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Cops
+    class ResponseBodyCop < BodyCop
+      validates :response
+    end
+  end
+end
+
+Pacto::Cops.register_cop Pacto::Cops::ResponseBodyCop

data/lib/pacto/{validators/response_header_validator.rb → cops/response_header_cop.rb}

@@ -1,18 +1,10 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  module Validators
-    class ResponseHeaderValidator
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        expected_headers = env[:contract].response.headers
-        actual_headers = env[:actual_response].headers
-        env[:validation_results].concat self.class.validate(expected_headers, actual_headers)
-        @app.call env
-      end
-
-      def self.validate(expected_headers, actual_headers)
+  module Cops
+    class ResponseHeaderCop
+      def self.investigate(_request, response, contract)
+        expected_headers = contract.response.headers
+        actual_headers = response.headers
         actual_headers = Pacto::Extensions.normalize_header_keys actual_headers
         headers_to_validate = Pacto::Extensions.normalize_header_keys expected_headers
 
@@ -28,7 +20,7 @@ module Pacto
 
       private
 
-      HeaderValidatorMap = Hash.new do |map, key|
+      HeaderValidatorMap = Hash.new do |_map, key|
         proc do |expected_value, actual_value|
           unless expected_value.eql? actual_value
             "Invalid response header #{key}: expected #{expected_value.inspect} but received #{actual_value.inspect}"
@@ -47,3 +39,5 @@ module Pacto
     end
   end
 end
+
+Pacto::Cops.register_cop Pacto::Cops::ResponseHeaderCop

data/lib/pacto/cops/response_status_cop.rb

@@ -0,0 +1,18 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Cops
+    class ResponseStatusCop
+      def self.investigate(_request, response, contract)
+        expected_status = contract.response.status
+        actual_status = response.status
+        errors = []
+        if expected_status != actual_status
+          errors << "Invalid status: expected #{expected_status} but got #{actual_status}"
+        end
+        errors
+      end
+    end
+  end
+end
+
+Pacto::Cops.register_cop Pacto::Cops::ResponseStatusCop

data/lib/pacto/core/configuration.rb

@@ -1,17 +1,28 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   class Configuration
-    attr_accessor :provider, :strict_matchers,
-                  :contracts_path, :logger, :generator_options
+    attr_accessor :adapter, :strict_matchers,
+                  :contracts_path, :logger, :generator_options,
+                  :hide_deprecations, :default_consumer, :default_provider,
+                  :stenographer_log_file, :color
     attr_reader :hook
 
     def initialize
-      @provider = Stubs::WebMockAdapter.new
+      @middleware = Pacto::Core::HTTPMiddleware.new
+      @middleware.add_observer Pacto::Cops, :investigate
+      @generator = Pacto::Generator.contract_generator
+      @middleware.add_observer @generator, :generate
+      @stenographer_log_file ||= File.expand_path('pacto_stenographer.log')
+      @default_consumer = Pacto::Consumer.new
+      @default_provider = Pacto::Provider.new
+      @adapter = Stubs::WebMockAdapter.new(@middleware)
       @strict_matchers = true
-      @contracts_path = nil
+      @contracts_path = '.'
       @logger = Logger::SimpleLogger.instance
       define_logger_level
       @hook = Hook.new {}
-      @generator_options = { :schema_version => 'draft3' }
+      @generator_options = { schema_version: 'draft3' }
+      @color = $stdout.tty?
     end
 
     def register_hook(hook = nil, &block)