pact 1.67.4 → 2.0.0

data/lib/pact/provider/pact_config/mixed.rb

@@ -0,0 +1,38 @@
+# # frozen_string_literal: true
+
+module Pact
+  module Provider
+    module PactConfig
+      # Mixed config allows composing one of each: async, grpc, http
+      class Mixed < Base
+        attr_reader :async_config, :grpc_config, :http_config
+
+        def initialize(provider_name:, opts: {})
+          super
+          @provider_setup_server = ProviderServerRunner.new(port: @provider_setup_port, logger: @logger)
+          if @broker_url.present?
+            @pact_proxy_server = PactBrokerProxyRunner.new(
+              port: @pact_proxy_port,
+              pact_broker_host: @broker_url,
+              pact_broker_user: @broker_username,
+              pact_broker_password: @broker_password,
+              pact_broker_token: @broker_token,
+              logger: @logger
+            )
+          end
+          @http_config = opts[:http] ? Http.new(provider_name: provider_name, opts: opts[:http].merge(provider_setup_server: provider_setup_server, pact_proxy_server: @pact_proxy_server)) : nil
+          @grpc_config = opts[:grpc] ? Grpc.new(provider_name: provider_name, opts: opts[:grpc].merge(provider_setup_server: provider_setup_server, pact_proxy_server: @pact_proxy_server)) : nil
+          @async_config = opts[:async] ? Async.new(provider_name: provider_name, opts: opts[:async].merge(provider_setup_server: provider_setup_server, pact_proxy_server: @pact_proxy_server)) : nil
+        end
+
+        def configs
+          [@async_config, @grpc_config, @http_config].compact
+        end
+
+        def start_servers
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/provider/pact_config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# require_relative "pact_config/grpc"
+
+module Pact
+  module Provider
+    module PactConfig
+      def self.new(transport_type, provider_name:, opts: {})
+        case transport_type
+        when :http
+          Http.new(provider_name: provider_name, opts: opts)
+        when :grpc
+          Grpc.new(provider_name: provider_name, opts: opts)
+        when :async
+          Async.new(provider_name: provider_name, opts: opts)
+        when :mixed
+          Mixed.new(provider_name: provider_name, opts: opts)
+        else
+          raise ArgumentError, "unknown transport_type: #{transport_type}"
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/provider_server_runner.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Pact
+  module Provider
+    class ProviderServerRunner
+      attr_reader :logger
+
+      SETUP_PROVIDER_STATE_PATH = "/setup-provider"
+      VERIFY_MESSAGE_PATH = "/verify-message"
+
+      def initialize(port: 9001, host: "127.0.0.1", logger: nil)
+        @host = host
+        @port = port
+        @provider_setup_states = {}
+        @provider_teardown_states = {}
+        @logger = logger || Logger.new($stdout)
+
+        @state_servlet = ProviderStateServlet.new(logger: @logger)
+        @message_servlet = MessageProviderServlet.new(logger: @logger)
+        @thread = nil
+      end
+
+      def state_setup_url
+        "http://#{@host}:#{@port}#{SETUP_PROVIDER_STATE_PATH}"
+      end
+
+      def message_setup_url
+        "http://#{@host}:#{@port}#{VERIFY_MESSAGE_PATH}"
+      end
+
+      def start
+        raise "server already running, stop server before starting new one" if @thread
+
+          @server = WEBrick::HTTPServer.new(
+          { BindAddress: @host, Port: @port, Logger: @logger, AccessLog: [] },
+          WEBrick::Config::HTTP
+          )
+        @server.mount(SETUP_PROVIDER_STATE_PATH, @state_servlet)
+        @server.mount(VERIFY_MESSAGE_PATH, @message_servlet)
+
+        @thread = Thread.new do
+          @logger.debug "starting provider setup server"
+          @server.start
+        end
+      end
+
+      def stop
+        @logger.info("stopping provider setup server")
+
+        @server&.shutdown
+        @thread&.join
+
+        @logger.info("provider setup server stopped")
+      end
+
+      def run
+        start
+
+        yield
+      rescue => e
+        logger.fatal("FATAL ERROR: #{e.message} #{e.backtrace.join("\n")}")
+        raise
+      ensure
+        stop
+      end
+
+      def add_message_handler(state_name, &block)
+        @message_servlet.add_message_handler(state_name, &block)
+      end
+
+      def add_setup_state(state_name, use_before_setup_hook = true, &block)
+        @state_servlet.add_setup_state(state_name, use_before_setup_hook, &block)
+      end
+
+      def add_teardown_state(state_name, use_after_teardown_hook = true, &block)
+        @state_servlet.add_teardown_state(state_name, use_after_teardown_hook, &block)
+      end
+
+      def set_before_setup_hook(&block)
+        @state_servlet.before_setup(&block)
+      end
+
+      def set_after_teardown_hook(&block)
+        @state_servlet.after_teardown(&block)
+      end
+    end
+  end
+end

