beaneater 0.1.0

data/test/pool_test.rb

@@ -0,0 +1,154 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::Pool do
+
+  before do
+    @hosts = ['localhost', 'localhost']
+    @bp = Beaneater::Pool.new(@hosts)
+  end
+
+  describe 'for #new' do
+
+    describe "for multiple connection" do
+      before do
+        @host_string_port = 'localhost:11301'
+        @host_num_port = '127.0.0.1:11302'
+        @host_string = 'host.local'
+        @host_num = '1.1.1.1:11303'
+        @hosts = [@host_string_port, @host_num_port, @host_string, @host_num]
+
+        Net::Telnet.expects(:new).with('Host' => 'localhost', "Port" => 11301, "Prompt" => /\n/).once
+        Net::Telnet.expects(:new).with('Host' => '127.0.0.1', "Port" => 11302, "Prompt" => /\n/).once
+        Net::Telnet.expects(:new).with('Host' => 'host.local', "Port" => 11300, "Prompt" => /\n/).once
+        Net::Telnet.expects(:new).with('Host' => '1.1.1.1', "Port" => 11303, "Prompt" => /\n/).once
+
+        @bp = Beaneater::Pool.new(@hosts)
+      end
+
+      it "should init 4 connections" do
+        assert_equal 4, @bp.connections.size
+      end
+    end
+
+    describe "for invalid connection in setup" do
+      it "should raise NotConnected" do
+        assert_raises(Beaneater::NotConnected) { Beaneater::Pool.new('localhost:5679') }
+      end
+    end
+
+    describe "for clearing watch list" do
+      it "should clear connections of tube watches" do
+        @bp.tubes.watch!('foo', 'bar')
+        assert_equal ['foo', 'bar'].sort, @bp.tubes.watched.map(&:name).sort
+        @bp2 = Beaneater::Pool.new(@hosts)
+        assert_equal ['default'], @bp2.tubes.watched.map(&:name)
+      end
+    end
+
+    describe "with ENV variable set" do
+      before do
+        ENV['BEANSTALKD_URL'] = '0.0.0.0:11300,127.0.0.1:11300'
+      end
+
+      it "should create 1 connection" do
+        bp = Beaneater::Pool.new
+        bc = bp.connections.first
+        bc2 = bp.connections.last
+
+        assert_equal 2, bp.connections.size
+        assert_equal '0.0.0.0', bc.host
+        assert_equal 11300, bc.port
+
+        assert_equal '127.0.0.1', bc2.host
+        assert_equal 11300, bc2.port
+      end
+    end
+  end # new
+
+  describe 'for #transmit_to_all' do
+    it "should return yaml loaded response" do
+      res = @bp.transmit_to_all 'stats'
+      assert_equal 2, res.size
+      refute_nil res.first[:body]['current-connections']
+    end
+  end # transmit_to_all
+
+  describe 'for #transmit_to_rand' do
+    it "should return yaml loaded response" do
+      res = @bp.transmit_to_rand 'stats'
+      refute_nil res[:body]['current-connections']
+      assert_equal 'OK', res[:status]
+    end
+
+    it "should return id" do
+      Net::Telnet.any_instance.expects(:cmd).with(has_entries('String' => 'foo')).returns('INSERTED 254')
+      res = @bp.transmit_to_rand 'foo'
+      assert_equal '254', res[:id]
+      assert_equal 'INSERTED', res[:status]
+    end
+  end # transmit_to_rand
+
+  describe 'for #transmit_until_res' do
+    before do
+      Beaneater::Connection.any_instance.expects(:transmit).with('foo', {}).twice.
+      returns({:status => "FAILED", :body => 'x'}).then.
+      returns({:status => "OK", :body => 'y'}).then.returns({:status => "OK", :body => 'z'})
+    end
+
+    it "should returns first matching status" do
+      assert_equal 'y', @bp.transmit_until_res('foo', :status => 'OK')[:body]
+    end
+  end # transmit_until_res
+
+  describe 'for #stats' do
+    it("should return stats object"){ assert_kind_of Beaneater::Stats, @bp.stats }
+  end # stats
+
+  describe 'for #tubes' do
+    it("should return Tubes object"){ assert_kind_of Beaneater::Tubes, @bp.tubes }
+  end # tubes
+
+  describe "for #safe_transmit" do
+    it "should retry 3 times for temporary failed connection" do
+      Net::Telnet.any_instance.expects(:cmd).raises(EOFError).then.
+        raises(Errno::ECONNRESET).then.returns('INSERTED 254').times(3)
+      res = @bp.transmit_to_rand 'foo'
+      assert_equal '254', res[:id]
+      assert_equal 'INSERTED', res[:status]
+    end
+
+    it "should retry on fail 3 times for dead connection" do
+      Net::Telnet.any_instance.expects(:cmd).raises(EOFError).times(3)
+      assert_raises(Beaneater::NotConnected) { @bp.transmit_to_rand 'foo' }
+    end
+
+    it 'should raise proper exception for invalid status NOT_FOUND' do
+      Net::Telnet.any_instance.expects(:cmd).returns('NOT_FOUND')
+      assert_raises(Beaneater::NotFoundError) { @bp.transmit_to_rand 'foo' }
+    end
+
+    it 'should raise proper exception for invalid status BAD_FORMAT' do
+      Net::Telnet.any_instance.expects(:cmd).returns('BAD_FORMAT')
+      assert_raises(Beaneater::BadFormatError) { @bp.transmit_to_rand 'foo' }
+    end
+
+    it 'should raise proper exception for invalid status DEADLINE_SOON' do
+      Net::Telnet.any_instance.expects(:cmd).returns('DEADLINE_SOON')
+      assert_raises(Beaneater::DeadlineSoonError) { @bp.transmit_to_rand 'foo' }
+    end
+  end
+
+  describe "for #close" do
+    it "should support closing the pool" do
+      connection = @bp.connections.first
+      assert_equal 2, @bp.connections.size
+      assert_kind_of Beaneater::Connection, connection
+      assert_kind_of Net::Telnet, connection.telnet_connection
+      @bp.close
+      assert_equal 0, @bp.connections.size
+      assert_nil connection.telnet_connection
+    end
+  end # close
+end # Beaneater::Pool

