karafka-rdkafka 0.12.0

data/spec/rdkafka/error_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe Rdkafka::RdkafkaError do
+  it "should raise a type error for a nil response" do
+    expect {
+      Rdkafka::RdkafkaError.new(nil)
+    }.to raise_error TypeError
+  end
+
+  it "should create an error with a message prefix" do
+    expect(Rdkafka::RdkafkaError.new(10, "message prefix").message_prefix).to eq "message prefix"
+  end
+
+  it "should create an error with a broker message" do
+    expect(Rdkafka::RdkafkaError.new(10, broker_message: "broker message").broker_message).to eq "broker message"
+  end
+
+  describe "#code" do
+    it "should handle an invalid response" do
+      expect(Rdkafka::RdkafkaError.new(933975).code).to eq :err_933975?
+    end
+
+    it "should return error messages from rdkafka" do
+      expect(Rdkafka::RdkafkaError.new(10).code).to eq :msg_size_too_large
+    end
+
+    it "should strip a leading underscore" do
+      expect(Rdkafka::RdkafkaError.new(-191).code).to eq :partition_eof
+    end
+  end
+
+  describe "#to_s" do
+    it "should handle an invalid response" do
+      expect(Rdkafka::RdkafkaError.new(933975).to_s).to eq "Err-933975? (err_933975?)"
+    end
+
+    it "should return error messages from rdkafka" do
+      expect(Rdkafka::RdkafkaError.new(10).to_s).to eq "Broker: Message size too large (msg_size_too_large)"
+    end
+
+    it "should add the message prefix if present" do
+      expect(Rdkafka::RdkafkaError.new(10, "Error explanation").to_s).to eq "Error explanation - Broker: Message size too large (msg_size_too_large)"
+    end
+  end
+
+  describe "#message" do
+    it "should handle an invalid response" do
+      expect(Rdkafka::RdkafkaError.new(933975).message).to eq "Err-933975? (err_933975?)"
+    end
+
+    it "should return error messages from rdkafka" do
+      expect(Rdkafka::RdkafkaError.new(10).message).to eq "Broker: Message size too large (msg_size_too_large)"
+    end
+
+    it "should add the message prefix if present" do
+      expect(Rdkafka::RdkafkaError.new(10, "Error explanation").message).to eq "Error explanation - Broker: Message size too large (msg_size_too_large)"
+    end
+  end
+
+  describe "#is_partition_eof?" do
+    it "should be false when not partition eof" do
+      expect(Rdkafka::RdkafkaError.new(933975).is_partition_eof?).to be false
+    end
+
+    it "should be true when partition eof" do
+      expect(Rdkafka::RdkafkaError.new(-191).is_partition_eof?).to be true
+    end
+  end
+
+  describe "#==" do
+    subject { Rdkafka::RdkafkaError.new(10, "Error explanation") }
+
+    it "should equal another error with the same content" do
+      expect(subject).to eq Rdkafka::RdkafkaError.new(10, "Error explanation")
+    end
+
+    it "should not equal another error with a different error code" do
+      expect(subject).not_to eq Rdkafka::RdkafkaError.new(20, "Error explanation")
+    end
+
+    it "should not equal another error with a different message" do
+      expect(subject).not_to eq Rdkafka::RdkafkaError.new(10, "Different error explanation")
+    end
+
+    it "should not equal another error with no message" do
+      expect(subject).not_to eq Rdkafka::RdkafkaError.new(10)
+    end
+  end
+end

