rdkafka 0.14.0 → 0.15.1

data/lib/rdkafka/producer.rb

@@ -23,6 +23,9 @@ module Rdkafka
     attr_reader :delivery_callback_arity
 
     # @private
+    # @param native_kafka [NativeKafka]
+    # @param partitioner_name [String, nil] name of the partitioner we want to use or nil to use
+    #   the "consistent_random" default
     def initialize(native_kafka, partitioner_name)
       @native_kafka = native_kafka
       @partitioner_name = partitioner_name || "consistent_random"
@@ -37,10 +40,16 @@ module Rdkafka
           topic_metadata = ::Rdkafka::Metadata.new(inner, topic).topics&.first
         end
 
-        cache[topic] = [
-          monotonic_now,
-          topic_metadata ? topic_metadata[:partition_count] : nil
-        ]
+        partition_count = topic_metadata ? topic_metadata[:partition_count] : -1
+
+        # This approach caches the failure to fetch only for 1 second. This will make sure, that
+        # we do not cache the failure for too long but also "buys" us a bit of time in case there
+        # would be issues in the cluster so we won't overaload it with consecutive requests
+        cache[topic] = if partition_count.positive?
+                         [monotonic_now, partition_count]
+                       else
+                         [monotonic_now - PARTITIONS_COUNT_TTL + 5, partition_count]
+                       end
       end
     end
 
@@ -134,14 +143,15 @@ module Rdkafka
     # Partition count for a given topic.
     #
     # @param topic [String] The topic name.
-    # @return [Integer] partition count for a given topic
+    # @return [Integer] partition count for a given topic or `-1` if it could not be obtained.
     #
     # @note If 'allow.auto.create.topics' is set to true in the broker, the topic will be
     #   auto-created after returning nil.
     #
     # @note We cache the partition count for a given topic for given time.
     #   This prevents us in case someone uses `partition_key` from querying for the count with
-    #   each message. Instead we query once every 30 seconds at most
+    #   each message. Instead we query once every 30 seconds at most if we have a valid partition
+    #   count or every 5 seconds in case we were not able to obtain number of partitions
     def partition_count(topic)
       closed_producer_check(__method__)
 
@@ -164,11 +174,12 @@ module Rdkafka
     # @param partition_key [String, nil] Optional partition key based on which partition assignment can happen
     # @param timestamp [Time,Integer,nil] Optional timestamp of this message. Integer timestamp is in milliseconds since Jan 1 1970.
     # @param headers [Hash<String,String>] Optional message headers
-    #
-    # @raise [RdkafkaError] When adding the message to rdkafka's queue failed
+    # @param label [Object, nil] a label that can be assigned when producing a message that will be part of the delivery handle and the delivery report
     #
     # @return [DeliveryHandle] Delivery handle that can be used to wait for the result of producing this message
-    def produce(topic:, payload: nil, key: nil, partition: nil, partition_key: nil, timestamp: nil, headers: nil)
+    #
+    # @raise [RdkafkaError] When adding the message to rdkafka's queue failed
+    def produce(topic:, payload: nil, key: nil, partition: nil, partition_key: nil, timestamp: nil, headers: nil, label: nil)
       closed_producer_check(__method__)
 
       # Start by checking and converting the input
@@ -190,7 +201,7 @@ module Rdkafka
       if partition_key
         partition_count = partition_count(topic)
         # If the topic is not present, set to -1
-        partition = Rdkafka::Bindings.partitioner(partition_key, partition_count, @partitioner_name) if partition_count
+        partition = Rdkafka::Bindings.partitioner(partition_key, partition_count, @partitioner_name) if partition_count.positive?
       end
 
       # If partition is nil, use -1 to let librdafka set the partition randomly or
@@ -210,6 +221,7 @@ module Rdkafka
                       end
 
       delivery_handle = DeliveryHandle.new
+      delivery_handle.label = label
       delivery_handle[:pending] = true
       delivery_handle[:response] = -1
       delivery_handle[:partition] = -1
@@ -256,13 +268,27 @@ module Rdkafka
       delivery_handle
     end
 
+    # Calls (if registered) the delivery callback
+    #
+    # @param delivery_report [Producer::DeliveryReport]
+    # @param delivery_handle [Producer::DeliveryHandle]
     def call_delivery_callback(delivery_report, delivery_handle)
       return unless @delivery_callback
 