data/lib/pact/provider/provider_state_configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pact
+  module Provider
+    class ProviderStateConfiguration
+      attr_reader :name, :opts, :setup_proc, :teardown_proc
+
+      class ProviderStateConfigurationError < ::Pact::Error; end
+
+      def initialize(name, opts: {})
+        @name = name
+        @opts = opts
+        @setup_proc = nil
+        @teardown_proc = nil
+      end
+
+      def set_up(&block)
+        @setup_proc = block
+      end
+
+      def tear_down(&block)
+        @teardown_proc = block
+      end
+
+      def validate!
+        return if @setup_proc || @teardown_proc
+
+        raise ProviderStateConfigurationError.new("no hooks configured for state #{@name}: \"provider_state\" declaration only needed if setup/teardown hooks are used for that state. Please add hooks or remove \"provider_state\" declaration") # rubocop:disable Layout/LineLength
+      end
+    end
+  end
+end

data/lib/pact/provider/provider_state_servlet.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Pact
+  module Provider
+    class ProviderStateServlet < WEBrick::HTTPServlet::ProcHandler
+      attr_reader :logger
+
+      def initialize(logger: nil)
+        super(build_proc)
+
+        @logger = logger || Logger.new($stdout)
+
+        @provider_setup_states = {}
+        @provider_teardown_states = {}
+
+        @before_setup_hook_proc = nil
+        @after_teardown_hook_proc = nil
+
+        @global_setup_hook = ::Pact.configuration.before_provider_state_proc
+        @global_teardown_hook = ::Pact.configuration.after_provider_state_proc
+      end
+
+      def add_setup_state(name, use_before_setup_hook, &block)
+        raise "provider state #{name} already configured" if @provider_setup_states[name].present?
+
+        @provider_setup_states[name] = {proc: block, use_hooks: use_before_setup_hook}
+      end
+
+      def add_teardown_state(name, use_after_teardown_hook, &block)
+        raise "provider state #{name} already configured" if @provider_teardown_states[name].present?
+
+        @provider_teardown_states[name] = {proc: block, use_hooks: use_after_teardown_hook}
+      end
+
+      def before_setup(&block)
+        @before_setup_hook_proc = block
+      end
+
+      def after_teardown(&block)
+        @after_teardown_hook_proc = block
+      end
+
+      private
+
+      def call_setup(state_name, state_data)
+        logger.debug "call_setup #{state_name} with #{state_data}"
+        @global_setup_hook&.call
+        @before_setup_hook_proc&.call(state_name, state_data) if @provider_setup_states.dig(state_name, :use_hooks)
+        @provider_setup_states.dig(state_name, :proc)&.call(state_data)
+      end
+
+      def call_teardown(state_name, state_data)
+        logger.debug "call_teardown #{state_name} with #{state_data}"
+        @provider_teardown_states.dig(state_name, :proc)&.call(state_data)
+        @after_teardown_hook_proc&.call(state_name, state_data) if @provider_setup_states.dig(state_name, :use_hooks)
+        @global_teardown_hook&.call
+      end
+
+      def build_proc
+        proc do |request, response|
+          # {"action" => "setup", "params" => {"order_uuid" => "mxfcpcsfUOHO"},"state" => "order exists and can be saved"}
+          # {"action"=> "teardown", "params" => {"order_uuid" => "mxfcpcsfUOHO"}, "state" => "order exists and can be saved"}
+          data = JSON.parse(request.body)
+
+          action = data["action"]
+          state_name = data["state"]
+          state_data = data["params"]
+
+          logger.warn("unknown callback state action: #{action}") if action.blank?
+
+          call_setup(state_name, state_data) if action == "setup"
+          call_teardown(state_name, state_data) if action == "teardown"
+
+          response.status = 200
+        rescue JSON::ParserError => ex
+          logger.error("cannot parse request: #{ex.message}")
+          response.status = 500
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider.rb

