hs-pact-mock_service 3.9.2

data/lib/pact/mock_service/app.rb

@@ -0,0 +1,85 @@
+require 'rack'
+require 'uri'
+require 'json'
+require 'pact/mock_service/logger'
+require 'pact/consumer/mock_service/cors_origin_header_middleware'
+require 'pact/mock_service/request_handlers'
+require 'pact/consumer/mock_service/error_handler'
+require 'pact/mock_service/session'
+
+module Pact
+  module MockService
+
+    def self.new *args
+      App.new(*args)
+    end
+
+    class App
+      def initialize options = {}
+        logger = Logger.from_options(options)
+        @options = options
+        stubbing = options[:stub_pactfile_paths] && options[:stub_pactfile_paths].any?
+        @name = options.fetch(:name, "MockService")
+        @session = Session.new(options.merge(logger: logger, warn_on_too_many_interactions: !stubbing))
+        setup_stub(options[:stub_pactfile_paths]) if stubbing
+        request_handlers = RequestHandlers.new(@name, logger, @session, options)
+        @app = Rack::Builder.app do
+          use Pact::Consumer::MockService::ErrorHandler, logger
+          use Pact::Consumer::CorsOriginHeaderMiddleware, options[:cors_enabled]
+          run request_handlers
+        end
+      end
+
+      def call env
+        @app.call env
+      end
+
+      def shutdown
+        write_pact_if_configured
+      end
+
+      def setup_stub stub_pactfile_paths
+        interactions = stub_pactfile_paths.collect do | pactfile_path |
+          $stdout.puts "INFO: Loading interactions from #{pactfile_path}"
+          hash_interactions = JSON.parse(Pact::PactFile.read(pactfile_path, pactfile_options))['interactions']
+          hash_interactions.collect { | hash | Interaction.from_hash(hash) }
+        end.flatten
+        @session.set_expected_interactions interactions
+      end
+
+      def write_pact_if_configured
+        consumer_contract_writer = ConsumerContractWriter.new(@session.consumer_contract_details, StdoutLogger.new)
+        if consumer_contract_writer.can_write? && !@session.pact_written?
+          $stdout.puts "INFO: Writing pact before shutting down"
+          consumer_contract_writer.write
+        end
+      end
+
+      def to_s
+        "#{@name} #{super.to_s}"
+      end
+
+      private
+
+      def pactfile_options
+        {
+          :token => broker_token,
+          :username => @options[:broker_username],
+          :password => @options[:broker_password],
+        }
+      end
+
+      def broker_token
+        @options[:broker_token] || ENV['PACT_BROKER_TOKEN']
+      end
+    end
+
+    # Can't write to a file in a TRAP, might deadlock
+    # Not sure why we can still write to the pact file though
+    class StdoutLogger
+      def info message
+        $stdout.puts "\n#{message}"
+      end
+    end
+  end
+end

data/lib/pact/mock_service/app_manager.rb

