rom-kafka 0.0.1

data/spec/unit/connection/producer_spec.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+describe ROM::Kafka::Connection::Producer do
+
+  # ============================================================================
+  # We test not the poseidon API, but its proper usage by the Producer.
+  # That's why we stub poseidon classes.
+  # ----------------------------------------------------------------------------
+  let(:driver)     { Poseidon::Producer }
+  let(:message)    { Poseidon::MessageToSend }
+  let(:connection) { double :connection, send_messages: nil }
+
+  before do
+    allow(driver).to receive(:new) { connection }
+
+    allow(message).to receive(:new) do |*args|
+      double :message, to_tuple: Hash[[:topic, :value, :key].zip(args)]
+    end
+  end
+  # ============================================================================
+
+  let(:producer) { described_class.new options }
+  let(:client)   { "foo" }
+  let(:brokers)  { %w(127.0.0.1:9092 127.0.0.2:9093) }
+  let(:options)  { attributes.merge(brokers: brokers, client_id: client) }
+  let(:attributes) do
+    {
+      partitioner: proc { |v, c| v % c },
+      type: :sync,
+      compression_codec: :gzip,
+      metadata_refresh_interval_ms: 100,
+      max_send_retries: 3,
+      retry_backoff_ms: 300,
+      required_acks: 2,
+      ack_timeout_ms: 200,
+      socket_timeout_ms: 400
+    }
+  end
+
+  describe "#connection" do
+    subject { producer.connection }
+
+    it "instantiates the driver" do
+      expect(driver).to receive(:new).with(brokers, client, attributes)
+      expect(subject).to eql(connection)
+    end
+  end # describe #connection
+
+  describe "#publish" do
+    subject { producer.publish(*input) }
+
+    let(:input) do
+      [
+        { value: "foo", topic: "foos", key: 1 },
+        [{ value: "bar", topic: "bars" }]
+      ]
+    end
+
+    let(:output) do
+      [
+        { value: "foo", topic: "foos", key: "1" },
+        { value: "bar", topic: "bars", key: nil }
+      ]
+    end
+
+    it "builds messages and sends it to the #connection" do
+      expect(connection).to receive(:send_messages) do |args|
+        expect(args.map(&:to_tuple)).to eql output
+      end
+
+      subject
+    end
+
+    it "returns the plain array of tuples" do
+      expect(subject).to eql output
+    end
+  end # describe #publish
+
+end # describe ROM::Kafka::Connection::Producer

data/spec/unit/create_spec.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+describe ROM::Kafka::Commands::Create do
+
+  let(:command)  { described_class.new relation }
+  let(:relation) { double :relation, dataset: dataset }
+  let(:dataset)  { double :dataset, producer: producer, topic: "qux" }
+  let(:producer) { double :producer, publish: output }
+  let(:output)   { double :output }
+
+  describe ".adapter" do
+    subject { described_class.adapter }
+
+    it { is_expected.to eql(:kafka) }
+  end # describe .adapter
+
+  describe ".new" do
+    subject { command }
+
+    it { is_expected.to be_kind_of ROM::Commands::Create }
+  end # describe .new
+
+  describe "#key" do
+    subject { command.key }
+
+    it { is_expected.to be_nil }
+  end # describe #key
+
+  describe "#with" do
+    subject { command.with(key: "foo") }
+
+    it "returns a command" do
+      expect(subject).to be_kind_of described_class
+    end
+
+    it "preserves current relation" do
+      expect(subject.relation).to eql relation
+    end
+
+    it "updates the key" do
+      expect(subject.key).to eql("foo")
+    end
+  end # describe #using
+
+  describe "#call" do
+    subject { command.call(:bar, ["baz"]) }
+
+    context "when key isn't set" do
+      let(:bar) { { value: "bar", topic: "qux", key: nil } }
+      let(:baz) { { value: "baz", topic: "qux", key: nil } }
+
+      it "publishes tuples to the producer" do
+        expect(producer).to receive(:publish).with(bar, baz)
+        subject
+      end
+
+      it "returns tuples" do
+        expect(subject).to eql output
+      end
+    end
+
+    context "when key is set" do
+      let(:command) { described_class.new(relation).with(key: "foo") }
+
+      let(:bar) { { value: "bar", topic: "qux", key: "foo" } }
+      let(:baz) { { value: "baz", topic: "qux", key: "foo" } }
+
+      it "publishes tuples to the producer" do
+        expect(producer).to receive(:publish).with(bar, baz)
+        subject
+      end
+
+      it "returns tuples" do
+        expect(subject).to eql output
+      end
+    end
+  end # describe #call
+
+end # describe ROM::Kafka::Relation

