rdkafka 0.8.0.beta.1 → 0.10.0

data/spec/rdkafka/admin/create_topic_report_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+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_topic_handle_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+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 }
+
+    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_topic_report_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+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_spec.rb

@@ -0,0 +1,203 @@
+require "spec_helper"
+require "ostruct"
+
+describe Rdkafka::Admin do
+  let(:config)   { rdkafka_config }
+  let(:admin)    { config.admin }
+
+  after do
+    # Registry should always end up being empty
+    expect(Rdkafka::Admin::CreateTopicHandle::REGISTRY).to be_empty
+    admin.close
+  end
+
+  let(:topic_name)               { "test-topic-#{Random.new.rand(0..1_000_000)}" }
+  let(:topic_partition_count)    { 3 }
+  let(:topic_replication_factor) { 1 }
+  let(:topic_config)             { {"cleanup.policy" => "compact", "min.cleanable.dirty.ratio" => 0.8} }
+  let(:invalid_topic_config)     { {"cleeeeenup.policee" => "campact"} }
+
+  describe "#create_topic" do
+    describe "called with invalid input" do
+      describe "with an invalid topic name" do
+        # https://github.com/apache/kafka/blob/trunk/clients/src/main/java/org/apache/kafka/common/internals/Topic.java#L29
+        # public static final String LEGAL_CHARS = "[a-zA-Z0-9._-]";
+        let(:topic_name) { "[!@#]" }
+
+        it "raises an exception" do
+          create_topic_handle = admin.create_topic(topic_name, topic_partition_count, topic_replication_factor)
+          expect {
+            create_topic_handle.wait(max_wait_timeout: 15.0)
+          }.to raise_exception { |ex|
+            expect(ex).to be_a(Rdkafka::RdkafkaError)
+            expect(ex.message).to match(/Broker: Invalid topic \(topic_exception\)/)
+            expect(ex.broker_message).to match(/Topic name.*is illegal, it contains a character other than ASCII alphanumerics/)
+          }
+        end
+      end
+
+      describe "with the name of a topic that already exists" do
+        let(:topic_name) { "empty_test_topic" } # created in spec_helper.rb
+
+        it "raises an exception" do
+          create_topic_handle = admin.create_topic(topic_name, topic_partition_count, topic_replication_factor)
+          expect {
+            create_topic_handle.wait(max_wait_timeout: 15.0)
+          }.to raise_exception { |ex|
+            expect(ex).to be_a(Rdkafka::RdkafkaError)
+            expect(ex.message).to match(/Broker: Topic already exists \(topic_already_exists\)/)
+            expect(ex.broker_message).to match(/Topic 'empty_test_topic' already exists/)
+          }
+        end
+      end
+
+      describe "with an invalid partition count" do
+        let(:topic_partition_count) { -1 }
+
+        it "raises an exception" do
+          expect {
+            admin.create_topic(topic_name, topic_partition_count, topic_replication_factor)
+          }.to raise_error Rdkafka::Config::ConfigError, /num_partitions out of expected range/
+        end
+      end
+
+      describe "with an invalid replication factor" do
+        let(:topic_replication_factor) { -2  }
+
+        it "raises an exception" do
+          expect {
+            admin.create_topic(topic_name, topic_partition_count, topic_replication_factor)
+          }.to raise_error Rdkafka::Config::ConfigError, /replication_factor out of expected range/
+        end
+      end
+
+      describe "with an invalid topic configuration" do
+        it "doesn't create the topic" do
+          create_topic_handle = admin.create_topic(topic_name, topic_partition_count, topic_replication_factor, invalid_topic_config)
+          expect {
+            create_topic_handle.wait(max_wait_timeout: 15.0)
+          }.to raise_error Rdkafka::RdkafkaError, /Broker: Configuration is invalid \(invalid_config\)/
+        end
+      end
+    end
+
+    context "edge case" do
+      context "where we are unable to get the background queue" do
+        before do
+          allow(Rdkafka::Bindings).to receive(:rd_kafka_queue_get_background).and_return(FFI::Pointer::NULL)
+        end
+
+        it "raises an exception" do
+          expect {
+            admin.create_topic(topic_name, topic_partition_count, topic_replication_factor)
+          }.to raise_error Rdkafka::Config::ConfigError, /rd_kafka_queue_get_background was NULL/
+        end
+      end
+
+      context "where rd_kafka_CreateTopics raises an exception" do
+        before do
+          allow(Rdkafka::Bindings).to receive(:rd_kafka_CreateTopics).and_raise(RuntimeError.new("oops"))
+        end
+
+        it "raises an exception" do
+          expect {
+            admin.create_topic(topic_name, topic_partition_count, topic_replication_factor)
+          }.to raise_error RuntimeError, /oops/
+        end
+      end
+    end
+
+    it "creates a topic" do
+      create_topic_handle = admin.create_topic(topic_name, topic_partition_count, topic_replication_factor, topic_config)
+      create_topic_report = create_topic_handle.wait(max_wait_timeout: 15.0)
+      expect(create_topic_report.error_string).to be_nil
+      expect(create_topic_report.result_name).to eq(topic_name)
+    end
+  end
+
+  describe "#delete_topic" do
+    describe "called with invalid input" do
+      # https://github.com/apache/kafka/blob/trunk/clients/src/main/java/org/apache/kafka/common/internals/Topic.java#L29
+      # public static final String LEGAL_CHARS = "[a-zA-Z0-9._-]";
+      describe "with an invalid topic name" do
+        let(:topic_name) { "[!@#]" }
+
+        it "raises an exception" do
+          delete_topic_handle = admin.delete_topic(topic_name)
+          expect {
+            delete_topic_handle.wait(max_wait_timeout: 15.0)
+          }.to raise_exception { |ex|
+            expect(ex).to be_a(Rdkafka::RdkafkaError)
+            expect(ex.message).to match(/Broker: Unknown topic or partition \(unknown_topic_or_part\)/)
+            expect(ex.broker_message).to match(/Broker: Unknown topic or partition/)
+          }
+        end
+      end
+
+      describe "with the name of a topic that does not exist" do
+        it "raises an exception" do
+          delete_topic_handle = admin.delete_topic(topic_name)
+          expect {
+            delete_topic_handle.wait(max_wait_timeout: 15.0)
+          }.to raise_exception { |ex|
+            expect(ex).to be_a(Rdkafka::RdkafkaError)
+            expect(ex.message).to match(/Broker: Unknown topic or partition \(unknown_topic_or_part\)/)
+            expect(ex.broker_message).to match(/Broker: Unknown topic or partition/)
+          }
+        end
+      end
+    end
+
+    context "edge case" do
+      context "where we are unable to get the background queue" do
+        before do
+          allow(Rdkafka::Bindings).to receive(:rd_kafka_queue_get_background).and_return(FFI::Pointer::NULL)
+        end
+
+        it "raises an exception" do
+          expect {
+            admin.delete_topic(topic_name)
+          }.to raise_error Rdkafka::Config::ConfigError, /rd_kafka_queue_get_background was NULL/
+        end
+      end
+
+      context "where rd_kafka_DeleteTopics raises an exception" do
+        before do
+          allow(Rdkafka::Bindings).to receive(:rd_kafka_DeleteTopics).and_raise(RuntimeError.new("oops"))
+        end
+
+        it "raises an exception" do
+          expect {
+            admin.delete_topic(topic_name)
+          }.to raise_error RuntimeError, /oops/
+        end
+      end
+    end
+
+
+    it "deletes a topic that was newly created" do
+      create_topic_handle = admin.create_topic(topic_name, topic_partition_count, topic_replication_factor)
+      create_topic_report = create_topic_handle.wait(max_wait_timeout: 15.0)
+      expect(create_topic_report.error_string).to be_nil
+      expect(create_topic_report.result_name).to eq(topic_name)
+
+      # Retry topic deletion a few times. On CI Kafka seems to not
+      # always be ready for it immediately
+      delete_topic_report = nil
+      10.times do |i|
+        begin
+          delete_topic_handle = admin.delete_topic(topic_name)
+          delete_topic_report = delete_topic_handle.wait(max_wait_timeout: 15.0)
+          break
+        rescue Rdkafka::RdkafkaError => ex
+          if i > 3
+            raise ex
+          end
+        end
+      end
+
+      expect(delete_topic_report.error_string).to be_nil
+      expect(delete_topic_report.result_name).to eq(topic_name)
+    end
+  end
+end