data/test/stat_struct_test.rb

@@ -0,0 +1,41 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::StatStruct do
+  before do
+    @hash = { :foo => "bar", :bar => "baz", :baz => "foo", :"under-score" => "demo" }
+    @struct = Beaneater::StatStruct.from_hash(@hash)
+  end
+
+  describe "for #from_hash" do
+    it "should have 4 keys" do
+      assert_equal 'bar', @struct.foo
+      assert_equal 'baz', @struct.bar
+      assert_equal 'foo', @struct.baz
+      assert_equal 'demo', @struct.under_score
+    end
+  end # from_hash
+
+  describe "for [] access" do
+    it "should have hash lookup" do
+      assert_equal 'bar', @struct['foo']
+      assert_equal 'baz', @struct['bar']
+    end
+
+    it "should convert keys to string" do
+      assert_equal 'foo', @struct[:baz]
+      assert_equal 'demo', @struct[:"under_score"]
+    end
+  end # []
+
+  describe "for #keys" do
+    it "should return 4 keys" do
+      assert_equal 4, @struct.keys.size
+    end
+
+    it "should return expected keys" do
+      assert_equal ['foo', 'bar', 'baz', 'under_score'], @struct.keys
+    end
+  end # keys
+end

data/test/stats_test.rb

@@ -0,0 +1,42 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::Stats do
+  before do
+    @pool =  stub(:transmit_to_all => [{ :body => { 'uptime' => 1, 'cmd-use' => 2 }}, {:body => { 'uptime' => 3,'cmd-use' => 4 }}])
+    @stats = Beaneater::Stats.new(@pool)
+  end
+
+  describe 'for #[]' do
+    it "should return stats by key" do
+      assert_equal 4, @stats[:uptime]
+    end
+
+    it "should return stats by underscore key" do
+      assert_equal 6, @stats[:'cmd_use']
+    end
+  end # []
+
+  describe 'for #keys' do
+    it "should return list of keys" do
+      assert_equal 2, @stats.keys.size
+      assert @stats.keys.include?('uptime'), "Expected keys to include 'uptime'"
+      assert @stats.keys.include?('cmd_use'), "Expected keys to include 'cmd-use'"
+    end
+  end # keys
+
+  describe 'for #method_missing' do
+    it "should return stats by key" do
+      assert_equal 4, @stats.uptime
+    end
+
+    it "should return stats by underscore key" do
+      assert_equal 6, @stats.cmd_use
+    end
+
+    it "should raise NoMethodError" do
+      assert_raises(NoMethodError) { @stats.cmd }
+    end
+  end # method_missing
+end # Beaneater::Stats

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+ENV["TEST"] = 'true'
+require 'rubygems'
+require 'minitest/autorun'
+$:.unshift File.expand_path("../../lib")
+require 'beaneater'
+require 'fakeweb'
+require 'mocha'
+
+FakeWeb.allow_net_connect = false
+
+class MiniTest::Unit::TestCase
+
+  # Cleans up all jobs from tubes
+  # cleanup_tubes!(['foo'], @bp)
+  def cleanup_tubes!(tubes, bp=nil)
+    bp ||= @pool
+    tubes.each do |name|
+      bp.tubes.find(name).clear
+    end
+  end
+end

