karafka-rdkafka 0.20.0.rc3-x86_64-linux-gnu

data/spec/rdkafka/consumer/message_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+describe Rdkafka::Consumer::Message do
+  let(:native_client) { new_native_client }
+  let(:native_topic) { new_native_topic(native_client: native_client) }
+  let(:payload) { nil }
+  let(:key) { nil }
+  let(:native_message) do
+    Rdkafka::Bindings::Message.new.tap do |message|
+      message[:rkt] = native_topic
+      message[:partition] = 3
+      message[:offset] = 100
+      if payload
+        ptr = FFI::MemoryPointer.new(:char, payload.bytesize)
+        ptr.put_bytes(0, payload)
+        message[:payload] = ptr
+        message[:len] = payload.bytesize
+      end
+      if key
+        ptr = FFI::MemoryPointer.new(:char, key.bytesize)
+        ptr.put_bytes(0, key)
+        message[:key] = ptr
+        message[:key_len] = key.bytesize
+      end
+    end
+  end
+
+  after(:each) do
+    Rdkafka::Bindings.rd_kafka_destroy(native_client)
+  end
+
+  subject { Rdkafka::Consumer::Message.new(native_message) }
+
+  before do
+    # mock headers, because it produces 'segmentation fault' while settings or reading headers for
+    # a message which is created from scratch
+    #
+    # Code dump example:
+    #
+    # ```
+    # frame #7: 0x000000010dacf5ab librdkafka.dylib`rd_list_destroy + 11
+    # frame #8: 0x000000010dae5a7e librdkafka.dylib`rd_kafka_headers_destroy + 14
+    # frame #9: 0x000000010da9ab40 librdkafka.dylib`rd_kafka_message_set_headers + 32
+    # ```
+    expect( Rdkafka::Bindings).to receive(:rd_kafka_message_headers).with(any_args) do
+      Rdkafka::Bindings::RD_KAFKA_RESP_ERR__NOENT
+    end
+  end
+
+  it "should have a topic" do
+    expect(subject.topic).to eq "topic_name"
+  end
+
+  it "should have a partition" do
+    expect(subject.partition).to eq 3
+  end
+
+  context "payload" do
+    it "should have a nil payload when none is present" do
+      expect(subject.payload).to be_nil
+    end
+
+    context "present payload" do
+      let(:payload) { "payload content" }
+
+      it "should have a payload" do
+        expect(subject.payload).to eq "payload content"
+      end
+    end
+  end
+
+  context "key" do
+    it "should have a nil key when none is present" do
+      expect(subject.key).to be_nil
+    end
+
+    context "present key" do
+      let(:key) { "key content" }
+
+      it "should have a key" do
+        expect(subject.key).to eq "key content"
+      end
+    end
+  end
+
+  it "should have an offset" do
+    expect(subject.offset).to eq 100
+  end
+
+  describe "#timestamp" do
+    context "without a timestamp" do
+      before do
+        allow(Rdkafka::Bindings).to receive(:rd_kafka_message_timestamp).and_return(-1)
+      end
+
+      it "should have a nil timestamp if not present" do
+        expect(subject.timestamp).to be_nil
+      end
+    end
+
+    context "with a timestamp" do
+      before do
+        allow(Rdkafka::Bindings).to receive(:rd_kafka_message_timestamp).and_return(1505069646250)
+      end
+
+      it "should have timestamp if present" do
+        expect(subject.timestamp).to eq Time.at(1505069646, 250_000)
+      end
+    end
+  end
+
+  describe "#to_s" do
+    before do
+      allow(subject).to receive(:timestamp).and_return(1000)
+    end
+
+    it "should have a human readable representation" do
+      expect(subject.to_s).to eq "<Message in 'topic_name' with key '', payload '', partition 3, offset 100, timestamp 1000>"
+    end
+
+    context "with key and payload" do
+      let(:key) { "key" }
+      let(:payload) { "payload" }
+
+      it "should have a human readable representation" do
+        expect(subject.to_s).to eq "<Message in 'topic_name' with key 'key', payload 'payload', partition 3, offset 100, timestamp 1000>"
+      end
+    end
+
+    context "with a very long key and payload" do
+      let(:key) { "k" * 100_000 }
+      let(:payload) { "p" * 100_000 }
+
+      it "should have a human readable representation" do
+        expect(subject.to_s).to eq "<Message in 'topic_name' with key 'kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk...', payload 'pppppppppppppppppppppppppppppppppppppppp...', partition 3, offset 100, timestamp 1000>"
+      end
+    end
+  end
+end