data/spec/rdkafka/bindings_spec.rb

@@ -25,39 +25,39 @@ describe Rdkafka::Bindings do
   end
 
   describe "log callback" do
-    let(:log) { StringIO.new }
+    let(:log_queue) { Rdkafka::Config.log_queue }
     before do
-      Rdkafka::Config.logger = Logger.new(log)
+      allow(log_queue).to receive(:<<)
     end
 
     it "should log fatal messages" do
       Rdkafka::Bindings::LogCallback.call(nil, 0, nil, "log line")
-      expect(log.string).to include "FATAL -- : rdkafka: log line"
+      expect(log_queue).to have_received(:<<).with([Logger::FATAL, "rdkafka: log line"])
     end
 
     it "should log error messages" do
       Rdkafka::Bindings::LogCallback.call(nil, 3, nil, "log line")
-      expect(log.string).to include "ERROR -- : rdkafka: log line"
+      expect(log_queue).to have_received(:<<).with([Logger::ERROR, "rdkafka: log line"])
     end
 
     it "should log warning messages" do
       Rdkafka::Bindings::LogCallback.call(nil, 4, nil, "log line")
-      expect(log.string).to include "WARN -- : rdkafka: log line"
+      expect(log_queue).to have_received(:<<).with([Logger::WARN, "rdkafka: log line"])
     end
 
     it "should log info messages" do
       Rdkafka::Bindings::LogCallback.call(nil, 5, nil, "log line")