@@ -1,3 +1,6 @@
-require 'pact/configuration'
-require 'pact/provider/configuration'
-require 'pact/provider/world'
+# frozen_string_literal: true
+
+module Pact
+  module Provider
+  end
+end

data/lib/pact/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module Pact
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'pact/tasks/pact.rake'
+    end
+  end
+end

data/lib/pact/{v2/rspec → rspec}/support/pact_consumer_helpers.rb

@@ -3,9 +3,9 @@
 require_relative "pact_message_helpers"
 require "json"
 
-module PactV2ConsumerDsl
-  include Pact::V2::Matchers
-  include Pact::V2::Generators
+module PactConsumerDsl
+  include Pact::Matchers
+  include Pact::Generators
 
   module ClassMethods
     def has_http_pact_between(consumer, provider, opts: {})
@@ -39,7 +39,7 @@ module PactV2ConsumerDsl
 
       # rubocop:disable RSpec/BeforeAfterAll
       before(:context) do
-        @_pact_config = Pact::V2::Consumer::PactConfig.new(transport_type, consumer_name: consumer, provider_name: provider, opts: opts)
+        @_pact_config = Pact::Consumer::PactConfig.new(transport_type, consumer_name: consumer, provider_name: provider, opts: opts)
       end
       # rubocop:enable RSpec/BeforeAfterAll
     end
@@ -59,7 +59,7 @@ module PactV2ConsumerDsl
 
   def execute_http_pact
     raise InteractionBuilderError.new("interaction is designed to be used one-time only") if defined?(@used)
