pacto 0.3.0.pre → 0.3.0

data/lib/pacto/core/contract_registry.rb

@@ -0,0 +1,43 @@
+module Pacto
+  class ContractRegistry
+    def initialize
+      @registry = Hash.new { |hash, key| hash[key] = Set.new }
+    end
+
+    def [](tag)
+      @registry[tag]
+    end
+
+    def register(contract, *tags)
+      tags << :default if tags.empty?
+
+      tags.each do |tag|
+        @registry[tag] << contract
+      end
+
+      self
+    end
+
+    def use(tag, values = {})
+      merged_contracts = @registry[:default] + @registry[tag]
+
+      fail ArgumentError, "contract \"#{tag}\" not found" if merged_contracts.empty?
+
+      merged_contracts.each do |contract|
+        contract.stub_contract! values
+      end
+
+      self
+    end
+
+    def contracts_for(request_signature)
+      all_contracts.select { |c| c.matches? request_signature }
+    end
+
+    private
+
+    def all_contracts
+      @registry.values.inject(Set.new, :+)
+    end
+  end
+end

data/lib/pacto/core/{callback.rb → hook.rb}

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

data/lib/pacto/core/modes.rb

@@ -0,0 +1,33 @@
+module Pacto
+  class << self
+    def generate!
+      modes << :generate
+    end
+
+    def stop_generating!
+      modes.delete :generate
+    end
+
+    def generating?
+      modes.include? :generate
+    end
+
+    def validate!
+      modes << :validate
+    end
+
+    def stop_validating!
+      modes.delete :validate
+    end
+
+    def validating?
+      modes.include? :validate
+    end
+
+    private
+
+    def modes
+      @modes ||= []
+    end
+  end
+end

data/lib/pacto/core/validation_registry.rb

@@ -0,0 +1,45 @@
+module Pacto
+  class ValidationRegistry
+    include Singleton
+    attr_reader :validations
+
+    def initialize
+      @validations = []
+    end
+
+    def reset!
+      @validations.clear
+    end
+
+    def validated?(request_pattern)
+      matched_validations = @validations.select do |validation|
+        request_pattern.matches? validation.request
+      end
+      matched_validations unless matched_validations.empty?
+    end
+
+    def register_validation(validation)
+      @validations << validation
+      logger.info "Detected #{validation.summary}"
+      validation
+    end
+
+    def unmatched_validations
+      @validations.select do |validation|
+        validation.contract.nil?
+      end
+    end
+
+    def failed_validations
+      @validations.select do |validation|
+        !validation.successful?
+      end
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.instance
+    end
+  end
+end

data/lib/pacto/erb_processor.rb

@@ -1,7 +1,6 @@
 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}"

data/lib/pacto/extensions.rb

@@ -1,12 +1,25 @@
 module Pacto
   module Extensions
-    module HashSubsetOf
-      def subset_of?(other)
-        (to_a - other.to_a).empty?
+    # Adapted from Faraday
+    HeaderKeyMap = Hash.new do |map, key|
+      split_char = key.to_s.include?('-') ? '-' : '_'
+      map[key] = key.to_s.split(split_char).     # :user_agent => %w(user agent)
+          each { |w| w.capitalize! }.   # => %w(User Agent)
+          join('-')                     # => "User-Agent"
+    end
+    HeaderKeyMap[:etag] = 'ETag'
+
+    def self.normalize_header_keys(headers)
+      headers.reduce({}) do |normalized, (key, value)|
+        normalized[HeaderKeyMap[key]] = value
+        normalized
       end
+    end
 
+    module HashSubsetOf
+      # FIXME: Only used by HashMergeProcessor, which I'd like to deprecate
       def normalize_keys
-        inject({}) do |normalized, (key, value)|
+        reduce({}) do |normalized, (key, value)|
           normalized[key.to_s.downcase] = value
           normalized
         end
@@ -15,4 +28,5 @@ module Pacto
   end
 end
 
+# FIXME: Let's not extend Hash...
 Hash.send(:include, Pacto::Extensions::HashSubsetOf)