@@ -0,0 +1,156 @@
+require 'net/http'
+require 'uri'
+require 'pact/logging'
+require 'pact/consumer/server'
+require 'singleton'
+require 'pact/mock_service/app'
+
+module Pact
+  module MockService
+    class AppManager
+
+      include Pact::Logging
+
+      include Singleton
+
+      def initialize
+        @apps_spawned = false
+        @app_registrations = []
+      end
+
+      def register_mock_service_for(name, url, options = {})
+        uri = URI(url)
+        raise "Currently only http is supported" unless uri.scheme == 'http'
+        uri.port = nil if options[:find_available_port]
+
+        app = Pact::MockService.new(
+          name: name,
+          log_file: create_log_file(name),
+          pact_dir: pact_dir,
+          pact_specification_version: options.fetch(:pact_specification_version)
+        )
+        register(app, uri.host, uri.port)
+      end
+
+      def register(app, host, port = nil)
+        if port
+          existing = existing_app_on_host_and_port(host, port)
+          raise "Port #{port} is already being used by #{existing}" if existing and not existing == app
+        end
+        app_registration = register_app(app, host, port)
+        app_registration.spawn
+        app_registration.port
+      end
+
+      def urls_of_mock_services
+        app_registrations.find_all(&:is_a_mock_service?).collect{ |ar| "http://#{ar.host}:#{ar.port}" }
+      end
+
+      def kill_all
+        app_registrations.find_all(&:spawned?).collect(&:kill)
+        @apps_spawned = false
+      end
+
+      def clear_all
+        kill_all
+        @app_registrations = []
+      end
+
+      def spawn_all
+        app_registrations.find_all(&:not_spawned?).collect(&:spawn)
+        @apps_spawned = true
+      end
+
+      def app_registered_on?(port)
+        app_registrations.any? { |app_registration| app_registration.port == port }
+      end
+
+      private
+
+      def existing_app_on_host_and_port(host, port)
+        app_registration = registration_on_host_and_port(host, port)
+        app_registration ? app_registration.app : nil
+      end
+
+      def registration_on_host_and_port(host, port)
+        @app_registrations.find { |app_registration| app_registration.port == port && app_registration.host == host }
+      end
+
+      def pact_dir
+        Pact.configuration.pact_dir
+      end
+
+      def create_log_file(service_name)
+        FileUtils::mkdir_p(Pact.configuration.log_dir)
+        log = File.open(log_file_path(service_name), 'w')
+        log.sync = true
+        log
+      end
+
+      def log_file_path(service_name)
+        File.join(Pact.configuration.log_dir, "#{log_file_name(service_name)}.log")
+      end
+
+      def log_file_name(service_name)
+        lower_case_name = service_name.downcase.gsub(/\s+/, '_')
+        if lower_case_name.include?('_service')
+          lower_case_name.gsub('_service', '_mock_service')
+        else
+          lower_case_name + '_mock_service'
+        end
+      end
+
+      def app_registrations
+        @app_registrations
+      end
+
+      def register_app(app, host, port)
+        app_registration = AppRegistration.new(app: app, host: host, port: port)
+        app_registrations << app_registration
+        app_registration
+      end
+    end
+
+    class AppRegistration
+      include Pact::Logging
+      attr_accessor :host, :port, :app
+
+      def initialize(opts)
+        @max_wait = 10
+        @port = opts[:port]
+        @host = opts[:host]
+        @app = opts[:app]
+        @spawned = false
+      end
+
+      def kill
+        logger.debug "Supposed to be stopping"
+        @spawned = false
+      end
+
+      def not_spawned?
+        !spawned?
+      end
+
+      def spawned?
+        @spawned
+      end
+
+      def is_a_mock_service?
+        app.is_a?(Pact::MockService::App)
+      end
+
+      def to_s
+        "#{app} on port #{port}"
+      end
+
+      def spawn
+        logger.info "Starting app #{self}..."
+        @server = Pact::Server.new(app, host, port).boot
+        @port = @server.port
+        @spawned = true
+        logger.info "Started on port #{port}"
+      end
+    end
+  end
+end

data/lib/pact/mock_service/cli/custom_thor.rb

@@ -0,0 +1,74 @@
+require 'thor'
+
+module Pact
+  module MockService
+    class CLI < Thor
+      ##
+      # Custom Thor task allows the following:
+      #
+      # `script arg1 arg2` to be interpreted as `script <default_task> arg1 arg2`
+      # `--option 1 --option 2` to be interpreted as `--option 1 2` (the standard Thor format for multiple value options)
+      # `script --help` to display the help for the default task instead of the command list
+      #
+      class CustomThor < ::Thor
+        def self.exit_on_failure? # Thor 1.0 deprecation guard
+          false
+        end
+
+        no_commands do
+          def self.start given_args = ARGV, config = {}
+            super(massage_args(given_args))
+          end
+
+          def help *args
+            if args.empty?
+              super(self.class.default_task)
+            else
+              super
+            end
+          end
+
+          def self.massage_args argv
+            prepend_default_task_name(turn_muliple_tag_options_into_array(argv))
+          end
+
+          def self.prepend_default_task_name argv
+            if known_first_arguments.include?(argv[0])
+              argv
+            else
+              [default_command] + argv
+            end
+          end
+
+          # other task names, help, and the help shortcuts
+          def self.known_first_arguments
+            @known_first_arguments ||= tasks.keys + ::Thor::HELP_MAPPINGS + ['help']
+          end
+
+          def self.turn_muliple_tag_options_into_array argv
+            new_argv = []
+            opt_name = nil
+            argv.each_with_index do | arg, i |
+              if arg.start_with?('-')
+                opt_name = arg
+                existing = new_argv.find { | a | a.first == opt_name }
+                if !existing
+                  new_argv << [arg]
+                end
+              else
+                if opt_name
+                  existing = new_argv.find { | a | a.first == opt_name }
+                  existing << arg
+                  opt_name = nil
+                else
+                  new_argv << [arg]
+                end
+              end
+            end
+            new_argv.flatten
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/cli/pidfile.rb

