pacto 0.3.1 → 0.4.0.rc1

data/lib/pacto/provider.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  def self.providers
+    @providers ||= {}
+  end
+
+  class Provider
+    include Resettable
+
+    def self.reset!
+      Pacto.providers.clear
+    end
+
+    def actor
+      @actor ||= Pacto::Actors::FromExamples.new
+    end
+
+    def actor=(actor)
+      fail ArgumentError, 'The actor must respond to :build_response' unless actor.respond_to? :build_response
+      @actor = actor
+    end
+
+    def response_for(contract, data = {})
+      actor.build_response contract, data
+    end
+  end
+end

data/lib/pacto/rake_task.rb

@@ -1,13 +1,25 @@
+# -*- encoding : utf-8 -*-
 require 'pacto'
+require 'thor'
+require 'pacto/cli'
+require 'pacto/cli/helpers'
 
 # FIXME: RakeTask is a huge class, refactor this please
 # rubocop:disable ClassLength
 module Pacto
   class RakeTask
+    extend Forwardable
+    include Thor::Actions
     include Rake::DSL
+    include Pacto::CLI::Helpers
 
     def initialize
       @exit_with_error = false
+      @cli = Pacto::CLI::Main.new
+    end
+
+    def run(task, args, opts = {})
+      Pacto::CLI::Main.new([], opts).public_send(task, *args)
     end
 
     def install
@@ -21,86 +33,44 @@ module Pacto
 
     def validate_task
       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 Pacto::UI.yellow('USAGE: rake pacto:validate[<host>, <contract_dir>]')
-        end
-
-        validate_contracts(args[:host], args[:dir])
+      task :validate, :host, :dir do |_t, args|
+        opts = args.to_hash
+        dir = opts.delete :dir
+        run(:validate, dir, opts)
       end
     end
 
     def generate_task
       desc 'Generates contracts from partial contracts'
-      task :generate, :input_dir, :output_dir, :host do |t, args|
+      task :generate, :input_dir, :output_dir, :host do |_t, args|
         if args.to_a.size < 3
-          fail Pacto::UI.yellow('USAGE: rake pacto:generate[<request_contract_dir>, <output_dir>, <record_host>]')
+          fail Pacto::UI.colorize('USAGE: rake pacto:generate[<request_contract_dir>, <output_dir>, <record_host>]', :yellow)
         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 Pacto::UI.yellow('USAGE: rake pacto:meta_validate[<contract_dir>]')
-        end
-
-        each_contract(args[:dir]) do |contract_file|
-          fail unless Pacto.validate_contract contract_file
-        end
-        puts 'All contracts successfully meta-validated'
+      task :meta_validate, :dir do |_t, args|
+        run(:meta_validate, *args)
       end
     end
 
-    def validate_contracts(host, dir)
-      WebMock.allow_net_connect!
-      puts "Validating contracts in directory #{dir} against host #{host}\n\n"
-
-      total_failed = 0
-      contracts = []
-      each_contract(dir) do |contract_file|
-        contracts << contract_file
-        print "#{contract_file.split('/').last}:"
-        contract = Pacto.load_contract(contract_file, host)
-        errors = contract.validate_provider
-
-        if errors.empty?
-          puts Pacto::UI.green(' OK!')
-        else
-          @exit_with_error = true
-          total_failed += 1
-          puts Pacto::UI.red(' FAILED!')
-          errors.each do |error|
-            puts Pacto::UI.red("\t* #{error}")
-          end
-          puts ''
-        end
-      end
-
-      if @exit_with_error
-        fail Pacto::UI.red("#{total_failed} of #{contracts.size} failed. Check output for detailed error messages.")
-      else
-        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
+      generator = Pacto::Generator.contract_generator
       puts "Generating contracts from partial contracts in #{input_dir} and recording to #{output_dir}\n\n"
 
       failed_contracts = []
       each_contract(input_dir) do |contract_file|
         begin
-          contract = generator.generate(contract_file, host)
+          contract = generator.generate_from_partial_contract(contract_file, host)
           output_file = File.expand_path(File.basename(contract_file), output_dir)
           output_file = File.open(output_file, 'wb')
           output_file.write contract
@@ -108,32 +78,17 @@ module Pacto
           output_file.close
         rescue InvalidContract => e
           failed_contracts << contract_file
-          puts Pacto::UI.red(e.message)
+          puts Pacto::UI.colorize(e.message, :red)
         end
       end
 
       if failed_contracts.empty?
-        puts Pacto::UI.green('Successfully generated all contracts')
+        puts Pacto::UI.colorize('Successfully generated all contracts', :green)
       else
-        fail Pacto::UI.red("The following contracts could not be generated: #{failed_contracts.join ','}")
+        fail Pacto::UI.colorize("The following contracts could not be generated: #{failed_contracts.join ','}", :red)
       end
     end
     # rubocop:enable MethodLength