data/lib/pacto/generator.rb

@@ -2,73 +2,58 @@ 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)
+      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
-      @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)
+      @generator_options = generator_options
+      @filters = filters
     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)
-        }
-      }
+      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/, ''
+      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
+    def generate_contract(source, request, response)
+      {
+        :request => generate_request(request, response, source),
+        :response => generate_response(request, response, source)
+      }
+    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
+
+    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 filter_response_headers headers
-      headers.reject do |header|
-        @response_headers_to_filter.include? header.downcase
+    def generate_body(source, body)
+      if body && !body.empty?
+        body_schema = JSON::SchemaGenerator.generate source, body, @generator_options
+        MultiJson.load(body_schema)
       end
     end
   end

data/lib/pacto/generator/filters.rb

@@ -0,0 +1,41 @@
+module Pacto
+  class Generator
+    class Filters
+      CONNECTION_CONTROL_HEADERS = %w{
+        Via
+        Server
+        Connection
+        Transfer-Encoding
+        Content-Length
+      }
+
+      FRESHNESS_HEADERS =
+      %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 = [vary_headers] if vary_headers.is_a? String
+        vary_headers = vary_headers.map do |h|
+          h.split(',').map(&:strip)
+        end.flatten
+
+        request.headers.select do |header|
+          vary_headers.map(&:downcase).include? header.downcase
+        end
+      end
+
+      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
+      end
+    end
+  end
+end

data/lib/pacto/hooks/erb_hook.rb

@@ -1,17 +1,18 @@
+require_relative '../erb_processor'
+
 module Pacto
   module Hooks
-    class ERBHook < Pacto::Callback
+    class ERBHook < Pacto::Hook
       def initialize
         @processor = ERBProcessor.new
       end
 
       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
-
     end
   end
 end

data/lib/pacto/logger.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Pacto
   class Logger
     include Singleton
@@ -9,13 +11,13 @@ module Pacto
       log ::Logger.new STDOUT
     end
 
-    def log log
+    def log(log)
       @log = log
       @log.level = default_level
       @log.progname = 'Pacto'
     end
 
-    def level= level
+    def level=(level)
       @log.level = log_levels.fetch(level, default_level)
     end
 

data/lib/pacto/meta_schema.rb

@@ -4,13 +4,15 @@ module Pacto
 
     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)
       @engine = engine
     end
 
-    def validate definition
+    def validate(definition)
       errors = engine.fully_validate(schema, definition, :version => :draft3)
       unless errors.empty?
-        raise InvalidContract.new(errors)
+        fail InvalidContract, errors
       end
     end
   end

data/lib/pacto/rake_task.rb

@@ -1,13 +1,7 @@
 require 'pacto'
 
-unless String.respond_to?(:colors)
-  class String
-    def colorize(*args)
-      self
-    end
-  end
-end
-
+# FIXME: RakeTask is a huge class, refactor this please
+# rubocop:disable ClassLength
 module Pacto
   class RakeTask
     include Rake::DSL
@@ -29,7 +23,7 @@ module Pacto
       desc 'Validates all contracts in a given directory against a given host'
       task :validate, :host, :dir do |t, args|
         if args.to_a.size < 2
-          fail 'USAGE: rake pacto:validate[<host>, <contract_dir>]'.colorize(:yellow)
+          fail Pacto::UI.yellow('USAGE: rake pacto:validate[<host>, <contract_dir>]')
         end
 
         validate_contracts(args[:host], args[:dir])
@@ -40,24 +34,26 @@ module Pacto
       desc 'Generates contracts from partial contracts'
       task :generate, :input_dir, :output_dir, :host do |t, args|
         if args.to_a.size < 3
-          fail 'USAGE: rake pacto:generate[<request_contract_dir>, <output_dir>, <record_host>]'.colorize(:yellow)
+          fail Pacto::UI.yellow('USAGE: rake pacto:generate[<request_contract_dir>, <output_dir>, <record_host>]')
         end
 
         generate_contracts(args[:input_dir], args[:output_dir], args[:host])
       end
     end
 