-      args = [delivery_report, delivery_handle].take(@delivery_callback_arity)
-      @delivery_callback.call(*args)
+      case @delivery_callback_arity
+      when 0
+        @delivery_callback.call
+      when 1
+        @delivery_callback.call(delivery_report)
+      else
+        @delivery_callback.call(delivery_report, delivery_handle)
+      end
     end
 
+    # Figures out the arity of a given block/method
+    #
+    # @param callback [#call, Proc]
+    # @return [Integer] arity of the provided block/method
     def arity(callback)
       return callback.arity if callback.respond_to?(:arity)
 
@@ -271,6 +297,10 @@ module Rdkafka
 
     private
 
+    # Ensures, no operations can happen on a closed producer
+    #
+    # @param method [Symbol] name of the method that invoked producer
+    # @raise [Rdkafka::ClosedProducerError]
     def closed_producer_check(method)
       raise Rdkafka::ClosedProducerError.new(method) if closed?
     end

data/lib/rdkafka/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Rdkafka
-  VERSION = "0.14.0"
-  LIBRDKAFKA_VERSION = "2.2.0"
-  LIBRDKAFKA_SOURCE_SHA256 = "af9a820cbecbc64115629471df7c7cecd40403b6c34bfdbb9223152677a47226"
+  VERSION = "0.15.1"
+  LIBRDKAFKA_VERSION = "2.3.0"
+  LIBRDKAFKA_SOURCE_SHA256 = "2d49c35c77eeb3d42fa61c43757fcbb6a206daa560247154e60642bcdcc14d12"
 end

data/lib/rdkafka.rb

@@ -11,8 +11,19 @@ require "rdkafka/abstract_handle"
 require "rdkafka/admin"
 require "rdkafka/admin/create_topic_handle"
 require "rdkafka/admin/create_topic_report"
+require "rdkafka/admin/delete_groups_handle"
+require "rdkafka/admin/delete_groups_report"
 require "rdkafka/admin/delete_topic_handle"
 require "rdkafka/admin/delete_topic_report"
+require "rdkafka/admin/create_partitions_handle"
+require "rdkafka/admin/create_partitions_report"
+require "rdkafka/admin/create_acl_handle"
+require "rdkafka/admin/create_acl_report"
+require "rdkafka/admin/delete_acl_handle"
+require "rdkafka/admin/delete_acl_report"
+require "rdkafka/admin/describe_acl_handle"
+require "rdkafka/admin/describe_acl_report"
+require "rdkafka/admin/acl_binding_result"
 require "rdkafka/bindings"
 require "rdkafka/callbacks"
 require "rdkafka/config"

data/rdkafka.gemspec

@@ -3,10 +3,10 @@
 require File.expand_path('lib/rdkafka/version', __dir__)
 
 Gem::Specification.new do |gem|
-  gem.authors = ['Thijs Cadier']
+  gem.authors = ['Thijs Cadier', 'Maciej Mensfeld']
   gem.email = ["contact@karafka.io"]
   gem.description = "Modern Kafka client library for Ruby based on librdkafka"
-  gem.summary = "The rdkafka gem is a modern Kafka client library for Ruby based on librdkafka. It wraps the production-ready C client using the ffi gem and targets Kafka 1.0+ and Ruby 2.4+."
+  gem.summary = "The rdkafka gem is a modern Kafka client library for Ruby based on librdkafka. It wraps the production-ready C client using the ffi gem and targets Kafka 1.0+ and Ruby 2.7+."
   gem.license = 'MIT'
 
   gem.files = `git ls-files`.split($\)

data/spec/rdkafka/admin/create_acl_handle_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Rdkafka::Admin::CreateAclHandle do
+  # If create acl was successful there is no error object
+  # the error code is set to RD_KAFKA_RESP_ERR_NO_ERRORa
+  # https://github.com/confluentinc/librdkafka/blob/1f9f245ac409f50f724695c628c7a0d54a763b9a/src/rdkafka_error.c#L169
+  let(:response) { Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR }
+
+  subject do
+    Rdkafka::Admin::CreateAclHandle.new.tap do |handle|
+      handle[:pending] = pending_handle
+      handle[:response] = response
+      # If create acl was successful there is no error object and the error_string is set to ""
+      # https://github.com/confluentinc/librdkafka/blob/1f9f245ac409f50f724695c628c7a0d54a763b9a/src/rdkafka_error.c#L178
+      handle[:response_string] = FFI::MemoryPointer.from_string("")
+    end
+  end
+
+  describe "#wait" do
+    let(:pending_handle) { true }
+
+    it "should wait until the timeout and then raise an error" do
+      expect {
+        subject.wait(max_wait_timeout: 0.1)
+      }.to raise_error Rdkafka::Admin::CreateAclHandle::WaitTimeoutError, /create acl/
+    end
+
+    context "when not pending anymore and no error" do
+      let(:pending_handle) { false }
+
+      it "should return a create acl report" do
+        report = subject.wait
+
+        expect(report.rdkafka_response_string).to eq("")
+      end
+
+      it "should wait without a timeout" do
+        report = subject.wait(max_wait_timeout: nil)
+
+        expect(report.rdkafka_response_string).to eq("")
+      end
+    end
+  end
+
+  describe "#raise_error" do
+    let(:pending_handle) { false }
+
+    it "should raise the appropriate error" do
+      expect {
+        subject.raise_error
+      }.to raise_exception(Rdkafka::RdkafkaError, /Success \(no_error\)/)
+    end
+  end
+end

