pacto 0.3.1 → 0.4.0.rc1

data/lib/pacto/generator.rb

@@ -1,66 +1,44 @@
-require 'json/schema_generator'
+# -*- encoding : utf-8 -*-
+require 'pacto/generator/native_contract_generator'
+require 'pacto/generator/hint'
 
 module Pacto
-  class Generator
-    def initialize(schema_version = 'draft3',
-      schema_generator = JSON::SchemaGenerator,
-      validator = Pacto::MetaSchema.new,
-      generator_options = Pacto.configuration.generator_options,
-      filters = Pacto::Generator::Filters.new)
-      @schema_version = schema_version
-      @validator = validator
-      @schema_generator = schema_generator
-      @generator_options = generator_options
-      @filters = filters
-    end
+  module Generator
+    include Logger
 
-    def generate(request_file, host)
-      contract = Pacto.load_contract request_file, host
-      request = contract.request
-      response = contract.request.execute
-      save(request_file, request, response)
-    end
+    class << self
+      # Factory method to return the active contract generator implementation
+      def contract_generator
+        NativeContractGenerator.new
+      end
 
-    def save(source, request, response)
-      contract = generate_contract source, request, response
-      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
+      # Factory method to return the active contract generator implementation
+      def schema_generator
+        JSON::SchemaGenerator
+      end
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
 
-    private
+      def configure
+        yield(configuration)
+      end
 
-    def generate_contract(source, request, response)
-      {
-        :request => generate_request(request, response, source),
-        :response => generate_response(request, response, source)
-      }
+      def hint_for(pacto_request)
+        configuration.hints.find { |hint| hint.matches? pacto_request }
+      end
     end
 
-    def generate_request(request, response, source)
-      {
-        :headers => @filters.filter_request_headers(request, response),
-        :method => request.method,
-        :params => request.params,
-        :path => request.path,
-        :body => generate_body(source, request.body)
-      }.delete_if { |k, v| v.nil? }
-    end
+    class Configuration
+      attr_reader :hints
 
-    def generate_response(request, response, source)
-      {
-        :headers => @filters.filter_response_headers(request, response),
-        :status => response.status,
-        :body => generate_body(source, response.body)
-      }.delete_if { |k, v| v.nil? }
-    end
+      def initialize
+        @hints = Set.new
+      end
 
-    def generate_body(source, body)
-      if body && !body.empty?
-        body_schema = JSON::SchemaGenerator.generate source, body, @generator_options
-        MultiJson.load(body_schema)
+      def hint(name, hint_data)
+        @hints << Pacto::Generator::Hint.new(hint_data.merge(service_name: name))
       end
     end
   end

data/lib/pacto/generator/filters.rb

@@ -1,26 +1,27 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  class Generator
+  module Generator
     class Filters
-      CONNECTION_CONTROL_HEADERS = %w{
+      CONNECTION_CONTROL_HEADERS = %w(
         Via
         Server
         Connection
         Transfer-Encoding
         Content-Length
-      }
+      )
 
       FRESHNESS_HEADERS =
-      %w{
+      %w(
         Date
         Last-Modified
         ETag
-      }
+      )
 
       HEADERS_TO_FILTER = CONNECTION_CONTROL_HEADERS + FRESHNESS_HEADERS
 
       def filter_request_headers(request, response)
         # FIXME: Do we need to handle all these cases in real situations, or just because of stubbing?
-        vary_headers = response.headers['Vary'] || []
+        vary_headers = response.headers['vary'] || response.headers['Vary'] || []
         vary_headers = [vary_headers] if vary_headers.is_a? String
         vary_headers = vary_headers.map do |h|
           h.split(',').map(&:strip)
@@ -31,7 +32,7 @@ module Pacto
         end
       end
 
-      def filter_response_headers(request, response)
+      def filter_response_headers(_request, response)
         Pacto::Extensions.normalize_header_keys(response.headers).reject do |header|
           (HEADERS_TO_FILTER.include? header) || (header.start_with?('X-'))
         end

data/lib/pacto/generator/hint.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Generator
+    class Hint < Pacto::RequestClause
+      property :service_name, required: true
+      property :target_file
+
+      def initialize(data)
+        super
+        self.target_file ||= "#{slugify(service_name)}.json"
+        self
+      end
+
+      def matches?(pacto_request)
+        return false if pacto_request.nil?
+        Pacto::RequestPattern.for(self).matches?(pacto_request)
+      end
+
+      private
+
+      def slugify(path)
+        path.downcase.gsub(' ', '_')
+      end
+    end
+  end
+end

data/lib/pacto/generator/native_contract_generator.rb

