pacto 0.3.1 → 0.4.0.rc1

data/features/validate/validation.feature

@@ -7,7 +7,7 @@ Feature: Validation
       """
           {
           "request": {
-            "method": "GET",
+            "http_method": "GET",
             "path": "/hello",
             "headers": { "Accept": "application/json" },
             "params": {}
@@ -16,7 +16,7 @@ Feature: Validation
           "response": {
             "status": 200,
             "headers": { "Content-Type": "application/json" },
-            "body": {
+            "schema": {
               "description": "A simple response",
               "type": "object",
               "properties": {
@@ -27,10 +27,9 @@ Feature: Validation
         }
       """
       When I successfully run `bundle exec rake pacto:validate['http://localhost:8000','tmp/aruba/contracts/simple_contract.json']`
-      Then the output should contain:
+      Then the stdout should contain:
         """"
-        Validating contracts in directory tmp/aruba/contracts/simple_contract.json against host http://localhost:8000
-
-        simple_contract.json: OK!
+        Validating contracts against host http://localhost:8000
+                 OK!  simple_contract.json
         1 valid contract
         """

data/lib/pacto.rb

@@ -1,9 +1,10 @@
+# -*- encoding : utf-8 -*-
 require 'pacto/version'
 
 require 'addressable/template'
+require 'swagger'
 require 'middleware'
 require 'faraday'
-require 'hash_deep_merge'
 require 'multi_json'
 require 'json-schema'
 require 'json-generator'
@@ -12,45 +13,53 @@ require 'ostruct'
 require 'erb'
 require 'logger'
 
+require 'pacto/dash'
+require 'pacto/resettable'
+require 'pacto/exceptions/invalid_contract.rb'
 require 'pacto/logger'
 require 'pacto/ui'
+require 'pacto/request_pattern'
+require 'pacto/core/http_middleware'
+require 'pacto/consumer/faraday_driver'
+require 'pacto/actor'
+require 'pacto/consumer'
+require 'pacto/provider'
+require 'pacto/actors/json_generator'
+require 'pacto/actors/from_examples'
+require 'pacto/core/pacto_request'
+require 'pacto/core/pacto_response'
 require 'pacto/core/contract_registry'
-require 'pacto/core/validation_registry'
+require 'pacto/core/investigation_registry'
 require 'pacto/core/configuration'
 require 'pacto/core/modes'
 require 'pacto/core/hook'
-require 'pacto/exceptions/invalid_contract.rb'
 require 'pacto/extensions'
 require 'pacto/request_clause'
 require 'pacto/response_clause'
 require 'pacto/stubs/webmock_adapter'
 require 'pacto/stubs/uri_pattern'
 require 'pacto/contract'
-require 'pacto/contract_validator'
-require 'pacto/contract_factory'
-require 'pacto/validation'
+require 'pacto/cops'
 require 'pacto/meta_schema'
+require 'pacto/contract_factory'
+require 'pacto/investigation'
 require 'pacto/hooks/erb_hook'
+require 'pacto/observers/stenographer'
 require 'pacto/generator'
 require 'pacto/generator/filters'
 require 'pacto/contract_files'
-require 'pacto/contract_list'
-require 'pacto/request_pattern'
+require 'pacto/contract_set'
 require 'pacto/uri'
 
-# Validators
-require 'pacto/validators/body_validator'
-require 'pacto/validators/request_body_validator'
-require 'pacto/validators/response_body_validator'
-require 'pacto/validators/response_status_validator'
-require 'pacto/validators/response_header_validator'
+# Cops
+require 'pacto/cops/body_cop'
+require 'pacto/cops/request_body_cop'
+require 'pacto/cops/response_body_cop'
+require 'pacto/cops/response_status_cop'
+require 'pacto/cops/response_header_cop'
 
 module Pacto
   class << self
-    def contract_factory
-      @factory = ContractFactory.new
-    end
-
     def configuration
       @configuration ||= Configuration.new
     end
@@ -59,12 +68,18 @@ module Pacto
       @registry ||= ContractRegistry.new
     end
 
+    # Resets data and metrics only. It usually makes sense to call this between test scenarios.
+    def reset
+      Pacto::InvestigationRegistry.instance.reset!
+      # Pacto::Resettable.reset_all
+    end
+
+    # Resets but also clears configuration, loaded contracts, and plugins.
     def clear!
-      Pacto.configuration.provider.reset!
+      Pacto::Resettable.reset_all
       @modes = nil
       @configuration = nil
       @registry = nil
-      Pacto::ValidationRegistry.instance.reset!
     end
 
     def configure
@@ -75,29 +90,22 @@ module Pacto
       contract_registry.contracts_for(request_signature)
     end
 
+    # @throws Pacto::InvalidContract
     def validate_contract(contract)
       Pacto::MetaSchema.new.validate contract
