pacto 0.2.5 → 0.3.0.pre

data/lib/pacto.rb

@@ -1,46 +1,75 @@
-require "pacto/version"
-
-require "httparty"
-require "hash_deep_merge"
-require "json"
-require "json-schema"
-require "json-generator"
-require "webmock"
-require "ostruct"
-require "erb"
-
-require "pacto/exceptions/invalid_contract.rb"
-require "pacto/extensions"
-require "pacto/request"
-require "pacto/response_adapter"
-require "pacto/response"
-require "pacto/instantiated_contract"
-require "pacto/contract"
-require "pacto/contract_factory"
-require "pacto/file_pre_processor"
+require 'pacto/version'
+
+require 'httparty'
+require 'hash_deep_merge'
+require 'multi_json'
+require 'json-schema'
+require 'json-generator'
+require 'webmock'
+require 'ostruct'
+require 'erb'
+require 'logger'
+
+require 'pacto/core/contract_repository'
+require 'pacto/core/configuration'
+require 'pacto/core/callback'
+require 'pacto/logger'
+require 'pacto/exceptions/invalid_contract.rb'
+require 'pacto/extensions'
+require 'pacto/request'
+require 'pacto/response_adapter'
+require 'pacto/response'
+require 'pacto/stubs/built_in'
+require 'pacto/contract'
+require 'pacto/contract_factory'
+require 'pacto/erb_processor'
+require 'pacto/hash_merge_processor'
+require 'pacto/stubs/built_in'
+require 'pacto/meta_schema'
+require 'pacto/hooks/erb_hook'
+require 'pacto/generator'
 
 module Pacto
-  def self.build_from_file(contract_path, host, file_pre_processor=FilePreProcessor.new)
-    ContractFactory.build_from_file(contract_path, host, file_pre_processor)
+  class << self
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def clear!
+      Pacto.configuration.provider.reset!
+      @configuration = nil
+      unregister_all!
+    end
+
+    def configure
+      yield(configuration)
+    end
   end
 
-  def self.register(name, contract)
-    raise ArgumentError, "contract \" #{name}\" has already been registered" if registered.has_key?(name)
-    registered[name] = contract
+  def self.validate_contract contract
+    Pacto::MetaSchema.new.validate contract
+    puts 'All contracts successfully meta-validated'
+    true
+  rescue InvalidContract => exception
+    puts 'Validation errors detected'
+    exception.errors.each do |error|
+      puts "  Error: #{error}"
+    end
+    false
   end
 
-  def self.use(contract_name, values = nil)
-    raise ArgumentError, "contract \"#{contract_name}\" not found" unless registered.has_key?(contract_name)
-    instantiated_contract = registered[contract_name].instantiate(values)
-    instantiated_contract.stub!
-    instantiated_contract
+  def self.build_from_file(contract_path, host, file_pre_processor = Pacto.configuration.preprocessor)
+    ContractFactory.build_from_file(contract_path, host, file_pre_processor)
   end
 
-  def self.registered
-    @registered ||= {}
+  def self.load(contract_name)
+    build_from_file(path_for(contract_name), nil)
   end
 
-  def self.unregister_all!
-    @registered = {}
+  private
+
+  def self.path_for(contract)
+    File.join(configuration.contracts_path, "#{contract}.json")
   end
 end

data/lib/pacto/contract.rb

@@ -1,22 +1,36 @@
 module Pacto
   class Contract
-    def initialize(request, response)
+    attr_reader :values
+    attr_reader :request, :response
+
+    def initialize(request, response, file = nil)
       @request = request
       @response = response
+      @file = file
+    end
+
+    def stub_contract! values = {}
+      @values = values
+      @stub = Pacto.configuration.provider.stub_request!(@request, stub_response) unless @request.nil?
     end
 
-    def instantiate(values = nil)
-      instantiated_contract = InstantiatedContract.new(@request, @response.instantiate)
-      instantiated_contract.replace!(values) unless values.nil?
-      instantiated_contract
+    def validate(response_gotten = provider_response, opt = {})
+      @response.validate(response_gotten, opt)
     end
 
-    def validate
-      response_gotten = @request.execute
-      if ENV["DEBUG_CONTRACTS"]
-        puts "[DEBUG] Response: #{response_gotten.inspect}"
-      end
-      @response.validate(response_gotten)
+    def matches? request_signature
+      @stub.matches? request_signature unless @stub.nil?
     end