-    mock_server = Pact::V2::Consumer::MockServer.create_for_http!(
+    mock_server = Pact::Consumer::MockServer.create_for_http!(
       pact: pact_config.pact_handle, host: pact_config.mock_host, port: pact_config.mock_port
     )
 
@@ -70,7 +70,7 @@ module PactV2ConsumerDsl
       mock_server.write_pacts!(pact_config.pact_dir)
     else
       msg = mismatches_error_msg(mock_server)
-      raise Pact::V2::Consumer::HttpInteractionBuilder::InteractionMismatchesError.new(msg)
+      raise Pact::Consumer::HttpInteractionBuilder::InteractionMismatchesError.new(msg)
     end
     @used = true
     mock_server&.cleanup
@@ -88,6 +88,6 @@ module PactV2ConsumerDsl
 end
 
 RSpec.configure do |config|
-  config.include PactV2ConsumerDsl, pact_entity: :consumer
-  config.extend PactV2ConsumerDsl::ClassMethods, pact_entity: :consumer
+  config.include PactConsumerDsl, pact_entity: :consumer
+  config.extend PactConsumerDsl::ClassMethods, pact_entity: :consumer
 end

data/lib/pact/{v2/rspec → rspec}/support/pact_provider_helpers.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "pact_message_helpers"
-require_relative "webmock/webmock_helpers"
+require_relative 'pact_message_helpers'
+require_relative 'webmock/webmock_helpers'
 
-module PactV2ProducerDsl
+module PactProducerDsl
   module ClassMethods
-    PACT_PROVIDER_NOT_DECLARED_MESSAGE = "http_pact_provider or grpc_pact_provider should be declared first"
+    PACT_PROVIDER_NOT_DECLARED_MESSAGE = 'http_pact_provider or grpc_pact_provider should be declared first'
 
     def http_pact_provider(provider, opts: {})
       _pact_provider(:http, provider, opts: opts)
@@ -26,22 +26,21 @@ module PactV2ProducerDsl
     def execute_mixed_pact_provider(transport_type, provider, opts: {})
       raise "#{transport_type}_pact_provider is designed to be used with RSpec" unless defined?(::RSpec)
       raise "#{transport_type}_pact_provider has to be declared at the top level of a suite" unless top_level?
-      raise "mixed_pact_provider is designed to be run once per provider so cannot be declared more than once" if defined?(@_pact_config)
+      if defined?(@_pact_config)
+        raise 'mixed_pact_provider is designed to be run once per provider so cannot be declared more than once'
+      end
 
-      pact_config_instance = Pact::V2::Provider::PactConfig.new(transport_type, provider_name: provider, opts: opts)
+      pact_config_instance = Pact::Provider::PactConfig.new(transport_type, provider_name: provider, opts: opts)
       instance_variable_set(:@_pact_config, pact_config_instance)
 
-      # rubocop:disable RSpec/BeforeAfterAll
       before(:context) do
         # rspec allows only context ivars in specs and ignores the rest
         # so we use block-as-a-closure feature to save pact_config ivar reference and make it available for descendants
         @_pact_config = pact_config_instance
       end
-      # rubocop:enable RSpec/BeforeAfterAll
-
       it "verifies mixed interactions with provider #{provider}" do
         pact_config.start_servers
-        # todo: call any available verifier, or exit if none specified
+        # TODO: call any available verifier, or exit if none specified
         pact_config.http_config.new_verifier(@_pact_config).verify!
       end
     end
@@ -49,19 +48,18 @@ module PactV2ProducerDsl
     def _pact_provider(transport_type, provider, opts: {})
       raise "#{transport_type}_pact_provider is designed to be used with RSpec" unless defined?(::RSpec)
       raise "#{transport_type}_pact_provider has to be declared at the top level of a suite" unless top_level?
-      raise "*_pact_provider is designed to be run once per provider so cannot be declared more than once" if defined?(@_pact_config)
+      if defined?(@_pact_config)
+        raise '*_pact_provider is designed to be run once per provider so cannot be declared more than once'
+      end
 
-      pact_config_instance = Pact::V2::Provider::PactConfig.new(transport_type, provider_name: provider, opts: opts)
+      pact_config_instance = Pact::Provider::PactConfig.new(transport_type, provider_name: provider, opts: opts)
       instance_variable_set(:@_pact_config, pact_config_instance)
 
-      # rubocop:disable RSpec/BeforeAfterAll
       before(:context) do
         # rspec allows only context ivars in specs and ignores the rest
         # so we use block-as-a-closure feature to save pact_config ivar reference and make it available for descendants
         @_pact_config = pact_config_instance
       end
-      # rubocop:enable RSpec/BeforeAfterAll
-
       it "verifies interactions with provider #{provider}" do
         pact_config.new_verifier.verify!
       end
@@ -69,37 +67,40 @@ module PactV2ProducerDsl
 
     def before_state_setup(&block)
       raise PACT_PROVIDER_NOT_DECLARED_MESSAGE unless pact_config
+
       pact_config.before_setup(&block)
     end
 
     def after_state_teardown(&block)
       raise PACT_PROVIDER_NOT_DECLARED_MESSAGE unless pact_config
+
       pact_config.after_teardown(&block)
     end
 
     def provider_state(name, opts: {}, &block)
       raise PACT_PROVIDER_NOT_DECLARED_MESSAGE unless pact_config
+
       pact_config.new_provider_state(name, opts: opts, &block)
     end
 
     def handle_message(name, opts: {}, &block)
-      async_klass = Pact::V2::Provider::PactConfig::Async
+      async_klass = Pact::Provider::PactConfig::Async
       if defined?(@_pact_config) &&
-          @_pact_config.respond_to?(:async_config) &&
-          @_pact_config.async_config.is_a?(async_klass)
+         @_pact_config.respond_to?(:async_config) &&
+         @_pact_config.async_config.is_a?(async_klass)
         @_pact_config.async_config.new_message_handler(name, opts: opts, &block)
       elsif pact_config &&
-          pact_config.respond_to?(:async_config) &&
-          pact_config.async_config.is_a?(async_klass)
+            pact_config.respond_to?(:async_config) &&
+            pact_config.async_config.is_a?(async_klass)
         pact_config.async_config.new_message_handler(name, opts: opts, &block)
       elsif defined?(@_pact_config) &&
-          @_pact_config.is_a?(async_klass)
+            @_pact_config.is_a?(async_klass)
         @_pact_config.new_message_handler(name, opts: opts, &block)
       elsif pact_config.is_a?(async_klass)
         pact_config.new_message_handler(name, opts: opts, &block)
 
       else
-        raise "handle_message can only be used with message_pact_provider or mixed_pact_provider with an async block"
+        raise 'handle_message can only be used with message_pact_provider or mixed_pact_provider with an async block'
       end
     end
 
@@ -114,8 +115,8 @@ module PactV2ProducerDsl
 end
 
 RSpec.configure do |config|
-  config.include PactV2ProducerDsl, pact_entity: :provider
-  config.extend PactV2ProducerDsl::ClassMethods, pact_entity: :provider
+  config.include PactProducerDsl, pact_entity: :provider
+  config.extend PactProducerDsl::ClassMethods, pact_entity: :provider
 
   config.around pact_entity: :provider do |example|
     WebmockHelpers.turned_off do

data/lib/pact/{v2/rspec.rb → rspec.rb}

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-require "rspec"
-require_relative "rspec/support/pact_consumer_helpers"
-require_relative "rspec/support/pact_provider_helpers"
+require 'rspec'
+require 'pact'
+require_relative 'rspec/support/pact_consumer_helpers'
+require_relative 'rspec/support/pact_provider_helpers'
 
 RSpec.configure do |config|
   config.define_derived_metadata(file_path: %r{spec/pact/}) { |metadata| metadata[:pact] = true }
 
-  # it's not an error: consumer tests contain `providers` subdirectory (because we're testing against different providers)
+  # it's not an error: consumer tests contain `providers` subdirectory (because we're testing against different providers) # rubocop:disable Layout/LineLength
   config.define_derived_metadata(file_path: %r{spec/pact/providers/}) { |metadata| metadata[:pact_entity] = :consumer }
   # for provider tests it's the same thing: we're running tests which test consumers
   config.define_derived_metadata(file_path: %r{spec/pact/consumers/}) { |metadata| metadata[:pact_entity] = :provider }
 
   # exclude pact specs from generic rspec pipeline
-  config.filter_run_excluding :pact_v2
+  config.filter_run_excluding :pact
 end

data/lib/pact/tasks/pact.rake

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:pact).tap do |task|
+  task.pattern = 'spec/pact/consumers/**/*_spec.rb'
+  task.rspec_opts = '--require rails_helper --tag pact'
+end
+
+namespace :pact do
+  desc 'Verifies the pact files'
+  task verify: :pact
+end