+    # FIXME: meta_validate is a big method =(. Needs refactoring
+    # rubocop:disable MethodLength
     def meta_validate
       desc 'Validates a directory of contract definitions'
       task :meta_validate, :dir do |t, args|
         if args.to_a.size < 1
-          fail 'USAGE: rake pacto:meta_validate[<contract_dir>]'.colorize(:yellow)
+          fail Pacto::UI.yellow('USAGE: rake pacto:meta_validate[<contract_dir>]')
         end
 
         each_contract(args[:dir]) do |contract_file|
-          puts "Validating #{contract_file}"
           fail unless Pacto.validate_contract contract_file
         end
+        puts 'All contracts successfully meta-validated'
       end
     end
 
@@ -66,31 +62,36 @@ module Pacto
       puts "Validating contracts in directory #{dir} against host #{host}\n\n"
 
       total_failed = 0
-      each_contract(dir) do |contact_file|
+      contracts = []
+      each_contract(dir) do |contract_file|
+        contracts << contract_file
         print "#{contract_file.split('/').last}:"
-        contract = Pacto.build_from_file(contract_file, host)
-        errors = contract.validate
+        contract = Pacto.load_contract(contract_file, host)
+        errors = contract.validate_provider
 
         if errors.empty?
-          puts ' OK!'.colorize(:green)
+          puts Pacto::UI.green(' OK!')
         else
           @exit_with_error = true
           total_failed += 1
-          puts ' FAILED!'.colorize(:red)
+          puts Pacto::UI.red(' FAILED!')
           errors.each do |error|
-            puts "\t* #{error}".colorize(:light_red)
+            puts Pacto::UI.red("\t* #{error}")
           end
           puts ''
         end
       end
 
       if @exit_with_error
-        fail "#{total_failed} of #{contracts.size} failed. Check output for detailed error messages.".colorize(:red)
+        fail Pacto::UI.red("#{total_failed} of #{contracts.size} failed. Check output for detailed error messages.")
       else
-        puts "#{contracts.size} valid contract#{contracts.size > 1 ? 's' : nil}".colorize(:green)
+        puts Pacto::UI.green("#{contracts.size} valid contract#{contracts.size > 1 ? 's' : nil}")
       end
     end
+    # rubocop:enable MethodLength
 
+    # FIXME: generate_contracts is a big method =(. Needs refactoring
+    # rubocop:disable MethodLength
     def generate_contracts(input_dir, output_dir, host)
       WebMock.allow_net_connect!
       generator = Pacto::Generator.new
@@ -107,16 +108,17 @@ module Pacto
           output_file.close
         rescue InvalidContract => e
           failed_contracts << contract_file
-          puts e.message.colorize(:red)
+          puts Pacto::UI.red(e.message)
         end
       end
 
       if failed_contracts.empty?
-        puts 'Successfully generated all contracts'.colorize(:green)
+        puts Pacto::UI.green('Successfully generated all contracts')
       else
-        fail "The following contracts could not be generated: #{failed_contracts.join ','}".colorize(:red)
+        fail Pacto::UI.red("The following contracts could not be generated: #{failed_contracts.join ','}")
       end
     end
+    # rubocop:enable MethodLength
 
     private
 
@@ -124,8 +126,8 @@ module Pacto
       if File.file? dir
         yield dir
       else
-        contracts = Dir[File.join(dir, '*{.json.erb,.json}')]
-        fail "No contracts found in directory #{dir}".colorize(:yellow) if contracts.empty?
+        contracts = Dir[File.join(dir, '**/*{.json.erb,.json}')]
+        fail Pacto::UI.yellow("No contracts found in directory #{dir}") if contracts.empty?
 
         contracts.sort.each do |contract_file|
           yield contract_file
@@ -134,5 +136,6 @@ module Pacto
     end
   end
 end
+# rubocop:enable ClassLength
 
 Pacto::RakeTask.new.install