pact 0.1.28 → 1.3.3

data/example/zoo-app/spec/service_providers/animal_service_client_spec.rb

@@ -0,0 +1,71 @@
+require_relative 'pact_helper'
+require 'zoo_app/animal_service_client'
+
+module ZooApp
+  describe AnimalServiceClient, :pact => true do
+
+    before do
+      AnimalServiceClient.base_uri animal_service.mock_service_base_url
+    end
+
+    describe ".find_alligator_by_name" do
+      context "when an alligator by the given name exists" do
+
+        before do
+          animal_service.given("there is an alligator named Mary").
+            upon_receiving("a request for an alligator").with(
+              method: :get,
+              path: '/alligators/Mary',
+              headers: {'Accept' => 'application/json'} ).
+            will_respond_with(
+              status: 200,
+              headers: {'Content-Type' => 'application/json;charset=utf-8'},
+              body: {name: 'Mary'}
+            )
+        end
+
+        it "returns the alligator" do
+          expect(AnimalServiceClient.find_alligator_by_name("Mary")).to eq ZooApp::Animals::Alligator.new(name: 'Mary')
+        end
+
+      end
+
+      context "when an alligator by the given name does not exist" do
+
+        before do
+          animal_service.given("there is not an alligator named Mary").
+            upon_receiving("a request for an alligator").with(
+              method: :get,
+              path: '/alligators/Mary',
+              headers: {'Accept' => 'application/json'} ).
+            will_respond_with(status: 404)
+        end
+
+        it "returns nil" do
+          expect(AnimalServiceClient.find_alligator_by_name("Mary")).to be_nil
+        end
+
+      end
+
+      context "when an error occurs retrieving the alligator" do
+
+        before do
+          animal_service.given("an error occurs retrieving an alligator").
+            upon_receiving("a request for an alligator").with(
+              method: :get,
+              path: '/alligators/Mary',
+              headers: {'Accept' => 'application/json'}).
+            will_respond_with(
+              status: 500,
+              headers: { 'Content-Type' => 'application/json;charset=utf-8'},
+              body: {error: 'Argh!!!'})
+        end
+
+        it "raises an error" do
+          expect{ AnimalServiceClient.find_alligator_by_name("Mary") }.to raise_error /Argh/
+        end
+
+      end
+    end
+  end
+end

data/example/zoo-app/spec/service_providers/pact_helper.rb

@@ -0,0 +1,15 @@
+require_relative '../spec_helper'
+require 'pact/consumer/rspec'
+
+Pact.configure do | config |
+  config.doc_generator = :markdown
+end
+
+Pact.service_consumer 'Zoo App' do
+  has_pact_with "Animal Service" do
+    mock_service :animal_service do
+      port 1234
+    end
+  end
+end
+

data/example/zoo-app/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$: << File.expand_path("../../lib", __FILE__)
+
+RSpec.configure do | config |
+  config.color = true
+  config.formatter = :documentation
+end

data/lib/pact/cli.rb

