karafka-rdkafka 0.14.0 → 0.14.1

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,72 @@
+# 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_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

data/spec/rdkafka/admin_spec.rb

@@ -9,6 +9,10 @@ describe Rdkafka::Admin do
   after do
     # Registry should always end up being empty
     expect(Rdkafka::Admin::CreateTopicHandle::REGISTRY).to be_empty
+    expect(Rdkafka::Admin::CreatePartitionsHandle::REGISTRY).to be_empty
+    expect(Rdkafka::Admin::DescribeAclHandle::REGISTRY).to be_empty
+    expect(Rdkafka::Admin::CreateAclHandle::REGISTRY).to be_empty
+    expect(Rdkafka::Admin::DeleteAclHandle::REGISTRY).to be_empty
     admin.close
   end
 
@@ -17,6 +21,15 @@ describe Rdkafka::Admin do
   let(:topic_replication_factor) { 1 }
   let(:topic_config)             { {"cleanup.policy" => "compact", "min.cleanable.dirty.ratio" => 0.8} }
   let(:invalid_topic_config)     { {"cleeeeenup.policee" => "campact"} }
+  let(:group_name)               { "test-group-#{Random.new.rand(0..1_000_000)}" }
+
+  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}
 
   describe "#create_topic" do
     describe "called with invalid input" do
@@ -200,4 +213,195 @@ describe Rdkafka::Admin do
       expect(delete_topic_report.result_name).to eq(topic_name)
     end
   end