-      puts "Validating #{contract}"
       true
-    rescue InvalidContract => exception
-      puts 'Validation errors detected'
-      exception.errors.each do |error|
-        puts "  Error: #{error}"
-      end
-      false
     end
 
-    def load_contract(contract_path, host)
-      load_contracts(contract_path, host).contracts.first
+    def load_contract(contract_path, host, format = :default)
+      load_contracts(contract_path, host, format).first
     end
 
-    def load_contracts(contracts_path, host)
-      files = ContractFiles.for(contracts_path)
-      contracts = contract_factory.build(files, host)
+    def load_contracts(contracts_path, host, format = :default)
+      contracts = ContractFactory.load_contracts(contracts_path, host, format)
       contracts.each do |contract|
         contract_registry.register(contract)
       end
-      ContractList.new(contracts)
+      ContractSet.new(contracts)
     end
   end
 end

data/lib/pacto/actor.rb

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  class Actor
+  end
+end

data/lib/pacto/actors/from_examples.rb

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Actors
+    class FirstExampleSelector
+      def self.select(examples, _values)
+        Hashie::Mash.new examples.values.first
+      end
+    end
+    class RandomExampleSelector
+      def self.select(examples, _values)
+        Hashie::Mash.new examples.values.sample
+      end
+    end
+    class NamedExampleSelector
+      def self.select(examples, values)
+        name = values[:example_name]
+        if name.nil?
+          RandomExampleSelector.select(examples, values)
+        else
+          Hashie::Mash.new examples[name]
+        end
+      end
+    end
+    class FromExamples < Actor
+      def initialize(fallback_actor = JSONGenerator.new, selector = Pacto::Actors::FirstExampleSelector)
+        @fallback_actor = fallback_actor
+        @selector = selector
+      end
+
+      def build_request(contract, values = {})
+        request_values = (values || {}).dup
+        if contract.examples?
+          example = @selector.select(contract.examples, values)
+          data = contract.request.to_hash
+          request_values.merge! example_uri_values(contract)
+          data['uri'] = contract.request.uri(request_values)
+          data['body'] = example.request.body
+          data['method'] = contract.request.http_method
+          Pacto::PactoRequest.new(data)
+        else
+          @fallback_actor.build_request contract, values
+        end
+      end
+
+      def build_response(contract, values = {})
+        if contract.examples?
+          example = @selector.select(contract.examples, values)
+          data = contract.response.to_hash
+          data['body'] = example.response.body
+          Pacto::PactoResponse.new(data)
+        else
+          @fallback_actor.build_response contract, values
+        end
+      end
+
+      def example_uri_values(contract)
+        uri_template = contract.request.pattern.uri_template
+        if contract.examples && contract.examples.values.first[:request][:uri]
+          example_uri = contract.examples.values.first[:request][:uri]
+          uri_template.extract example_uri
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/pacto/actors/json_generator.rb

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Actors
+    class JSONGenerator < Actor
+      def build_request(contract, values = {})
+        data = contract.request.to_hash
+        data['uri'] = contract.request.uri(values)
+        data['body'] = JSON::Generator.generate(data['schema'])
+        data['method'] = contract.request.http_method
+        Pacto::PactoRequest.new(data)
+      end
+
+      def build_response(contract, _values = {})
+        data = contract.response.to_hash
+        data['body'] = JSON::Generator.generate(data['schema'])
+        Pacto::PactoResponse.new(data)
+      end
+    end
+  end
+end

data/lib/pacto/cli.rb

@@ -0,0 +1,75 @@
+require 'thor'
+require 'pacto'
+require 'pacto/cli/helpers'
+
+module Pacto
+  module CLI
+    class Main < Thor
+      include Pacto::CLI::Helpers
+
+      desc 'meta_validate [CONTRACTS...]', 'Validates a directory of contract definitions'
+      def meta_validate(*contracts)
+        invalid = []
+        each_contract(*contracts) do |contract_file|
+          begin
+            Pacto.validate_contract(contract_file)
+            say_status :validated, contract_file
+          rescue InvalidContract => exception
+            invalid << contract_file
+            shell.say_status :invalid, contract_file, :red
+            exception.errors.each do |error|
+              say set_color("  Error: #{error}", :red)
+            end
+          end
+        end
+        abort "The following contracts were invalid: #{invalid.join(',')}" unless invalid.empty?
+        say 'All contracts successfully meta-validated'
+      end
+
+      desc 'validate [CONTRACTS...]', 'Validates all contracts in a given directory against a given host'
+      method_option :host, type: :string, desc: 'Override host in contracts for validation'
+      def validate(*contracts)
+        host = options[:host]
+        WebMock.allow_net_connect!
+        banner = 'Validating contracts'
+        banner << " against host #{host}" unless host.nil?
+        say banner
+
+        invalid_contracts = []
+        tested_contracts = []
+        each_contract(*contracts) do |contract_file|
+          tested_contracts << contract_file
+          invalid_contracts << contract_file unless contract_is_valid?(contract_file, host)
+        end
+
+        validation_summary(tested_contracts, invalid_contracts)
+      end
+
+      private
+
+      def validation_summary(contracts, invalid_contracts)
+        if invalid_contracts.empty?
+          say set_color("#{contracts.size} valid contract#{contracts.size > 1 ? 's' : nil}", :green)
+        else
+          abort set_color("#{invalid_contracts.size} of #{contracts.size} failed. Check output for detailed error messages.", :red)
+        end
+      end
+
+      def contract_is_valid?(contract_file, host)
+        name = File.split(contract_file).last
+        contract = Pacto.load_contract(contract_file, host)
+        investigation = contract.simulate_request
+
+        if investigation.successful?
+          say_status 'OK!', name
+          true
+        else
+          say_status 'FAILED!', name, :red
+          say set_color(investigation.summary, :red)
+          say set_color(investigation.to_s, :red)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/pacto/cli/helpers.rb