@@ -0,0 +1,138 @@
+require 'find_a_port'
+require 'thor'
+require 'thwait'
+require 'pact/consumer'
+require 'rack/handler/webrick'
+
+module Pact
+  class CLI < Thor
+
+    desc 'verify', "Verify a pact"
+    method_option :pact_helper, aliases: "-h", desc: "Pact helper file", :required => true
+    method_option :pact_uri, aliases: "-p", desc: "Pact URI"
+
+    def verify
+      RunPactVerification.call(options)
+    end
+
+    desc 'service', "Start a mock service"
+    method_option :port, aliases: "-p", desc: "Port on which to run the service"
+    method_option :log, aliases: "-l", desc: "File to which to log output"
+    method_option :quiet, aliases: "-q", desc: "If true, no admin messages will be shown"
+
+    def service
+      RunStandaloneMockService.call(options)
+    end
+
+    private
+
+    def log message
+      puts message unless options[:quiet]
+    end
+  end
+
+  class RunPactVerification
+
+    attr_reader :options
+
+    def initialize options
+      @options = options
+    end
+
+    def self.call options
+      new(options).call
+    end
+
+
+    def call
+      initialize_rspec
+      setup_load_path
+      load_pact_helper
+      run_specs
+    end
+
+    private
+
+    def initialize_rspec
+      # With RSpec3, if the pact_helper loads a library that adds its own formatter before we set one,
+      # we will get a ProgressFormatter too, and get little dots sprinkled throughout our output.
+      require 'pact/rspec'
+      ::RSpec.configuration.add_formatter Pact::RSpec.formatter_class
+    end
+
+    def setup_load_path
+      require 'pact/provider/pact_spec_runner'
+      lib = File.join(Dir.pwd, "lib") # Assume we are running from within the project root. RSpec is smarter about this.
+      spec = File.join(Dir.pwd, "spec")
+      $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+      $LOAD_PATH.unshift(spec) if Dir.exist?(spec) && !$LOAD_PATH.include?(spec)
+    end
+
+    def load_pact_helper
+      load options[:pact_helper]
+    end
+
+    def run_specs
+      exit_code = if options[:pact_uri]
+        run_with_pact_uri
+      else
+        run_with_configured_pacts
+      end
+      exit 1 unless exit_code == 0
+    end
+
+    def run_with_pact_uri
+      Pact::Provider::PactSpecRunner.new([{uri: options[:pact_uri]}], pact_spec_options).run
+    end
+
+    def run_with_configured_pacts
+      pact_verifications = Pact.configuration.pact_verifications
+      verification_configs = pact_verifications.collect { | pact_verification | { :uri => pact_verification.uri }}
+      raise "Please configure a pact to verify" if verification_configs.empty?
+      Pact::Provider::PactSpecRunner.new(verification_configs, options).run
+    end
+
+    def pact_spec_options
+      {criteria: SpecCriteria.call}
+    end
+
+  end
+
+  class RunStandaloneMockService
+
+    def self.call options
+      service_options = {}
+      if options[:log]
+        log = File.open(options[:log], 'w')
+        log.sync = true
+        service_options[:log_file] = log
+      end
+
+      port = options[:port] || FindAPort.available_port
+      mock_service = Consumer::MockService.new(service_options)
+      trap(:INT) { Rack::Handler::WEBrick.shutdown }
+      Rack::Handler::WEBrick.run(mock_service, :Port => port, :AccessLog => [])
+    end
+  end
+
+  class SpecCriteria
+
+    def self.call
+      criteria = {}
+
+      description = ENV["PACT_DESCRIPTION"]
+      criteria[:description] = Regexp.new(description) if description
+
+      provider_state = ENV["PACT_PROVIDER_STATE"]
+      if provider_state
+        if provider_state.length == 0
+          criteria[:provider_state] = nil #Allow PACT_PROVIDER_STATE="" to mean no provider state
+        else
+          criteria[:provider_state] = Regexp.new(provider_state)
+        end
+      end
+
+      criteria
+    end
+  end
+end

data/lib/pact/configuration.rb

@@ -1,22 +1,186 @@
 require 'ostruct'
 require 'logger'
+require 'pact/doc/markdown/generator'
+require 'pact/matchers/unix_diff_formatter'
+require 'pact/matchers/embedded_diff_formatter'
+require 'pact/matchers/list_diff_formatter'
+require 'pact/shared/json_differ'
+require 'pact/shared/text_differ'
 
 module Pact
 
   class Configuration
+
+    DOC_GENERATORS = { markdown: Pact::Doc::Markdown::Generator }
+
+    DIFF_FORMATTERS = {
+      :embedded => Pact::Matchers::EmbeddedDiffFormatter,
+      :unix => Pact::Matchers::UnixDiffFormatter,
+      :list => Pact::Matchers::ListDiffFormatter
+    }
+
+
+    class NilMatcher
+      def self.=~ other
+        other == nil ? 0 : nil
+      end
+    end
+
+    DIFF_FORMATTER_REGISTRATIONS = [
+      [/.*/, Pact::Matchers::UnixDiffFormatter],
+      [NilMatcher, Pact::Matchers::UnixDiffFormatter]
+    ]
+
+    DIFFERS = [
+      [/json/, Pact::JsonDiffer],
+      [NilMatcher, Pact::TextDiffer],
+      [/.*/, Pact::TextDiffer]
+    ]
+
+
+    DEFAULT_DIFFER = Pact::TextDiffer
+
     attr_accessor :pact_dir
     attr_accessor :log_dir