data/spec/rdkafka/consumer/partition_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+describe Rdkafka::Consumer::Partition do
+  let(:offset) { 100 }
+  let(:err) { 0 }
+  subject { Rdkafka::Consumer::Partition.new(1, offset, err) }
+
+  it "should have a partition" do
+    expect(subject.partition).to eq 1
+  end
+
+  it "should have an offset" do
+    expect(subject.offset).to eq 100
+  end
+
+  it "should have an err code" do
+    expect(subject.err).to eq 0
+  end
+
+  describe "#to_s" do
+    it "should return a human readable representation" do
+      expect(subject.to_s).to eq "<Partition 1 offset=100>"
+    end
+  end
+
+  describe "#inspect" do
+    it "should return a human readable representation" do
+      expect(subject.to_s).to eq "<Partition 1 offset=100>"
+    end
+
+    context "without offset" do
+      let(:offset) { nil }
+
+      it "should return a human readable representation" do
+        expect(subject.to_s).to eq "<Partition 1>"
+      end
+    end
+
+    context "with err code" do
+      let(:err) { 1 }
+
+      it "should return a human readable representation" do
+        expect(subject.to_s).to eq "<Partition 1 offset=100 err=1>"
+      end
+    end
+  end
+
+  describe "#==" do
+    it "should equal another partition with the same content" do
+      expect(subject).to eq Rdkafka::Consumer::Partition.new(1, 100)
+    end
+
+    it "should not equal another partition with different content" do
+      expect(subject).not_to eq Rdkafka::Consumer::Partition.new(2, 101)
+    end
+  end
+end