data/spec/rdkafka/metadata_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+require "securerandom"
+
+describe Rdkafka::Metadata do
+  let(:config)        { rdkafka_consumer_config }
+  let(:native_config) { config.send(:native_config) }
+  let(:native_kafka)  { config.send(:native_kafka, native_config, :rd_kafka_consumer) }
+
+  after do
+    Rdkafka::Bindings.rd_kafka_consumer_close(native_kafka)
+    Rdkafka::Bindings.rd_kafka_destroy(native_kafka)
+  end
+
+  context "passing in a topic name" do
+    context "that is non-existent topic" do
+      let(:topic_name) { SecureRandom.uuid.to_s }
+
+      it "raises an appropriate exception" do
+        expect {
+          described_class.new(native_kafka, topic_name)
+        }.to raise_exception(Rdkafka::RdkafkaError, "Broker: Unknown topic or partition (unknown_topic_or_part)")
+      end
+    end
+
+    context "that is one of our test topics" do
+      subject { described_class.new(native_kafka, topic_name) }
+      let(:topic_name) { "partitioner_test_topic" }
+
+      it "#brokers returns our single broker" do
+        expect(subject.brokers.length).to eq(1)
+        expect(subject.brokers[0][:broker_id]).to eq(1)
+        expect(subject.brokers[0][:broker_name]).to eq("localhost")
+        expect(subject.brokers[0][:broker_port]).to eq(9092)
+      end
+
+      it "#topics returns data on our test topic" do
+        expect(subject.topics.length).to eq(1)
+        expect(subject.topics[0][:partition_count]).to eq(25)
+        expect(subject.topics[0][:partitions].length).to eq(25)
+        expect(subject.topics[0][:topic_name]).to eq(topic_name)
+      end
+    end
+  end
+
+  context "not passing in a topic name" do
+    subject { described_class.new(native_kafka, topic_name) }
+    let(:topic_name) { nil }
+    let(:test_topics) {
+      %w(consume_test_topic empty_test_topic load_test_topic produce_test_topic rake_test_topic watermarks_test_topic partitioner_test_topic)
+    } # Test topics crated in spec_helper.rb
+
+    it "#brokers returns our single broker" do
+      expect(subject.brokers.length).to eq(1)
+      expect(subject.brokers[0][:broker_id]).to eq(1)
+      expect(subject.brokers[0][:broker_name]).to eq("localhost")
+      expect(subject.brokers[0][:broker_port]).to eq(9092)
+    end
+
+    it "#topics returns data about all of our test topics" do
+      result = subject.topics.map { |topic| topic[:topic_name] }
+      expect(result).to include(*test_topics)
+    end
+  end
+
+  context "when a non-zero error code is returned" do
+    let(:topic_name) { SecureRandom.uuid.to_s }
+
+    before do
+      allow(Rdkafka::Bindings).to receive(:rd_kafka_metadata).and_return(-165)
+    end
+
+    it "creating the instance raises an exception" do
+      expect {
+        described_class.new(native_kafka, topic_name)
+      }.to raise_error(Rdkafka::RdkafkaError, /Local: Required feature not supported by broker \(unsupported_feature\)/)
+    end
+  end
+end

data/spec/rdkafka/producer/client_spec.rb