data/test/tube_test.rb

@@ -0,0 +1,164 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::Tube do
+  before do
+    @pool = Beaneater::Pool.new(['localhost'])
+    @tube = Beaneater::Tube.new(@pool, 'baz')
+  end
+
+  describe "for #put" do
+    before do
+      @time = Time.now.to_i
+    end
+
+    it "should insert a job" do
+      @tube.put "bar put #{@time}"
+      assert_equal "bar put #{@time}", @tube.peek(:ready).body
+    end
+
+    it "should insert a delayed job" do
+      @tube.put "delayed put #{@time}", :delay => 1
+      assert_equal "delayed put #{@time}", @tube.peek(:delayed).body
+    end
+
+    it "should try to put 2 times before put successfully" do
+      Beaneater::Connection.any_instance.expects(:transmit).once.with(includes('use baz'), {})
+      Beaneater::Connection.any_instance.expects(:transmit).times(2).with(includes("bar put #{@time}"), {}).
+        raises(Beaneater::DrainingError.new(nil, nil)).then.returns('foo')
+      assert_equal 'foo', @tube.put("bar put #{@time}")
+    end
+
+    it "should try to put 3 times before to raise" do
+      Beaneater::Connection.any_instance.expects(:transmit).once.with(includes('use baz'), {})
+      Beaneater::Connection.any_instance.expects(:transmit).with(includes("bar put #{@time}"), {}).
+        times(3).raises(Beaneater::DrainingError.new(nil, nil))
+      assert_raises(Beaneater::DrainingError) { @tube.put "bar put #{@time}" }
+    end
+
+    it "supports JSON" do
+      json = "{ 'foo' : 'bar' }"
+      @tube.put(json)
+      assert_equal 'bar', @tube.peek(:ready).body['foo']
+    end
+
+    after do
+      Beaneater::Connection.any_instance.unstub(:transmit)
+    end
+  end # put
+
+  describe "for #peek" do
+    before do
+      @time = Time.now.to_i
+    end
+
+    it "should peek delayed" do
+      @tube.put "foo delay #{@time}", :delay => 1
+      assert_equal "foo delay #{@time}", @tube.peek(:delayed).body
+    end
+
+    it "should peek ready" do
+      @tube.put "foo ready #{@time}", :delay => 0
+      assert_equal "foo ready #{@time}", @tube.peek(:ready).body
+    end
+
+    it "should peek buried" do
+      @tube.put "foo buried #{@time}"
+      @tube.reserve.bury
+
+      assert_equal "foo buried #{@time}", @tube.peek(:buried).body
+    end
+
+    it "should return nil for empty peek" do
+      assert_nil @tube.peek(:buried)
+    end
+  end # peek
+
+  describe "for #reserve" do
+    before do
+      @time = Time.now.to_i
+      @tube.put "foo reserve #{@time}"
+    end
+
+    it "should reserve job" do
+      assert_equal "foo reserve #{@time}", @tube.reserve.body
+    end
+
+    it "should reserve job with block" do
+      job = nil
+      @tube.reserve { |j| job = j; job.delete }
+      assert_equal "foo reserve #{@time}", job.body
+    end
+  end # reserve
+
+  describe "for #pause" do
+    before do
+      @time = Time.now.to_i
+      @tube = Beaneater::Tube.new(@pool, 'bam')
+      @tube.put "foo pause #{@time}"
+    end
+
+    it "should allow tube pause" do
+      assert_equal 0, @tube.stats.pause
+      @tube.pause(1)
+      assert_equal 1, @tube.stats.pause
+    end
+  end # pause
+
+  describe "for #stats" do
+    before do
+      @time = Time.now.to_i
+      @tube.put "foo stats #{@time}"
+      @stats = @tube.stats
+    end
+
+    it "should return total number of jobs in tube" do
+      assert_equal 1, @stats['current_jobs_ready']
+      assert_equal 0, @stats.current_jobs_delayed
+    end
+
+    it "should raise error for empty tube" do
+      assert_raises(Beaneater::NotFoundError) { @pool.tubes.find('fake_tube').stats }
+    end
+  end # stats
+
+  describe "for #kick" do
+    before do
+      @time, @time2 = 2.times.map { Time.now.to_i }
+      @tube.put "kick #{@time}"
+      @tube.put "kick #{@time2}"
+
+      2.times.map { @tube.reserve.bury }
+    end
+
+    it "should kick 2 buried jobs" do
+      assert_equal 2, @tube.stats.current_jobs_buried
+      @tube.kick(2)
+      assert_equal 0, @tube.stats.current_jobs_buried
+      assert_equal 2, @tube.stats.current_jobs_ready
+    end
+  end # kick
+
+  describe "for #clear" do
+    @time = Time.now.to_i
+    before do
+      2.times { |i| @tube.put "to clear success #{i} #{@time}" }
+      2.times { |i| @tube.put "to clear delayed #{i} #{@time}", :delay => 5 }
+      2.times { |i| @tube.put "to clear bury #{i} #{@time}", :pri => 1 }
+      @tube.reserve.bury while @tube.peek(:ready).stats['pri'] == 1
+    end
+
+    it "should clear all jobs in tube" do
+      tube_counts = lambda { %w(ready buried delayed).map { |s| @tube.stats["current_jobs_#{s}"] } }
+      assert_equal [2, 2, 2], tube_counts.call
+      @tube.clear
+      stats = @tube.stats
+      assert_equal [0, 0, 0], tube_counts.call
+    end
+  end # clear
+
+  after do
+    cleanup_tubes!(['baz'])
+  end
+end # Beaneater::Tubes

