pacto 0.3.0.pre → 0.3.0

data/features/{journeys/validation.feature → validate/meta_validation.feature}

@@ -1,37 +1,54 @@
-Feature: Validation journey
-  Scenario: Meta-validation of a valid contract
+Feature: Meta-validation
+
+  Meta-validation ensures that a Contract file matches the Contract format.  It does not validation actual responses, just the Contract itself.
+
+  You can easily do meta-validation with the Rake task pacto:meta_validate, or programmatically.
+
+  Background:
     Given a file named "contracts/my_contract.json" with:
-    """
-        {
-        "request": {
-          "method": "GET",    
-          "path": "/hello_world",
-          "headers": {
-            "Accept": "application/json"
+      """
+          {
+          "request": {
+            "method": "GET",    
+            "path": "/hello_world",
+            "headers": {
+              "Accept": "application/json"
+            },
+            "params": {}
           },
-          "params": {}
-        },
 
-        "response": {
-          "status": 200,
-          "headers": {
-            "Content-Type": "application/json"
-          },
-          "body": {
-            "description": "A simple response",
-            "type": "object",
-            "properties": {
-              "message": {
-                "type": "string"
+          "response": {
+            "status": 200,
+            "headers": {
+              "Content-Type": "application/json"
+            },
+            "body": {
+              "description": "A simple response",
+              "type": "object",
+              "properties": {
+                "message": {
+                  "type": "string"
+                }
               }
             }
           }
         }
-      }
-    """
+      """
+
+  Scenario: Meta-validation via a rake task
     When I successfully run `bundle exec rake pacto:meta_validate['tmp/aruba/contracts/my_contract.json']`
     Then the output should contain "All contracts successfully meta-validated"
 
+  Scenario: Programmatic meta-validation
+    Given a file named "meta_validate.rb" with:
+    """ruby
+    require 'pacto'
+    Pacto.validate_contract 'contracts/my_contract.json'
+    """
+    When I successfully run `bundle exec ruby meta_validate.rb`
+    Then the output should contain "Validating contracts/my_contract.json"
+
+# The tests from here down should probably be specs instead of relish
 
   Scenario: Meta-validation of an invalid contract
     Given a file named "contracts/my_contract.json" with:

data/features/validate/validation.feature

@@ -0,0 +1,36 @@
+Feature: Validation
+
+  Validation ensures that a external service conform to a Contract.
+
+  Scenario: Validation via a rake task
+    Given a file named "contracts/simple_contract.json" with:
+      """
+          {
+          "request": {
+            "method": "GET",
+            "path": "/hello",
+            "headers": { "Accept": "application/json" },
+            "params": {}
+          },
+
+          "response": {
+            "status": 200,
+            "headers": { "Content-Type": "application/json" },
+            "body": {
+              "description": "A simple response",
+              "type": "object",
+              "properties": {
+                "message": { "type": "string" }
+              }
+            }
+          }
+        }
+      """
+      When I successfully run `bundle exec rake pacto:validate['http://localhost:8000','tmp/aruba/contracts/simple_contract.json']`
+      Then the output should contain:
+        """"
+        Validating contracts in directory tmp/aruba/contracts/simple_contract.json against host http://localhost:8000
+
+        simple_contract.json: OK!
+        1 valid contract
+        """

data/lib/pacto.rb

@@ -1,6 +1,8 @@
 require 'pacto/version'
 
-require 'httparty'
+require 'addressable/template'
+require 'middleware'
+require 'faraday'
 require 'hash_deep_merge'
 require 'multi_json'
 require 'json-schema'
@@ -10,66 +12,92 @@ require 'ostruct'
 require 'erb'
 require 'logger'
 
-require 'pacto/core/contract_repository'
-require 'pacto/core/configuration'
-require 'pacto/core/callback'
 require 'pacto/logger'
+require 'pacto/ui'
+require 'pacto/core/contract_registry'
+require 'pacto/core/validation_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'
-require 'pacto/response_adapter'
-require 'pacto/response'
-require 'pacto/stubs/built_in'
+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/erb_processor'
-require 'pacto/hash_merge_processor'
-require 'pacto/stubs/built_in'
+require 'pacto/validation'
 require 'pacto/meta_schema'
 require 'pacto/hooks/erb_hook'
 require 'pacto/generator'
+require 'pacto/generator/filters'
+require 'pacto/contract_files'
+require 'pacto/contract_list'
+require 'pacto/request_pattern'
+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'
 
 module Pacto
   class << self
+    def contract_factory
+      @factory = ContractFactory.new
+    end
 
     def configuration
       @configuration ||= Configuration.new
     end
 
+    def contract_registry
+      @registry ||= ContractRegistry.new
+    end
+
     def clear!
       Pacto.configuration.provider.reset!
+      @modes = nil
       @configuration = nil
-      unregister_all!
+      @registry = nil
+      Pacto::ValidationRegistry.instance.reset!
     end
 
     def configure
       yield(configuration)
     end
-  end
 
-  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}"
+    def contracts_for(request_signature)
+      contract_registry.contracts_for(request_signature)
     end
-    false
-  end
-
-  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.load(contract_name)
-    build_from_file(path_for(contract_name), nil)
-  end
+    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
 
-  private
+    def load_contract(contract_path, host)
+      load_contracts(contract_path, host).contracts.first
+    end
 
-  def self.path_for(contract)
-    File.join(configuration.contracts_path, "#{contract}.json")
+    def load_contracts(contracts_path, host)
+      files = ContractFiles.for(contracts_path)
+      contracts = contract_factory.build(files, host)
+      contracts.each do |contract|
+        contract_registry.register(contract)
+      end
+      ContractList.new(contracts)
+    end
   end
 end

data/lib/pacto/contract.rb

@@ -1,25 +1,33 @@
 module Pacto
   class Contract
-    attr_reader :values
-    attr_reader :request, :response
+    attr_reader :name, :values, :request, :response, :file, :request_pattern
 
-    def initialize(request, response, file = nil)
+    def initialize(request, response, file, name = nil, request_pattern_provider = RequestPattern)
       @request = request
       @response = response
-      @file = file
+      @file = file.to_s
+      @name = name || @file
+      @request_pattern = request_pattern_provider.for(request)
+      @values = {}
     end
 
-    def stub_contract! values = {}
+    def stub_contract!(values = {})
       @values = values
-      @stub = Pacto.configuration.provider.stub_request!(@request, stub_response) unless @request.nil?
+      Pacto.configuration.provider.stub_request!(request, response)
     end
 
-    def validate(response_gotten = provider_response, opt = {})
-      @response.validate(response_gotten, opt)
+    def validate_provider(opts = {})
+      request = @request
+      response = provider_response
+      validate_consumer request, response, opts
     end
 
-    def matches? request_signature
-      @stub.matches? request_signature unless @stub.nil?
+    def validate_consumer(request, response, opts = {})
+      Pacto::ContractValidator.validate self, request, response, opts
+    end
+
+    def matches?(request_signature)
+      request_pattern.matches? request_signature
     end
 
     private
@@ -27,10 +35,5 @@ module Pacto
     def provider_response
       @request.execute
     end
-
-    def stub_response
-      @response.instantiate
-    end
-
   end
 end

data/lib/pacto/contract_factory.rb

@@ -1,19 +1,22 @@
 module Pacto
   class ContractFactory
-    def self.build_from_file(contract_path, host, preprocessor)
+    attr_reader :schema
+
+    def initialize(options = {})
+      @schema = options[:schema] || MetaSchema.new
+    end
+
+    def build(contract_files, host)
+      contract_files.map { |file| build_from_file(file, host) }
+    end
+
+    def build_from_file(contract_path, host)
       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
+      request = RequestClause.new(host, definition['request'])
+      response = ResponseClause.new(definition['response'])
+      Contract.new(request, response, contract_path, definition['name'])
     end
   end
 end

data/lib/pacto/contract_files.rb

@@ -0,0 +1,17 @@
+require 'pathname'
+module Pacto
+  class ContractFiles
+    def self.for(path)
+      full_path = Pathname.new(path).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
+  end
+end

data/lib/pacto/contract_list.rb

@@ -0,0 +1,17 @@
+module Pacto
+  class ContractList
+    attr_reader :contracts
+
+    def initialize(contracts)
+      @contracts = contracts
+    end
+
+    def stub_all(values = {})
+      contracts.each { |contract| contract.stub_contract!(values) }
+    end
+
+    def validate_all
+      contracts.map { |contract| contract.validate_provider }
+    end
+  end
+end

data/lib/pacto/contract_validator.rb

@@ -0,0 +1,29 @@
+module Pacto
+  class ContractValidator
+    class << self
+      def validate(contract, request, response, opts)
+        env = {
+          :contract => contract,
+          :actual_request => request,
+          :actual_response => response,
+          :validation_results => []
+        }
+        validation_stack(opts).call env
+        env[:validation_results].compact
+      end
+
+      private
+
+      def validation_stack(opts)
+        Middleware::Builder.new do
+          use Pacto::Validators::RequestBodyValidator
+          unless opts[:body_only]
+            use Pacto::Validators::ResponseStatusValidator
+            use Pacto::Validators::ResponseHeaderValidator
+          end
+          use Pacto::Validators::ResponseBodyValidator
+        end
+      end
+    end
+  end
+end

data/lib/pacto/core/configuration.rb

@@ -1,33 +1,35 @@
 module Pacto
   class Configuration
-    attr_accessor :preprocessor, :postprocessor, :provider, :strict_matchers, :contracts_path, :logger
-    attr_reader :callback
+    attr_accessor :provider, :strict_matchers,
+                  :contracts_path, :logger, :generator_options
+    attr_reader :hook
 
     def initialize
-      @preprocessor = ERBProcessor.new
-      @postprocessor = HashMergeProcessor.new
-      @provider = Pacto::Stubs::BuiltIn.new
+      @provider = Stubs::WebMockAdapter.new
       @strict_matchers = true
       @contracts_path = nil
       @logger = Logger.instance
-      if ENV['PACTO_DEBUG']
-        @logger.level = :debug
+      define_logger_level
+      @hook = Hook.new {}
+      @generator_options = { :schema_version => 'draft3' }
+    end
+
+    def register_hook(hook = nil, &block)
+      if block_given?
+        @hook = Hook.new(&block)
       else
-        @logger.level = :default
+        fail 'Expected a Pacto::Hook' unless hook.is_a? Hook
+        @hook = hook
       end
-      @callback = Pacto::Hooks::ERBHook.new
     end
 
-    def register_contract(contract = nil, *tags)
-      Pacto.register_contract(contract, *tags)
-    end
+    private
 
-    def register_callback(callback = nil, &block)
-      if block_given?
-        @callback = Pacto::Callback.new(&block)
+    def define_logger_level
+      if ENV['PACTO_DEBUG']
+        @logger.level = :debug
       else
-        raise 'Expected a Pacto::Callback' unless callback.is_a? Pacto::Callback
-        @callback = callback
+        @logger.level = :default
       end
     end
   end