data/spec/unit/dataset_spec.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+describe ROM::Kafka::Dataset do
+
+  let(:gateway_class)  { ROM::Kafka::Gateway }
+  let(:consumer_class) { ROM::Kafka::Connection::Consumer }
+  let(:consumer)       { double :consumer }
+  before { allow(consumer_class).to receive(:new) { consumer } }
+
+  let(:dataset) { described_class.new(gateway, topic.to_sym) }
+  let(:gateway) { gateway_class.new client_id: "foo" }
+  let(:topic)   { "bar" }
+
+  describe "#gateway" do
+    subject { dataset.gateway }
+
+    it "is initialized" do
+      expect(subject).to eql gateway
+    end
+  end # describe #gateway
+
+  describe "#topic" do
+    subject { dataset.topic }
+
+    it "is initialized" do
+      expect(subject).to eql topic
+    end
+  end # describe #topic
+
+  describe "#attributes" do
+    subject { dataset.attributes }
+
+    context "by default" do
+      let(:attributes) do
+        {
+          partition: 0,
+          offset: 0,
+          limit: 0,
+          min_bytes: gateway.min_bytes,
+          max_bytes: gateway.max_bytes,
+          max_wait_ms: gateway.max_wait_ms
+        }
+      end
+
+      it "is taken from a gateway" do
+        expect(subject).to eql attributes
+      end
+    end
+
+    context "when options are set" do
+      let(:dataset) { described_class.new(gateway, topic, attributes) }
+      let(:attributes) do
+        {
+          partition: 1,
+          offset: 2,
+          limit: 10,
+          min_bytes: 1_024,
+          max_bytes: 10_240,
+          max_wait_ms: 100
+        }
+      end
+
+      it "is initialized" do
+        expect(subject).to eql attributes
+      end
+    end
+  end # describe #attributes
+
+  describe "#producer" do
+    subject { dataset.producer }
+
+    it "is taken from #gateway" do
+      expect(subject).to eql gateway.producer
+    end
+  end # describe #producer
+
+  describe "#consumer" do
+    subject { dataset.consumer }
+
+    let(:dataset) { described_class.new(gateway, topic, attributes) }
+
+    let(:attributes) do
+      {
+        partition: 1,
+        offset: 2,
+        limit: 0,
+        min_bytes: 1_024,
+        max_bytes: 10_240,
+        max_wait_ms: 100
+      }
+    end
+
+    let(:options) do
+      attributes.merge(
+        topic: topic,
+        client_id: gateway.client_id,
+        brokers: gateway.brokers
+      )
+    end
+
+    it "is initialized with proper options" do
+      expect(consumer_class).to receive(:new).with(options)
+      expect(subject).to eql consumer
+    end
+  end # describe #consumer
+
+  describe "#using" do
+    subject { dataset.using(update) }
+
+    let(:dataset) { described_class.new gateway, topic, min_bytes: 8 }
+    let(:update)  { { partition: 1, offset: 2 } }
+
+    it "builds new dataset" do
+      expect(subject).to be_kind_of described_class
+    end
+
+    it "preserves gateway" do
+      expect(subject.gateway).to eql(gateway)
+    end
+
+    it "preserves topic" do
+      expect(subject.topic).to eql(topic)
+    end
+
+    it "updates attributes" do
+      expect(subject.attributes).to eql(dataset.attributes.merge(update))
+    end
+  end # describe #using
+
+  describe "#each" do
+    subject { dataset.to_a }
+
+    let(:consumer) { double :consumer, each: data.each }
+    let(:data)     { %w(foo bar baz qux) }
+
+    context "when limit isn't set" do
+      it "is delegated to the consumer" do
+        expect(subject).to eql data
+      end
+
+      it "yields limited number of times" do
+        expect { |b| dataset.each(&b) }.to yield_control.exactly(4).times
+      end
+    end
+
+    context "when limit is set" do
+      let(:dataset) { described_class.new(gateway, topic, limit: 2) }
+
+      it "is delegated to the consumer" do
+        expect(subject).to eql data[0..1]
+      end
+
+      it "yields limited number of times" do
+        expect { |b| dataset.each(&b) }.to yield_control.twice
+      end
+    end
+
+    context "without a block" do
+      subject { dataset.each }
+
+      it { is_expected.to be_kind_of Enumerator }
+    end
+  end # describe #each
+
+end # describe ROM::Kafka::Dataset

