pacto 0.4.0.rc1 → 0.4.0.rc2

data/lib/pacto/core/http_middleware.rb

@@ -15,7 +15,7 @@ module Pacto
         begin
           notify_observers request, response
         rescue StandardError => e
-          logger.error(e)
+          logger.error Pacto::Errors.formatted_trace(e)
         end
       end
     end

data/lib/pacto/core/pacto_request.rb

@@ -6,6 +6,8 @@ module Pacto
     # FIXME: Need case insensitive header lookup, but case-sensitive storage
     attr_accessor :headers, :body, :method, :uri
 
+    include BodyParsing
+
     def initialize(data)
       mash = Hashie::Mash.new data
       @headers = mash.headers.nil? ? {} : mash.headers
@@ -27,7 +29,7 @@ module Pacto
     def to_s
       string = Pacto::UI.colorize_method(method)
       string << " #{relative_uri}"
-      string << " with body (#{body.bytesize} bytes)" if body
+      string << " with body (#{raw_body.bytesize} bytes)" if raw_body
       string
     end
 
@@ -37,20 +39,6 @@ module Pacto
       end
     end
 
-    def parsed_body
-      if body.is_a?(String) && content_type == 'application/json'
-        JSON.parse(body)
-      else
-        body
-      end
-    rescue
-      body
-    end
-
-    def content_type
-      headers['Content-Type']
-    end
-
     def normalize
       @method = @method.to_s.downcase.to_sym
       @uri = @uri.normalize if @uri

data/lib/pacto/core/pacto_response.rb

@@ -5,6 +5,8 @@ module Pacto
     attr_accessor :headers, :body, :status, :parsed_body
     attr_reader :parsed_body
 
+    include BodyParsing
+
     def initialize(data)
       mash = Hashie::Mash.new data
       @headers = mash.headers.nil? ? {} : mash.headers
@@ -22,20 +24,8 @@ module Pacto
 
     def to_s
       string = "STATUS: #{status}"
-      string << " with body (#{body.bytesize} bytes)" if body
+      string << " with body (#{raw_body.bytesize} bytes)" if raw_body
       string
     end
-
-    def parsed_body
-      if body.is_a?(String) && content_type == 'application/json'
-        JSON.parse(body)
-      else
-        body
-      end
-    end
-
-    def content_type
-      headers['Content-Type']
-    end
   end
 end

data/lib/pacto/errors.rb

@@ -0,0 +1,68 @@
+module Pacto
+  class InvalidContract < ArgumentError
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+    end
+
+    def message
+      @errors.join "\n"
+    end
+  end
+
+  module Errors
+    # Creates an array of strings, representing a formatted exception,
+    # containing backtrace and nested exception info as necessary, that can
+    # be viewed by a human.
+    #
+    # For example:
+    #
+    #     ------Exception-------
+    #     Class: Crosstest::StandardError
+    #     Message: Failure starting the party
+    #     ---Nested Exception---
+    #     Class: IOError
+    #     Message: not enough directories for a party
+    #     ------Backtrace-------
+    #     nil
+    #     ----------------------
+    #
+    # @param exception [::StandardError] an exception
+    # @return [Array<String>] a formatted message
+    def self.formatted_trace(exception)
+      arr = formatted_exception(exception).dup
+      last = arr.pop
+      if exception.respond_to?(:original) && exception.original
+        arr += formatted_exception(exception.original, 'Nested Exception')
+        last = arr.pop
+      end
+      arr += ['Backtrace'.center(22, '-'), exception.backtrace, last].flatten
+      arr
+    end
+
+    # Creates an array of strings, representing a formatted exception that
+    # can be viewed by a human. Thanks to MiniTest for the inspiration
+    # upon which this output has been designed.
+    #
+    # For example:
+    #
+    #     ------Exception-------
+    #     Class: Crosstest::StandardError
+    #     Message: I have failed you
+    #     ----------------------
+    #
+    # @param exception [::StandardError] an exception
+    # @param title [String] a custom title for the message
+    #   (default: `"Exception"`)
+    # @return [Array<String>] a formatted message
+    def self.formatted_exception(exception, title = 'Exception')
+      [
+        title.center(22, '-'),
+        "Class: #{exception.class}",
+        "Message: #{exception.message}",
+        ''.center(22, '-')
+      ]
+    end
+  end
+end

data/lib/pacto/formats/legacy/contract.rb

@@ -0,0 +1,49 @@
+# -*- encoding : utf-8 -*-
+require 'pacto/formats/legacy/request_clause'
+require 'pacto/formats/legacy/response_clause'
+
+module Pacto
+  module Formats
+    module Legacy
+      class Contract < Pacto::Dash
+        include Pacto::Contract
+
+        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(opts)
+          skip_freeze = opts.delete(:skip_freeze)
+
+          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
+          freeze unless skip_freeze
+        end
+
+        def freeze
+          (keys.map(&:to_sym) - [:values, :adapter, :consumer, :provider]).each do | key |
+            send(key).freeze
+          end
+          self
+        end
+      end
+    end
+  end
+end

data/lib/pacto/formats/legacy/contract_builder.rb