data/lib/pact/version.rb

@@ -1,4 +1,4 @@
 # Remember to bump pact-provider-proxy when this changes major version
 module Pact
-  VERSION = "1.67.4"
+  VERSION = "2.0.0"
 end

data/lib/pact.rb

@@ -1,12 +1,47 @@
-require 'pact/support'
-require 'pact/version'
-require 'pact/configuration'
-require 'pact/consumer'
-require 'pact/provider'
-require 'pact/consumer_contract'
-
-begin
-  require 'pact/v2'
-rescue LoadError
-  # "Please ensure that the 'pact-ffi' gem is included in your Gemfile for pact/v2 support."
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'pact/ffi'
+
+require 'pact/railtie' if defined?(Rails::Railtie)
+
+module Pact
+  class Error < StandardError; end
+
+  class ImplementationRequired < Error; end
+
+  class FfiError < Error
+    def initialize(msg, reason, status)
+      super(msg)
+
+      @msg = msg
+      @reason = reason
+      @status = status
+    end
+
+    def message
+      "FFI error: reason: #{@reason}, status: #{@status}, message: #{@msg}"
+    end
+  end
+
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  def self.configuration
+    @configuration ||= Pact::Configuration.new
+  end
 end
+
+loader = Zeitwerk::Loader.new
+loader.push_dir(File.join(__dir__))
+
+loader.tag = 'pact'
+
+loader.ignore("#{__dir__}/pact/version.rb")
+loader.ignore("#{__dir__}/pact/rspec.rb")
+loader.ignore("#{__dir__}/pact/rspec")
+loader.ignore("#{__dir__}/pact/railtie.rb") unless defined?(Rails::Railtie)
+
+loader.setup
+loader.eager_load