data/spec/rdkafka/admin/create_acl_report_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Rdkafka::Admin::CreateAclReport do
+  subject { Rdkafka::Admin::CreateAclReport.new(
+      rdkafka_response: Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR,
+      rdkafka_response_string: FFI::MemoryPointer.from_string("")
+  )}
+
+  it "should get RD_KAFKA_RESP_ERR_NO_ERROR " do
+    expect(subject.rdkafka_response).to eq(0)
+  end
+
+  it "should get empty string" do
+    expect(subject.rdkafka_response_string).to eq("")
+  end
+end

data/spec/rdkafka/admin/delete_acl_handle_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Rdkafka::Admin::DeleteAclHandle do
+  let(:response) { Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR }
+  let(:resource_name)         {"acl-test-topic"}
+  let(:resource_type)         {Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC}
+  let(:resource_pattern_type) {Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL}
+  let(:principal)             {"User:anonymous"}
+  let(:host)                  {"*"}
+  let(:operation)             {Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_READ}
+  let(:permission_type)       {Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW}
+  let(:delete_acl_ptr)        {FFI::Pointer::NULL}
+
+  subject do
+    error_buffer = FFI::MemoryPointer.from_string(" " * 256)
+    delete_acl_ptr = Rdkafka::Bindings.rd_kafka_AclBinding_new(
+      resource_type,
+      FFI::MemoryPointer.from_string(resource_name),
+      resource_pattern_type,
+      FFI::MemoryPointer.from_string(principal),
+      FFI::MemoryPointer.from_string(host),
+      operation,
+      permission_type,
+      error_buffer,
+      256
+    )
+    if delete_acl_ptr.null?
+      raise Rdkafka::Config::ConfigError.new(error_buffer.read_string)
+    end
+    pointer_array = [delete_acl_ptr]
+    delete_acls_array_ptr = FFI::MemoryPointer.new(:pointer)
+    delete_acls_array_ptr.write_array_of_pointer(pointer_array)
+    Rdkafka::Admin::DeleteAclHandle.new.tap do |handle|
+      handle[:pending] = pending_handle
+      handle[:response] = response
+      handle[:response_string] = FFI::MemoryPointer.from_string("")
+      handle[:matching_acls] = delete_acls_array_ptr
+      handle[:matching_acls_count] = 1
+    end
+  end
+
+  after do
+    if delete_acl_ptr != FFI::Pointer::NULL
+      Rdkafka::Bindings.rd_kafka_AclBinding_destroy(delete_acl_ptr)
+    end
+  end
+
+  describe "#wait" do
+    let(:pending_handle) { true }
+
+    it "should wait until the timeout and then raise an error" do
+      expect {
+        subject.wait(max_wait_timeout: 0.1)
+      }.to raise_error Rdkafka::Admin::DeleteAclHandle::WaitTimeoutError, /delete acl/
+    end
+
+    context "when not pending anymore and no error" do
+      let(:pending_handle) { false }
+
+      it "should return a delete acl report" do
+        report = subject.wait
+
+        expect(report.deleted_acls.length).to eq(1)
+      end
+
+      it "should wait without a timeout" do
+        report = subject.wait(max_wait_timeout: nil)
+
+        expect(report.deleted_acls[0].matching_acl_resource_name).to eq(resource_name)
+      end
+    end
+  end
+
+  describe "#raise_error" do
+    let(:pending_handle) { false }
+
+    it "should raise the appropriate error" do
+      expect {
+        subject.raise_error
+      }.to raise_exception(Rdkafka::RdkafkaError, /Success \(no_error\)/)
+    end
+  end
+end

