pacto 0.2.5 → 0.3.0.pre

data/lib/pacto/hooks/erb_hook.rb

@@ -0,0 +1,17 @@
+module Pacto
+  module Hooks
+    class ERBHook < Pacto::Callback
+      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}})
+        response.body = @processor.process response.body, bound_values
+        response.body
+      end
+
+    end
+  end
+end

data/lib/pacto/logger.rb

@@ -0,0 +1,42 @@
+module Pacto
+  class Logger
+    include Singleton
+    extend Forwardable
+
+    def_delegators :@log, :debug, :info, :warn, :error, :fatal
+
+    def initialize
+      log ::Logger.new STDOUT
+    end
+
+    def log log
+      @log = log
+      @log.level = default_level
+      @log.progname = 'Pacto'
+    end
+
+    def level= level
+      @log.level = log_levels.fetch(level, default_level)
+    end
+
+    def level
+      log_levels.key @log.level
+    end
+
+    private
+
+    def default_level
+      ::Logger::ERROR
+    end
+
+    def log_levels
+      {
+        debug: ::Logger::DEBUG,
+        info:  ::Logger::INFO,
+        warn:  ::Logger::WARN,
+        error: ::Logger::ERROR,
+        fatal: ::Logger::FATAL
+      }
+    end
+  end
+end

data/lib/pacto/meta_schema.rb

@@ -0,0 +1,17 @@
+module Pacto
+  class MetaSchema
+    attr_accessor :schema, :engine
+
+    def initialize(engine = JSON::Validator)
+      @schema = File.join(File.dirname(File.expand_path(__FILE__)), '../../resources/contract_schema.json')
+      @engine = engine
+    end
+
+    def validate definition
+      errors = engine.fully_validate(schema, definition, :version => :draft3)
+      unless errors.empty?
+        raise InvalidContract.new(errors)
+      end
+    end
+  end
+end

data/lib/pacto/rake_task.rb

@@ -17,49 +17,70 @@ module Pacto
     end
 
     def install
-      desc "Tasks for Pacto gem"
+      desc 'Tasks for Pacto gem'
       namespace :pacto do
         validate_task
+        generate_task
+        meta_validate
       end
     end
 
     def validate_task
-      desc "Validates all contracts in a given directory against a given host"
+      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 'USAGE: rake pacto:validate[<host>, <contract_dir>]'.colorize(:yellow)
         end
 
         validate_contracts(args[:host], args[:dir])
       end
     end
 
-    def validate_contracts(host, dir)
-      WebMock.allow_net_connect!
+    def generate_task
+      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)
+        end
+
+        generate_contracts(args[:input_dir], args[:output_dir], args[:host])
+      end
+    end
+
+    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)
+        end
 
-      contracts = Dir[File.join(dir, '*{.json.erb,.json}')]
-      if contracts.empty?
-        fail "No contracts found in directory #{dir}".colorize(:yellow)
+        each_contract(args[:dir]) do |contract_file|
+          puts "Validating #{contract_file}"
+          fail unless Pacto.validate_contract contract_file
+        end
       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.sort.each do |contract_file|
+      each_contract(dir) do |contact_file|
         print "#{contract_file.split('/').last}:"
         contract = Pacto.build_from_file(contract_file, host)
         errors = contract.validate
 
         if errors.empty?
-          puts " OK!".colorize(:green)
+          puts ' OK!'.colorize(:green)
         else
           @exit_with_error = true
           total_failed += 1
-          puts " FAILED!".colorize(:red)
+          puts ' FAILED!'.colorize(:red)
           errors.each do |error|
             puts "\t* #{error}".colorize(:light_red)
           end
-          puts ""
+          puts ''
         end
       end
 
@@ -69,6 +90,48 @@ module Pacto
         puts "#{contracts.size} valid contract#{contracts.size > 1 ? 's' : nil}".colorize(:green)
       end
     end
+
+    def generate_contracts(input_dir, output_dir, host)
+      WebMock.allow_net_connect!
+      generator = Pacto::Generator.new
+      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)
+          output_file = File.expand_path(File.basename(contract_file), output_dir)
+          output_file = File.open(output_file, 'wb')
+          output_file.write contract
+          output_file.flush
+          output_file.close
+        rescue InvalidContract => e
+          failed_contracts << contract_file
+          puts e.message.colorize(:red)
+        end
+      end
+
+      if failed_contracts.empty?
+        puts 'Successfully generated all contracts'.colorize(:green)
+      else
+        fail "The following contracts could not be generated: #{failed_contracts.join ','}".colorize(:red)
+      end
+    end
+
+    private
+
+    def each_contract(dir)
+      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.sort.each do |contract_file|
+          yield contract_file
+        end
+      end
+    end
   end
 end
 

data/lib/pacto/request.rb

@@ -1,14 +1,12 @@
 module Pacto
   class Request
+    attr_reader :host
+
     def initialize(host, definition)
       @host = host
       @definition = definition
     end
 
-    def host
-      @host
-    end
-
     def method
       @definition['method'].to_s.downcase.to_sym
     end
@@ -47,6 +45,7 @@ module Pacto
     end
 
     private
+
     def httparty_params_key
       method == :get ? :query : :body
     end

data/lib/pacto/response.rb

@@ -1,55 +1,63 @@
 module Pacto
   class Response
+    attr_reader :status, :headers, :schema
+
     def initialize(definition)
       @definition = definition