-      expect(log.string).to include "INFO -- : rdkafka: log line"
+      expect(log_queue).to have_received(:<<).with([Logger::INFO, "rdkafka: log line"])
     end
 
     it "should log debug messages" do
       Rdkafka::Bindings::LogCallback.call(nil, 7, nil, "log line")
-      expect(log.string).to include "DEBUG -- : rdkafka: log line"
+      expect(log_queue).to have_received(:<<).with([Logger::DEBUG, "rdkafka: log line"])
     end
 
     it "should log unknown messages" do
       Rdkafka::Bindings::LogCallback.call(nil, 100, nil, "log line")
-      expect(log.string).to include "ANY -- : rdkafka: log line"
+      expect(log_queue).to have_received(:<<).with([Logger::UNKNOWN, "rdkafka: log line"])
     end
   end
 
@@ -100,4 +100,28 @@ describe Rdkafka::Bindings do
       end
     end
   end
+
+  describe "error callback" do
+    context "without an error callback" do
+      it "should do nothing" do
+        expect {
+          Rdkafka::Bindings::ErrorCallback.call(nil, 1, "error", nil)
+        }.not_to raise_error
+      end
+    end
+
+    context "with an error callback" do
+      before do
+        Rdkafka::Config.error_callback = lambda do |error|
+          $received_error = error
+        end
+      end
+
+      it "should call the error callback with an Rdkafka::Error" do
+        Rdkafka::Bindings::ErrorCallback.call(nil, 8, "Broker not available", nil)
+        expect($received_error.code).to eq(:broker_not_available)
+        expect($received_error.broker_message).to eq("Broker not available")
+      end
+    end
+  end
 end