@@ -0,0 +1,145 @@
+require "spec_helper"
+
+describe Rdkafka::Producer::Client do
+  let(:config) { rdkafka_producer_config }
+  let(:native) { config.send(:native_kafka, config.send(:native_config), :rd_kafka_producer) }
+  let(:closing) { false }
+  let(:thread) { double(Thread) }
+
+  subject(:client) { described_class.new(native) }
+
+  before do
+    allow(Rdkafka::Bindings).to receive(:rd_kafka_poll).with(instance_of(FFI::Pointer), 250).and_call_original
+    allow(Rdkafka::Bindings).to receive(:rd_kafka_outq_len).with(instance_of(FFI::Pointer)).and_return(0).and_call_original
+    allow(Rdkafka::Bindings).to receive(:rd_kafka_destroy)
+    allow(Thread).to receive(:new).and_return(thread)
+
+    allow(thread).to receive(:[]=).with(:closing, anything)
+    allow(thread).to receive(:join)
+    allow(thread).to receive(:abort_on_exception=).with(anything)
+  end
+
+  context "defaults" do
+    it "sets the thread to abort on exception" do
+      expect(thread).to receive(:abort_on_exception=).with(true)
+
+      client
+    end
+
+    it "sets the thread `closing` flag to false" do
+      expect(thread).to receive(:[]=).with(:closing, false)
+
+      client
+    end
+  end
+
+  context "the polling thread" do
+    it "is created" do
+      expect(Thread).to receive(:new)
+
+      client
+    end
+
+    it "polls the native with default 250ms timeout" do
+      polling_loop_expects do
+        expect(Rdkafka::Bindings).to receive(:rd_kafka_poll).with(instance_of(FFI::Pointer), 250).at_least(:once)
+      end
+    end
+
+    it "check the out queue of native client" do
+      polling_loop_expects do
+        expect(Rdkafka::Bindings).to receive(:rd_kafka_outq_len).with(native).at_least(:once)
+      end
+    end
+  end
+
+  def polling_loop_expects(&block)
+    Thread.current[:closing] = true # this forces the loop break with line #12
+
+    allow(Thread).to receive(:new).and_yield do |_|
+      block.call
+    end.and_return(thread)
+
+    client
+  end
+
+  it "exposes `native` client" do
+    expect(client.native).to eq(native)
+  end
+
+  context "when client was not yet closed (`nil`)" do
+    it "is not closed" do
+      expect(client.closed?).to eq(false)
+    end
+
+    context "and attempt to close" do
+      it "calls the `destroy` binding" do
+        expect(Rdkafka::Bindings).to receive(:rd_kafka_destroy).with(native)
+
+        client.close
+      end
+
+      it "indicates to the polling thread that it is closing" do
+        expect(thread).to receive(:[]=).with(:closing, true)
+
+        client.close
+      end
+
+      it "joins the polling thread" do
+        expect(thread).to receive(:join)
+
+        client.close
+      end
+
+      it "closes and unassign the native client" do
+        client.close
+
+        expect(client.native).to eq(nil)
+        expect(client.closed?).to eq(true)
+      end
+    end
+  end
+
+  context "when client was already closed" do
+    before { client.close }
+
+    it "is closed" do
+      expect(client.closed?).to eq(true)
+    end
+
+    context "and attempt to close again" do
+      it "does not call the `destroy` binding" do
+        expect(Rdkafka::Bindings).not_to receive(:rd_kafka_destroy)
+
+        client.close
+      end
+
+      it "does not indicate to the polling thread that it is closing" do
+        expect(thread).not_to receive(:[]=).with(:closing, true)
+
+        client.close
+      end
+
+      it "does not join the polling thread" do
+        expect(thread).not_to receive(:join)
+
+        client.close
+      end
+
+      it "does not close and unassign the native client again" do
+        client.close
+
+        expect(client.native).to eq(nil)
+        expect(client.closed?).to eq(true)
+      end
+    end
+  end
+
+  it "provide a finalizer Proc that closes the `native` client" do
+    expect(client.closed?).to eq(false)
+
+    client.finalizer.call("some-ignored-object-id")
+
+    expect(client.closed?).to eq(true)
+  end
+end

data/spec/rdkafka/producer/delivery_handle_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Rdkafka::Producer::DeliveryHandle do
+  let(:response) { 0 }
+
+  subject do
+    Rdkafka::Producer::DeliveryHandle.new.tap do |handle|
+      handle[:pending] = pending_handle
+      handle[:response] = response
+      handle[:partition] = 2
+      handle[:offset] = 100
+    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::Producer::DeliveryHandle::WaitTimeoutError, /delivery/
+    end
+
+    context "when not pending anymore and no error" do
+      let(:pending_handle) { false }
+
+      it "should return a delivery report" do
+        report = subject.wait
+
+        expect(report.partition).to eq(2)
+        expect(report.offset).to eq(100)
+      end
+
+      it "should wait without a timeout" do
+        report = subject.wait(max_wait_timeout: nil)
+
+        expect(report.partition).to eq(2)
+        expect(report.offset).to eq(100)
+      end
+    end
+  end
+end

data/spec/rdkafka/producer/delivery_report_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Rdkafka::Producer::DeliveryReport do
+  subject { Rdkafka::Producer::DeliveryReport.new(2, 100, "error") }
+
+  it "should get the partition" do
+    expect(subject.partition).to eq 2
+  end
+
+  it "should get the offset" do
+    expect(subject.offset).to eq 100
+  end
+
+  it "should get the error" do
+    expect(subject.error).to eq "error"
+  end
+end