-    attr_accessor :logger
+    attr_accessor :doc_dir
+    attr_accessor :reports_dir
+    attr_writer :logger
     attr_accessor :tmp_dir
-    attr_accessor :pactfile_write_mode
+    attr_writer :pactfile_write_mode
+
+    attr_accessor :error_stream
+    attr_accessor :output_stream
+
+    def self.default_configuration
+      c = Configuration.new
+      c.pact_dir = File.expand_path('./spec/pacts')
+      c.tmp_dir = File.expand_path('./tmp/pacts')
+      c.log_dir = default_log_dir
+      c.pactfile_write_mode = :overwrite
+      c.reports_dir = File.expand_path('./reports/pacts')
+      c.doc_dir = File.expand_path("./doc/pacts")
+      c.output_stream = $stdout
+      c.error_stream = $stderr
+      c
+    end
+
+    def initialize
+      @differ_registrations = []
+      @diff_formatter_registrations = []
+    end
+
+    def logger
+      @logger ||= create_logger
+    end
+
+    def doc_generator= doc_generator
+      doc_generators << begin
+        if DOC_GENERATORS[doc_generator]
+          DOC_GENERATORS[doc_generator]
+        elsif doc_generator.respond_to?(:call)
+          doc_generator
+        else
+          raise "Pact.configuration.doc_generator needs to respond to call, or be in the preconfigured list: #{DOC_GENERATORS.keys}"
+        end
+      end
+    end
+
+    def doc_generators
+      @doc_generators  ||= []
+    end
+
+    # Should this be deprecated in favour of register_diff_formatter???
+    def diff_formatter= diff_formatter
+      register_diff_formatter /.*/, diff_formatter
+      register_diff_formatter nil, diff_formatter
+    end
+
+    def register_diff_formatter content_type, diff_formatter
+      key = content_type_regexp_for content_type
+      @diff_formatter_registrations << [key, diff_formatter_for(diff_formatter)]
+    end
+
+    def diff_formatter_for_content_type content_type
+      diff_formatter_registrations.find{ | registration | registration.first =~ content_type }.last
+    end
+
+    def register_body_differ content_type, differ
+      key = content_type_regexp_for content_type
+      validate_differ differ
+      @differ_registrations << [key, differ]
+    end
+
+    def body_differ_for_content_type content_type
+      differ_registrations.find{ | registration | registration.first =~ content_type }.last
+    end
 
     def log_path