data/spec/rdkafka/admin/delete_acl_report_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Rdkafka::Admin::DeleteAclReport do
+
+  let(:resource_name)         {"acl-test-topic"}
+  let(:resource_type)         {Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC}
+  let(:resource_pattern_type) {Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL}
+  let(:principal)             {"User:anonymous"}
+  let(:host)                  {"*"}
+  let(:operation)             {Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_READ}
+  let(:permission_type)       {Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW}
+  let(:delete_acl_ptr)        {FFI::Pointer::NULL}
+
+  subject do
+    error_buffer = FFI::MemoryPointer.from_string(" " * 256)
+    delete_acl_ptr = Rdkafka::Bindings.rd_kafka_AclBinding_new(
+      resource_type,
+      FFI::MemoryPointer.from_string(resource_name),
+      resource_pattern_type,
+      FFI::MemoryPointer.from_string(principal),
+      FFI::MemoryPointer.from_string(host),
+      operation,
+      permission_type,
+      error_buffer,
+      256
+    )
+    if delete_acl_ptr.null?
+      raise Rdkafka::Config::ConfigError.new(error_buffer.read_string)
+    end
+    pointer_array = [delete_acl_ptr]
+    delete_acls_array_ptr = FFI::MemoryPointer.new(:pointer)
+    delete_acls_array_ptr.write_array_of_pointer(pointer_array)
+    Rdkafka::Admin::DeleteAclReport.new(matching_acls: delete_acls_array_ptr, matching_acls_count: 1)
+  end
+
+  after do
+    if delete_acl_ptr != FFI::Pointer::NULL
+      Rdkafka::Bindings.rd_kafka_AclBinding_destroy(delete_acl_ptr)
+    end
+  end
+
+  it "should get deleted acl resource type as Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC" do
+    expect(subject.deleted_acls[0].matching_acl_resource_type).to eq(Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC)
+  end
+
+  it "should get deleted acl resource name as acl-test-topic" do
+    expect(subject.deleted_acls[0].matching_acl_resource_name).to eq(resource_name)
+  end
+
+  it "should get deleted acl resource pattern type as Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL" do
+    expect(subject.deleted_acls[0].matching_acl_resource_pattern_type).to eq(Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL)
+    expect(subject.deleted_acls[0].matching_acl_pattern_type).to eq(Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL)
+  end
+
+  it "should get deleted acl principal as User:anonymous" do
+    expect(subject.deleted_acls[0].matching_acl_principal).to eq("User:anonymous")
+  end
+
+  it "should get deleted  acl host as * " do
+    expect(subject.deleted_acls[0].matching_acl_host).to eq("*")
+  end
+
+  it "should get deleted acl operation as Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_READ" do
+    expect(subject.deleted_acls[0].matching_acl_operation).to eq(Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_READ)
+  end
+
+  it "should get deleted acl permission_type as Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW" do
+    expect(subject.deleted_acls[0].matching_acl_permission_type).to eq(Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW)
+  end
+end

