wooga-kafka-rb 0.0.7

data/lib/kafka/producer.rb

@@ -0,0 +1,68 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+module Kafka
+  class Producer
+
+    include Kafka::IO
+
+    PRODUCE_REQUEST_ID = Kafka::RequestType::PRODUCE
+
+    attr_accessor :topic, :partition
+
+    def initialize(options = {})
+      self.topic     = options[:topic]      || "test"
+      self.partition = options[:partition]  || 0
+      self.host      = options[:host]       || "localhost"
+      self.port      = options[:port]       || 9092
+      self.connect(self.host, self.port)
+    end
+
+    def encode(message)
+      if RUBY_VERSION[0,3] == "1.8"  # Use old iconv on Ruby 1.8 for encoding
+        ic = Iconv.new('UTF-8//IGNORE', 'UTF-8')
+        [message.magic].pack("C") + [message.calculate_checksum].pack("N") + ic.iconv(message.payload.to_s)
+      else
+        [message.magic].pack("C") + [message.calculate_checksum].pack("N") + message.payload.to_s.force_encoding(Encoding::ASCII_8BIT)
+      end
+    end
+
+    def encode_request(topic, partition, messages)
+      message_set = Array(messages).collect { |message|
+        encoded_message = self.encode(message)
+        [encoded_message.length].pack("N") + encoded_message
+      }.join("")
+
+      request   = [PRODUCE_REQUEST_ID].pack("n")
+      topic     = [topic.length].pack("n") + topic
+      partition = [partition].pack("N")
+      messages  = [message_set.length].pack("N") + message_set
+
+      data = request + topic + partition + messages
+
+      return [data.length].pack("N") + data
+    end
+
+    def send(messages)
+      self.write(self.encode_request(self.topic, self.partition, messages))
+    end
+
+    def batch(&block)
+      batch = Kafka::Batch.new
+      block.call( batch )
+      self.send(batch.messages)
+      batch.messages.clear
+    end
+  end
+end

data/lib/kafka/request_type.rb

@@ -0,0 +1,23 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+module Kafka
+  module RequestType
+    PRODUCE      = 0
+    FETCH        = 1
+    MULTIFETCH   = 2
+    MULTIPRODUCE = 3
+    OFFSETS      = 4
+  end
+end

data/lib/kafka.rb

@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require 'socket'
+require 'zlib'
+if RUBY_VERSION[0,3] == "1.8"
+  require 'iconv'
+end
+
+require File.join(File.dirname(__FILE__), "kafka", "io")
+require File.join(File.dirname(__FILE__), "kafka", "request_type")
+require File.join(File.dirname(__FILE__), "kafka", "error_codes")
+require File.join(File.dirname(__FILE__), "kafka", "batch")
+require File.join(File.dirname(__FILE__), "kafka", "message")
+require File.join(File.dirname(__FILE__), "kafka", "producer")
+require File.join(File.dirname(__FILE__), "kafka", "consumer")
+
+module Kafka
+
+  class SocketError < RuntimeError; end
+
+end

data/spec/batch_spec.rb

@@ -0,0 +1,35 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Batch do
+
+  before(:each) do
+    @batch = Batch.new
+  end
+
+  describe "batch messages" do
+    it "holds all messages to be sent" do
+      @batch.should respond_to(:messages)
+      @batch.messages.class.should eql(Array)
+    end
+
+    it "supports queueing/adding messages to be send" do
+      @batch.messages << mock(Kafka::Message.new("one"))
+      @batch.messages << mock(Kafka::Message.new("two"))
+      @batch.messages.length.should eql(2)
+    end
+  end
+end

data/spec/consumer_spec.rb

