karafka-rdkafka 0.21.0.rc1-arm64-darwin → 0.22.0-arm64-darwin

data/spec/rdkafka/admin/create_acl_handle_spec.rb

@@ -1,56 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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/create_topic_handle_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-describe Rdkafka::Admin::CreateTopicHandle do
-  let(:response) { 0 }
-
-  subject do
-    Rdkafka::Admin::CreateTopicHandle.new.tap do |handle|
-      handle[:pending] = pending_handle
-      handle[:response] = response
-      handle[:error_string] = FFI::Pointer::NULL
-      handle[:result_name] = FFI::MemoryPointer.from_string("my-test-topic")
-    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::CreateTopicHandle::WaitTimeoutError, /create topic/
-    end
-
-    context "when not pending anymore and no error" do
-      let(:pending_handle) { false }
-
-      it "should return a create topic report" do
-        report = subject.wait
-
-        expect(report.error_string).to eq(nil)
-        expect(report.result_name).to eq("my-test-topic")
-      end
-
-      it "should wait without a timeout" do
-        report = subject.wait(max_wait_timeout: nil)
-
-        expect(report.error_string).to eq(nil)
-        expect(report.result_name).to eq("my-test-topic")
-      end
-    end
-  end
-
-  describe "#raise_error" do
-    let(:pending_handle) { false }
-
-    before { subject[:response] = -1 }
-
-    it "should raise the appropriate error when there is an error" do
-      expect {
-        subject.raise_error
-      }.to raise_exception(Rdkafka::RdkafkaError, /Unknown broker error \(unknown\)/)
-    end
-  end
-end

data/spec/rdkafka/admin/create_topic_report_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-describe Rdkafka::Admin::CreateTopicReport do
-  subject { Rdkafka::Admin::CreateTopicReport.new(
-      FFI::MemoryPointer.from_string("error string"),
-      FFI::MemoryPointer.from_string("result name")
-  )}
-
-  it "should get the error string" do
-    expect(subject.error_string).to eq("error string")
-  end
-
-  it "should get the result name" do
-    expect(subject.result_name).to eq("result name")
-  end
-end

data/spec/rdkafka/admin/delete_acl_handle_spec.rb

@@ -1,85 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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/delete_topic_handle_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-describe Rdkafka::Admin::DeleteTopicHandle do
-  let(:response) { 0 }
-
-  subject do
-    Rdkafka::Admin::DeleteTopicHandle.new.tap do |handle|
-      handle[:pending] = pending_handle
-      handle[:response] = response
-      handle[:error_string] = FFI::Pointer::NULL
-      handle[:result_name] = FFI::MemoryPointer.from_string("my-test-topic")
-    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::DeleteTopicHandle::WaitTimeoutError, /delete topic/
-    end
-
-    context "when not pending anymore and no error" do
-      let(:pending_handle) { false }
-
-      it "should return a delete topic report" do
-        report = subject.wait
-
-        expect(report.error_string).to eq(nil)
-        expect(report.result_name).to eq("my-test-topic")
-      end
-
-      it "should wait without a timeout" do
-        report = subject.wait(max_wait_timeout: nil)
-
-        expect(report.error_string).to eq(nil)
-        expect(report.result_name).to eq("my-test-topic")
-      end
-    end
-  end
-
-  describe "#raise_error" do
-    let(:pending_handle) { false }
-
-    before { subject[:response] = -1 }
-
-    it "should raise the appropriate error" do
-      expect {
-        subject.raise_error
-      }.to raise_exception(Rdkafka::RdkafkaError, /Unknown broker error \(unknown\)/)
-    end
-  end
-end

data/spec/rdkafka/admin/delete_topic_report_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-describe Rdkafka::Admin::DeleteTopicReport do
-  subject { Rdkafka::Admin::DeleteTopicReport.new(
-      FFI::MemoryPointer.from_string("error string"),
-      FFI::MemoryPointer.from_string("result name")
-  )}
-
-  it "should get the error string" do
-    expect(subject.error_string).to eq("error string")
-  end
-
-  it "should get the result name" do
-    expect(subject.result_name).to eq("result name")
-  end
-end

data/spec/rdkafka/admin/describe_acl_handle_spec.rb

@@ -1,85 +0,0 @@
-# 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

@@ -1,73 +0,0 @@
-# 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