test_kafka 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0
+
+* Initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in test_kafka.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Brian Schroeder
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# TestKafka
+
+Minimal Kafka 0.8 runner suitable for integration testing.
+
+Adapted from the excellent [poseidon](https://github.com/bpot/poseidon)'s integration tests.
+
+## Installation
+
+Add TestKafka to your application's Gemfile:
+
+```ruby
+gem 'test_kafka'
+```
+
+and bundle:
+
+    $ bundle
+
+## Usage
+
+```ruby
+require 'test_kafka'
+
+cluster = TestKafka.start('/usr/local/kafka')
+# or specify custom a temp directory and kafka/zk ports:
+# cluster = TestKafka.start('/usr/local/kafka', '/tmp', 9092, 2181)
+
+# ... interact with Kafka/ZK ...
+
+cluster.stop
+```
+
+## Requirements
+
+* Kafka 0.8 or higher

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/test_kafka/broker.rb

@@ -0,0 +1,64 @@
+require 'test_kafka/java_runner'
+
+module TestKafka
+  class Broker
+    DEFAULT_PROPERTIES = {
+      "broker.id" => 0,
+      "port" => 9092,
+      "num.network.threads" => 2,
+      "num.io.threads" => 2,
+      "socket.send.buffer.bytes" => 1048576,
+      "socket.receive.buffer.bytes" => 1048576,
+      "socket.request.max.bytes" => 104857600,
+      "log.dir" => "/tmp/kafka-logs",
+      "num.partitions" => 1,
+      "log.flush.interval.messages" => 10000,
+      "log.flush.interval.ms" => 1000,
+      "log.retention.hours" => 168,
+      "log.segment.bytes" => 536870912,
+      "log.cleanup.interval.mins" => 1,
+      "zookeeper.connect" => "localhost:2181",
+      "zookeeper.connection.timeout.ms" => 1000000,
+      "kafka.metrics.polling.interval.secs" => 5,
+      "kafka.metrics.reporters" => "kafka.metrics.KafkaCSVMetricsReporter",
+      "kafka.csv.metrics.dir" => "/tmp/kafka_metrics",
+      "kafka.csv.metrics.reporter.enabled" => "false",
+    }.freeze
+
+    def initialize(kafka_path, tmp_dir, port, zk_port, broker_id=0, partition_count=1)
+      @broker_id = broker_id
+      @port = port
+      @jr = JavaRunner.new("broker_#{broker_id}",
+                           tmp_dir,
+                           "kafka.Kafka",
+                           port,
+                           kafka_path,
+                           DEFAULT_PROPERTIES.merge(
+                             "broker.id" => broker_id,
+                             "port" => port,
+                             "log.dir" => "#{tmp_dir}/kafka-logs_#{broker_id}",
+                             "kafka.csv.metrics.dir" => "#{tmp_dir}/kafka_metrics",
+                             "num.partitions" => partition_count,
+                             "zookeeper.connect" => "localhost:#{zk_port}"
+                           ))
+    end
+
+    attr_reader :broker_id, :port
+
+    def start
+      @jr.start
+    end
+
+    def stop
+      @jr.stop
+    end
+
+    def pid
+      @jr.pid
+    end
+
+    def with_interruption(&block)
+      @jr.with_interruption(&block)
+    end
+  end
+end

data/lib/test_kafka/cluster.rb

@@ -0,0 +1,31 @@
+require 'test_kafka/zookeeper'
+require 'test_kafka/broker'
+
+module TestKafka
+  class Cluster
+    def initialize(kafka_path, tmp_dir, kafka_port, zk_port)
+      @zookeeper = Zookeeper.new(kafka_path, tmp_dir, zk_port)
+      @broker = Broker.new(kafka_path, tmp_dir, kafka_port, zk_port)
+    end
+
+    attr_reader :broker, :zookeeper
+
+    def start
+      @zookeeper.start
+      @broker.start
+
+      self
+    end
+
+    def stop
+      @zookeeper.stop
+      @broker.stop
+
+      self
+    end
+
+    def with_interruption(&block)
+      @broker.with_interruption(&block)
+    end
+  end
+end

data/lib/test_kafka/java_runner.rb

@@ -0,0 +1,105 @@
+require 'fileutils'
+require 'socket' # daemon_controller needs this but currently doesn't require it
+require 'daemon_controller'
+
+module TestKafka
+  class JavaRunner
+    MAX_HEAP_SIZE = 512
+    JAR_PATTERN = "core/target/scala-*/*.jar"
+
+    def initialize(id, tmp_dir, java_class, port, kafka_path, properties={})
+      @id = id
+      @tmp_dir = tmp_dir
+      @java_class = java_class
+      @port = port
+      @kafka_path = kafka_path
+      @properties = properties
+    end
+
+    attr_reader :tmp_dir, :java_class, :kafka_path
+
+    def start
+      write_properties
+      run
+    end
+
+    def stop
+      daemon_controller.stop
+    end
+
+    def with_interruption
+      stop
+      begin
+        yield
+      ensure
+        start
+      end
+    end
+
+    def pid
+      data = File.read(pid_path)
+
+      data.to_i if data
+    end
+
+    private
+
+    def classpath
+      Dir.glob(kafka_path + "/" + JAR_PATTERN).join(":")
+    end
+
+    def java_command
+      "exec java -Xmx#{MAX_HEAP_SIZE}M -server -cp #{classpath} #{java_class} #{config_path}"
+    end
+
+    def daemon_controller
+      @dc ||= DaemonController.new(
+        :identifier => @id,
+        :start_command => "#{java_command} >>#{log_path} 2>&1 & echo $! > #{pid_path}",
+        :ping_command => [:tcp, '127.0.0.1', @port],
+        :pid_file => pid_path,
+        :log_file => log_path,
+        :start_timeout => 25
+      )
+    end
+
+    def run
+      FileUtils.mkdir_p(log_dir)
+      FileUtils.mkdir_p(pid_dir)
+      daemon_controller.start
+    end
+
+    def write_properties
+      FileUtils.mkdir_p(config_dir)
+      File.open(config_path, "w+") do |f|
+        @properties.each do |k,v|
+          f.puts "#{k}=#{v}"
+        end
+      end
+    end
+
+    def pid_path
+      "#{pid_dir}/#{@id}.pid"
+    end
+
+    def pid_dir
+      "#{tmp_dir}/pid"
+    end
+
+    def log_path
+      "#{log_dir}/#{@id}.log"
+    end
+
+    def log_dir
+      "#{tmp_dir}/log"
+    end
+
+    def config_path
+      "#{config_dir}/#{@id}.properties"
+    end
+
+    def config_dir
+      "#{tmp_dir}/config"
+    end
+  end
+end

data/lib/test_kafka/version.rb

@@ -0,0 +1,3 @@
+module TestKafka
+  VERSION = "0.1.0"
+end

data/lib/test_kafka/zookeeper.rb

@@ -0,0 +1,35 @@
+require 'test_kafka/java_runner'
+
+module TestKafka
+  class Zookeeper
+    def initialize(kafka_path, tmp_dir, port)
+      @port = port
+      @jr = JavaRunner.new("zookeeper",
+                           tmp_dir,
+                           "org.apache.zookeeper.server.quorum.QuorumPeerMain",
+                           port,
+                           kafka_path,
+                           "dataDir" => "#{tmp_dir}/zookeeper",
+                           "clientPort" => port,
+                           "maxClientCnxns" => 0)
+    end
+
+    attr_reader :port
+
+    def start
+      @jr.start
+    end
+
+    def stop
+      @jr.stop
+    end
+
+    def pid
+      @jr.pid
+    end
+
+    def with_interruption(&block)
+      @jr.with_interruption(&block)
+    end
+  end
+end

data/lib/test_kafka.rb

@@ -0,0 +1,11 @@
+require 'fileutils'
+require 'test_kafka/cluster'
+
+module TestKafka
+  def self.start(kafka_path, tmp_root='/tmp', kafka_port=9092, zk_port=2181)
+    tmp_dir = tmp_root + "/test_kafka"
+    FileUtils.rm_rf(tmp_dir)
+
+    TestKafka::Cluster.new(kafka_path, tmp_dir, kafka_port, zk_port).start
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  # config.run_all_when_everything_filtered = true
+  # config.filter_run :focus
+  config.order = 'random'
+end
+
+DEFAULT_KAFKA_PATH = "/usr/local/kafka"
+KAFKA_PATH = ENV["KAFKA_PATH"] || DEFAULT_KAFKA_PATH
+
+require 'test_kafka/java_runner'
+
+if Dir.glob(KAFKA_PATH + "/" + TestKafka::JavaRunner::JAR_PATTERN).empty?
+  fail "Could not find Kafka. Set the environment variable KAFKA_PATH or install Kafka to /usr/local/kafka."
+end
+
+def running?(pid)
+  Process.kill(0, pid)
+  true
+rescue Errno::ESRCH
+  false
+end
+
+require 'poseidon'
+
+def write_messages(port, messages)
+  producer = Poseidon::Producer.new(["localhost:#{port}"],
+                                    'test_producer')
+  producer.send_messages(messages.map { |m|
+    Poseidon::MessageToSend.new('topic1', m)
+  })
+end
+
+def read_messages(port)
+  consumer = Poseidon::PartitionConsumer.new(
+    'test_consumer',
+    'localhost',
+    broker_port,
+    'topic1',
+    0,
+    :earliest_offset
+  )
+
+  consumer.fetch.map(&:value)
+end

data/spec/test_kafka/broker_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'test_kafka/broker'
+require 'test_kafka/zookeeper'
+
+describe TestKafka::Broker do
+  let(:broker_port) { 9093 }
+  let(:zk_port) { 2182 }
+  let(:broker_tmp_dir) { "/tmp/kafka-test" }
+  let(:broker) { TestKafka::Broker.new(KAFKA_PATH,
+                                       broker_tmp_dir,
+                                       broker_port,
+                                       zk_port) }
+
+  before(:all) do
+    zk_tmp_dir = "/tmp/zk-test"
+    FileUtils.rm_rf(zk_tmp_dir)
+    @zk = TestKafka::Zookeeper.new(KAFKA_PATH, zk_tmp_dir, zk_port)
+    @zk.start
+  end
+
+  after(:all) do
+    @zk.stop
+  end
+
+  before do
+    FileUtils.rm_rf(broker_tmp_dir)
+  end
+
+  describe '#start' do
+    it 'starts a Kafka broker' do
+      broker.start
+      messages = ['value1', 'value2']
+      write_messages(broker_port, messages)
+
+      read_messages(broker_port).should eql messages
+
+      broker.stop
+    end
+  end
+
+  describe '#pid' do
+    it 'is the PID of the broker process' do
+      broker.start
+      ps_output = `ps aux |
+          grep "kafka\\.Kafka" |
+          grep #{Regexp.escape(broker_tmp_dir)} |
+          grep -v grep`
+      ps_pid = ps_output[/(\d+)/, 1].to_i
+
+      broker.pid.should eql ps_output[/(\d+)/, 1].to_i
+
+      broker.stop
+    end
+  end
+
+  describe '#stop' do
+    it 'stops a running Kafka broker' do
+      broker.start
+      pid = broker.pid
+      broker.stop
+
+      running?(pid).should be_false
+    end
+  end
+
+  describe '#port' do
+    it 'is the provided port' do
+      broker.port.should eql broker_port
+    end
+  end
+
+  describe '#with_interruption' do
+    it 'temporarily drops the broker' do
+      broker.start
+      old_pid = broker.pid
+
+      broker.with_interruption do
+        running?(old_pid).should be_false
+      end
+      new_pid = broker.pid
+
+      running?(new_pid).should be_true
+
+      broker.stop
+    end
+  end
+end

data/spec/test_kafka/cluster_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'test_kafka/cluster'
+require 'poseidon'
+
+describe TestKafka::Cluster do
+  let(:tmp_dir) { "/tmp/cluster-test" }
+  let(:broker_port) { 9093 }
+  let(:zk_port) { 2182 }
+  let(:cluster) { TestKafka::Cluster.new(KAFKA_PATH, tmp_dir, broker_port, zk_port) }
+
+  before do
+    FileUtils.rm_rf(tmp_dir)
+  end
+
+  describe '#start' do
+    it 'starts the cluster' do
+      cluster.start
+      messages = ['value1', 'value2']
+      write_messages(broker_port, messages)
+
+      read_messages(broker_port).should eql messages
+
+      cluster.stop
+    end
+  end
+
+  describe '#stop' do
+    it 'stops a running cluster' do
+      cluster.start
+      broker_pid = cluster.broker.pid
+      zk_pid = cluster.zookeeper.pid
+      cluster.stop
+
+      running?(broker_pid).should be_false
+      running?(zk_pid).should be_false
+    end
+  end
+
+  describe '#with_interruption' do
+    it 'temporarily stops the kafka broker' do
+      cluster.start
+      old_broker_pid = cluster.broker.pid
+      old_zk_pid = cluster.zookeeper.pid
+
+      cluster.with_interruption do
+        running?(old_broker_pid).should be_false
+      end
+      new_broker_pid = cluster.broker.pid
+
+      running?(new_broker_pid).should be_true
+      running?(old_zk_pid).should be_true
+
+      cluster.stop
+    end
+  end
+end

data/spec/test_kafka/zookeeper_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'test_kafka/zookeeper'
+require 'zk'
+require 'fileutils'
+
+describe TestKafka::Zookeeper do
+  let(:port) { 2182 }
+  let(:tmp_dir) { "/tmp/zk-test" }
+  let(:server) { TestKafka::Zookeeper.new(KAFKA_PATH, tmp_dir, port) }
+
+  before do
+    FileUtils.rm_rf(tmp_dir)
+  end
+
+  describe '#start' do
+    it 'starts a ZK server' do
+      server.start
+      client = ZK.new("localhost:#{port}")
+      begin
+        client.create("/path", "foo")
+      rescue ZK::Exceptions::OperationTimeOut
+        sleep 0.1
+        retry
+      end
+
+      client.get("/path").first.should eql "foo"
+
+      server.stop
+    end
+  end
+
+  describe '#pid' do
+    it 'is the PID of the ZK process' do
+      server.start
+      ps_output = `ps aux |
+          grep zookeeper |
+          grep #{Regexp.escape(tmp_dir)} |
+          grep -v grep`
+      ps_pid = ps_output[/(\d+)/, 1].to_i
+
+      server.pid.should eql ps_output[/(\d+)/, 1].to_i
+
+      server.stop
+    end
+  end
+
+  describe '#stop' do
+    it 'stops a running ZK server' do
+      server.start
+      pid = server.pid
+      server.stop
+
+      running?(pid).should be_false
+    end
+  end
+
+  describe '#port' do
+    it 'is the provided port' do
+      server.port.should eql port
+    end
+  end
+
+  describe '#with_interruption' do
+    it 'temporarily stops the server' do
+      server.start
+      old_pid = server.pid
+
+      server.with_interruption do
+        running?(old_pid).should be_false
+      end
+      new_pid = server.pid
+
+      running?(new_pid).should be_true
+
+      server.stop
+    end
+  end
+end

data/spec/test_kafka_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'test_kafka'
+require 'fileutils'
+
+describe TestKafka do
+  describe '.start' do
+    context 'with custom args' do
+      let(:tmp_root) { '/tmp/test_kafka-test' }
+      let(:broker_port) { 9093 }
+      let(:zk_port) { 2182 }
+
+      it 'initializes and starts a single-node test cluster' do
+        cluster = TestKafka.start(KAFKA_PATH, tmp_root, broker_port, zk_port)
+
+        messages = ['value1', 'value2']
+        write_messages(broker_port, messages)
+
+        read_messages(broker_port).should eql messages
+
+        cluster.stop
+      end
+
+      it 'deletes an existing test_kafka temp directory if one exists' do
+        tmp_dir = tmp_root + "/test_kafka"
+        FileUtils.mkdir_p(tmp_dir)
+        canary_path = tmp_dir + "/canary"
+        File.write(canary_path, "chirp")
+
+        cluster = TestKafka.start(KAFKA_PATH, tmp_root, broker_port, zk_port)
+
+        File.exist?(canary_path).should be_false
+
+        cluster.stop
+      end
+    end
+
+    context 'with default args' do
+      before(:all) { @cluster = TestKafka.start(KAFKA_PATH) }
+      after(:all) { @cluster.stop }
+
+      it 'uses /tmp as a temp root' do
+        Dir.exist?('/tmp/test_kafka').should be_true
+      end
+
+      it 'uses kafka port 9092' do
+        @cluster.broker.port.should eql 9092
+      end
+
+      it 'uses ZK port 2181' do
+        @cluster.zookeeper.port.should eql 2181
+      end
+    end
+  end
+end

data/test_kafka.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'test_kafka/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "test_kafka"
+  spec.version       = TestKafka::VERSION
+  spec.authors       = ["Brian Schroeder"]
+  spec.email         = ["bts@gmail.com"]
+  spec.description   = %q{Minimal Kafka runner suitable for integration testing}
+  spec.summary       = spec.description
+  spec.homepage      = "http://github.com/bts/test_kafka"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.1.0"
+  spec.add_development_dependency "rspec", "~> 2.12.0"
+  spec.add_development_dependency "zk", "~> 1.9.2"
+  spec.add_development_dependency "poseidon", "~> 0.0.4"
+
+  spec.add_dependency "daemon_controller", "~> 1.0.0"
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: test_kafka
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Brian Schroeder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: zk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+- !ruby/object:Gem::Dependency
+  name: poseidon
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: daemon_controller
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: Minimal Kafka runner suitable for integration testing
+email:
+- bts@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/test_kafka.rb
+- lib/test_kafka/broker.rb
+- lib/test_kafka/cluster.rb
+- lib/test_kafka/java_runner.rb
+- lib/test_kafka/version.rb
+- lib/test_kafka/zookeeper.rb
+- spec/spec_helper.rb
+- spec/test_kafka/broker_spec.rb
+- spec/test_kafka/cluster_spec.rb
+- spec/test_kafka/zookeeper_spec.rb
+- spec/test_kafka_spec.rb
+- test_kafka.gemspec
+homepage: http://github.com/bts/test_kafka
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Minimal Kafka runner suitable for integration testing
+test_files:
+- spec/spec_helper.rb
+- spec/test_kafka/broker_spec.rb
+- spec/test_kafka/cluster_spec.rb
+- spec/test_kafka/zookeeper_spec.rb
+- spec/test_kafka_spec.rb