@@ -0,0 +1,99 @@
+require 'fileutils'
+
+module Pact
+  module MockService
+    class CLI < Thor
+      def self.exit_on_failure? # Thor 1.0 deprecation guard
+        false
+      end
+
+      class Pidfile
+        attr_accessor :pid_dir, :name, :pid
+
+        def initialize options
+          @pid_dir = options[:pid_dir] || 'tmp/pids'
+          @name = options[:name] || default_name
+          @pid = options[:pid] || Process.pid
+        end
+
+        def file_exists?
+          File.exist?(pidfile_path)
+        end
+
+        def process_running?
+          process_exists? pid_from_file
+        end
+
+        def pidfile_path
+          File.join(pid_dir, name)
+        end
+
+        def pid_from_file
+          File.read(pidfile_path).to_i
+        end
+
+        def default_name
+          File.basename($0, File.extname($0)) + ".pid"
+        end
+
+        def process_exists? pid
+          Process.kill 0, pid
+          true
+        rescue  Errno::ESRCH
+          false
+        end
+
+        def file_exists_and_process_running?
+          file_exists? && process_running?
+        end
+
+        def can_start?
+          if file_exists? && process_running?
+            $stderr.puts "Server already running."
+            false
+          elsif file_exists?
+            $stderr.puts "WARN: PID file #{pidfile_path} already exists, but process is not running. Overwriting pidfile."
+            true
+          else
+            true
+          end
+        end
+
+        def write
+          FileUtils.mkdir_p pid_dir
+          File.open(pidfile_path, "w") { |file| file << pid }
+        end
+
+        def delete
+          FileUtils.rm pidfile_path
+        end
+
+        def waitpid
+          tries = 0
+          sleep_time = 0.1
+          while process_running? && tries < 100
+            sleep sleep_time
+            tries += 1
+          end
+          raise "Process #{pid_from_file} not stopped after {100 * sleep_time} seconds." if process_running?
+        end
+
+        def kill_process
+          if file_exists?
+            begin
+              `ps -ef | grep pact`
+              Process.kill 2, pid_from_file
+              waitpid
+              delete
+            rescue Errno::ESRCH
+              $stderr.puts "Process in PID file #{pidfile_path} not running. Deleting PID file."
+              delete
+            end
+          else
+            $stderr.puts "No PID file found at #{pidfile_path}, server probably not running. Use `ps -ef | grep pact` if you suspect the process is still running."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/cli.rb