-
-    private
-
-    def each_contract(dir)
-      if File.file? dir
-        yield dir
-      else
-        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
-        end
-      end
-    end
   end
 end
 # rubocop:enable ClassLength

data/lib/pacto/request_clause.rb

@@ -1,43 +1,45 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  class RequestClause
-    attr_reader :host, :method, :schema
-    attr_accessor :body
+  class RequestClause < Pacto::Dash
+    include Logger
+    property :host # required?
+    property :http_method, required: true
+    property :schema, default: {}
+    property :path, default: '/'
+    property :headers
+    property :params, default: {}
+    property :request_pattern_provider, default: Pacto::RequestPattern
 
-    def initialize(host, definition)
-      @host = host
-      @definition = definition
-      @method = definition['method'].to_s.downcase.to_sym
-      @schema = definition['body'] || {}
+    def initialize(definition)
+      mash = Hashie::Mash.new definition
+      mash['http_method'] = normalize(mash['http_method'])
+      super mash
     end
 
-    def uri
-      @uri ||= Pacto::URI.for(host, path, params)
+    def http_method=(method)
+      normalize(method)
     end
 
-    def body
-      JSON::Generator.generate(@definition['body']) if @definition['body']
+    def pattern
+      @pattern ||= request_pattern_provider.for(self)
     end
 
-    def path
-      @definition['path']
-    end
-
-    def headers
-      @definition['headers']
+    def uri(values = {})
+      values ||= {}
+      uri_template = pattern.uri_template
+      missing_keys = uri_template.keys - values.keys
+      values[:scheme] = 'http' if missing_keys.delete(:scheme)
+      values[:server] = 'localhost' if missing_keys.delete(:server)
+      logger.warn "Missing keys for building a complete URL: #{missing_keys.inspect}" unless missing_keys.empty?
+      Addressable::URI.heuristic_parse(uri_template.expand(values)).tap do |uri|
+        uri.query_values = params unless params.nil? || params.empty?
+      end
     end
 
-    def params
-      @definition['params'] || {}
-    end
+    private
 
-    def execute
-      conn = Faraday.new(:url => uri.to_s) do |faraday|
-        faraday.response :logger if Pacto.configuration.logger.level == :debug
-        faraday.adapter  Faraday.default_adapter
-      end
-      conn.send(method) do |req|
-        req.headers = headers
-      end
+    def normalize(method)
+      method.to_s.downcase.to_sym
     end
   end
 end

data/lib/pacto/request_pattern.rb

@@ -1,8 +1,25 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  class RequestPattern
+  class RequestPattern < WebMock::RequestPattern
+    attr_accessor :uri_template
+
     def self.for(base_request)
-      uri_pattern = UriPattern.for(base_request)
-      WebMock::RequestPattern.new(base_request.method, uri_pattern)
+      new(base_request.http_method, UriPattern.for(base_request))
+    end
+
+    def initialize(http_method, uri_template)
+      @uri_template = uri_template
+      super
+    end
+
+    def to_s
+      string = Pacto::UI.colorize_method(@method_pattern.to_s)
+      string << " #{@uri_pattern}"
+      # WebMock includes this info, but I don't think we should. Pacto should match on URIs only and then validate the rest...
+      # string << " with body #{@body_pattern.to_s}" if @body_pattern
+      # string << " with headers #{@headers_pattern.to_s}" if @headers_pattern
+      # string << " with given block" if @with_block
+      string
     end
   end
 end

data/lib/pacto/resettable.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  # Included this module so that Pacto::Resettable.reset_all will call your class/module's self.reset! method.
+  module Resettable
+    def self.resettables
+      @resettables ||= []
+    end
+
+    def self.extended(base)
+      resettables << base
+    end
+
+    def self.included(base)
+      resettables << base
+    end
+
+    def self.reset_all
+      resettables.each(&:reset!)
+      true
+    end
+  end
+end

data/lib/pacto/response_clause.rb

@@ -1,15 +1,8 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  class ResponseClause
-    attr_reader :status, :headers, :schema
-
-    def initialize(definition)
-      @status = definition['status']
-      @headers = definition['headers']
-      @schema = definition['body'] || {}
-    end
-
-    def body
-      @body ||= JSON::Generator.generate(schema)
-    end
+  class ResponseClause < Pacto::Dash
+    property :status
+    property :headers, default: {}
+    property :schema, default: {}
   end
 end

data/lib/pacto/rspec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'pacto'
 
 begin
@@ -7,40 +8,44 @@ rescue LoadError
   raise 'pacto/rspec requires rspec 2 or later'
 end
 
-RSpec::Matchers.define :have_unmatched_requests do |method, uri|
-  @unmatched_validations = Pacto::ValidationRegistry.instance.unmatched_validations
+require 'pacto/forensics/investigation_filter'
+require 'pacto/forensics/investigation_matcher'
+
+RSpec::Matchers.define :have_unmatched_requests do |_method, _uri|
   match do