data/spec/rdkafka/callbacks_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Rdkafka::Callbacks do
+
+  # The code in the call back functions is 100% covered by other specs.  Due to
+  # the large number of collaborators, and the fact that FFI does not play
+  # nicely with doubles, it was very difficult to construct tests that were
+  # not over-mocked.
+
+  # For debugging purposes, if you suspect that you are running into trouble in
+  # one of the callback functions, it may be helpful to surround the inner body
+  # of the method with something like:
+  #
+  #   begin
+  #     <method body>
+  #   rescue => ex; puts ex.inspect; puts ex.backtrace; end;
+  #
+  # This will output to STDOUT any exceptions that are being raised in the callback.
+
+end

data/spec/rdkafka/config_spec.rb

@@ -18,25 +18,83 @@ describe Rdkafka::Config do
         Rdkafka::Config.logger = nil
       }.to raise_error(Rdkafka::Config::NoLoggerError)
     end
+
+    it "supports logging queue" do
+      log = StringIO.new
+      Rdkafka::Config.logger = Logger.new(log)
+
+      Rdkafka::Config.log_queue << [Logger::FATAL, "I love testing"]
+      20.times do
+        break if log.string != ""
+        sleep 0.05
+      end
+
+      expect(log.string).to include "FATAL -- : I love testing"
+    end
   end
 
   context "statistics callback" do
-    it "should set the callback" do
-      expect {
-        Rdkafka::Config.statistics_callback = lambda do |stats|
-          puts stats
+    context "with a proc/lambda" do
+      it "should set the callback" do
+        expect {
+          Rdkafka::Config.statistics_callback = lambda do |stats|
+            puts stats
+          end
+        }.not_to raise_error
+        expect(Rdkafka::Config.statistics_callback).to respond_to :call
+      end
+    end
+
+    context "with a callable object" do
+      it "should set the callback" do
+        callback = Class.new do
+          def call(stats); end
         end
-      }.not_to raise_error
-      expect(Rdkafka::Config.statistics_callback).to be_a Proc
+        expect {
+          Rdkafka::Config.statistics_callback = callback.new
+        }.not_to raise_error
+        expect(Rdkafka::Config.statistics_callback).to respond_to :call
+      end
     end
 
-    it "should not accept a callback that's not a proc" do
+    it "should not accept a callback that's not callable" do
       expect {
         Rdkafka::Config.statistics_callback = 'a string'
       }.to raise_error(TypeError)
     end
   end
 
+  context "error callback" do
+    context "with a proc/lambda" do
+      it "should set the callback" do
+        expect {
+          Rdkafka::Config.error_callback = lambda do |error|
+            puts error
+          end
+        }.not_to raise_error
+        expect(Rdkafka::Config.error_callback).to respond_to :call
+      end
+    end
+
+    context "with a callable object" do
+      it "should set the callback" do
+        callback = Class.new do
+          def call(stats); end
+        end
+        expect {
+          Rdkafka::Config.error_callback = callback.new
+        }.not_to raise_error
+        expect(Rdkafka::Config.error_callback).to respond_to :call
+      end
+    end
+
+    it "should not accept a callback that's not callable" do
+      expect {
+        Rdkafka::Config.error_callback = 'a string'
+      }.to raise_error(TypeError)
+    end
+  end
+
   context "configuration" do
     it "should store configuration" do
       config = Rdkafka::Config.new
@@ -90,6 +148,17 @@ describe Rdkafka::Config do
       }.to raise_error(Rdkafka::Config::ConfigError, "No such configuration property: \"invalid.key\"")
     end
 
+    it "should allow configuring zstd compression" do
+      config = Rdkafka::Config.new('compression.codec' => 'zstd')
+      begin
+        expect(config.producer).to be_a Rdkafka::Producer
+        config.producer.close
+      rescue Rdkafka::Config::ConfigError => ex
+        pending "Zstd compression not supported on this machine"
+        raise ex
+      end
+    end
+
     it "should raise an error when client creation fails for a consumer" do
       config = Rdkafka::Config.new(
         "security.protocol" => "SSL",