pact 1.67.4 → 2.0.0

data/lib/pact/matchers/v3/number.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V3
+      class Number < Pact::Matchers::Base
+        def initialize(template)
+          unless template.is_a?(Numeric)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{template} should be an instance of Numeric"
+          end
+
+          super(spec_version: Pact::Matchers::PACT_SPEC_V3, kind: 'number', template: template)
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/v3/semver.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V3
+      class Semver < Pact::Matchers::Base
+        def initialize(template = nil)
+          @template = template
+          super(spec_version: Pact::Matchers::PACT_SPEC_V3, kind: 'semver', template: template)
+        end
+
+        def as_plugin
+          if @template.nil? || @template.blank?
+            raise MatcherInitializationError, "#{self.class}: template must be provided when calling as_plugin"
+          end
+
+          "matching(semver, '#{@template}')"
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/v3/time.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V3
+      class Time < Pact::Matchers::Base
+        def initialize(format, template)
+          unless template.is_a?(String)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{format} should be an instance of String"
+          end
+          unless template.is_a?(String)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{template} should be an instance of String"
+          end
+
+          super(spec_version: Pact::Matchers::PACT_SPEC_V3, kind: 'time', template: template, opts: { format: format })
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/v3/values.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V3
+      class Values < Pact::Matchers::Base
+        def initialize
+          super(spec_version: Pact::Matchers::PACT_SPEC_V3, kind: 'values', template: nil)
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/v4/each_key.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V4
+      class EachKey < Pact::Matchers::Base
+        def initialize(key_matchers, template)
+          raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+
+          unless key_matchers.is_a?(Array)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{key_matchers} should be an Array"
+          end
+          unless key_matchers.all?(Pact::Matchers::Base)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{key_matchers} should be instances of Pact::Matchers::Base"
+          end
+          unless key_matchers.size > 0
+            raise MatcherInitializationError,
+                  "#{self.class}: #{key_matchers} size should be greater than 0"
+          end
+
+          super(spec_version: Pact::Matchers::PACT_SPEC_V4, kind: 'each-key', template: template, opts: { rules: key_matchers }) # rubocop:disable Layout/LineLength
+        end
+
+        def as_plugin
+          @opts[:rules].map do |matcher|
+            "eachKey(#{matcher.as_plugin})"
+          end.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/v4/each_key_value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V4
+      class EachKeyValue < Pact::Matchers::Base
+        def initialize(key_matchers, template)
+          raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+
+          unless key_matchers.is_a?(Array)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{key_matchers} should be an Array"
+          end
+          unless key_matchers.all?(Pact::Matchers::Base)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{key_matchers} should be instances of Pact::Matchers::Base"
+          end
+
+          super(
+            spec_version: Pact::Matchers::PACT_SPEC_V4,
+            kind: [
+              EachKey.new(key_matchers, {}),
+              EachValue.new([Pact::Matchers::V2::Type.new('')], {})
+            ],
+            template: template
+          )
+
+          @key_matchers = key_matchers
+        end
+
+        def as_plugin
+          raise MatcherInitializationError,
+                "#{self.class}: each-key-value is not supported in plugin syntax. Use each / each_key / each_value matchers instead" # rubocop:disable Layout/LineLength
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/v4/each_value.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V4
+      class EachValue < Pact::Matchers::Base
+        def initialize(value_matchers, template)
+          # raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+          unless value_matchers.is_a?(Array)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{value_matchers} should be an Array"
+          end
+          unless value_matchers.all?(Pact::Matchers::Base)
+            raise MatcherInitializationError,
+                  "#{self.class}: #{value_matchers} should be instances of Pact::Matchers::Base"
+          end
+          unless value_matchers.size > 0
+            raise MatcherInitializationError,
+                  "#{self.class}: #{value_matchers} size should be greater than 0"
+          end
+
+          super(spec_version: Pact::Matchers::PACT_SPEC_V4, kind: 'each-value', template: template, opts: { rules: value_matchers }) # rubocop:disable Layout/LineLength
+        end
+
+        def as_plugin
+          if @template.is_a?(Hash)
+            return {
+              'pact:match' => "eachValue(matching($'SAMPLE'))",
+              'SAMPLE' => serialize!(@template.deep_dup, :plugin)
+            }
+          end
+
+          @opts[:rules].map do |matcher|
+            "eachValue(#{matcher.as_plugin})"
+          end.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/v4/not_empty.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V4
+      class NotEmpty < Pact::Matchers::Base
+        def initialize(template = nil)
+          @template = template
+          super(spec_version: Pact::Matchers::PACT_SPEC_V4, kind: 'notEmpty', template: @template)
+        end
+
+        def as_plugin
+          if @template.nil? || @template.blank?
+            raise MatcherInitializationError, "#{self.class}: template must be provided when calling as_plugin"
+          end
+
+          "notEmpty('#{@template}')"
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/v4/status_code.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V4
+      class StatusCode < Pact::Matchers::Base
+        def initialize(template = nil)
+          super(spec_version: Pact::Matchers::PACT_SPEC_V4, kind: 'statusCode', opts: {
+            'status' => template
+          })
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    PACT_SPEC_V1 = 1
+    PACT_SPEC_V2 = 2
+    PACT_SPEC_V3 = 3
+    PACT_SPEC_V4 = 4
+
+    ANY_STRING_REGEX = /.*/
+    UUID_REGEX = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+
+    # simplified
+    ISO8601_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)*(.\d{2}:\d{2})*/i
+
+    def match_exactly(arg)
+      V1::Equality.new(arg)
+    end
+
+    def match_type_of(arg)
+      V2::Type.new(arg)
+    end
+
+    def match_include(arg)
+      V3::Include.new(arg)
+    end
+
+    def match_any_string(sample = "any")
+      V2::Regex.new(ANY_STRING_REGEX, sample)
+    end
+
+    def match_any_integer(sample = 10)
+      V3::Integer.new(sample)
+    end
+
+    def match_any_decimal(sample = 10.0)
+      V3::Decimal.new(sample)
+    end
+
+    def match_any_number(sample = 10.0)
+      V3::Number.new(sample)
+    end
+
+    def match_any_boolean(sample = true)
+      V3::Boolean.new(sample)
+    end
+
+    def match_uuid(sample = "e1d01e04-3a2b-4eed-a4fb-54f5cd257338")
+      V2::Regex.new(UUID_REGEX, sample)
+    end
+
+    def match_regex(regex, sample)
+      V2::Regex.new(regex, sample)
+    end
+
+    def match_datetime(format, sample)
+      V3::DateTime.new(format, sample)
+    end
+
+    def match_iso8601(sample = "2024-08-12T12:25:00.243118+03:00")
+      V2::Regex.new(ISO8601_REGEX, sample)
+    end
+
+    def match_date(format, sample)
+      V3::Date.new(format, sample)
+    end
+
+    def match_time(format, sample)
+      V3::Time.new(format, sample)
+    end
+
+    def match_each(template, min = nil)
+      V3::Each.new(template, min)
+    end
+
+    def match_each_regex(regex, sample)
+      match_each_value(sample, match_regex(regex, sample))
+    end
+
+    def match_each_key(template, key_matchers)
+      V4::EachKey.new(key_matchers.is_a?(Array) ? key_matchers : [key_matchers], template)
+    end
+
+    def match_each_value(template, value_matchers = V2::Type.new(""))
+      V4::EachValue.new(value_matchers.is_a?(Array) ? value_matchers : [value_matchers], template)
+    end
+
+    def match_each_kv(template, key_matchers)
+      V4::EachKeyValue.new(key_matchers.is_a?(Array) ? key_matchers : [key_matchers], template)
+    end
+
+    def match_semver(template = nil)
+      V3::Semver.new(template)
+    end
+
+    def match_content_type(content_type, template = nil)
+      V3::ContentType.new(content_type, template: template)
+    end
+
+    def match_not_empty(template = nil)
+      V4::NotEmpty.new(template)
+    end
+
+    def match_status_code(template)
+      V4::StatusCode.new(template)
+    end
+  end
+end