data/spec/rdkafka/admin/describe_acl_handle_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Rdkafka::Admin::DescribeAclHandle do
+  let(:response) { Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR }
+  let(:resource_name)         {"acl-test-topic"}
+  let(:resource_type)         {Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC}
+  let(:resource_pattern_type) {Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL}
+  let(:principal)             {"User:anonymous"}
+  let(:host)                  {"*"}
+  let(:operation)             {Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_READ}
+  let(:permission_type)       {Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW}
+  let(:describe_acl_ptr)      {FFI::Pointer::NULL}
+
+  subject do
+    error_buffer = FFI::MemoryPointer.from_string(" " * 256)
+    describe_acl_ptr = Rdkafka::Bindings.rd_kafka_AclBinding_new(
+      resource_type,
+      FFI::MemoryPointer.from_string(resource_name),
+      resource_pattern_type,
+      FFI::MemoryPointer.from_string(principal),
+      FFI::MemoryPointer.from_string(host),
+      operation,
+      permission_type,
+      error_buffer,
+      256
+    )
+    if describe_acl_ptr.null?
+       raise Rdkafka::Config::ConfigError.new(error_buffer.read_string)
+    end
+    pointer_array = [describe_acl_ptr]
+    describe_acls_array_ptr = FFI::MemoryPointer.new(:pointer)
+    describe_acls_array_ptr.write_array_of_pointer(pointer_array)
+    Rdkafka::Admin::DescribeAclHandle.new.tap do |handle|
+      handle[:pending] = pending_handle
+      handle[:response] = response
+      handle[:response_string] = FFI::MemoryPointer.from_string("")
+      handle[:acls] = describe_acls_array_ptr
+      handle[:acls_count] = 1
+    end
+  end
+
+  after do
+    if describe_acl_ptr != FFI::Pointer::NULL
+      Rdkafka::Bindings.rd_kafka_AclBinding_destroy(describe_acl_ptr)
+    end
+  end
+
+  describe "#wait" do
+    let(:pending_handle) { true }
+
+    it "should wait until the timeout and then raise an error" do
+      expect {
+        subject.wait(max_wait_timeout: 0.1)
+      }.to raise_error Rdkafka::Admin::DescribeAclHandle::WaitTimeoutError, /describe acl/
+    end
+
+    context "when not pending anymore and no error" do
+      let(:pending_handle) { false }
+
+      it "should return a describe acl report" do
+        report = subject.wait
+
+        expect(report.acls.length).to eq(1)
+      end
+
+      it "should wait without a timeout" do
+        report = subject.wait(max_wait_timeout: nil)
+
+        expect(report.acls[0].matching_acl_resource_name).to eq("acl-test-topic")
+      end
+    end
+  end
+
+  describe "#raise_error" do
+    let(:pending_handle) { false }
+
+    it "should raise the appropriate error" do
+      expect {
+        subject.raise_error
+      }.to raise_exception(Rdkafka::RdkafkaError, /Success \(no_error\)/)
+    end
+  end
+end

data/spec/rdkafka/admin/describe_acl_report_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Rdkafka::Admin::DescribeAclReport do
+
+  let(:resource_name)         {"acl-test-topic"}
+  let(:resource_type)         {Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC}
+  let(:resource_pattern_type) {Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL}
+  let(:principal)             {"User:anonymous"}
+  let(:host)                  {"*"}
+  let(:operation)             {Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_READ}
+  let(:permission_type)       {Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW}
+  let(:describe_acl_ptr)      {FFI::Pointer::NULL}
+
+  subject do
+    error_buffer = FFI::MemoryPointer.from_string(" " * 256)
+    describe_acl_ptr = Rdkafka::Bindings.rd_kafka_AclBinding_new(
+      resource_type,
+      FFI::MemoryPointer.from_string(resource_name),
+      resource_pattern_type,
+      FFI::MemoryPointer.from_string(principal),
+      FFI::MemoryPointer.from_string(host),
+      operation,
+      permission_type,
+      error_buffer,
+      256
+    )
+    if describe_acl_ptr.null?
+       raise Rdkafka::Config::ConfigError.new(error_buffer.read_string)
+    end
+    pointer_array = [describe_acl_ptr]
+    describe_acls_array_ptr = FFI::MemoryPointer.new(:pointer)
+    describe_acls_array_ptr.write_array_of_pointer(pointer_array)
+    Rdkafka::Admin::DescribeAclReport.new(acls: describe_acls_array_ptr, acls_count: 1)
+  end
+
+  after do
+    if describe_acl_ptr != FFI::Pointer::NULL
+      Rdkafka::Bindings.rd_kafka_AclBinding_destroy(describe_acl_ptr)
+    end
+  end
+
+
+  it "should get matching acl resource type as Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC" do
+    expect(subject.acls[0].matching_acl_resource_type).to eq(Rdkafka::Bindings::RD_KAFKA_RESOURCE_TOPIC)
+  end
+
+  it "should get matching acl resource name as acl-test-topic" do
+    expect(subject.acls[0].matching_acl_resource_name).to eq(resource_name)
+  end
+
+  it "should get matching acl resource pattern type as Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL" do
+    expect(subject.acls[0].matching_acl_resource_pattern_type).to eq(Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL)
+    expect(subject.acls[0].matching_acl_pattern_type).to eq(Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_LITERAL)
+  end
+
+  it "should get matching acl principal as User:anonymous" do
+    expect(subject.acls[0].matching_acl_principal).to eq("User:anonymous")
+  end
+
+  it "should get matching acl host as * " do
+    expect(subject.acls[0].matching_acl_host).to eq("*")
+  end
+
+  it "should get matching acl operation as Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_READ" do
+    expect(subject.acls[0].matching_acl_operation).to eq(Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_READ)
+  end
+
+  it "should get matching acl permission_type as Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW" do
+    expect(subject.acls[0].matching_acl_permission_type).to eq(Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW)
+  end
+end