-      log_dir + "/pact_gem.log"
+      log_dir + "/pact.log"
+    end
+
+    def pactfile_write_mode
+      if @pactfile_write_mode == :smart
+        is_rake_running? ? :overwrite : :update
+      else
+        @pactfile_write_mode
+      end
+    end
+
+    private
+
+    def diff_formatter_for input
+      if DIFF_FORMATTERS[input]
+        DIFF_FORMATTERS[input]
+      elsif input.respond_to?(:call)
+        input
+      else
+        raise "Pact diff_formatter needs to respond to call, or be in the preconfigured list: #{DIFF_FORMATTERS.keys}"
+      end
+    end
+
+    def validate_differ differ
+      if !differ.respond_to?(:call)
+        raise "Pact.configuration.register_body_differ expects a differ that is a lamda or a class/object that responds to call."
+      end
+    end
+
+    def content_type_regexp_for content_type
+      case content_type
+      when String then Regexp.new(/^#{Regexp.escape(content_type)}$/)
+      when Regexp then content_type
+      when nil then NilMatcher
+      else
+        raise "Invalid content type used to register a differ (#{content_type.inspect}). Please use a Regexp or a String."
+      end
+    end
+
+    def differ_registrations
+      @differ_registrations + DIFFERS
+    end
+
+    def diff_formatter_registrations
+      @diff_formatter_registrations + DIFF_FORMATTER_REGISTRATIONS
+    end
+
+    def self.default_log_dir
+      File.expand_path("./log")
+    end
+
+    #Would love a better way of determining this! It sure won't work on windows.
+    def is_rake_running?
+      `ps -ef | grep rake | grep #{Process.ppid} | grep -v 'grep'`.size > 0
+    end
+
+    def create_logger
+      FileUtils::mkdir_p log_dir
+      logger = Logger.new(log_path)
+      logger.level = Logger::DEBUG
+      logger
     end
   end
 
   def self.configuration
-    @configuration ||= default_configuration
+    @configuration ||= Configuration.default_configuration
   end
 
   def self.configure
@@ -25,30 +189,7 @@ module Pact
   end
 
   def self.clear_configuration
-    @configuration = default_configuration
-  end
-
-  private
-
-  def self.default_configuration
-    c = Configuration.new
-    c.pact_dir = File.expand_path('./spec/pacts')
-    c.tmp_dir = File.expand_path('./tmp/pacts')
-    c.log_dir = default_log_dir
-    c.logger = default_logger c.log_path
-    c.pactfile_write_mode = defined?(Rake) ? :overwrite : :update
-    c
-  end
-
-  def self.default_log_dir
-    File.expand_path("./log")
-  end
-
-  def self.default_logger path
-    FileUtils::mkdir_p File.dirname(path)
-    logger = Logger.new(path)
-    logger.level = Logger::INFO
-    logger
+    @configuration = nil
   end
 
 end

data/lib/pact/consumer/app_manager.rb

@@ -1,10 +1,11 @@
 require 'thwait'
-require 'capybara'
 
 require 'net/http'
 require 'uri'
 require 'find_a_port'
 require 'pact/logging'
+require 'pact/consumer/server'
+require 'singleton'
 
 module Pact
   module Consumer
@@ -82,7 +83,7 @@ module Pact
           lower_case_name.gsub('_service', '_mock_service')
         else
           lower_case_name + '_mock_service'
-        end        
+        end
       end
 
       def app_registrations
@@ -110,9 +111,11 @@ module Pact
       end
 
       def kill
-        logger.info "Killing #{self}"
-        Process.kill(9, pid)
-        Process.wait(pid)
+        # TODO: need to work out how to kill
+        # logger.info "Killing #{self}"
+        # Process.kill(9, pid)
+        # Process.wait(pid)
+        # self.pid = nil
         self.pid = nil
       end
 
@@ -133,31 +136,9 @@ module Pact
       end
 
       def spawn
-        # following stolen from https://github.com/jwilger/kookaburra
         logger.info "Starting app #{self}..."
-        self.pid = fork do
-          begin
-            Capybara.server_port = port
-            Capybara::Server.new(app).boot
-
-            # This ensures that this forked process keeps running, because the
-            # actual server is started in a thread by Capybara.
-            ThreadsWait.all_waits(Thread.list)
-          rescue Exception => e
-            logger.error "Error starting up #{self}"
-            $stderr.puts "Error starting up #{self}"
-            raise e
-          end
-        end
-
-
-        wait_until do
-          begin
-            Net::HTTP.get_response(URI.parse("http://localhost:#{port}/index.html"))
-          rescue Errno::ECONNREFUSED
-            false
-          end
-        end
+        Pact::Server.new(app, port).boot
+        self.pid = 'unknown'
         logger.info "Started with pid #{pid}"
       end
 

data/lib/pact/consumer/configuration/configuration_extensions.rb

@@ -0,0 +1,15 @@
+module Pact
+  module Consumer
+    module Configuration
+
+      module ConfigurationExtensions
+        def add_provider_verification &block
+          provider_verifications << block
+        end
+        def provider_verifications
+          @provider_verifications ||= []
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/configuration/dsl.rb

@@ -0,0 +1,12 @@
+require 'pact/consumer/configuration/service_consumer'
+
+module Pact
+
+  module Consumer
+    module DSL
+      def service_consumer name, &block
+        Configuration::ServiceConsumer.build(name, &block)
+      end
+    end
+  end
+end

data/lib/pact/consumer/configuration/mock_service.rb

@@ -0,0 +1,91 @@
+require 'pact/consumer/app_manager'
+require 'pact/consumer/consumer_contract_builder'
+require 'pact/consumer/consumer_contract_builders'
+require 'pact/consumer/world'
+
+module Pact
+  module Consumer
+    module Configuration
+      class MockService
+
+        extend Pact::DSL
+
+        attr_accessor :port, :standalone, :verify, :provider_name, :consumer_name
+
+        def initialize name, consumer_name, provider_name
+          @name = name
+          @consumer_name = consumer_name
+          @provider_name = provider_name
+          @port = nil
+          @standalone = false
+          @verify = true
+        end
+
+        dsl do
+          def port port
+            self.port = port
+          end
+
+          def standalone standalone
+            self.standalone = standalone
+          end
+
+          def verify verify
+            self.verify = verify
+          end
+        end
+
+        def finalize
+          validate
+          register_mock_service
+          configure_consumer_contract_builder
+        end
+
+        private
+
+        def register_mock_service
+          unless standalone
+            AppManager.instance.register_mock_service_for provider_name, "http://localhost:#{port}"
+          end
+        end
+
+        def configure_consumer_contract_builder
+          consumer_contract_builder = create_consumer_contract_builder
+          create_consumer_contract_builders_method consumer_contract_builder
+          setup_verification(consumer_contract_builder) if verify
+          consumer_contract_builder
+        end
+
+        def create_consumer_contract_builder
+          consumer_contract_builder_fields = {
+            :consumer_name => consumer_name,
+            :provider_name => provider_name,
+            :pactfile_write_mode => Pact.configuration.pactfile_write_mode,
+            :port => port
+          }
+          Pact::Consumer::ConsumerContractBuilder.new consumer_contract_builder_fields
+        end
+
+        def setup_verification consumer_contract_builder
+          Pact.configuration.add_provider_verification do | example_description |
+            consumer_contract_builder.verify example_description
+          end
+        end
+
+         # This makes the consumer_contract_builder available via a module method with the given identifier
+         # as the method name.
+         # I feel this should be defined somewhere else, but I'm not sure where
+        def create_consumer_contract_builders_method consumer_contract_builder
+          Pact::Consumer::ConsumerContractBuilders.send(:define_method, @name.to_sym) do
+            consumer_contract_builder
+          end
+          Pact.consumer_world.add_consumer_contract_builder consumer_contract_builder
+        end
+
+        def validate
+          raise "Please provide a port for service #{name}" unless port
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/configuration/service_consumer.rb

@@ -0,0 +1,51 @@
+require 'pact/shared/dsl'
+
+module Pact
+  module Consumer
+    module Configuration
+      class ServiceConsumer
+
+        extend Pact::DSL
+
+        attr_accessor :app, :port, :name
+
+        def initialize name
+          @name = name
+          @app = nil
+          @port = nil
+        end
+
+        dsl do
+          def app app
+            self.app = app
+          end
+
+          def port port
+            self.port = port
+          end
+
+          def has_pact_with service_provider_name, &block
+            ServiceProvider.build(service_provider_name, name, &block)
+          end
+        end
+
+        def finalize
+          validate
+          register_consumer_app if @app
+        end
+
+        private
+
+        def validate
+          raise "Please provide a consumer name" unless (name && !name.empty?)
+          raise "Please provide a port for the consumer app" if app && !port
+        end
+
+
+        def register_consumer_app
+          Pact::Consumer::AppManager.instance.register app, port
+        end
+      end
+    end
+  end
+end