+
+  describe "#ACL tests" do
+    let(:non_existing_resource_name) {"non-existing-topic"}
+    before do
+      #create topic for testing acl
+      create_topic_handle = admin.create_topic(resource_name, topic_partition_count, topic_replication_factor)
+      create_topic_report = create_topic_handle.wait(max_wait_timeout: 15.0)
+    end
+
+    after do
+      #delete acl
+      delete_acl_handle = admin.delete_acl(resource_type: resource_type, resource_name: resource_name, resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+      delete_acl_report = delete_acl_handle.wait(max_wait_timeout: 15.0)
+
+      #delete topic that was created for testing acl
+      delete_topic_handle = admin.delete_topic(resource_name)
+      delete_topic_report = delete_topic_handle.wait(max_wait_timeout: 15.0)
+    end
+
+    describe "#create_acl" do
+      it "create acl for a topic that does not exist" do
+        # acl creation for resources that does not exist will still get created successfully.
+        create_acl_handle = admin.create_acl(resource_type: resource_type, resource_name: non_existing_resource_name, resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        create_acl_report = create_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(create_acl_report.rdkafka_response).to eq(0)
+        expect(create_acl_report.rdkafka_response_string).to eq("")
+
+        # delete the acl that was created for a non existing topic"
+        delete_acl_handle = admin.delete_acl(resource_type: resource_type, resource_name: non_existing_resource_name, resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        delete_acl_report = delete_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(delete_acl_handle[:response]).to eq(0)
+        expect(delete_acl_report.deleted_acls.size).to eq(1)
+      end
+
+      it "creates a acl for topic that was newly created" do
+        create_acl_handle = admin.create_acl(resource_type: resource_type, resource_name: resource_name, resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        create_acl_report = create_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(create_acl_report.rdkafka_response).to eq(0)
+        expect(create_acl_report.rdkafka_response_string).to eq("")
+      end
+    end
+
+    describe "#describe_acl" do
+      it "describe acl of a topic that does not exist" do
+        describe_acl_handle = admin.describe_acl(resource_type: resource_type, resource_name: non_existing_resource_name, resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        describe_acl_report = describe_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(describe_acl_handle[:response]).to eq(0)
+        expect(describe_acl_report.acls.size).to eq(0)
+      end
+
+      it "create acls and describe the newly created acls" do
+        #create_acl
+        create_acl_handle = admin.create_acl(resource_type: resource_type, resource_name: "test_acl_topic_1", resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        create_acl_report = create_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(create_acl_report.rdkafka_response).to eq(0)
+        expect(create_acl_report.rdkafka_response_string).to eq("")
+
+        create_acl_handle = admin.create_acl(resource_type: resource_type, resource_name: "test_acl_topic_2", resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        create_acl_report = create_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(create_acl_report.rdkafka_response).to eq(0)
+        expect(create_acl_report.rdkafka_response_string).to eq("")
+
+        #describe_acl
+        describe_acl_handle = admin.describe_acl(resource_type: Rdkafka::Bindings::RD_KAFKA_RESOURCE_ANY, resource_name: nil, resource_pattern_type: Rdkafka::Bindings::RD_KAFKA_RESOURCE_PATTERN_ANY, principal: nil, host: nil, operation: Rdkafka::Bindings::RD_KAFKA_ACL_OPERATION_ANY, permission_type: Rdkafka::Bindings::RD_KAFKA_ACL_PERMISSION_TYPE_ANY)
+        describe_acl_report = describe_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(describe_acl_handle[:response]).to eq(0)
+        expect(describe_acl_report.acls.length).to eq(2)
+      end
+    end
+
+    describe "#delete_acl" do
+      it "delete acl of a topic that does not exist" do
+        delete_acl_handle = admin.delete_acl(resource_type: resource_type, resource_name: non_existing_resource_name, resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        delete_acl_report = delete_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(delete_acl_handle[:response]).to eq(0)
+        expect(delete_acl_report.deleted_acls.size).to eq(0)
+      end
+
+      it "create an acl and delete the newly created acl" do
+        #create_acl
+        create_acl_handle = admin.create_acl(resource_type: resource_type, resource_name: "test_acl_topic_1", resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        create_acl_report = create_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(create_acl_report.rdkafka_response).to eq(0)
+        expect(create_acl_report.rdkafka_response_string).to eq("")
+
+        create_acl_handle = admin.create_acl(resource_type: resource_type, resource_name: "test_acl_topic_2", resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        create_acl_report = create_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(create_acl_report.rdkafka_response).to eq(0)
+        expect(create_acl_report.rdkafka_response_string).to eq("")
+
+        #delete_acl - resource_name nil - to delete all acls with any resource name and matching all other filters.
+        delete_acl_handle = admin.delete_acl(resource_type: resource_type, resource_name: nil, resource_pattern_type: resource_pattern_type, principal: principal, host: host, operation: operation, permission_type: permission_type)
+        delete_acl_report = delete_acl_handle.wait(max_wait_timeout: 15.0)
+        expect(delete_acl_handle[:response]).to eq(0)
+        expect(delete_acl_report.deleted_acls.length).to eq(2)
+
+      end
+    end
+  end
+
+  describe('Group tests') do
+    describe "#delete_group" do
+      describe("with an existing group") do
+        let(:consumer_config) { rdkafka_consumer_config('group.id': group_name) }
+        let(:producer_config) { rdkafka_producer_config }
+        let(:producer) { producer_config.producer }
+        let(:consumer) { consumer_config.consumer }
+
+        before do
+          # Create a topic, post a message to it, consume it and commit offsets, this will create a group that we can then delete.
+          admin.create_topic(topic_name, topic_partition_count, topic_replication_factor).wait(max_wait_timeout: 15.0)
+
+          producer.produce(topic: topic_name, payload: "test", key: "test").wait(max_wait_timeout: 15.0)
+
+          consumer.subscribe(topic_name)
+          wait_for_assignment(consumer)
+          message = consumer.poll(100)
+
+          expect(message).to_not be_nil
+
+          consumer.commit
+          consumer.close
+        end
+
+        after do
+          producer.close
+          consumer.close
+        end
+
+        it "deletes the group" do
+          delete_group_handle = admin.delete_group(group_name)
+          report = delete_group_handle.wait(max_wait_timeout: 15.0)
+
+          expect(report.result_name).to eql(group_name)
+        end
+      end
+
+      describe "called with invalid input" do
+        describe "with the name of a group that does not exist" do
+          it "raises an exception" do
+            delete_group_handle = admin.delete_group(group_name)
+
+            expect {
+              delete_group_handle.wait(max_wait_timeout: 15.0)
+            }.to raise_exception { |ex|
+              expect(ex).to be_a(Rdkafka::RdkafkaError)
+              expect(ex.message).to match(/Broker: The group id does not exist \(group_id_not_found\)/)
+            }
+          end
+        end
+      end
+
+    end
+  end
+
+  describe '#create_partitions' do
+    let(:metadata) { admin.metadata(topic_name).topics.first }
+
+    context 'when topic does not exist' do
+      it 'expect to fail due to unknown partition' do
+        expect { admin.create_partitions(topic_name, 10).wait }.to raise_error(Rdkafka::RdkafkaError, /unknown_topic_or_part/)
+      end
+    end
+
+    context 'when topic already has the desired number of partitions' do
+      before { admin.create_topic(topic_name, 2, 1).wait }
+
+      it 'expect not to change number of partitions' do
+        expect { admin.create_partitions(topic_name, 2).wait }.to raise_error(Rdkafka::RdkafkaError, /invalid_partitions/)
+        expect(metadata[:partition_count]).to eq(2)
+      end
+    end
+
+    context 'when topic has more than the requested number of partitions' do
+      before { admin.create_topic(topic_name, 5, 1).wait }
+
+      it 'expect not to change number of partitions' do
+        expect { admin.create_partitions(topic_name, 2).wait }.to raise_error(Rdkafka::RdkafkaError, /invalid_partitions/)
+        expect(metadata[:partition_count]).to eq(5)
+      end
+    end
+
+    context 'when topic has less then desired number of partitions' do
+      before { admin.create_topic(topic_name, 1, 1).wait }
+
+      it 'expect to change number of partitions' do
+        admin.create_partitions(topic_name, 10).wait
+        expect(metadata[:partition_count]).to eq(10)
+      end
+    end
+  end
 end

data/spec/rdkafka/consumer_spec.rb

@@ -702,6 +702,15 @@ describe Rdkafka::Consumer do
         consumer.poll(100)
       }.to raise_error Rdkafka::RdkafkaError
     end
+
+    it "expect to raise error when polling non-existing topic" do
+      missing_topic = SecureRandom.uuid
+      consumer.subscribe(missing_topic)
+
+      expect {
+        consumer.poll(1_000)
+      }.to raise_error Rdkafka::RdkafkaError, /Subscribed topic not available: #{missing_topic}/
+    end
   end
 
   describe "#poll with headers" do

data/spec/rdkafka/producer_spec.rb

@@ -834,41 +834,6 @@ describe Rdkafka::Producer do
       expect(response.error.abortable?).to eq(false)
     end
 
-    # This may not always crash, depends on load but no other way to check it
-    context 'when timeout is too short and error occurs and we can abort' do
-      let(:producer) do
-        rdkafka_producer_config(
-          'transactional.id': SecureRandom.uuid,
-          'transaction.timeout.ms': 1_000
-        ).producer
-      end
-
-      it 'expect to allow to produce within a transaction, finalize and not ship data' do
-        producer.init_transactions
-        producer.begin_transaction
-
-        sleep(5)
-
-        handle1 = producer.produce(topic: 'produce_test_topic', payload: 'data1', partition: 1)
-        handle2 = producer.produce(topic: 'example_topic', payload: 'data2', partition: 0)
-
-        begin
-          producer.commit_transaction(15_000)
-        rescue Rdkafka::RdkafkaError => e
-          next unless e.abortable?
-
-          begin
-            producer.abort_transaction(15_000)
-          rescue Rdkafka::RdkafkaError => e
-            nil
-          end
-
-          expect { handle1.wait(max_wait_timeout: 15) }.to raise_error(Rdkafka::RdkafkaError)
-          expect { handle2.wait(max_wait_timeout: 15) }.to raise_error(Rdkafka::RdkafkaError)
-        end
-      end
-    end
-
     context 'fencing against previous active producer with same transactional id' do
       let(:transactional_id) { SecureRandom.uuid }
 

data/spec/spec_helper.rb

@@ -11,7 +11,7 @@ require "pry"
 require "rspec"
 require "rdkafka"
 require "timeout"
-require 'securerandom'
+require "securerandom"
 
 def rdkafka_base_config
   {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka-rdkafka
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.14.1
 platform: ruby
 authors:
 - Thijs Cadier
@@ -35,7 +35,7 @@ cert_chain:
   AnG1dJU+yL2BK7vaVytLTstJME5mepSZ46qqIJXMuWob/YPDmVaBF39TDSG9e34s
   msG3BiCqgOgHAnL23+CN3Rt8MsuRfEtoTKpJVcCfoEoNHOkc
   -----END CERTIFICATE-----
-date: 2023-11-17 00:00:00.000000000 Z
+date: 2023-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -171,6 +171,7 @@ extensions:
 - ext/Rakefile
 extra_rdoc_files: []
 files:
+- ".github/FUNDING.yml"
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
@@ -191,12 +192,21 @@ files:
 - lib/rdkafka.rb
 - lib/rdkafka/abstract_handle.rb
 - lib/rdkafka/admin.rb
+- lib/rdkafka/admin/acl_binding_result.rb
+- lib/rdkafka/admin/create_acl_handle.rb
+- lib/rdkafka/admin/create_acl_report.rb
 - lib/rdkafka/admin/create_partitions_handle.rb
 - lib/rdkafka/admin/create_partitions_report.rb
 - lib/rdkafka/admin/create_topic_handle.rb
 - lib/rdkafka/admin/create_topic_report.rb
+- lib/rdkafka/admin/delete_acl_handle.rb
+- lib/rdkafka/admin/delete_acl_report.rb
+- lib/rdkafka/admin/delete_groups_handle.rb
+- lib/rdkafka/admin/delete_groups_report.rb
 - lib/rdkafka/admin/delete_topic_handle.rb
 - lib/rdkafka/admin/delete_topic_report.rb
+- lib/rdkafka/admin/describe_acl_handle.rb
+- lib/rdkafka/admin/describe_acl_report.rb
 - lib/rdkafka/bindings.rb
 - lib/rdkafka/callbacks.rb
 - lib/rdkafka/config.rb
@@ -215,10 +225,16 @@ files:
 - lib/rdkafka/version.rb
 - renovate.json
 - spec/rdkafka/abstract_handle_spec.rb
+- spec/rdkafka/admin/create_acl_handle_spec.rb
+- spec/rdkafka/admin/create_acl_report_spec.rb
 - spec/rdkafka/admin/create_topic_handle_spec.rb
 - spec/rdkafka/admin/create_topic_report_spec.rb
+- spec/rdkafka/admin/delete_acl_handle_spec.rb
+- spec/rdkafka/admin/delete_acl_report_spec.rb
 - spec/rdkafka/admin/delete_topic_handle_spec.rb
 - spec/rdkafka/admin/delete_topic_report_spec.rb
+- spec/rdkafka/admin/describe_acl_handle_spec.rb
+- spec/rdkafka/admin/describe_acl_report_spec.rb
 - spec/rdkafka/admin_spec.rb
 - spec/rdkafka/bindings_spec.rb
 - spec/rdkafka/callbacks_spec.rb
@@ -269,10 +285,16 @@ summary: The rdkafka gem is a modern Kafka client library for Ruby based on libr
   and Ruby 2.4+.
 test_files:
 - spec/rdkafka/abstract_handle_spec.rb
+- spec/rdkafka/admin/create_acl_handle_spec.rb
+- spec/rdkafka/admin/create_acl_report_spec.rb
 - spec/rdkafka/admin/create_topic_handle_spec.rb
 - spec/rdkafka/admin/create_topic_report_spec.rb
+- spec/rdkafka/admin/delete_acl_handle_spec.rb
+- spec/rdkafka/admin/delete_acl_report_spec.rb
 - spec/rdkafka/admin/delete_topic_handle_spec.rb
 - spec/rdkafka/admin/delete_topic_report_spec.rb
+- spec/rdkafka/admin/describe_acl_handle_spec.rb
+- spec/rdkafka/admin/describe_acl_report_spec.rb
 - spec/rdkafka/admin_spec.rb
 - spec/rdkafka/bindings_spec.rb
 - spec/rdkafka/callbacks_spec.rb