data/lib/pact/native/blocking_verifier.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'pact/ffi/verifier'
+
+module Pact
+  module Native
+    module BlockingVerifier
+      extend FFI::Library
+      ffi_lib DetectOS.get_bin_path
+
+      attach_function :execute, :pactffi_verifier_execute, %i[pointer], :int32, blocking: true
+    end
+  end
+end

data/lib/pact/native/logger.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'pact/ffi/logger'
+
+module Pact
+  module Native
+    module Logger
+      LOG_LEVELS = {
+        off: PactFfi::FfiLogLevelFilter['LOG_LEVEL_OFF'],
+        error: PactFfi::FfiLogLevelFilter['LOG_LEVEL_ERROR'],
+        warn: PactFfi::FfiLogLevelFilter['LOG_LEVEL_WARN'],
+        info: PactFfi::FfiLogLevelFilter['LOG_LEVEL_INFO'],
+        debug: PactFfi::FfiLogLevelFilter['LOG_LEVEL_DEBUG'],
+        trace: PactFfi::FfiLogLevelFilter['LOG_LEVEL_TRACE']
+      }.freeze
+
+      def self.log_to_stdout(log_level)
+        raise 'invalid log level for PactFfi::FfiLogLevelFilter' unless LOG_LEVELS.key?(log_level)
+
+        PactFfi::Logger.log_to_stdout(LOG_LEVELS[log_level]) unless log_level == :off
+      end
+    end
+  end
+end