@@ -0,0 +1,213 @@
+require 'thor'
+
+module Pact
+  module MockService
+    class CLI < Thor
+      def self.exit_on_failure? # Thor 1.0 deprecation guard
+        false
+      end
+
+      PACT_FILE_WRITE_MODE_DESC = "`overwrite` or `merge`. Use `merge` when running multiple mock service instances in parallel for the same consumer/provider pair." +
+      " Ensure the pact file is deleted before running tests when using this option so that interactions deleted from the code are not maintained in the file."
+
+      desc 'service', "Start a mock service. If the consumer, provider and pact-dir options are provided, the pact will be written automatically on shutdown (INT)."
+      method_option :consumer, desc: "Consumer name"
+      method_option :provider, desc: "Provider name"
+      method_option :port, aliases: "-p", desc: "Port on which to run the service"
+      method_option :host, aliases: "-h", desc: "Host on which to bind the service", default: 'localhost'
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written"
+      method_option :pact_file_write_mode, aliases: "-m", desc: PACT_FILE_WRITE_MODE_DESC, type: :string, default: 'overwrite'
+      method_option :pact_specification_version, aliases: "-i", desc: "The pact specification version to use when writing the pact. Note that only versions 1 and 2 are currently supported.", default: '2'
+      method_option :log, aliases: "-l", desc: "File to which to log output"
+      method_option :log_level, desc: "Log level. Options are DEBUG INFO WARN ERROR", default: "DEBUG"
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS", type: :boolean, default: false
+      method_option :sslcert, desc: "Specify the path to the SSL cert to use when running the service over HTTPS"
+      method_option :sslkey, desc: "Specify the path to the SSL key to use when running the service over HTTPS"
+      method_option :monkeypatch, hide: true
+
+      def service
+        require_common_dependencies
+        require 'pact/mock_service/run'
+        Run.(options)
+      end
+
+      desc 'control', "Run a Pact mock service control server."
+      method_option :port, aliases: "-p", desc: "Port on which to run the service"
+      method_option :host, aliases: "-h", desc: "Host on which to bind the service", default: 'localhost'
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written"
+      method_option :log_dir, aliases: "-l", desc: "File to which to log output"
+      method_option :log_level, desc: "Log level. Options are DEBUG INFO WARN ERROR", default: "DEBUG"
+      method_option :pact_file_write_mode, aliases: "-m", desc: PACT_FILE_WRITE_MODE_DESC, type: :string, default: 'overwrite'
+      method_option :pact_specification_version, aliases: "-i", desc: "The pact specification version to use when writing the pact. Note that only versions 1 and 2 are currently supported.", default: '2'
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS", type: :boolean, default: false
+      method_option :sslcert, desc: "Specify the path to the SSL cert to use when running the service over HTTPS"
+      method_option :sslkey, desc: "Specify the path to the SSL key to use when running the service over HTTPS"
+
+      def control
+        require_common_dependencies
+        require 'pact/mock_service/control_server/run'
+        ControlServer::Run.(options)
+      end
+
+      desc 'start', "Start a mock service. If the consumer, provider and pact-dir options are provided, the pact will be written automatically on shutdown (INT)."
+      method_option :consumer, desc: "Consumer name"
+      method_option :provider, desc: "Provider name"
+      method_option :port, aliases: "-p", default: '1234', desc: "Port on which to run the service"
+      method_option :host, aliases: "-h", desc: "Host on which to bind the service", default: 'localhost'
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written"
+      method_option :pact_file_write_mode, aliases: "-m", desc: PACT_FILE_WRITE_MODE_DESC, type: :string, default: 'overwrite'
+      method_option :pid_dir, desc: "PID dir", default: 'tmp/pids'
+      method_option :log, aliases: "-l", desc: "File to which to log output"
+      method_option :log_level, desc: "Log level. Options are DEBUG INFO WARN ERROR", default: "DEBUG"
+      method_option :pact_specification_version, aliases: "-i", desc: "The pact specification version to use when writing the pact. Note that only versions 1 and 2 are currently supported.", default: '2'
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS", type: :boolean, default: false
+      method_option :sslcert, desc: "Specify the path to the SSL cert to use when running the service over HTTPS"
+      method_option :sslkey, desc: "Specify the path to the SSL key to use when running the service over HTTPS"
+      method_option :monkeypatch, hide: true
+
+      def start
+        require_common_dependencies
+        start_server(mock_service_pidfile) do
+          service
+        end
+      end
+
+      desc 'stop', "Stop a Pact mock service"
+      method_option :port, aliases: "-p", desc: "Port of the service to stop", default: '1234', required: true
+      method_option :pid_dir, desc: "PID dir, defaults to tmp/pids", default: "tmp/pids"
+
+      def stop
+        require_common_dependencies
+        mock_service_pidfile.kill_process
+      end
+
+      desc 'restart', "Start or restart a mock service. If the consumer, provider and pact-dir options are provided, the pact will be written automatically on shutdown (INT)."
+      method_option :consumer, desc: "Consumer name"
+      method_option :provider, desc: "Provider name"
+      method_option :port, aliases: "-p", default: '1234', desc: "Port on which to run the service"
+      method_option :host, aliases: "-h", desc: "Host on which to bind the service", default: 'localhost'
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written"
+      method_option :pact_file_write_mode, aliases: "-m", desc: PACT_FILE_WRITE_MODE_DESC, type: :string, default: 'overwrite'
+      method_option :pid_dir, desc: "PID dir", default: 'tmp/pids'
+      method_option :log, aliases: "-l", desc: "File to which to log output"
+      method_option :log_level, desc: "Log level. Options are DEBUG INFO WARN ERROR", default: "DEBUG"
+      method_option :pact_specification_version, aliases: "-i", desc: "The pact specification version to use when writing the pact. Note that only versions 1 and 2 are currently supported.", default: '2'
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS", type: :boolean, default: false
+      method_option :sslcert, desc: "Specify the path to the SSL cert to use when running the service over HTTPS"
+      method_option :sslkey, desc: "Specify the path to the SSL key to use when running the service over HTTPS"
+
+      def restart
+        require_common_dependencies
+        restart_server(mock_service_pidfile) do
+          service
+        end
+      end
+
+      desc 'control-start', "Start a Pact mock service control server."
+      method_option :port, aliases: "-p", desc: "Port on which to run the service", default: '1234'
+      method_option :host, aliases: "-h", desc: "Host on which to bind the service", default: 'localhost'
+      method_option :log_dir, aliases: "-l", desc: "File to which to log output", default: "log"
+      method_option :log_level, desc: "Log level. Options are DEBUG INFO WARN ERROR", default: "DEBUG"
+      method_option :pact_file_write_mode, aliases: "-m", desc: PACT_FILE_WRITE_MODE_DESC, type: :string, default: 'overwrite'
+      method_option :pact_specification_version, aliases: "-i", desc: "The pact specification version to use when writing the pact", default: '2'
+      method_option :pid_dir, desc: "PID dir", default: "tmp/pids"
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS", type: :boolean, default: false
+      method_option :sslcert, desc: "Specify the path to the SSL cert to use when running the service over HTTPS"
+      method_option :sslkey, desc: "Specify the path to the SSL key to use when running the service over HTTPS"
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written", default: "."
+
+      def control_start
+        require_common_dependencies
+        start_server(control_server_pidfile) do
+          control
+        end
+      end
+
+      desc 'control-stop', "Stop a Pact mock service control server."
+      method_option :port, aliases: "-p", desc: "Port of control server to stop", default: "1234"
+      method_option :pid_dir, desc: "PID dir, defaults to tmp/pids", default: "tmp/pids"
+
+      def control_stop
+        require_common_dependencies
+        control_server_pidfile.kill_process
+      end
+
+      desc 'control-restart', "Start a Pact mock service control server."
+      method_option :port, aliases: "-p", desc: "Port on which to run the service", default: '1234'
+      method_option :host, aliases: "-h", desc: "Host on which to bind the service", default: 'localhost'
+      method_option :log_dir, aliases: "-l", desc: "File to which to log output", default: "log"
+      method_option :log_level, desc: "Log level. Options are DEBUG INFO WARN ERROR", default: "DEBUG"
+      method_option :pact_dir, aliases: "-d", desc: "Directory to which the pacts will be written", default: "."
+      method_option :pact_file_write_mode, aliases: "-m", desc: PACT_FILE_WRITE_MODE_DESC, type: :string, default: 'overwrite'
+      method_option :pact_specification_version, aliases: "-i", desc: "The pact specification version to use when writing the pact. Note that only versions 1 and 2 are currently supported.", default: '2'
+      method_option :pid_dir, desc: "PID dir", default: "tmp/pids"
+      method_option :cors, aliases: "-o", desc: "Support browser security in tests by responding to OPTIONS requests and adding CORS headers to mocked responses"
+      method_option :ssl, desc: "Use a self-signed SSL cert to run the service over HTTPS", type: :boolean, default: false
+      method_option :sslcert, desc: "Specify the path to the SSL cert to use when running the service over HTTPS"
+      method_option :sslkey, desc: "Specify the path to the SSL key to use when running the service over HTTPS"
+
+      def control_restart
+        require_common_dependencies
+        restart_server(control_server_pidfile) do
+          control
+        end
+      end
+
+      desc 'version', "Show the pact-mock-service gem version"
+
+      def version
+        require 'pact/mock_service/version.rb'
+        puts Pact::MockService::VERSION
+      end
+
+      default_task :service
+
+      no_commands do
+
+        def require_common_dependencies
+          require 'webrick/https'
+          require 'rack/handler/webrick'
+          require 'fileutils'
+          require 'pact/mock_service/server/wait_for_server_up'
+          require 'pact/mock_service/cli/pidfile'
+          require 'socket'
+        end
+
+        def control_server_pidfile
+          Pidfile.new(pid_dir: options[:pid_dir], name: control_pidfile_name)
+        end
+
+        def mock_service_pidfile
+          Pidfile.new(pid_dir: options[:pid_dir], name: mock_service_pidfile_name)
+        end
+
+        def mock_service_pidfile_name
+          "mock-service-#{options[:port]}.pid"
+        end
+
+        def control_pidfile_name
+          "mock-service-control-#{options[:port]}.pid"
+        end
+
+        def start_server pidfile
+          require 'pact/mock_service/server/spawn'
+          Pact::MockService::Server::Spawn.(pidfile, options[:host], options[:port], options[:ssl]) do
+            yield
+          end
+        end
+
+        def restart_server pidfile
+          require 'pact/mock_service/server/respawn'
+          Pact::MockService::Server::Respawn.(pidfile, options[:host], options[:port], options[:ssl]) do
+            yield
+          end
+        end
+      end
+    end
+  end
+end