data/spec/rdkafka/consumer/topic_partition_list_spec.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+describe Rdkafka::Consumer::TopicPartitionList do
+  it "should create a new list and add unassigned topics" do
+    list = Rdkafka::Consumer::TopicPartitionList.new
+
+    expect(list.count).to eq 0
+    expect(list.empty?).to be true
+
+    list.add_topic("topic1")
+    list.add_topic("topic2")
+
+    expect(list.count).to eq 2
+    expect(list.empty?).to be false
+
+    hash = list.to_h
+    expect(hash.count).to eq 2
+    expect(hash).to eq ({
+      "topic1" => nil,
+      "topic2" => nil
+    })
+  end
+
+  it "should create a new list and add assigned topics as a range" do
+    list = Rdkafka::Consumer::TopicPartitionList.new
+
+    expect(list.count).to eq 0
+    expect(list.empty?).to be true
+
+    list.add_topic("topic1", (0..2))
+    list.add_topic("topic2", (0..1))
+
+    expect(list.count).to eq 5
+    expect(list.empty?).to be false
+
+    hash = list.to_h
+    expect(hash.count).to eq 2
+    expect(hash["topic1"]).to eq([
+      Rdkafka::Consumer::Partition.new(0, nil),
+      Rdkafka::Consumer::Partition.new(1, nil),
+      Rdkafka::Consumer::Partition.new(2, nil)
+    ])
+    expect(hash["topic2"]).to eq([
+      Rdkafka::Consumer::Partition.new(0, nil),
+      Rdkafka::Consumer::Partition.new(1, nil)
+    ])
+  end
+
+  it "should create a new list and add assigned topics as an array" do
+    list = Rdkafka::Consumer::TopicPartitionList.new
+
+    expect(list.count).to eq 0
+    expect(list.empty?).to be true
+
+    list.add_topic("topic1", [0, 1, 2])
+    list.add_topic("topic2", [0, 1])
+
+    expect(list.count).to eq 5
+    expect(list.empty?).to be false
+
+    hash = list.to_h
+    expect(hash.count).to eq 2
+    expect(hash["topic1"]).to eq([
+      Rdkafka::Consumer::Partition.new(0, nil),
+      Rdkafka::Consumer::Partition.new(1, nil),
+      Rdkafka::Consumer::Partition.new(2, nil)
+    ])
+    expect(hash["topic2"]).to eq([
+      Rdkafka::Consumer::Partition.new(0, nil),
+      Rdkafka::Consumer::Partition.new(1, nil)
+    ])
+  end
+
+  it "should create a new list and add assigned topics as a count" do
+    list = Rdkafka::Consumer::TopicPartitionList.new
+
+    expect(list.count).to eq 0
+    expect(list.empty?).to be true
+
+    list.add_topic("topic1", 3)
+    list.add_topic("topic2", 2)
+
+    expect(list.count).to eq 5
+    expect(list.empty?).to be false
+
+    hash = list.to_h
+    expect(hash.count).to eq 2
+    expect(hash["topic1"]).to eq([
+      Rdkafka::Consumer::Partition.new(0, nil),
+      Rdkafka::Consumer::Partition.new(1, nil),
+      Rdkafka::Consumer::Partition.new(2, nil)
+    ])
+    expect(hash["topic2"]).to eq([
+      Rdkafka::Consumer::Partition.new(0, nil),
+      Rdkafka::Consumer::Partition.new(1, nil)
+    ])
+  end
+
+  it "should create a new list and add topics and partitions with an offset" do
+    list = Rdkafka::Consumer::TopicPartitionList.new
+
+    expect(list.count).to eq 0
+    expect(list.empty?).to be true
+
+    list.add_topic_and_partitions_with_offsets("topic1", 0 => 5, 1 => 6, 2 => 7)
+
+    hash = list.to_h
+    expect(hash.count).to eq 1
+    expect(hash["topic1"]).to eq([
+      Rdkafka::Consumer::Partition.new(0, 5),
+      Rdkafka::Consumer::Partition.new(1, 6),
+      Rdkafka::Consumer::Partition.new(2, 7)
+    ])
+  end
+
+  describe "#to_s" do
+    let(:expected) do
+      if RUBY_VERSION >= '3.4.0'
+        "<TopicPartitionList: {\"topic1\" => [<Partition 0>, <Partition 1>]}>"
+      else
+        "<TopicPartitionList: {\"topic1\"=>[<Partition 0>, <Partition 1>]}>"
+      end
+    end
+
+    it "should return a human readable representation" do
+      list = Rdkafka::Consumer::TopicPartitionList.new
+      list.add_topic("topic1", [0, 1])
+
+      expect(list.to_s).to eq expected
+    end
+  end
+
+  describe "#==" do
+    subject do
+      Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic("topic1", [0])
+      end
+    end
+
+    it "should equal another partition with the same content" do
+      other = Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic("topic1", [0])
+      end
+      expect(subject).to eq other
+    end
+
+    it "should not equal another partition with different content" do
+      expect(subject).not_to eq Rdkafka::Consumer::TopicPartitionList.new
+    end
+  end
+
+  describe ".from_native_tpl" do
+    it "should create a list from an existing native list" do
+      pointer = Rdkafka::Bindings.rd_kafka_topic_partition_list_new(5)
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_add(
+        pointer,
+        "topic",
+        -1
+      )
+      list = Rdkafka::Consumer::TopicPartitionList.from_native_tpl(pointer)
+
+      other = Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic("topic")
+      end
+
+      expect(list).to eq other
+    end
+
+    it "should create a list from an existing native list with offsets" do
+      pointer = Rdkafka::Bindings.rd_kafka_topic_partition_list_new(5)
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_add(
+        pointer,
+        "topic",
+        0
+      )
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_set_offset(
+        pointer,
+        "topic",
+        0,
+        100
+      )
+      list = Rdkafka::Consumer::TopicPartitionList.from_native_tpl(pointer)
+
+      other = Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic_and_partitions_with_offsets("topic", 0 => 100)
+      end
+
+      expect(list).to eq other
+    end
+  end
+
+  describe "#to_native_tpl" do
+    it "should create a native list" do
+      list = Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic("topic")
+      end
+
+      tpl = list.to_native_tpl
+
+      other = Rdkafka::Consumer::TopicPartitionList.from_native_tpl(tpl)
+
+      expect(list).to eq other
+    end
+
+    it "should create a native list with partitions" do
+      list = Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic("topic", 0..16)
+      end
+
+      tpl = list.to_native_tpl
+
+      other = Rdkafka::Consumer::TopicPartitionList.from_native_tpl(tpl)
+
+      expect(list).to eq other
+    end
+
+    it "should create a native list with offsets" do
+      list = Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic_and_partitions_with_offsets("topic", 0 => 100)
+      end
+
+      tpl = list.to_native_tpl
+
+      other = Rdkafka::Consumer::TopicPartitionList.from_native_tpl(tpl)
+
+      expect(list).to eq other
+    end
+
+    it "should create a native list with timetamp offsets if offsets are Time" do
+      list = Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic_and_partitions_with_offsets("topic", 0 => Time.at(1505069646, 250_000))
+      end
+
+      tpl = list.to_native_tpl
+
+      compare_list = Rdkafka::Consumer::TopicPartitionList.new.tap do |list|
+        list.add_topic_and_partitions_with_offsets(
+          "topic",
+          0 => (Time.at(1505069646, 250_000).to_f * 1000).floor
+        )
+      end
+
+      native_list = Rdkafka::Consumer::TopicPartitionList.from_native_tpl(tpl)
+
+      expect(native_list).to eq compare_list
+    end
+  end
+end