+      @status = @definition['status']
+      @headers = @definition['headers']
+      @schema = @definition['body']
     end
 
     def instantiate
       OpenStruct.new({
-        'status' => @definition['status'],
-        'headers' => @definition['headers'],
-        'body' => JSON::Generator.generate(@definition['body'])
+        'status' => @status,
+        'headers' => @headers,
+        'body' => JSON::Generator.generate(@schema)
       })
     end
 
-    def validate(response)
-      if @definition['status'] != response.status
-        return [ "Invalid status: expected #{@definition['status']} but got #{response.status}" ]
-      end
-      
-      unless @definition['headers'].normalize_keys.subset_of?(response.headers.normalize_keys)
-        return [ "Invalid headers: expected #{@definition['headers'].inspect} to be a subset of #{response.headers.inspect}" ]
+    def validate(response, opt = {})
+
+      unless opt[:body_only]
+        if @definition['status'] != response.status
+          return ["Invalid status: expected #{@definition['status']} but got #{response.status}"]
+        end
+
+        unless @definition['headers'].normalize_keys.subset_of?(response.headers.normalize_keys)
+          return ["Invalid headers: expected #{@definition['headers'].inspect} to be a subset of #{response.headers.inspect}"]
+        end
       end
-      
+
       if @definition['body']
         if @definition['body']['type'] && @definition['body']['type'] == 'string'
           validate_as_pure_string response.body
         else
-          validate_as_json response.body
+          response.respond_to?(:body) ? validate_as_json(response.body) : validate_as_json(response)
         end
       else
         []
       end
     end
-    
+
     private
-    
+
     def validate_as_pure_string response_body
       errors = []
       if @definition['body']['required'] && response_body.nil?
-        errors << "The response does not contain a body"
+        errors << 'The response does not contain a body'
       end
-      
+
       pattern = @definition['body']['pattern']
       if pattern && !(response_body =~ Regexp.new(pattern))
         errors << "The response does not match the pattern #{pattern}"
       end
-      
+
       errors
     end
-    
+
     def validate_as_json response_body
-      JSON::Validator.fully_validate(@definition['body'], response_body)
+      JSON::Validator.fully_validate(@definition['body'], response_body, :version => :draft3)
     end
   end
 end

data/lib/pacto/server.rb

@@ -0,0 +1,2 @@
+require_relative 'server/dummy'
+require_relative 'server/playback_servlet'

data/lib/pacto/server/dummy.rb

@@ -0,0 +1,45 @@
+require 'webrick'
+require 'forwardable'
+
+module Pacto
+  module Server
+    class Servlet < WEBrick::HTTPServlet::AbstractServlet
+      extend Forwardable
+
+      def initialize server, json
+        super(server)
+
+        @doer = PlaybackServlet.new({
+          status: 200,
+          headers: {'Content-Type' => 'application/json'},
+          body: json
+        })
+      end
+
+      def_delegator :@doer, :do_GET
+    end
+
+    class Dummy
+      def initialize port, path, response
+        params = {
+          :Port => port,
+          :AccessLog => [],
+          :Logger => WEBrick::Log::new('/dev/null', 7)
+        }
+        @server = WEBrick::HTTPServer.new params
+        @server.mount path, Servlet, response
+      end
+
+      def start
+        @pid = Thread.new do
+          trap 'INT' do @server.shutdown end
+          @server.start
+        end
+      end
+
+      def terminate
+        @pid.kill
+      end
+    end
+  end
+end

data/lib/pacto/server/playback_servlet.rb

@@ -0,0 +1,21 @@
+module Pacto
+  module Server
+    class PlaybackServlet
+      attr_reader :status, :headers, :body
+
+      def initialize(attributes)
+        @status = attributes.fetch(:status, 200)
+        @headers = attributes.fetch(:headers, [])
+        @body = attributes.fetch(:body, nil)
+      end
+
+      def do_GET(request, response)
+        response.status = status
+        headers.each do |key, value|
+          response[key] = value
+        end
+        response.body = body
+      end
+    end
+  end
+end

data/lib/pacto/stubs/built_in.rb

@@ -0,0 +1,57 @@
+module Pacto
+  module Stubs
+    class BuiltIn
+
+      def initialize
+        register_callbacks
+      end
+
+      def stub_request! request, response
+        stub = WebMock.stub_request(request.method, "#{request.host}#{request.path}")
+        stub = stub.with(request_details(request)) if Pacto.configuration.strict_matchers
+        stub.to_return({
+            :status => response.status,
+            :headers => response.headers,
+            :body => format_body(response.body)
+          })
+      end
+
+      def reset!
+        WebMock.reset!
+        WebMock.reset_callbacks
+      end
+
+      private
+
+      def register_callbacks
+        WebMock.after_request do |request_signature, response|
+          contracts = Pacto.contract_for request_signature
+          Pacto.configuration.callback.process contracts, request_signature, response
+        end
+      end
+
+      def format_body(body)
+        if body.is_a?(Hash) || body.is_a?(Array)
+          body.to_json
+        else
+          body
+        end
+      end
+
+      def request_details request
+        details = {}
+        unless request.params.empty?
+          details[webmock_params_key(request)] = request.params
+        end
+        unless request.headers.empty?
+          details[:headers] = request.headers
+        end
+        details
+      end
+
+      def webmock_params_key request
+        request.method == :get ? :query : :body
+      end
+    end
+  end
+end