@@ -0,0 +1,179 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Consumer do
+
+  before(:each) do
+    @mocked_socket = mock(TCPSocket)
+    TCPSocket.stub!(:new).and_return(@mocked_socket) # don't use a real socket
+    @consumer = Consumer.new(:offset => 0)
+  end
+
+  describe "Kafka Consumer" do
+
+    it "should have a Kafka::RequestType::FETCH" do
+      Consumer::Kafka::RequestType::FETCH.should eql(1)
+      @consumer.should respond_to(:request_type)
+    end
+
+    it "should have a topic and a partition" do
+      @consumer.should respond_to(:topic)
+      @consumer.should respond_to(:partition)
+    end
+
+    it "should have a polling option, and a default value" do
+      Consumer::DEFAULT_POLLING_INTERVAL.should eql(2)
+      @consumer.should respond_to(:polling)
+      @consumer.polling.should eql(2)
+    end
+
+    it "should set a topic and partition on initialize" do
+      @consumer = Consumer.new({ :host => "localhost", :port => 9092, :topic => "testing" })
+      @consumer.topic.should eql("testing")
+      @consumer.partition.should eql(0)
+      @consumer = Consumer.new({ :topic => "testing", :partition => 3 })
+      @consumer.partition.should eql(3)
+    end
+
+    it "should set default host and port if none is specified" do
+      @consumer = Consumer.new
+      @consumer.host.should eql("localhost")
+      @consumer.port.should eql(9092)
+    end
+
+    it "should not have a default offset but be able to set it" do
+      @consumer = Consumer.new
+      @consumer.offset.should be_nil
+      @consumer = Consumer.new({ :offset => 1111 })
+      @consumer.offset.should eql(1111)
+    end
+
+    it "should have a max size" do
+      Consumer::MAX_SIZE.should eql(1048576)
+      @consumer.max_size.should eql(1048576)
+    end
+
+    it "should return the size of the request" do
+      @consumer.topic = "someothertopicname"
+      @consumer.encoded_request_size.should eql([38].pack("N"))
+    end
+
+    it "should encode a request to consume" do
+      bytes = [Kafka::RequestType::FETCH].pack("n") + ["test".length].pack("n") + "test" + [0].pack("N") + [0].pack("q").reverse + [Kafka::Consumer::MAX_SIZE].pack("N")
+      @consumer.encode_request(Kafka::RequestType::FETCH, "test", 0, 0, Kafka::Consumer::MAX_SIZE).should eql(bytes)
+    end
+
+    it "should read the response data" do
+      bytes = [0].pack("n") + [1120192889].pack("N") + "ale"
+      @mocked_socket.should_receive(:read).and_return([9].pack("N"))
+      @mocked_socket.should_receive(:read).with(9).and_return(bytes)
+      @consumer.read_data_response.should eql(bytes[2,7])
+    end
+
+    it "should send a consumer request" do
+      @consumer.stub!(:encoded_request_size).and_return(666)
+      @consumer.stub!(:encode_request).and_return("someencodedrequest")
+      @consumer.should_receive(:write).with("someencodedrequest").exactly(:once).and_return(true)
+      @consumer.should_receive(:write).with(666).exactly(:once).and_return(true)
+      @consumer.send_consume_request.should eql(true)
+    end
+
+    it "should parse a message set from bytes" do
+      bytes = [8].pack("N") + [0].pack("C") + [1120192889].pack("N") + "ale"
+      message = @consumer.parse_message_set_from(bytes).first
+      message.payload.should eql("ale")
+      message.checksum.should eql(1120192889)
+      message.magic.should eql(0)
+      message.valid?.should eql(true)
+    end
+
+    it "should skip an incomplete message at the end of the response" do
+      bytes = [8].pack("N") + [0].pack("C") + [1120192889].pack("N") + "ale"
+      # incomplete message
+      bytes += [8].pack("N")
+      messages = @consumer.parse_message_set_from(bytes)
+      messages.size.should eql(1)
+    end
+
+    it "should skip an incomplete message at the end of the response which has the same length as an empty message" do
+      bytes = [8].pack("N") + [0].pack("C") + [1120192889].pack("N") + "ale"
+      # incomplete message because payload is missing
+      bytes += [8].pack("N") + [0].pack("C") + [1120192889].pack("N")
+      messages = @consumer.parse_message_set_from(bytes)
+      messages.size.should eql(1)
+    end
+
+    it "should read empty messages correctly" do
+      # empty message
+      bytes = [5].pack("N") + [0].pack("C") + [0].pack("N") + ""
+      messages = @consumer.parse_message_set_from(bytes)
+      messages.size.should eql(1)
+      messages.first.payload.should eql("")
+    end
+
+    it "should consume messages" do
+      @consumer.should_receive(:send_consume_request).and_return(true)
+      @consumer.should_receive(:read_data_response).and_return("")
+      @consumer.consume.should eql([])
+    end
+
+    it "should loop and execute a block with the consumed messages" do
+      @consumer.stub!(:consume).and_return([mock(Kafka::Message)])
+      messages = []
+      messages.should_receive(:<<).exactly(:once).and_return([])
+      @consumer.loop do |message|
+        messages << message
+        break # we don't wanna loop forever on the test
+      end
+    end
+
+    it "should loop (every N seconds, configurable on polling attribute), and execute a block with the consumed messages" do
+      @consumer = Consumer.new({ :polling => 1 })
+      @consumer.stub!(:consume).and_return([mock(Kafka::Message)])
+      messages = []
+      messages.should_receive(:<<).exactly(:twice).and_return([])
+      executed_times = 0
+      @consumer.loop do |message|
+        messages << message
+        executed_times += 1
+        break if executed_times >= 2 # we don't wanna loop forever on the test, only 2 seconds
+      end
+
+      executed_times.should eql(2)
+    end
+
+    it "should fetch initial offset if no offset is given" do
+      @consumer = Consumer.new
+      @consumer.should_receive(:fetch_earliest_offset).exactly(:once).and_return(1000)
+      @consumer.should_receive(:send_consume_request).and_return(true)
+      @consumer.should_receive(:read_data_response).and_return("")
+      @consumer.consume
+      @consumer.offset.should eql(1000)
+    end
+
+    it "should encode an offset request" do
+      bytes = [Kafka::RequestType::OFFSETS].pack("n") + ["test".length].pack("n") + "test" + [0].pack("N") + [-2].pack("q").reverse + [Kafka::Consumer::MAX_OFFSETS].pack("N")
+      @consumer.encode_request(Kafka::RequestType::OFFSETS, "test", 0, -2, Kafka::Consumer::MAX_OFFSETS).should eql(bytes)
+    end
+
+    it "should parse an offsets response" do
+      bytes = [0].pack("n") + [1].pack('N') + [21346].pack('q').reverse
+      @mocked_socket.should_receive(:read).and_return([14].pack("N"))
+      @mocked_socket.should_receive(:read).and_return(bytes)
+      @consumer.read_offsets_response.should eql(21346)
+    end
+  end
+end