data/lib/pact/provider/async_message_verifier.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'pact/ffi/verifier'
+require 'pact/native/logger'
+
+module Pact
+  module Provider
+    class AsyncMessageVerifier < BaseVerifier
+      PROVIDER_TRANSPORT_TYPE = 'message'
+
+      def initialize(pact_config, mixed_config = nil)
+        super
+
+        return if pact_config.is_a?(::Pact::Provider::PactConfig::Async)
+
+        raise ArgumentError,
+              'pact_config must be an instance of Pact::Provider::PactConfig::Message'
+      end
+
+      private
+
+      def add_provider_transport(pact_handle)
+        setup_uri = URI(@pact_config.message_setup_url)
+        PactFfi::Verifier.add_provider_transport(pact_handle, PROVIDER_TRANSPORT_TYPE, setup_uri.port, setup_uri.path,
+                                                 '')
+      end
+    end
+  end
+end

data/lib/pact/provider/base_verifier.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require 'pact/ffi/verifier'
+require 'pact/native/logger'
+require 'pact/native/blocking_verifier'
+
+module Pact
+  module Provider
+    class BaseVerifier
+      PROVIDER_TRANSPORT_TYPE = nil
+      attr_reader :logger
+
+      class VerificationError < Pact::FfiError; end
+
+      class VerifierError < Pact::Error; end
+
+      DEFAULT_CONSUMER_SELECTORS = {}
+
+      # https://docs.rs/pact_ffi/0.4.17/pact_ffi/verifier/fn.pactffi_verify.html#errors
+      VERIFICATION_ERRORS = {
+        1 => { reason: :verification_failed, status: 1,
+               description: 'The verification process failed, see output for errors' },
+        2 => { reason: :null_pointer, status: 2, description: 'A null pointer was received' },
+        3 => { reason: :internal_error, status: 3, description: 'The method panicked' },
+        4 => { reason: :invalid_arguments, status: 4,
+               description: 'Invalid arguments were provided to the verification process' }
+      }.freeze
+
+      # env below are set up by pipeline-builder
+      # see paas/cicd/images/pact/pipeline-builder/-/blob/master/internal/commands/consumers-pipeline/ruby.go
+      def initialize(pact_config, mixed_config = nil)
+        unless pact_config.is_a?(::Pact::Provider::PactConfig::Base)
+          raise ArgumentError,
+                'pact_config must be a subclass of Pact::Provider::PactConfig::Base'
+        end
+
+        @pact_config = pact_config
+        @mixed_config = mixed_config
+        @logger = @pact_config.logger || Logger.new($stdout)
+      end
+
+      def verify!
+        raise VerifierError.new('interaction is designed to be used one-time only') if defined?(@used)
+
+        # if consumer_selectors.blank?
+        #   logger.info("[verifier] does not need to verify consumer #{@pact_config.consumer_name}")
+        #   return
+        # end
+
+        exception = nil
+        pact_handle = init_pact
+
+        start_servers!
+
+        logger.info('[verifier] starting provider verification')
+
+        result = Pact::Native::BlockingVerifier.execute(pact_handle)
+        if VERIFICATION_ERRORS[result].present?
+          error = VERIFICATION_ERRORS[result]
+          exception = VerificationError.new(
+            "There was an error while trying to verify provider \"#{@pact_config.provider_name}\"", error[:reason], error[:status] # rubocop:disable Layout/LineLength
+          )
+        end
+      ensure
+        @used = true
+        PactFfi::Verifier.shutdown(pact_handle) if pact_handle
+        stop_servers
+        @grpc_server.stop if @grpc_server
+        raise exception if exception
+      end
+
+      private
+
+      def create_c_pointer_array_from_string_array(string_array)
+        pointers = string_array.map { |str| FFI::MemoryPointer.from_string(str) }
+        array_pointer = FFI::MemoryPointer.new(:pointer, pointers.size)
+        pointers.each_with_index do |ptr, index|
+          array_pointer[index].put_pointer(0, ptr)
+        end
+        array_pointer
+      end
+
+      def bool_to_int(value)
+        value ? 1 : 0
+      end
+
+      def init_pact
+        handle = PactFfi::Verifier.new_for_application('pact-ruby', PactFfi.version)
+        set_provider_info(handle)
+
+        if defined?(@mixed_config.grpc_config) && @mixed_config.grpc_config
+          @grpc_server = GrufServer.new(host: "127.0.0.1:#{@mixed_config.grpc_config.grpc_port}",
+                                        services: @mixed_config.grpc_config.grpc_services)
+          @grpc_server.start
+          PactFfi::Verifier.add_provider_transport(handle, 'grpc', @mixed_config.grpc_config.grpc_port, '', '')
+        end
+
+        if defined?(@mixed_config.async_config) && @mixed_config.async_config
+          setup_uri = URI(@mixed_config.async_config.message_setup_url)
+          PactFfi::Verifier.add_provider_transport(handle, 'message', setup_uri.port, setup_uri.path, '')
+        end
+
+        # TODO: add http transport?
+
+        PactFfi::Verifier.set_provider_state(handle, @pact_config.provider_setup_url, 1, 1)
+        PactFfi::Verifier.set_verification_options(handle, 0, 10_000)
+        # pactffi_verifier_set_publish_options(
+        #     handle: *mut VerifierHandle,
+        #     provider_version: *const c_char,
+        #     build_url: *const c_char,
+        #     provider_tags: *const *const c_char,
+        #     provider_tags_len: c_ushort,
+        #     provider_branch: *const c_char,
+        # )
+        c_provider_version_tags = create_c_pointer_array_from_string_array(@pact_config.provider_version_tags)
+        c_provider_version_tags_size = @pact_config.provider_version_tags.size
+        c_consumer_version_tags = create_c_pointer_array_from_string_array(@pact_config.consumer_version_tags)
+        c_consumer_version_tags_size = @pact_config.consumer_version_tags.size
+
+        if @pact_config.provider_build_uri.present?
+          begin
+            URI.parse(@pact_config.provider_build_uri)
+          rescue URI::InvalidURIError
+            raise VerifierError.new('provider_build_uri is not a valid URI')
+          end
+        end
+
+        if @pact_config.publish_verification_results == true
+          if @pact_config.provider_version
+            PactFfi::Verifier.set_publish_options(handle, @pact_config.provider_version,
+                                                  @pact_config.provider_build_uri, c_provider_version_tags, c_provider_version_tags_size, @pact_config.provider_version_branch) # rubocop:disable Layout/LineLength
+          else
+            logger.warn('[verifier] - unable to publish verification results as provider version is not set')
+          end
+        end
+
+        configure_verification_source(handle, c_provider_version_tags, c_provider_version_tags_size,
+                                      c_consumer_version_tags, c_consumer_version_tags_size)
+
+        PactFfi::Verifier.set_no_pacts_is_error(handle, bool_to_int(@pact_config.fail_if_no_pacts_found))
+
+        add_provider_transport(handle)
+
+        # the core doesnt pick up these env vars, so we need to set them here
+        # https://github.com/pact-foundation/pact-reference/issues/451#issuecomment-2338130587
+        # PACT_DESCRIPTION
+        # Only validate interactions whose descriptions match this filter (regex format)
+        # PACT_PROVIDER_STATE
+        # Only validate interactions whose provider states match this filter (regex format)
+        # PACT_PROVIDER_NO_STATE
+        # Only validate interactions that have no defined provider state (true or false)
+        PactFfi::Verifier.set_filter_info(
+          handle,
+          ENV['PACT_DESCRIPTION'] || nil,
+          ENV['PACT_PROVIDER_STATE'] || nil,
+          bool_to_int(ENV['PACT_PROVIDER_NO_STATE'] || false)
+        )
+
+        Pact::Native::Logger.log_to_stdout(@pact_config.log_level)
+
+        logger.info("[verifier] verification initialized for provider #{@pact_config.provider_name}, version #{@pact_config.provider_version}, transport #{self.class::PROVIDER_TRANSPORT_TYPE}") # rubocop:disable Layout/LineLength
+
+        handle
+      end
+
+      def set_provider_info(pact_handle)
+        #   pub extern "C" fn pactffi_verifier_set_provider_info(
+        #     handle: *mut VerifierHandle,
+        #     name: *const c_char,
+        #     scheme: *const c_char,
+        #     host: *const c_char,
+        #     port: c_ushort,
+        #     path: *const c_char,
+        # ) {
+        PactFfi::Verifier.set_provider_info(pact_handle, @pact_config.provider_name, '', '', 0, '')
+      end
+
+      def add_provider_transport(pact_handle)
+        raise PactImplementationRequired, 'Implement #add_provider_transport in a subclass'
+      end
+
+      def start_servers!
+        logger.info('[verifier] starting services')
+
+        @servers_started = true
+        @pact_config.start_servers
+      end
+
+      def stop_servers
+        return unless @servers_started
+
+        logger.info('[verifier] stopping services')
+
+        @pact_config.stop_servers
+      end
+
+      def configure_verification_source(handle, c_provider_version_tags, c_provider_version_tags_size,
+                                        c_consumer_version_tags, c_consumer_version_tags_size)
+        logger.info('[verifier] configuring verification source')
+        if @pact_config.pact_broker_proxy_url.blank? && @pact_config.pact_uri.blank?
+          path = @pact_config.pact_dir || (defined?(Rails) ? Rails.root.join('pacts').to_s : 'pacts')
+          logger.info("[verifier] pact broker url or pact uri is not set, using directory #{path} as a verification source") # rubocop:disable Layout/LineLength
+          return PactFfi::Verifier.add_directory_source(handle, path)
+        end
+
+        if @pact_config.pact_uri.present?
+          if @pact_config.pact_uri.start_with?('http')
+            logger.info("[verifier] using pact uri #{@pact_config.pact_uri} as a verification source")
+            PactFfi::Verifier.url_source(handle, @pact_config.pact_uri, @pact_config.broker_username,
+                                         @pact_config.broker_password, @pact_config.broker_token)
+          else
+            logger.info("[verifier] using pact file #{@pact_config.pact_uri} as a verification source")
+            PactFfi::Verifier.add_file_source(handle, @pact_config.pact_uri)
+          end
+        else
+          logger.info("[verifier] using pact broker url #{@pact_config.broker_url} with consumer selectors: #{JSON.dump(consumer_selectors)} as a verification source") # rubocop:disable Layout/LineLength
+          consumer_selectors = [] if consumer_selectors.nil?
+          filters = consumer_selectors.map do |selector|
+            FFI::MemoryPointer.from_string(JSON.dump(selector).to_s)
+          end
+          filters_ptr = FFI::MemoryPointer.new(:pointer, filters.size + 1)
+          filters_ptr.write_array_of_pointer(filters)
+          PactFfi::Verifier.broker_source_with_selectors(handle, @pact_config.pact_broker_proxy_url,
+                                                         @pact_config.broker_username, @pact_config.broker_password, @pact_config.broker_token, bool_to_int(@pact_config.enable_pending), @pact_config.include_wip_pacts_since, c_provider_version_tags, c_provider_version_tags_size, @pact_config.provider_version_branch, filters_ptr, consumer_selectors.size, c_consumer_version_tags, c_consumer_version_tags_size) # rubocop:disable Layout/LineLength
+        end
+      end
+
+      def consumer_selectors
+        return unless @pact_config.consumer_version_selectors
+
+        (!@pact_config.consumer_version_selectors.empty? && @pact_config.consumer_version_selectors) || @consumer_selectors # rubocop:disable Layout/LineLength
+      end
+
+      def build_consumer_selectors(verify_only, consumer_name, consumer_branch)
+        # if verify_only and consumer_name are defined - select only needed consumer
+        if verify_only.present?
+          # select proper consumer branch if defined
+          if consumer_name.present?
+            return [] unless verify_only.include?(consumer_name)
+            return [{ 'branch' => consumer_branch, 'consumer' => consumer_name }] if consumer_branch.present?
+
+            return [DEFAULT_CONSUMER_SELECTORS.merge('consumer' => consumer_name)]
+          end
+          # or default selectors
+          return verify_only.map { |name| DEFAULT_CONSUMER_SELECTORS.merge('consumer' => name) }
+        end
+
+        # select provided consumer_name
+        if consumer_name.present? && consumer_branch.present?
+          return [{ 'branch' => consumer_branch,
+                    'consumer' => consumer_name }]
+        end
+        return [DEFAULT_CONSUMER_SELECTORS.merge('consumer' => consumer_name)] if consumer_name.present?
+
+        [DEFAULT_CONSUMER_SELECTORS]
+      end
+    end
+  end
+end