data/test/tubes_test.rb

@@ -0,0 +1,153 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::Tubes do
+  describe "for #find" do
+    before do
+      @pool  = stub
+      @tubes = Beaneater::Tubes.new(@pool)
+    end
+
+    it("should return Tube obj") { assert_kind_of Beaneater::Tube, @tubes.find(:foo) }
+    it("should return Tube name") { assert_equal "foo", @tubes.find(:foo).name }
+    it("should support hash syntax") { assert_equal "bar", @tubes["bar"].name }
+  end # find
+
+  describe "for #use" do
+    before do
+      @pool = Beaneater::Pool.new(['localhost'])
+    end
+
+    it "should switch to used tube for valid name" do
+      tube = Beaneater::Tube.new(@pool, 'some_name')
+      @pool.tubes.use('some_name')
+      assert_equal 'some_name', @pool.tubes.used.name
+    end
+
+    it "should raise for invalid tube name" do
+      assert_raises(Beaneater::InvalidTubeName) { @pool.tubes.use('; ') }
+    end
+  end # use
+
+  describe "for #watch & #watched" do
+    before do
+      @pool = Beaneater::Pool.new(['localhost'])
+    end
+
+    it 'should watch specified tubes' do
+      @pool.tubes.watch('foo')
+      @pool.tubes.watch('bar')
+      assert_equal ['default', 'foo', 'bar'].sort, @pool.tubes.watched.map(&:name).sort
+    end
+
+    it 'should raise invalid name for bad tube' do
+      assert_raises(Beaneater::InvalidTubeName) { @pool.tubes.watch('; ') }
+    end
+  end # watch! & watched
+
+  describe "for #all" do
+    before do
+      @pool = Beaneater::Pool.new(['localhost'])
+      @pool.tubes.find('foo').put 'bar'
+      @pool.tubes.find('bar').put 'foo'
+    end
+
+    it 'should retrieve all tubes' do
+      ['default', 'foo', 'bar'].each do |t|
+        assert @pool.tubes.all.map(&:name).include?(t)
+      end
+    end
+  end # all
+
+  describe "for #used" do
+    before do
+      @pool = Beaneater::Pool.new(['localhost'])
+      @pool.tubes.find('foo').put 'bar'
+      @pool.tubes.find('bar').put 'foo'
+    end
+
+    it 'should retrieve used tube' do
+      assert_equal'bar', @pool.tubes.used.name
+    end
+  end # used
+
+  describe "for #watch!" do
+    before do
+      @pool = Beaneater::Pool.new(['localhost'])
+    end
+
+    it 'should watch specified tubes' do
+      @pool.tubes.watch!(:foo)
+      @pool.tubes.watch!('bar')
+      assert_equal ['bar'].sort, @pool.tubes.watched.map(&:name).sort
+    end
+  end # watch!
+
+  describe "for #ignore" do
+    before do
+      @pool = Beaneater::Pool.new(['localhost'])
+    end
+
+    it 'should ignore specified tubes' do
+      @pool.tubes.watch('foo')
+      @pool.tubes.watch('bar')
+      @pool.tubes.ignore('foo')
+      assert_equal ['default', 'bar'].sort, @pool.tubes.watched.map(&:name).sort
+    end
+  end # ignore
+
+  describe "for #reserve" do
+    before do
+      @pool  = Beaneater::Pool.new(['localhost'])
+      @tube  = @pool.tubes.find 'tube'
+      @time = Time.now.to_i
+      @tube.put "foo reserve #{@time}"
+    end
+
+    it("should reserve job") do
+      @pool.tubes.watch 'tube'
+      job = @pool.tubes.reserve
+      assert_equal "foo reserve #{@time}", job.body
+      job.delete
+    end
+
+    it("should reserve job with block") do
+      @pool.tubes.watch 'tube'
+      job = nil
+      @pool.tubes.reserve { |j| job = j; job.delete }
+      assert_equal "foo reserve #{@time}", job.body
+    end
+
+    it("should reserve job with block and timeout") do
+      @pool.tubes.watch 'tube'
+      job = nil
+      res = @pool.tubes.reserve(0)  { |j| job = j; job.delete }
+      assert_equal "foo reserve #{@time}", job.body
+    end
+
+    it "should raise TimedOutError with timeout" do
+      @pool.tubes.watch 'tube'
+      @pool.tubes.reserve(0)  { |j| job = j; job.delete }
+      assert_raises(Beaneater::TimedOutError) { @pool.tubes.reserve(0) }
+    end
+
+    it "should raise TimedOutError no delete, with timeout" do
+      @pool.tubes.watch 'tube'
+      @pool.tubes.reserve(0)
+      assert_raises(Beaneater::TimedOutError) { @pool.tubes.reserve(0) }
+    end
+
+    it "should raise DeadlineSoonError with ttr 1" do
+      @tube.reserve.delete
+      @tube.put "foo reserve #{@time}", :ttr => 1
+      @pool.tubes.watch 'tube'
+      @pool.tubes.reserve
+      assert_raises(Beaneater::DeadlineSoonError) { @pool.tubes.reserve(0) }
+    end
+
+    after do
+      cleanup_tubes!(['foo', 'tube'])
+    end
+  end # reserve
+end # Beaneater::Tubes