@@ -0,0 +1,20 @@
+module Pacto
+  module CLI
+    module Helpers
+      def each_contract(*contracts)
+        [*contracts].each do |contract|
+          if File.file? contract
+            yield contract
+          else # Should we assume it's a dir, or also support glob patterns?
+            contracts = Dir[File.join(contract, '**/*{.json.erb,.json}')]
+            fail Pacto::UI.colorize("No contracts found in directory #{contract}", :yellow) if contracts.empty?
+
+            contracts.sort.each do |contract_file|
+              yield contract_file
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacto/consumer.rb

@@ -0,0 +1,80 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  def self.consumers
+    @consumers ||= {}
+  end
+
+  def self.simulate_consumer(consumer_name = :consumer, &block)
+    consumers[consumer_name] ||= Consumer.new(consumer_name)
+    consumers[consumer_name].simulate(&block)
+  end
+
+  class Consumer
+    include Logger
+    include Resettable
+
+    def initialize(name = :consumer)
+      @name = name
+    end
+
+    def simulate(&block)
+      instance_eval(&block)
+    end
+
+    def playback(stenographer_script)
+      script = File.read(stenographer_script)
+      instance_eval script, stenographer_script
+    end
+
+    def self.reset!
+      Pacto.consumers.clear
+    end
+
+    def actor
+      @actor ||= Pacto::Actors::FromExamples.new
+    end
+
+    def actor=(actor)
+      fail ArgumentError, 'The actor must respond to :build_request' unless actor.respond_to? :build_request
+      @actor = actor
+    end
+
+    def request(contract, data = {})
+      contract = Pacto.contract_registry.find_by_name(contract) if contract.is_a? String
+      logger.info "Sending request to #{contract.name.inspect}"
+      logger.info "  with #{data.inspect}"
+      reenact(contract, data)
+    rescue ContractNotFound => e
+      logger.warn "Ignoring request: #{e.message}"
+    end
+
+    def reenact(contract, data = {})
+      request = build_request contract, data
+      response = driver.execute request
+      [request, response]
+    end
+
+    # Returns the current driver
+    def driver
+      @driver ||= Pacto::Consumer::FaradayDriver.new
+    end
+
+    # Changes the driver
+    def driver=(driver)
+      fail ArgumentError, 'The driver must respond to :execute' unless driver.respond_to? :execute
+      @driver = driver
+    end
+
+    # @api private
+    def build_request(contract, data = {})
+      actor.build_request(contract, data[:values]).tap do |request|
+        if data[:headers] && data[:headers].respond_to?(:call)
+          request.headers = data[:headers].call(request.headers)
+        end
+        if data[:body] && data[:body].respond_to?(:call)
+          request.body = data[:body].call(request.body)
+        end
+      end
+    end
+  end
+end

data/lib/pacto/consumer/faraday_driver.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  class Consumer
+    class FaradayDriver
+      # Sends a Pacto::PactoRequest
+      def execute(req)
+        conn = Faraday.new(url: req.uri.site) do |faraday|
+          faraday.response :logger if Pacto.configuration.logger.level == :debug
+          faraday.adapter Faraday.default_adapter
+        end
+
+        response = conn.send(req.method) do |faraday_request|
+          faraday_request.url(req.uri.path, req.uri.query_values)
+          faraday_request.headers = req.headers
+          faraday_request.body = req.body
+        end
+
+        faraday_to_pacto_response response
+      end
+
+      private
+
+      # This belongs in an adapter
+      def faraday_to_pacto_response(faraday_response)
+        data = {
+          status: faraday_response.status,
+          headers: faraday_response.headers,
+          body: faraday_response.body
+        }
+        Pacto::PactoResponse.new(data)
+      end
+    end
+  end
+end