@@ -0,0 +1,74 @@
+# -*- encoding : utf-8 -*-
+require 'json/schema_generator'
+require 'pacto/contract_builder'
+
+module Pacto
+  module Generator
+    class NativeContractGenerator
+      include Logger
+
+      def initialize(_schema_version = 'draft3',
+        schema_generator = JSON::SchemaGenerator,
+        validator = Pacto::MetaSchema.new,
+        filters = Pacto::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

data/lib/pacto/hooks/erb_hook.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require_relative '../erb_processor'
 
 module Pacto
@@ -9,7 +10,7 @@ module Pacto
 
       def process(contracts, request_signature, response)
         bound_values = contracts.empty? ? {} : contracts.first.values
-        bound_values.merge!(:req => { 'HEADERS' => request_signature.headers})
+        bound_values.merge!(req: { 'HEADERS' => request_signature.headers })
         response.body = @processor.process response.body, bound_values
         response.body
       end

data/lib/pacto/investigation.rb

@@ -0,0 +1,49 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  class Investigation
+    include Logger
+    attr_reader :request, :response, :contract, :citations
+
+    def initialize(request, response, contract = nil, citations = nil)
+      @request = request
+      @response = response
+      @contract = contract
+      @citations = citations || []
+    end
+
+    def successful?
+      @citations.empty?
+    end
+
+    def against_contract?(contract_pattern)
+      return nil if @contract.nil?
+
+      case contract_pattern
+      when String
+        @contract if @contract.file.eql? contract_pattern
+      when Regexp
+        @contract if @contract.file =~ contract_pattern
+      end
+    end
+
+    def to_s
+      contract_name = @contract.nil? ? 'nil' : contract.name
+      citation_string = Pacto::UI.colorize(@citations.join("\n\t\t"), :red)
+      ''"
+      Investigation:
+      \tContract: #{contract_name}
+      \tRequest: #{@request}
+      \tCitations: \n\t\t#{citation_string}
+      "''
+    end
+
+    def summary
+      if @contract.nil?
+        "Missing contract for services provided by #{@request.uri.host}"
+      else
+        status = successful? ? 'successful' : 'unsuccessful'
+        "#{status} investigation of #{@contract.name}"
+      end
+    end
+  end
+end

data/lib/pacto/logger.rb

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

data/lib/pacto/meta_schema.rb

@@ -1,19 +1,25 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   class MetaSchema
     attr_accessor :schema, :engine
 
     def initialize(engine = JSON::Validator)
       @schema = File.join(File.dirname(File.expand_path(__FILE__)), '../../resources/contract_schema.json')
-      @base_schema = File.join(File.dirname(File.expand_path(__FILE__)), '../../resources/draft-03.json')
-      JSON::Validator.validate!(@base_schema, @schema)
+      base_schemas = ['../../resources/draft-03.json', '../../resources/draft-04.json']
+      validatable = false
+      base_schemas.each do |base_schema|
+        base_schema_file = File.join(File.dirname(File.expand_path(__FILE__)), base_schema)
+        # This has a side-effect of caching local schemas, so we don't
+        # look up json-schemas over HTTP.
+        validatable ||= JSON::Validator.validate(base_schema_file, @schema)
+      end
+      fail 'Could not validate metaschema against any known version of json-schema' unless validatable
       @engine = engine
     end
 
     def validate(definition)
-      errors = engine.fully_validate(schema, definition, :version => :draft3)
-      unless errors.empty?
-        fail InvalidContract, errors
-      end
+      errors = engine.fully_validate(schema, definition)
+      fail InvalidContract, errors unless errors.empty?
     end
   end
 end

data/lib/pacto/native_contract_factory.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  # Builds {Pacto::Contract} instances from Pacto's native Contract format.
+  class NativeContractFactory
+    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
+  end
+end
+
+factory = Pacto::NativeContractFactory.new
+
+Pacto::ContractFactory.add_factory(:native, factory)
+Pacto::ContractFactory.add_factory(:default, factory)

data/lib/pacto/observers/stenographer.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Observers
+    class Stenographer
+      def initialize(output)
+        @output = output
+      end
+
+      def log_investigation(investigation)
+        return if @output.nil?
+
+        contract = investigation.contract
+        request = investigation.request
+        response = investigation.response
+        name = name_for(contract, request)
+        values = values_for(contract, request)
+
+        msg = "request #{name.inspect}, values: #{values.inspect}, response: {status: #{response.status}} # #{number_of_citations(investigation)} contract violations"
+        @output.puts msg
+        @output.flush
+      end
+
+      protected
+
+      def name_for(contract, request)
+        return "Unknown (#{request.uri})" if contract.nil?
+        contract.name
+      end
+
+      def number_of_citations(investigation)
+        return 0 if investigation.nil?
+        return 0 if investigation.citations.nil?
+        investigation.citations.size.to_s
+      end
+
+      def values_for(_contract, request)
+        # FIXME: Extract vars w/ URI::Template
+        request.uri.query_values
+      end
+    end
+  end
+end