gemerald_beanstalk 0.0.1 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 41a9a36dce59da44d721a91e44b7198756fa55a7
+  data.tar.gz: 7fec76d5aa209abc2dd69cd9c4b826e2e1025646
+SHA512:
+  metadata.gz: 15a963ae599e27e9df6a908b284eecbca492c08193e78c5ab824741a81c82214134766a70b76a3a769d2311f0f51397f450374b9bf2314b28b8387affb564867
+  data.tar.gz: 00d797ae54d95b37c161c40ec8fb3eb414e9d8f88cabf96200a4dc19d45be43c14a6d515de87ecc5ddb52eff4d2276a931ca28718d087cb9f6837c37d77cb384

data/.travis.yml

@@ -3,6 +3,7 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.0
   - jruby-19mode
   - rbx-19mode
 
@@ -25,3 +26,4 @@ script:
 matrix:
   allow_failures:
     - rvm: jruby-19mode
+    - rvm: rbx-19mode

data/.yardopts

@@ -0,0 +1,7 @@
+--output-dir doc/
+--readme README.md
+--title GemeraldBeanstalk
+--markup=markdown
+--protected
+--private
+lib/gemerald_beanstalk/**/*.rb

data/Gemfile

@@ -3,6 +3,5 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'beanstalk_integration_tests', '~> 0.0.8'
   gem 'coveralls', :require => false
 end

data/README.md

@@ -1,4 +1,5 @@
 # GemeraldBeanstalk