-    !@unmatched_validations.empty?
+    @unmatched_investigations = Pacto::InvestigationRegistry.instance.unmatched_investigations
+    !@unmatched_investigations.empty?
   end
 
-  failure_message_for_should do
+  failure_message do
     'Expected Pacto to have not matched all requests to a Contract, but all requests were matched.'
   end
 
-  failure_message_for_should_not do
-    unmatched_requests = @unmatched_validations.map(&:request).join("\n  ")
+  failure_message_when_negated do
+    unmatched_requests = @unmatched_investigations.map(&:request).join("\n  ")
     "Expected Pacto to have matched all requests to a Contract, but the following requests were not matched: \n  #{unmatched_requests}"
   end
 end
 
-RSpec::Matchers.define :have_failed_validations do |method, uri|
-  @failed_validations = Pacto::ValidationRegistry.instance.failed_validations
+RSpec::Matchers.define :have_failed_investigations do |_method, _uri|
   match do
-    !@failed_validations.empty?
+    @failed_investigations = Pacto::InvestigationRegistry.instance.failed_investigations
+    !@failed_investigations.empty?
   end
 
-  failure_message_for_should do
-    'Expected Pacto to have found validation problems, but none were found.'
+  failure_message do
+    'Expected Pacto to have found investigation problems, but none were found.'
   end
 
-  failure_message_for_should_not do
-    "Expected Pacto to have successfully validated all requests, but the following issues were found: #{@failed_validations}"
+  failure_message_when_negated do
+    "Expected Pacto to have successfully validated all requests, but the following issues were found: #{@failed_investigations}"
   end
 end
 
 RSpec::Matchers.define :have_validated do |method, uri|
-  @request_pattern = WebMock::RequestPattern.new(method, uri)
   match do
+    @request_pattern = Pacto::RequestPattern.new(method, uri)
+    @request_pattern.with(@options) if @options
     validated? @request_pattern
   end
 
@@ -49,51 +54,53 @@ RSpec::Matchers.define :have_validated do |method, uri|
   end
 
   chain :with do |options|
-    @request_pattern.with options
+    @options = options
   end
 
-  def validated?(request_pattern)
-    @matching_validations = Pacto::ValidationRegistry.instance.validated? @request_pattern
-    validated = !@matching_validations.nil?
+  def validated?(_request_pattern)
+    @matching_investigations = Pacto::InvestigationRegistry.instance.validated? @request_pattern
+    validated = !@matching_investigations.nil?
     validated && successfully? && contract_matches?
   end
 
-  def validation_results
-    @validation_results ||= @matching_validations.map(&:results).flatten.compact
+  def investigation_citations
+    @investigation_citations ||= @matching_investigations.map(&:citations).flatten.compact
   end
 
   def successfully?
-    @matching_validations.map(&:successful?).uniq.eql? [true]
+    @matching_investigations.map(&:successful?).uniq.eql? [true]
   end
 
   def contract_matches?
     if @contract
-      validated_contracts = @matching_validations.map(&:contract)
+      validated_contracts = @matching_investigations.map(&:contract).compact
       # Is there a better option than case equality for string & regex support?
-      validated_contracts.map(&:file).index { |file| @contract === file } # rubocop:disable CaseEquality
+      validated_contracts.any? do |contract|
+        @contract === contract.file || @contract === contract.name # rubocop:disable CaseEquality
+      end
     else
       true
     end
   end
 
-  failure_message_for_should do
+  failure_message do
     buffer = StringIO.new
     buffer.puts "expected Pacto to have validated #{@request_pattern}"
-    if @matching_validations.nil? || @matching_validations.empty?
+    if @matching_investigations.nil? || @matching_investigations.empty?
       buffer.puts '  but no matching request was received'
       buffer.puts '    received:'
       buffer.puts "#{WebMock::RequestRegistry.instance}"
-    elsif @matching_validations.map(&:contract).compact.empty?
+    elsif @matching_investigations.map(&:contract).compact.empty?
       buffer.puts '  but a matching Contract was not found'
     elsif !successfully?
-      buffer.puts '  but validation errors were found:'
+      buffer.puts '  but investigation errors were found:'
       buffer.print '    '
-      buffer.puts validation_results.join "\n    "
-      # validation_results.each do |validation_result|
-      #   buffer.puts "    #{validation_result}"
+      buffer.puts investigation_citations.join "\n    "
+      # investigation_citations.each do |investigation_result|
+      #   buffer.puts "    #{investigation_result}"
       # end
     elsif @contract
-      validated_against = @matching_validations.map { |v| v.against_contract?  @contract }.compact.join ','
+      validated_against = @matching_investigations.map { |v| v.against_contract? @contract }.compact.join ','
       buffer.puts "  against Contract #{@contract}"
       buffer.puts "    but it was validated against #{validated_against}"
     end