@@ -0,0 +1,129 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Formats
+    module Legacy
+      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] ||= 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
+  end
+end

data/lib/pacto/formats/legacy/contract_factory.rb

@@ -0,0 +1,63 @@
+# -*- encoding : utf-8 -*-
+require 'pacto/formats/legacy/contract'
+
+module Pacto
+  module Formats
+    module Legacy
+      # Builds {Pacto::Formats::Legacy::Contract} instances from Pacto's legacy Contract format.
+      class ContractFactory
+        attr_reader :schema
+
+        def initialize(options = {})
+          @schema = options[:schema] || MetaSchema.new
+        end
+
+        def build_from_file(contract_path, host)
+          contract_definition = File.read(contract_path)
+          definition = JSON.parse(contract_definition)
+          schema.validate definition
+          definition['request'].merge!('host' => host)
+          body_to_schema(definition, 'request', contract_path)
+          body_to_schema(definition, 'response', contract_path)
+          method_to_http_method(definition, contract_path)
+          request = RequestClause.new(definition['request'])
+          response = ResponseClause.new(definition['response'])
+          Contract.new(request: request, response: response, file: contract_path, name: definition['name'], examples: definition['examples'])
+        end
+
+        def files_for(contracts_dir)
+          full_path = Pathname.new(contracts_dir).realpath
+
+          if  full_path.directory?
+            all_json_files = "#{full_path}/**/*.json"
+            Dir.glob(all_json_files).map do |f|
+              Pathname.new(f)
+            end
+          else
+            [full_path]
+          end
+        end
+
+        private
+
+        def body_to_schema(definition, section, file)
+          schema = definition[section].delete 'body'
+          return nil unless schema
+
+          Pacto::UI.deprecation "Contract format deprecation: #{section}:body will be moved to #{section}:schema (#{file})"
+          definition[section]['schema'] = schema
+        end
+
+        def method_to_http_method(definition, file)
+          method = definition['request'].delete 'method'
+          return nil unless method
+
+          Pacto::UI.deprecation "Contract format deprecation: request:method will be moved to request:http_method (#{file})"
+          definition['request']['http_method'] = method
+        end
+
+        Pacto::ContractFactory.add_factory(:legacy, ContractFactory.new)
+      end
+    end
+  end
+end

data/lib/pacto/formats/legacy/contract_generator.rb

@@ -0,0 +1,77 @@
+# -*- encoding : utf-8 -*-
+require 'json/schema_generator'
+require 'pacto/formats/legacy/contract_builder'
+require 'pacto/formats/legacy/generator/filters'
+
+module Pacto
+  module Formats
+    module Legacy
+      class ContractGenerator
+        include Logger
+
+        def initialize(_schema_version = 'draft3',
+          schema_generator = JSON::SchemaGenerator,
+          validator = Pacto::MetaSchema.new,
+          filters = Generator::Filters.new,
+          consumer = Pacto::Consumer.new)
+          @contract_builder = ContractBuilder.new(schema_generator: schema_generator, filters: filters)
+          @consumer = consumer
+          @validator = validator
+        end
+
+        def generate(pacto_request, pacto_response)
+          return unless Pacto.generating?
+          logger.debug("Generating Contract for #{pacto_request}, #{pacto_response}")
+          begin
+            contract_file = load_contract_file(pacto_request)
+
+            unless File.exist? contract_file
+              uri = URI(pacto_request.uri)
+              FileUtils.mkdir_p(File.dirname contract_file)
+              raw_contract = save(uri, pacto_request, pacto_response)
+              File.write(contract_file, raw_contract)
+              logger.debug("Generating #{contract_file}")
+
+              Pacto.load_contract contract_file, uri.host
+            end
+          rescue => e
+            raise StandardError, "Error while generating Contract #{contract_file}: #{e.message}", e.backtrace
+          end
+        end
+
+        def generate_from_partial_contract(request_file, host)
+          contract = Pacto.load_contract request_file, host
+          request, response = @consumer.request(contract)
+          save(request_file, request, response)
+        end
+
+        def save(source, request, response)
+          @contract_builder.source = source
+          # TODO: Get rid of the generate_contract call, just use add_example/infer_all
+          @contract_builder.add_example('default', request, response).generate_contract(request, response) # .infer_all
+          @contract_builder.without_examples if Pacto.configuration.generator_options[:no_examples]
+          contract = @contract_builder.build_hash
+          pretty_contract = MultiJson.encode(contract, pretty: true)
+          # This is because of a discrepency w/ jruby vs MRI pretty json
+          pretty_contract.gsub!(/^$\n/, '')
+          @validator.validate pretty_contract
+          pretty_contract
+        end
+
+        private
+
+        def load_contract_file(pacto_request)
+          hint = Pacto::Generator.hint_for(pacto_request)
+          if hint.nil?
+            uri = URI(pacto_request.uri)
+            path = uri.path
+            basename = File.basename(path, '.json') + '.json'
+            File.join(Pacto.configuration.contracts_path, uri.host, File.dirname(path), basename)
+          else
+            File.expand_path(hint.target_file, Pacto.configuration.contracts_path)
+          end
+        end
+      end
+    end
+  end
+end