+[![Gem Version](https://badge.fury.io/rb/gemerald_beanstalk.png)](http://badge.fury.io/rb/gemerald_beanstalk)
 [![Build Status](https://travis-ci.org/gemeraldbeanstalk/gemerald_beanstalk.png?branch=master)](https://travis-ci.org/gemeraldbeanstalk/gemerald_beanstalk)
 [![Coverage Status](https://coveralls.io/repos/gemeraldbeanstalk/gemerald_beanstalk/badge.png)](https://coveralls.io/r/gemeraldbeanstalk/gemerald_beanstalk)
 [![Code Climate](https://codeclimate.com/github/gemeraldbeanstalk/gemerald_beanstalk.png)](https://codeclimate.com/github/gemeraldbeanstalk/gemerald_beanstalk)
@@ -27,7 +28,9 @@ The internals of GemeraldBeanstalk are undocumented at this point, with the
 expectation being that it should be interacted with strictly via the [beanstalkd
 protocol](https://github.com/kr/beanstalkd/blob/master/doc/protocol.md). This
 will likely change in the future, allowing more programatic access directly to
-the GemeraldBeanstalk::Beanstalk.
+the GemeraldBeanstalk::Beanstalk. If you think better documentation is needed
+pronto, create an issue and I will add docs.
+
 
 ## Installation
 

data/Rakefile

@@ -10,10 +10,11 @@ end
 
 task :start_gemerald_beanstalk_test_server do
   Thread.abort_on_exception = true
-  server_thread, beanstalk = GemeraldBeanstalk::Server.start(ENV['BIND_ADDRESS'], ENV['PORT'])
-  trap("SIGINT") { server_thread.kill }
-  puts "GemeraldBeanstalk listening on #{beanstalk.address}"
-  server_thread.join
+  server = GemeraldBeanstalk::Server.new(ENV['BIND_ADDRESS'], ENV['PORT'])
+  event_reactor = GemeraldBeanstalk::Server.event_reactor_thread
+  trap("SIGINT") { event_reactor.kill }
+  puts "GemeraldBeanstalk listening on #{server.full_address}"
+  event_reactor.join
 end
 
 task :default => :test

data/gemerald_beanstalk.gemspec

@@ -22,4 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'thread_safe'
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'beanstalk_integration_tests', '~> 0.0.8'
+  spec.add_development_dependency 'minitest_should'
+  spec.add_development_dependency 'mocha'
 end

data/lib/gemerald_beanstalk.rb

@@ -1,10 +1,16 @@
 require 'set'
-require 'gemerald_beanstalk/version'
 require 'thread_safe'
+require 'gemerald_beanstalk/version'
 require 'gemerald_beanstalk/job'
 require 'gemerald_beanstalk/beanstalk'
 require 'gemerald_beanstalk/connection'
 require 'gemerald_beanstalk/command'
 require 'gemerald_beanstalk/jobs'
 require 'gemerald_beanstalk/tube'
+require 'gemerald_beanstalk/event_server'
 require 'gemerald_beanstalk/server'
+
+module GemeraldBeanstalk
+  module Plugin
+  end
+end

data/lib/gemerald_beanstalk/beanstalk.rb

@@ -4,25 +4,11 @@ require 'gemerald_beanstalk/beanstalk_helper'
 
 class GemeraldBeanstalk::Beanstalk
 
-  # contains functionality supporting core commands
   include GemeraldBeanstalk::BeanstalkHelper
 
-  # Colon-separated host and port of the Server the Beanstalk instance is
-  # running on.
-  attr_reader :address
+  attr_reader :address, :max_job_size
 
-  # The maximum size in bytes that a job can be. Jobs exceeding this threshold
-  # will result in JOB_TOO_BIG responses.
-  attr_reader :max_job_size
 
-
-  # Initializes a new Beanstalk instance with the given +address+ and
-  # +maximum_job_size+. +address+ is a string identifying the host and port
-  # that the Beanstalk instance is running on. +maximum_job_size+ is the
-  # maximum size in bytes that a job can be. Jobs exceeding this threshold will
-  # result in JOB_TOO_BIG responses.
-  #
-  #   beanstalk = GemeraldBeanstalk::Beanstalk.new('localhost:11300')
   def initialize(address, maximum_job_size = 2**16)
     @max_job_size = maximum_job_size
     @address = address

data/lib/gemerald_beanstalk/beanstalk_helper.rb

@@ -19,6 +19,21 @@ module GemeraldBeanstalk::BeanstalkHelper
   JOB_INACTIVE_STATES = GemeraldBeanstalk::Job::INACTIVE_STATES
   JOB_RESERVED_STATES = GemeraldBeanstalk::Job::RESERVED_STATES
 
+
+  def self.included(beanstalk)
+    beanstalk.extend(ClassMethods)
+  end
+
+
+  module ClassMethods
+
+    def load_plugin(plugin_name)
+      include(GemeraldBeanstalk::Plugin.const_get(plugin_name))
+    end
+
+  end
+
+
   # ease handling of odd case where put can return BAD_FORMAT but increment stats
   def adjust_stats_cmd_put
     adjust_stats_key(:'cmd-put')
@@ -296,5 +311,4 @@ module GemeraldBeanstalk::BeanstalkHelper
     return "OK #{response.bytesize}\r\n#{response}\r\n"
   end
 
-
 end

data/lib/gemerald_beanstalk/event_server.rb

@@ -0,0 +1,36 @@
+module GemeraldBeanstalk::EventServer
+
+  def beanstalk
+    return @beanstalk
+  end
+
+
+  def initialize(beanstalk)
+    @beanstalk = beanstalk
+    @partial_message = ''
+    super
+  end
+
+
+  def post_init
+    @connection = beanstalk.connect(self)
+  end
+
+
+  def receive_data(data)
+    if data[-2, 2] == "\r\n"
+      message = @partial_message + data
+      @partial_message = ''
+      EventMachine.defer(proc { @connection.execute(message) })
+    else
+      @partial_message += data
+    end
+  end
+
+
+  def unbind
+    beanstalk.disconnect(@connection)
+    @connection.close_connection
+  end
+
+end

data/lib/gemerald_beanstalk/plugins/direct_connection.rb

@@ -0,0 +1,11 @@
+require 'gemerald_beanstalk/plugins/direct_connection/client'
+
+module GemeraldBeanstalk::Plugin::DirectConnection
+
+  def direct_connection_client
+    return GemeraldBeanstalk::Plugin::DirectConnection::Client.new(self)
+  end
+
+end
+
+GemeraldBeanstalk::Beanstalk.load_plugin(:DirectConnection)

data/lib/gemerald_beanstalk/plugins/direct_connection/client.rb

@@ -0,0 +1,38 @@
+module GemeraldBeanstalk::Plugin::DirectConnection
+  class Client
+
+    attr_reader :beanstalk, :connection
+
+    def close_connection
+      return unless connection.alive?
+      connection.close_connection
+      beanstalk.disconnect(self)
+    end
+
+
+    def initialize(beanstalk)
+      @beanstalk = beanstalk
+      @connection = beanstalk.connect(self)
+      @async_response = nil
+    end
+
+
+    def transmit(message)
+      message += "\r\n" unless message[-2, 2] == "\r\n"
+      connection.execute(message)
+      while (async_response = @async_response).nil?
+        sleep 0.1
+      end
+      @async_response = nil
+      return async_response
+    end
+
+
+    def send_data(message)
+      @async_response = message
+    end
+
+  end
+
+end
+

data/lib/gemerald_beanstalk/plugins/introspection.rb

@@ -0,0 +1,19 @@
+module GemeraldBeanstalk::Plugin::Introspection
+
+  def connections
+    return @connections
+  end
+
+
+  def jobs
+    return @jobs.compact
+  end
+
+
+  def tubes
+    return active_tubes
+  end
+
+end
+
+GemeraldBeanstalk::Beanstalk.load_plugin(:Introspection)

data/lib/gemerald_beanstalk/server.rb

@@ -1,54 +1,139 @@
 require 'eventmachine'
 
-module GemeraldBeanstalk::Server
-
-  def self.start(bind_address = nil, port = nil)
-    bind_address ||= '0.0.0.0'
-    port ||= 11300
-    full_address = "#{bind_address}:#{port}"
-    beanstalk = GemeraldBeanstalk::Beanstalk.new(full_address)
-    thread = Thread.new do
-      EventMachine.run do
-        EventMachine.start_server(bind_address, port, GemeraldBeanstalk::Server, beanstalk)
-        EventMachine.add_periodic_timer(0.01, beanstalk.method(:update_state))
-      end
-    end
-    $PROGRAM_NAME = "gemerald_beanstalk:#{full_address}"
-    return [thread, beanstalk]
+class GemeraldBeanstalk::Server
+
+  # The default address to bind a server to. Matches beanstalkd.
+  DEFAULT_BIND_ADDRESS = '0.0.0.0'
+
+  # The default port that a server should listen on. Matches beanstalkd.
+  DEFAULT_PORT = 11300
+
+  # The address or hostname of the host the server is bound to
+  attr_reader :bind_address
+
+  # The port the server should listen on
+  attr_reader :port
+
+  # The bind_address and port of the server
+  attr_reader :full_address
+
+  # The beanstalk instance the server provides an interface for
+  attr_reader :beanstalk
+
+  # Index of existing servers
+  @@servers = ThreadSafe::Cache.new
+
+
+  # Returns the thread that the EventMachine event reactor is running in.
+  #
+  # @return [Thread] the thread the event reactor is running in.
+  def self.event_reactor_thread
+    return @@event_reactor_thread
+  end
+
+
+  # Create a new GemeraldBeanstalk::Server at the given `bind_address` and
+  # `port`. `start_on_init` controls whether the server is immediately started
+  # or starting the server should be deferred.
+  #
+  # @param bind_address [String] IP or hostname of the host the server is bound
+  #   to
+  # @param port [Integer, String] The port the server should listen on
+  # @param start_on_init [Boolean] A boolean indicating whether or not the
+  #   server should be started immediately or deferred.
+  # @example Start a new server immediately at 0.0.0.0:11300
+  #   GemeraldBeanstalk::Server.new
+  # @example Create a new server at 127.0.0.1:11301 to be started later
+  #   GemeraldBeanstalk::Server.new('127.0.0.1', 11301, false)
+  def initialize(bind_address = nil, port = nil, start_on_init = true)
+    @bind_address = bind_address || DEFAULT_BIND_ADDRESS
+    @port = port.nil? ? DEFAULT_PORT : Integer(port)
+    @full_address = "#{@bind_address}:#{@port}"
+    @started = false
+    start if start_on_init
   end
 
 
-  def beanstalk
-    return @beanstalk
+  # Flag indicating whether the server has been started and is currently
+  # running
+  def running?
+    return @started
   end
 
 
-  def initialize(beanstalk)
-    @beanstalk = beanstalk
-    @partial_message = ''
-    super
+  # Adds the server to the EventMachine reactor, effectively starting the
+  # server. If the EventMachine reactor has not been started, it is started in
+  # a new thread. In the process create a new GemeraldBeanstalk::Beanstalk that
+  # the server provides the interface for. Returns after the server is open for
+  # connections.
+  #
+  # Currently changes $PROGRAM_NAME, however this behavior is likely to change.
+  #
+  # @raise RuntimeError if a server is already registered at the server's full
+  #   address
+  # @return [GemeraldBeanstalk::Server] returns self
+  def start
+    raise RuntimeError, "Server already exists for address #{full_address}" if @@servers.put_if_absent(full_address, self)
+    @beanstalk = GemeraldBeanstalk::Beanstalk.new(full_address)
+    start_event_reactor
+    EventMachine.run do
+      @event_server = EventMachine.start_server(bind_address, port, GemeraldBeanstalk::EventServer, beanstalk)
+      EventMachine.add_periodic_timer(0.01, beanstalk.method(:update_state))
+    end
+    $PROGRAM_NAME = "gemerald_beanstalk:#{full_address}"
+    wait_for_action(:start)
+    @started = true
+    return self
   end
 
 
-  def post_init
-    @connection = beanstalk.connect(self)
+  # Stops the server by removing it from the EventMachine reactor. Returns when
+  # the server is no longer available for connections.
+  #
+  # @raise RuntimeError if no server is registered at the server's full address.
+  # @return [GemeraldBeanstalk::Server] returns self
+  def stop
+    registered_server = @@servers[full_address]
+    raise "Server with address #{full_address} does not appear to have been started" unless registered_server
+    EventMachine.stop_server(@event_server)
+    wait_for_action(:stop)
+    @@servers.delete(full_address)
+    @started = false
+    return self
   end
 
 
-  def receive_data(data)
-    if data[-2, 2] == "\r\n"
-      message = @partial_message + data
-      @partial_message = ''
-      EventMachine.defer(proc { @connection.execute(message) })
-    else
-      @partial_message += data
+  private
+
+
+  # Starts the EventMachine reactor in a new thread.
+  def start_event_reactor
+    return true if EventMachine.reactor_running?
+    unless EventMachine.reactor_running?
+      @@event_reactor_thread = Thread.new { EventMachine.run }
+      while !EventMachine.reactor_running?
+        sleep 0.1
+      end
     end
+    return true
   end
 
 
-  def unbind
-    beanstalk.disconnect(@connection)
-    @connection.close_connection
+  # Handles waiting for a server instance to start or stop by repeatedly
+  # attempting to open TCPSocket connections.
+  def wait_for_action(action)
+    action = action.to_sym
+    loop do
+      begin
+        TCPSocket.new(bind_address, port)
+      rescue Errno::ECONNREFUSED
+        next if action == :start
+        break if action == :stop
+      rescue Errno::ECONNRESET
+        break if action == :stop
+      end
+      break if action == :start
+    end
   end
 
 end

data/lib/gemerald_beanstalk/tube.rb

@@ -1,6 +1,6 @@
 class GemeraldBeanstalk::Tube
 
-  attr_reader :jobs, :name, :reservartions
+  attr_reader :jobs, :name, :reservations
 
 
   def active?

data/lib/gemerald_beanstalk/version.rb

@@ -1,3 +1,3 @@
 module GemeraldBeanstalk
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/test/test_helper.rb

@@ -1,8 +1,16 @@
 require 'coveralls'
 Coveralls.wear!
 
+require 'test/unit'
+require 'mocha/setup'
+require 'minitest/autorun'
+require 'minitest/should'
+
 lib = File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'gemerald_beanstalk'
-$server ||= GemeraldBeanstalk::Server.start(ENV['BIND_ADDRESS'], ENV['PORT']).first
+$server ||= GemeraldBeanstalk::Server.new(ENV['BIND_ADDRESS'], ENV['PORT'])
+
+class GemeraldBeanstalkTest < MiniTest::Should::TestCase
+end

data/test/unit/beanstalk_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class BeanstalkTest < GemeraldBeanstalkTest
+
+  context '::load_plugin' do
+
+    should 'raise NameError if unknown plugin' do
+      assert_raises(NameError) do
+        GemeraldBeanstalk::Beanstalk.load_plugin(:Foo)
+      end
+    end
+
+
+    should 'include the given plugin' do
+      GemeraldBeanstalk::Beanstalk.load_plugin(:Dummy)
+      assert GemeraldBeanstalk::Beanstalk.included_modules.include?(GemeraldBeanstalk::Plugin::Dummy)
+    end
+
+  end
+
+end
+
+module GemeraldBeanstalk::Plugin::Dummy; end

data/test/unit/plugins/direct_connection/client_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+require 'gemerald_beanstalk/plugins/direct_connection'
+
+class DirectConnectionClientTest < GemeraldBeanstalkTest
+
+  setup do
+    @beanstalk = GemeraldBeanstalk::Beanstalk.new('localhost:11300')
+    @beanstalk.extend(GemeraldBeanstalk::Plugin::DirectConnection)
+  end
+
+
+  context '#transmit' do
+
+    should 'connect directly to Gemerald server' do
+      GemeraldBeanstalk::EventServer.expects(:new).never
+
+      current_connections = @beanstalk.send(:stats_connections)['current-connections']
+      client = @beanstalk.direct_connection_client
+      assert_equal "WATCHING 2\r\n", client.transmit("watch foo\r\n")
+      assert_equal "WATCHING 1\r\n", client.transmit("ignore default\r\n")
+      response = client.transmit("list-tubes-watched\r\n")
+      assert_equal "OK 9\r\n---\n- foo\r\n", response
+      assert_equal current_connections + 1, @beanstalk.send(:stats_connections)['current-connections']
+    end
+
+
+    should 'reset @async_response after receiving message' do
+      message = 'foo'
+      client = @beanstalk.direct_connection_client
+      connection = client.instance_variable_get(:@connection)
+      connection.expects(:execute)
+      client.instance_variable_set(:@async_response, message)
+      assert_equal message, client.transmit("stats\r\n")
+      assert_nil client.instance_variable_get(:@async_response)
+    end
+
+
+    should 'wait for and return response' do
+      client = @beanstalk.direct_connection_client
+
+      # Overwrite send_data to sleep to ensure delay
+      client.instance_eval do
+        def self.send_data(*)
+          sleep 1
+          @async_response = 'foo'
+        end
+      end
+
+      assert_equal 'foo', client.transmit("stats\r\n")
+    end
+
+  end
+
+
+  context '#close_connection' do
+
+    setup do
+      @client = @beanstalk.direct_connection_client
+    end
+
+
+    should 'only execute when connection is alive to avoid stack overflow' do
+      @client.instance_variable_get(:@beanstalk).expects(:disconnect).never
+      @client.instance_variable_get(:@connection).expects(:alive?).returns(false)
+      @client.close_connection
+    end
+
+
+    should 'close connection connection and disconnect from beanstalk' do
+      @client.instance_variable_get(:@connection).expects(:close_connection)
+      @client.instance_variable_get(:@beanstalk).expects(:disconnect)
+      @client.close_connection
+    end
+
+  end
+
+
+  context '#send_data' do
+
+    should 'set @async_response to argument' do
+      assert_equal nil, @client.instance_variable_get(:@async_response)
+      @client = @beanstalk.direct_connection_client
+      message = 'foo'
+      @client.send_data(message)
+      assert_equal message, @client.instance_variable_get(:@async_response)
+    end
+
+  end
+
+end

data/test/unit/plugins/direct_connection_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class DirectConnectionTest < GemeraldBeanstalkTest
+
+  context 'autoload' do
+
+    should 'automatically load plugin' do
+      GemeraldBeanstalk::Beanstalk.expects(:load_plugin).with(:DirectConnection)
+      load 'gemerald_beanstalk/plugins/direct_connection.rb'
+    end
+
+  end
+
+
+  context 'instance methods' do
+
+    setup do
+      @beanstalk = GemeraldBeanstalk::Beanstalk.new('localhost:11300')
+      @beanstalk.extend(GemeraldBeanstalk::Plugin::DirectConnection)
+    end
+
+
+    context '#direct_connection_client' do
+
+      should 'return a new GemeraldBeanstalk::DirrectConnection' do
+        assert_kind_of(
+          GemeraldBeanstalk::Plugin::DirectConnection::Client,
+          @beanstalk.direct_connection_client
+        )
+      end
+
+    end
+
+  end
+
+end

data/test/unit/plugins/introspection_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class IntrospectionTest < GemeraldBeanstalkTest
+
+  context 'autoload' do
+
+    should 'automatically load plugin' do
+      GemeraldBeanstalk::Beanstalk.expects(:load_plugin).with(:Introspection)
+      load 'gemerald_beanstalk/plugins/introspection.rb'
+    end
+
+  end
+
+
+  context 'instance methods' do
+
+    setup do
+      @beanstalk = GemeraldBeanstalk::Beanstalk.new('localhost:11300')
+      @beanstalk.extend(GemeraldBeanstalk::Plugin::Introspection)
+    end
+
+
+    context '#connections' do
+
+      should 'return the beanstalk instance connections object' do
+        assert_equal @beanstalk.instance_variable_get(:@connections), @beanstalk.connections
+      end
+
+    end
+
+
+    context '#jobs' do
+
+      should 'return the compacted beanstalk instance jobs object' do
+        assert_equal @beanstalk.instance_variable_get(:@jobs).compact, @beanstalk.jobs
+      end
+
+    end
+
+
+    context '#tubes' do
+
+      should 'return the beanstalk instance active_tubes' do
+        @beanstalk.expects(:active_tubes).once.returns({})
+        @beanstalk.tubes
+      end
+
+    end
+
+  end
+
+end

data/test/unit/server_test.rb

@@ -0,0 +1,152 @@
+require 'test_helper'
+
+class ServerTest < GemeraldBeanstalkTest
+
+  context '#new' do
+
+    should 'use defaults if specific values are not provided' do
+      default_bind_address = GemeraldBeanstalk::Server::DEFAULT_BIND_ADDRESS
+      default_port = GemeraldBeanstalk::Server::DEFAULT_PORT
+      GemeraldBeanstalk::Server.any_instance.expects(:start)
+      server = GemeraldBeanstalk::Server.new
+      assert_equal default_bind_address, server.bind_address
+      assert_equal default_port, server.port
+      assert_equal "#{default_bind_address}:#{default_port}", server.full_address
+    end
+
+
+    should 'take a bind_address, port, and auto start value' do
+      GemeraldBeanstalk::Server.any_instance.expects(:start).never
+      bind_address = '127.0.0.1'
+      port = 11301
+      server = GemeraldBeanstalk::Server.new(bind_address, port, false)
+      assert_equal bind_address, server.bind_address
+      assert_equal port, server.port
+      assert_equal "#{bind_address}:#{port}", server.full_address
+      assert_equal false, server.running?
+    end
+
+
+    should 'raise ArgumentError if port is not a valid integer' do
+      assert_raises(ArgumentError) do
+        GemeraldBeanstalk::Server.new('0.0.0.0', 'xxx', false)
+      end
+    end
+
+  end
+
+
+  context '#start' do
+
+    setup do
+      @bind_address = '0.0.0.0'
+      @port = 11400
+      @full_address = "#{@bind_address}:#{@port}"
+      @server = GemeraldBeanstalk::Server.new(@bind_address, @port, false)
+    end
+
+
+    teardown do
+      @server.stop if @server.running?
+    end
+
+
+    should 'raise RuntimeError if a server is already registered at given address' do
+      @server.start
+      assert_raises(RuntimeError) do
+        GemeraldBeanstalk::Server.new(@bind_address, @port)
+      end
+    end
+
+
+    should 'create a beanstalk with correct address for the server' do
+      beanstalk = GemeraldBeanstalk::Beanstalk.new(@full_address)
+      GemeraldBeanstalk::Beanstalk.expects(:new).with(@full_address).returns(beanstalk)
+      @server.start
+    end
+
+
+    should 'wait for server to start and set started to true' do
+      @server.start
+      begin
+        socket = TCPSocket.new(@bind_address, @port)
+        socket.close
+        started = true
+      rescue
+        started = false
+      end
+      assert_equal true, @server.running?
+      assert started, 'Expected to be able to open TCP connection to started server'
+    end
+
+
+    should 'register the server' do
+      @server.start
+      assert_equal GemeraldBeanstalk::Server.class_variable_get(:@@servers)[@full_address], @server
+    end
+
+  end
+
+
+  context '#stop' do
+
+    setup do
+      @bind_address = '0.0.0.0'
+      @port = 11400
+      @full_address = "#{@bind_address}:#{@port}"
+      @server = GemeraldBeanstalk::Server.new(@bind_address, @port, false)
+    end
+
+
+    should 'raise an error if the server is not registered' do
+      assert_raises(RuntimeError) do
+        @server.stop
+      end
+      @server.start
+      @server.stop
+      assert_equal false, @server.running?
+      assert_raises(RuntimeError) do
+        @server.stop
+      end
+    end
+
+
+    should 'kill the server and wait for its death' do
+      @server.start
+      @server.stop
+      assert_equal false, @server.running?
+      begin
+        socket = TCPSocket.new(@bind_address, @port)
+        socket.close
+        stopped = false
+      rescue
+        stopped = true
+      end
+      assert stopped, 'Did not expect to be able to open TCP connection to stopped server'
+    end
+
+  end
+
+
+  context '#start_event_reactor' do
+
+    setup do
+      @server = GemeraldBeanstalk::Server.new(nil, nil, false)
+    end
+
+
+    should 'start the EventMachine reactor' do
+      @server.send(:start_event_reactor)
+      assert EventMachine.reactor_running?
+    end
+
+
+    should 'not try to start EventMachine reactor if already running' do
+      @server.send(:start_event_reactor)
+      Thread.expects(:new).never
+      @server.send(:start_event_reactor)
+    end
+
+  end
+
+end

metadata

@@ -1,78 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: gemerald_beanstalk
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
 - Freewrite.org
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-20 00:00:00.000000000 Z
+date: 2014-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: thread_safe
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !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: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: beanstalk_integration_tests
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: minitest_should
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: RubyGem implementation of beanstalkd
@@ -82,8 +115,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
 - Gemfile
 - LICENSE
 - README.md
@@ -94,40 +128,52 @@ files:
 - lib/gemerald_beanstalk/beanstalk_helper.rb
 - lib/gemerald_beanstalk/command.rb
 - lib/gemerald_beanstalk/connection.rb
+- lib/gemerald_beanstalk/event_server.rb
 - lib/gemerald_beanstalk/job.rb
 - lib/gemerald_beanstalk/jobs.rb
+- lib/gemerald_beanstalk/plugins/direct_connection.rb
+- lib/gemerald_beanstalk/plugins/direct_connection/client.rb
+- lib/gemerald_beanstalk/plugins/introspection.rb
 - lib/gemerald_beanstalk/server.rb
 - lib/gemerald_beanstalk/tube.rb
 - lib/gemerald_beanstalk/version.rb
 - test/beanstalk_integration_tests_test.rb
 - test/test_helper.rb
+- test/unit/beanstalk_test.rb
+- test/unit/plugins/direct_connection/client_test.rb
+- test/unit/plugins/direct_connection_test.rb
+- test/unit/plugins/introspection_test.rb
+- test/unit/server_test.rb
 homepage: https://github.com/gemeraldbeanstalk/gemerald_beanstalk
 licenses:
 - MIT
+metadata: {}
 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.25
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Gemerald Beanstalk offers a Ruby implementation of beanstalkd for testing
   and other uses.
 test_files:
 - test/beanstalk_integration_tests_test.rb
 - test/test_helper.rb
-has_rdoc: 
+- test/unit/beanstalk_test.rb
+- test/unit/plugins/direct_connection/client_test.rb
+- test/unit/plugins/direct_connection_test.rb
+- test/unit/plugins/introspection_test.rb
+- test/unit/server_test.rb