data/spec/unit/gateway_spec.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+
+describe ROM::Kafka::Gateway do
+
+  let(:gateway) { described_class.new(client_id: :foo) }
+
+  describe ".new" do
+    context "without client id" do
+      subject { gateway }
+
+      it { is_expected.to be_kind_of ROM::Gateway }
+    end
+
+    context "without client id" do
+      subject { described_class.new }
+
+      it "fails" do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+  end # describe .new
+
+  describe "#brokers" do
+    subject { gateway.brokers }
+
+    let(:brokers) { %w(localhost:9092 127.0.0.1:9092) }
+
+    context "from strings" do
+      let(:gateway) { described_class.new(*brokers, client_id: :foo) }
+
+      it { is_expected.to eql brokers }
+    end
+
+    context "from hosts and port options" do
+      let(:gateway) do
+        described_class
+          .new(client_id: :foo, hosts: %w(localhost 127.0.0.1), port: 9092)
+      end
+
+      it { is_expected.to eql brokers }
+    end
+
+    context "from mixed options" do
+      let(:gateway) do
+        described_class
+          .new("localhost", client_id: :foo, hosts: %w(127.0.0.1), port: 9092)
+      end
+
+      it { is_expected.to eql brokers }
+    end
+  end # describe #hosts
+
+  describe "#attributes" do
+    subject { gateway.attributes }
+
+    context "by default" do
+      let(:attributes) { { client_id: :foo } }
+
+      it "is set" do
+        expect(subject).to eql(
+          ack_timeout_ms: 1_500,
+          brokers: ["localhost:9092"],
+          client_id: "foo",
+          compression_codec: nil,
+          max_bytes: 1_048_576,
+          max_send_retries: 3,
+          max_wait_ms: 100,
+          metadata_refresh_interval_ms: 600_000,
+          min_bytes: 1,
+          partitioner: nil,
+          required_acks: 0,
+          retry_backoff_ms: 100,
+          socket_timeout_ms: 10_000
+        )
+      end
+    end
+
+    context "when assigned" do
+      let(:gateway) { described_class.new(attributes) }
+
+      let(:attributes) do
+        {
+          ack_timeout_ms: 200,
+          brokers: ["localhost:9092"],
+          client_id: "foo",
+          compression_codec: :gzip,
+          max_bytes: 2_048,
+          max_send_retries: 2,
+          max_wait_ms: 300,
+          metadata_refresh_interval_ms: 300_000,
+          min_bytes: 1_024,
+          partitioner: proc { |value, count| value % count },
+          required_acks: 1,
+          retry_backoff_ms: 200,
+          socket_timeout_ms: 20_000
+        }
+      end
+
+      it { is_expected.to eql attributes }
+    end
+  end # describe #attributes
+
+  describe "#[]" do
+    subject { gateway[:foo] }
+
+    it { is_expected.to eql(nil) }
+  end # describe #[]
+
+  describe "#dataset?" do
+    before do
+      allow(gateway).to receive(:[]) { |name| { foo: :FOO }[name.to_sym] }
+    end
+
+    context "when dataset is registered" do
+      subject { gateway.dataset? "foo" }
+
+      it { is_expected.to eql true }
+    end
+
+    context "when dataset isn't registered" do
+      subject { gateway.dataset? "bar" }
+
+      it { is_expected.to eql false }
+    end
+  end # describe #dataset
+
+  describe "#dataset" do
+    subject { gateway.dataset topic }
+
+    let(:klass)   { ROM::Kafka::Dataset }
+    let(:dataset) { double :dataset }
+    let(:topic)   { "foobar" }
+
+    before { allow(klass).to receive(:new) { dataset } }
+
+    it "builds a dataset" do
+      expect(klass).to receive(:new).with(gateway, topic)
+      subject
+    end
+
+    it "registers a dataset by symbol" do
+      expect { subject }.to change { gateway[:foobar] }.from(nil).to(dataset)
+    end
+
+    it "registers a dataset by string" do
+      expect { subject }.to change { gateway["foobar"] }.from(nil).to(dataset)
+    end
+
+    it "returns a dataset" do
+      expect(subject).to eql(dataset)
+    end
+  end # describe #dataset
+
+  describe "#producer" do
+    subject { gateway.producer }
+    let(:producer) { double :producer }
+
+    it "builds a producer" do
+      attributes = {}
+      producer   = double :producer
+
+      expect(ROM::Kafka::Connection::Producer).to receive(:new) do |opts|
+        attributes = opts
+        producer
+      end
+      expect(subject).to eql producer
+      expect(attributes).to eql gateway.attributes
+    end
+  end # describe #producer
+
+end # describe ROM::Kafka::Gateway