+
+    private
+
+    def provider_response
+      @request.execute
+    end
+
+    def stub_response
+      @response.instantiate
+    end
+
   end
 end

data/lib/pacto/contract_factory.rb

@@ -1,50 +1,19 @@
 module Pacto
   class ContractFactory
-    def self.build_from_file(contract_path, host, file_pre_processor)
-      contract_definition_expanded = file_pre_processor.process(File.read(contract_path))
-      definition = JSON.parse(contract_definition_expanded)
-      validate_contract definition, contract_path
-      request = Request.new(host, definition["request"])
-      response = Response.new(definition["response"])
-      Contract.new(request, response)
-    end
-    
-    def self.validate_contract definition, contract_path
-      contract_format = {
-        type: "object",
-        required: true,
-        properties: {
-          request: {
-            type: "object",
-            required: true,
-            properties: {
-              method: {type: "string", required: true, pattern: "(GET)|(POST)|(PUT)|(DELETE)"},
-              path: {type: "string", required: true},
-              params: {type: "object", required: true},
-              headers: {type: "object", required: true}
-            }
-          },
-          response: {
-            type: "object",
-            required: true,
-            properties: {
-              status: {type: "integer", required: true},
-              headers: {type: "object", required: true},
-              body: {
-                type: "object",
-                required: false,
-                properties: {
-                  type: { type: "string", required: true, pattern: "(string)|(object)|(array)"}
-                }
-              }
-            }
-          }
-        }
-      }.to_json
-      errors = JSON::Validator.fully_validate(contract_format, definition)
-      unless errors.empty?
-        raise InvalidContract, errors.join("\n")
+    def self.build_from_file(contract_path, host, preprocessor)
+      contract_definition = File.read(contract_path)
+      if preprocessor
+        contract_definition = preprocessor.process(contract_definition)
       end
+      definition = JSON.parse(contract_definition)
+      schema.validate definition
+      request = Request.new(host, definition['request'])
+      response = Response.new(definition['response'])
+      Contract.new(request, response, contract_path)
+    end
+
+    def self.schema
+      @schema ||= MetaSchema.new
     end
   end
 end

data/lib/pacto/core/callback.rb

@@ -0,0 +1,11 @@
+module Pacto
+  class Callback
+    def initialize(&block)
+      @callback = block
+    end
+
+    def process(contracts, request_signature, response)
+      @callback.call contracts, request_signature, response
+    end
+  end
+end

data/lib/pacto/core/configuration.rb

@@ -0,0 +1,34 @@
+module Pacto
+  class Configuration
+    attr_accessor :preprocessor, :postprocessor, :provider, :strict_matchers, :contracts_path, :logger
+    attr_reader :callback
+
+    def initialize
+      @preprocessor = ERBProcessor.new
+      @postprocessor = HashMergeProcessor.new
+      @provider = Pacto::Stubs::BuiltIn.new
+      @strict_matchers = true
+      @contracts_path = nil
+      @logger = Logger.instance
+      if ENV['PACTO_DEBUG']
+        @logger.level = :debug
+      else
+        @logger.level = :default
+      end
+      @callback = Pacto::Hooks::ERBHook.new
+    end
+
+    def register_contract(contract = nil, *tags)
+      Pacto.register_contract(contract, *tags)
+    end
+
+    def register_callback(callback = nil, &block)
+      if block_given?
+        @callback = Pacto::Callback.new(&block)
+      else
+        raise 'Expected a Pacto::Callback' unless callback.is_a? Pacto::Callback
+        @callback = callback
+      end
+    end
+  end
+end

data/lib/pacto/core/contract_repository.rb