data/spec/io_spec.rb

@@ -0,0 +1,88 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require File.dirname(__FILE__) + '/spec_helper'
+
+class IOTest
+  include Kafka::IO
+end
+
+describe IO do
+
+  before(:each) do
+    @mocked_socket = mock(TCPSocket)
+    TCPSocket.stub!(:new).and_return(@mocked_socket) # don't use a real socket
+    @io = IOTest.new
+    @io.connect("somehost", 9093)
+  end
+
+  describe "default methods" do
+    it "has a socket, a host and a port" do
+      [:socket, :host, :port].each do |m|
+        @io.should respond_to(m.to_sym)
+      end
+    end
+
+    it "raises an exception if no host and port is specified" do
+      lambda {
+        io = IOTest.new
+        io.connect
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should remember the port and host on connect" do
+      @io.connect("somehost", 9093)
+      @io.host.should eql("somehost")
+      @io.port.should eql(9093)
+    end
+
+    it "should write to a socket" do
+      data = "some data"
+      @mocked_socket.should_receive(:write).with(data).and_return(9)
+      @io.write(data).should eql(9)
+    end
+
+    it "should read from a socket" do
+      length = 200
+      @mocked_socket.should_receive(:read).with(length).and_return("foo")
+      @io.read(length)
+    end
+
+    it "should disconnect on a timeout when reading from a socket (to aviod protocol desync state)" do
+      length = 200
+      @mocked_socket.should_receive(:read).with(length).and_raise(Errno::EAGAIN)
+      @io.should_receive(:disconnect)
+      lambda { @io.read(length) }.should raise_error(Kafka::SocketError)
+    end
+
+    it "should disconnect" do
+      @io.should respond_to(:disconnect)
+      @mocked_socket.should_receive(:close).and_return(nil)
+      @io.disconnect
+    end
+
+    it "should reconnect" do
+      TCPSocket.should_receive(:new)
+      @io.reconnect
+    end
+
+    it "should disconnect on a broken pipe error" do
+      [Errno::ECONNABORTED, Errno::EPIPE, Errno::ECONNRESET].each do |error|
+        @mocked_socket.should_receive(:write).exactly(:once).and_raise(error)
+        @mocked_socket.should_receive(:close).exactly(:once).and_return(nil)
+        lambda { @io.write("some data to send") }.should raise_error(Kafka::SocketError)
+      end
+    end
+  end
+end

data/spec/kafka_spec.rb

@@ -0,0 +1,21 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Kafka do
+
+  before(:each) do
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,69 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Message do
+
+  before(:each) do
+    @message = Message.new
+  end
+
+  describe "Kafka Message" do
+    it "should have a default magic number" do
+      Message::MAGIC_IDENTIFIER_DEFAULT.should eql(0)
+    end
+
+    it "should have a magic field, a checksum and a payload" do
+      [:magic, :checksum, :payload].each do |field|
+        @message.should respond_to(field.to_sym)
+      end
+    end
+
+    it "should set a default value of zero" do
+      @message.magic.should eql(Kafka::Message::MAGIC_IDENTIFIER_DEFAULT)
+    end
+
+    it "should allow to set a custom magic number" do
+      @message = Message.new("ale", 1)
+      @message.magic.should eql(1)
+    end
+
+    it "should calculate the checksum (crc32 of a given message)" do
+      @message.payload = "ale"
+      @message.calculate_checksum.should eql(1120192889)
+      @message.payload = "alejandro"
+      @message.calculate_checksum.should eql(2865078607)
+    end
+
+    it "should say if the message is valid using the crc32 signature" do
+      @message.payload  = "alejandro"
+      @message.checksum = 2865078607
+      @message.valid?.should eql(true)
+      @message.checksum = 0
+      @message.valid?.should eql(false)
+      @message = Message.new("alejandro", 0, 66666666) # 66666666 is a funny checksum
+      @message.valid?.should eql(false)
+    end
+
+    it "should parse a message from bytes" do
+      bytes = [12].pack("N") + [0].pack("C") + [1120192889].pack("N") + "ale"
+      message = Kafka::Message.parse_from(bytes)
+      message.valid?.should eql(true)
+      message.magic.should eql(0)
+      message.checksum.should eql(1120192889)
+      message.payload.should eql("ale")
+    end
+  end
+end

data/spec/producer_spec.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Producer do
+
+  before(:each) do
+    @mocked_socket = mock(TCPSocket)
+    TCPSocket.stub!(:new).and_return(@mocked_socket) # don't use a real socket
+    @producer = Producer.new
+  end
+
+  describe "Kafka Producer" do
+    it "should have a PRODUCE_REQUEST_ID" do
+      Producer::PRODUCE_REQUEST_ID.should eql(0)
+    end
+
+    it "should have a topic and a partition" do
+      @producer.should respond_to(:topic)
+      @producer.should respond_to(:partition)
+    end
+
+    it "should set a topic and partition on initialize" do
+      @producer = Producer.new({ :host => "localhost", :port => 9092, :topic => "testing" })
+      @producer.topic.should eql("testing")
+      @producer.partition.should eql(0)
+      @producer = Producer.new({ :topic => "testing", :partition => 3 })
+      @producer.partition.should eql(3)
+    end
+
+    it "should set default host and port if none is specified" do
+      @producer = Producer.new
+      @producer.host.should eql("localhost")
+      @producer.port.should eql(9092)
+    end
+
+    describe "Message Encoding" do
+      it "should encode a message" do
+        message = Kafka::Message.new("alejandro")
+        full_message = [message.magic].pack("C") + [message.calculate_checksum].pack("N") + message.payload
+        @producer.encode(message).should eql(full_message)
+      end
+      
+      it "should encode an empty message" do
+        message = Kafka::Message.new()
+        full_message = [message.magic].pack("C") + [message.calculate_checksum].pack("N") + message.payload.to_s
+        @producer.encode(message).should eql(full_message)
+      end
+
+      it "should encode strings containing non-ASCII characters" do
+        message = Kafka::Message.new("ümlaut")
+        encoded = @producer.encode(message)
+        data = [encoded.size].pack("N") + encoded
+        if RUBY_VERSION[0,3] == "1.8" # Use old iconv on Ruby 1.8 for encoding
+          ic = Iconv.new('UTF-8//IGNORE', 'UTF-8')
+          ic.iconv(Kafka::Message.parse_from(data).payload).should eql("ümlaut")
+        else
+          Kafka::Message.parse_from(data).payload.force_encoding(Encoding::UTF_8).should eql("ümlaut")
+        end
+      end
+    end
+
+    describe "Request Encoding" do
+      it "should binary encode an empty request" do
+        bytes = @producer.encode_request("test", 0, [])
+        bytes.length.should eql(20)
+        bytes.should eql("\000\000\000\020\000\000\000\004test\000\000\000\000\000\000\000\000")
+      end
+
+      it "should binary encode a request with a message, using a specific wire format" do
+        message = Kafka::Message.new("ale")
+        bytes = @producer.encode_request("test", 3, message)
+        data_size  = bytes[0, 4].unpack("N").shift
+        request_id = bytes[4, 2].unpack("n").shift
+        topic_length = bytes[6, 2].unpack("n").shift
+        topic = bytes[8, 4]
+        partition = bytes[12, 4].unpack("N").shift
+        messages_length = bytes[16, 4].unpack("N").shift
+        messages = bytes[20, messages_length]
+
+        bytes.length.should eql(32)
+        data_size.should eql(28)
+        request_id.should eql(0)
+        topic_length.should eql(4)
+        topic.should eql("test")
+        partition.should eql(3)
+        messages_length.should eql(12)
+      end
+    end
+  end
+
+  it "should send messages" do
+    @producer.should_receive(:write).and_return(32)
+    message = Kafka::Message.new("ale")
+    @producer.send(message).should eql(32)
+  end
+
+  describe "Message Batching" do
+    it "should batch messages and send them at once" do
+      message1 = Kafka::Message.new("one")
+      message2 = Kafka::Message.new("two")
+      @producer.should_receive(:send).with([message1, message2]).exactly(:once).and_return(nil)
+      @producer.batch do |messages|
+        messages << message1
+        messages << message2
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require 'rubygems'
+require 'kafka'
+
+include Kafka