@@ -0,0 +1,44 @@
+module Pacto
+  class << self
+
+    def register_contract(contract = nil, *tags)
+      tags << :default if tags.empty?
+      start_count = registered.count
+      tags.uniq.each do |tag|
+        registered[tag] << contract
+      end
+      registered.count - start_count
+    end
+
+    def use(tag, values = {})
+      merged_contracts = registered[:default] + registered[tag]
+
+      raise ArgumentError, "contract \"#{tag}\" not found" if merged_contracts.empty?
+
+      merged_contracts.each do |contract|
+        contract.stub_contract! values
+      end
+      merged_contracts.count
+    end
+
+    def registered
+      @registered ||= Hash.new { |hash, key| hash[key] = Set.new }
+    end
+
+    def unregister_all!
+      registered.clear
+    end
+
+    def contract_for(request_signature)
+      matches = Set.new
+      registered.values.each do |contract_set|
+        contract_set.each do |contract|
+          if contract.matches? request_signature
+            matches.add contract
+          end
+        end
+      end
+      matches
+    end
+  end
+end

data/lib/pacto/erb_processor.rb

@@ -0,0 +1,18 @@
+module Pacto
+  class ERBProcessor
+    def process(contract, values = {})
+      values ||= {}
+      erb = ERB.new(contract)
+      erb_result = erb.result hash_binding(values)
+      Logger.instance.debug "Processed contract: #{erb_result.inspect}"
+      erb_result
+    end
+
+    private
+
+    def hash_binding(values)
+      namespace = OpenStruct.new(values)
+      namespace.instance_eval { binding }
+    end
+  end
+end

data/lib/pacto/exceptions/invalid_contract.rb

@@ -1,2 +1,11 @@
 class InvalidContract < ArgumentError
-end
+  attr_reader :errors
+
+  def initialize(errors)
+    @errors = errors
+  end
+
+  def message
+    @errors.join "\n"
+  end
+end

data/lib/pacto/extensions.rb

@@ -2,11 +2,11 @@ module Pacto
   module Extensions
     module HashSubsetOf
       def subset_of?(other)
-        (self.to_a - other.to_a).empty?
+        (to_a - other.to_a).empty?
       end
 
       def normalize_keys
-        self.inject({}) do |normalized, (key, value)|
+        inject({}) do |normalized, (key, value)|
           normalized[key.to_s.downcase] = value
           normalized
         end

data/lib/pacto/generator.rb

@@ -0,0 +1,75 @@
+require 'json/schema_generator'
+
+module Pacto
+  class Generator
+    attr_accessor :request_headers_to_filter
+    attr_accessor :response_headers_to_filter
+
+    INFORMATIONAL_REQUEST_HEADERS =
+    %w{
+      content-length
+      via
+    }
+
+    INFORMATIONAL_RESPONSE_HEADERS =
+    %w{
+      server
+      date
+      content-length
+      connection
+    }
+
+    def initialize(schema_version = 'draft3',
+      schema_generator = JSON::SchemaGenerator,
+      validator = Pacto::MetaSchema.new)
+      @schema_version = schema_version
+      @validator = validator
+      @schema_generator = schema_generator
+      @response_headers_to_filter = INFORMATIONAL_RESPONSE_HEADERS
+      @request_headers_to_filter = INFORMATIONAL_REQUEST_HEADERS
+    end
+
+    def generate(request_file, host)
+      contract = Pacto.build_from_file request_file, host
+      request = contract.request
+      response = request.execute
+      save(request_file, request, response)
+    end
+
+    def save(source, request, response)
+      body_schema = JSON::SchemaGenerator.generate source, response.body, @schema_version
+      contract = {
+        :request => {
+          :headers => filter_request_headers(request.headers),
+          :method => request.method,
+          :params => request.params,
+          :path => request.path
+        },
+        :response => {
+          :headers => filter_response_headers(response.headers),
+          :status => response.status,
+          :body => MultiJson.load(body_schema)
+        }
+      }
+      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 filter_request_headers headers
+      headers.reject do |header|
+        @request_headers_to_filter.include? header.downcase
+      end
+    end
+
+    def filter_response_headers headers
+      headers.reject do |header|
+        @response_headers_to_filter.include? header.downcase
+      end
+    end
+  end
+end

data/lib/pacto/hash_merge_processor.rb

@@ -0,0 +1,14 @@
+module Pacto
+  class HashMergeProcessor
+    def process(response_body, values = {})
+      unless values.nil? || values.empty?
+        if response_body.respond_to?(:normalize_keys)
+          response_body = response_body.normalize_keys.deep_merge(values.normalize_keys)
+        else
+          response_body = values
+        end
+      end
+      response_body.to_s
+    end
+  end
+end