beaneater 0.1.0

data/test/connection_test.rb

@@ -0,0 +1,64 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::Connection do
+
+  describe 'for #new' do
+    before do
+      @host = 'localhost'
+      @bc = Beaneater::Connection.new(@host)
+    end
+
+    it "should store address, host and port" do
+      assert_equal 'localhost', @bc.address
+      assert_equal 'localhost', @bc.host
+      assert_equal 11300, @bc.port
+    end
+
+    it "should init telnet connection" do
+      telops = @bc.telnet_connection.instance_variable_get(:@options)
+      assert_kind_of Net::Telnet, @bc.telnet_connection
+      assert_equal 'localhost', telops["Host"]
+      assert_equal 11300, telops["Port"]
+    end
+
+    it "should raise on invalid connection" do
+      assert_raises(Beaneater::NotConnected) { Beaneater::Connection.new("localhost:8544") }
+    end
+  end # new
+
+  describe 'for #transmit' do
+    before do
+      @host = 'localhost'
+      @bc = Beaneater::Connection.new(@host)
+    end
+
+    it "should return yaml loaded response" do
+      res = @bc.transmit '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 = @bc.transmit 'foo'
+      assert_equal '254', res[:id]
+      assert_equal 'INSERTED', res[:status]
+    end
+  end # transmit
+
+  describe 'for #close' do
+    before do
+      @host = 'localhost'
+      @bc = Beaneater::Connection.new(@host)
+    end
+
+    it "should clear telnet connection" do
+      assert_kind_of Net::Telnet, @bc.telnet_connection
+      @bc.close
+      assert_nil @bc.telnet_connection
+      assert_raises(Beaneater::NotConnected) { @bc.transmit 'stats' }
+    end
+  end # close
+end # Beaneater::Connection

data/test/errors_test.rb

@@ -0,0 +1,26 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Beaneater::Errors" do
+  it 'should raise proper exception for invalid status NOT_FOUND' do
+    @klazz = Beaneater::UnexpectedResponse.from_status("NOT_FOUND", "job-stats -1")
+    assert_kind_of(Beaneater::NotFoundError, @klazz)
+    assert_equal 'job-stats -1', @klazz.cmd
+    assert_equal 'NOT_FOUND', @klazz.status
+  end
+
+  it 'should raise proper exception for invalid status BAD_FORMAT' do
+    @klazz = Beaneater::UnexpectedResponse.from_status("BAD_FORMAT", "FAKE")
+    assert_kind_of(Beaneater::BadFormatError, @klazz)
+    assert_equal 'FAKE', @klazz.cmd
+    assert_equal 'BAD_FORMAT', @klazz.status
+  end
+
+  it 'should raise proper exception for invalid status DEADLINE_SOON' do
+    @klazz = Beaneater::UnexpectedResponse.from_status("DEADLINE_SOON", "reserve 0")
+    assert_kind_of(Beaneater::DeadlineSoonError, @klazz)
+    assert_equal 'reserve 0', @klazz.cmd
+    assert_equal 'DEADLINE_SOON', @klazz.status
+  end
+end

data/test/job_test.rb

@@ -0,0 +1,213 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::Job do
+  before do
+    @pool  = Beaneater::Pool.new(['localhost'])
+    @tube  = @pool.tubes.find 'tube'
+  end
+
+  describe "for #bury" do
+    before do
+      @time = Time.now.to_i
+      @tube.put "foo bury #{@time}", :pri => 5
+    end
+
+    it("should be buried with same pri") do
+      job = @tube.reserve
+      assert_equal "foo bury #{@time}", job.body
+      assert_equal 'reserved', job.stats.state
+      job.bury
+      assert_equal 'buried', job.stats.state
+      assert_equal 5, job.stats.pri
+      assert_equal "foo bury #{@time}", @tube.peek(:buried).body
+    end
+
+    it("should be released with new pri") do
+      job = @tube.reserve
+      assert_equal "foo bury #{@time}", job.body
+      assert_equal 'reserved', job.stats.state
+      job.bury(:pri => 10)
+      assert_equal 'buried', job.stats.state
+      assert_equal 10, job.stats.pri
+      assert_equal "foo bury #{@time}", @tube.peek(:buried).body
+    end
+
+    it "should not bury if not reserved" do
+      job = @tube.peek(:ready)
+      assert_raises(Beaneater::JobNotReserved) { job.bury }
+    end
+
+    it "should not bury if reserved and deleted" do
+      job = @tube.reserve
+      job.delete
+      assert_equal false, job.reserved
+      assert_raises(Beaneater::NotFoundError) { job.bury }
+    end
+  end # bury
+
+  describe "for #release" do
+    before do
+      @time = Time.now.to_i
+      @tube.put "foo release #{@time}", :pri => 5
+    end
+
+    it("should be released with same pri") do
+      job = @tube.reserve
+      assert_equal "foo release #{@time}", job.body
+      assert_equal 'reserved', job.stats.state
+      job.release
+      assert_equal 'ready', job.stats.state
+      assert_equal 5, job.stats.pri
+      assert_equal 0, job.stats.delay
+    end
+
+    it("should be released with new pri") do
+      job = @tube.reserve
+      assert_equal "foo release #{@time}", job.body
+      assert_equal 'reserved', job.stats.state
+      job.release :pri => 10, :delay => 2
+      assert_equal 'delayed', job.stats.state
+      assert_equal 10, job.stats.pri
+      assert_equal 2, job.stats.delay
+    end
+
+    it "should not released if not reserved" do
+      job = @tube.peek(:ready)
+      assert_raises(Beaneater::JobNotReserved) { job.release }
+    end
+
+    it "should not release if not reserved and buried" do
+      job = @tube.reserve
+      job.bury
+      assert_raises(Beaneater::JobNotReserved) { job.release }
+    end
+  end # release
+
+  describe "for #delete" do
+    before do
+      @tube.put 'foo'
+    end
+
+    it("should deletable") do
+      job = @tube.peek(:ready)
+      assert_equal 'foo', job.body
+      job.delete
+      assert_nil @tube.peek(:ready)
+    end
+  end # delete
+
+  describe "for #touch" do
+    before do
+      @tube.put 'foo touch', :ttr => 1
+    end
+
+    it("should be toucheable") do
+      job = @tube.reserve
+      assert_equal 'foo touch', job.body
+      job.touch
+      assert_equal 1, job.stats.reserves
+      job.delete
+    end
+
+    it "should not touch if not reserved" do
+      job = @tube.peek(:ready)
+      assert_raises(Beaneater::JobNotReserved) { job.touch }
+    end
+
+    it "should not touch if not reserved and released" do
+      job = @tube.reserve
+      job.release
+      assert_raises(Beaneater::JobNotReserved) { job.touch }
+    end
+
+    it "should not touch if reserved and deleted" do
+      job = @tube.reserve
+      job.delete
+      assert_raises(Beaneater::NotFoundError) { job.touch }
+    end
+  end # touch
+
+  describe "for #kick" do
+    before do
+      @tube.put 'foo touch', :ttr => 1
+    end
+
+    it("should be toucheable") do
+      job = @tube.reserve
+      assert_equal 'foo touch', job.body
+      job.bury
+      assert_equal 1, @tube.stats.current_jobs_buried
+      if @pool.stats.version > 1.7
+        job.kick
+        assert_equal 0, @tube.stats.current_jobs_buried
+        assert_equal 1, @tube.stats.current_jobs_ready
+      end
+    end
+  end # kick
+
+  describe "for #stats" do
+    before do
+      @tube.put 'foo'
+      @job = @tube.peek(:ready)
+    end
+
+    it("should have stats") do
+      assert_equal 'tube', @job.stats['tube']
+      assert_equal 'ready', @job.stats.state
+    end
+
+    it "should return nil for deleted job with no stats" do
+      @job.delete
+      assert_raises(Beaneater::NotFoundError) { @job.stats }
+    end
+  end # stats
+
+  describe "for #reserved?" do
+    before do
+      @tube.put 'foo'
+      @job = @tube.peek(:ready)
+    end
+
+    it("should have stats") do
+      assert_equal false, @job.reserved?
+      job = @tube.reserve
+      assert_equal job.id, @job.id
+      assert_equal true, @job.reserved?
+      @job.delete
+      assert_raises(Beaneater::NotFoundError) { @job.reserved? }
+    end
+  end # reserved?
+
+  describe "for #exists?" do
+    before do
+      @tube.put 'foo'
+      @job = @tube.peek(:ready)
+    end
+
+    it("should exists") { assert @job.exists? }
+
+    it "should not exist" do
+      @job.delete
+      assert !@job.exists?
+    end
+  end # exists?
+
+  describe "for #tube" do
+    before do
+      @tube.put 'bar'
+      @job = @tube.peek(:ready)
+    end
+
+    it("should have stats") do
+      job = @tube.reserve
+      assert_equal @tube.name, job.tube
+      job.release
+    end
+  end # tube
+
+  after do
+    cleanup_tubes!(['tube'])
+  end
+end # Beaneater::Tubes

data/test/jobs_test.rb

@@ -0,0 +1,107 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::Jobs do
+  before do
+    @pool = Beaneater::Pool.new(['localhost'])
+    @jobs = Beaneater::Jobs.new(@pool)
+    @tube = @pool.tubes.find('baz')
+  end
+
+  describe "for #find" do
+    before do
+      @time = Time.now.to_i
+      @tube.put("foo find #{@time}")
+      @job = @tube.peek(:ready)
+    end
+
+    it "should return job from id" do
+      assert_equal "foo find #{@time}", @jobs.find(@job.id).body
+    end
+
+    it "should return job using peek" do
+      assert_equal "foo find #{@time}", @jobs.find(@job.id).body
+    end
+
+    it "should return job using hash syntax" do
+      assert_equal "foo find #{@time}", @jobs.find(@job.id).body
+    end
+
+    it "should return nil for invalid id" do
+      assert_nil @jobs.find(-1)
+    end
+  end # find
+
+  describe "for #register!" do
+    before do
+      $foo = 0
+      @jobs.register('tube', :retry_on => [Timeout::Error]) do |job|
+        $foo += 1
+      end
+    end
+
+    it "should store processor" do
+      assert_equal 'tube', @jobs.processors.keys.first
+      assert_equal [Timeout::Error], @jobs.processors.values.first[:retry_on]
+    end
+
+    it "should store block for 'tube'" do
+      @jobs.processors['tube'][:block].call nil
+      assert_equal 1, $foo
+    end
+  end # register!
+
+  describe "for process!" do
+    before do
+      $foo = []
+
+      @jobs.register('tube_success', :retry_on => [Timeout::Error]) do |job|
+        # p job.body
+        $foo << job.body
+        raise Beaneater::AbortProcessingError if job.body =~ /abort/
+      end
+
+      @jobs.register('tube_release', :retry_on => [Timeout::Error], :max_retries => 2) do |job|
+        $foo << job.body
+        raise Timeout::Error
+      end
+
+      @jobs.register('tube_buried') do |job|
+        $foo << job.body
+        raise RuntimeError
+      end
+
+      cleanup_tubes!(['tube_success', 'tube_release', 'tube_buried'])
+
+      @pool.tubes.find('tube_success').put("success abort", :pri => 2**31 + 1)
+      @pool.tubes.find('tube_success').put("success 2", :pri => 1)
+      @pool.tubes.find('tube_release').put("released")
+      @pool.tubes.find('tube_buried').put("buried")
+
+      @jobs.process!(:release_delay => 0)
+    end
+
+    it "should process all jobs" do
+      assert_equal ['success 2', 'released', 'released', 'released', 'buried', 'success abort'], $foo
+    end
+
+    it "should clear successful_jobs" do
+      assert_equal 0, @pool.tubes.find('tube_success').stats.current_jobs_ready
+      assert_equal 1, @pool.tubes.find('tube_success').stats.current_jobs_buried
+      assert_equal 0, @pool.tubes.find('tube_success').stats.current_jobs_reserved
+    end
+
+    it "should retry release jobs 2 times" do
+      assert_equal 2, @pool.tubes.find('tube_release').peek(:buried).stats.releases
+    end
+
+    it "should bury unexpected exception" do
+      assert_equal 1, @pool.tubes.find('tube_buried').stats.current_jobs_buried
+    end
+  end
+
+  after do
+    cleanup_tubes!(['baz', 'tube_success', 'tube_release', 'tube_buried'])
+  end
+end

data/test/pool_command_test.rb

@@ -0,0 +1,68 @@
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Beaneater::PoolCommand do
+
+  describe 'for #new' do
+    before do
+      @pool = stub
+      @command = Beaneater::PoolCommand.new(@pool)
+    end
+
+    it "should store pool" do
+      assert_equal @pool, @command.pool
+    end
+  end #new
+
+  describe 'for #transmit_to_all' do
+    describe 'for regular command' do
+      before do
+        @pool = stub(:transmit_to_all => "OK")
+        @command = Beaneater::PoolCommand.new(@pool)
+      end
+
+      it "can run regular command" do
+        assert_equal "OK", @command.transmit_to_all("foo")
+      end
+    end # regular command
+
+    describe 'for merged command' do
+      before do
+        @pool = stub(:transmit_to_all => [{ :body => { 'x' => 1, 'version' => 1.1 }}, {:body => { 'x' => 3,'version' => 1.2 }}])
+        @command = Beaneater::PoolCommand.new(@pool)
+      end
+
+      it "can run merge command" do
+        cmd = @command.transmit_to_all("bar", :merge => true)
+        assert_equal 4, cmd[:body]['x']
+        assert_equal Set[1.1, 1.2], cmd[:body]['version']
+      end
+    end # merged command
+  end # transmit_to_all
+
+  describe 'for #method_missing' do
+    describe '#transmit_to_rand' do
+      before do
+        @pool = stub
+        @pool.expects(:transmit_to_rand).with('foo').returns('OK')
+        @command = Beaneater::PoolCommand.new(@pool)
+      end
+
+      it 'delegates to connection' do
+        assert_equal 'OK', @command.transmit_to_rand('foo')
+      end
+    end # transmit_to_rand
+
+    describe 'invalid method' do
+      before do
+        @pool = stub
+        @command = Beaneater::PoolCommand.new(@pool)
+      end
+
+      it 'raises no method error' do
+        assert_raises(NoMethodError) { @command.foo('foo') }
+      end
+    end # transmit_to_rand
+  end
+end # Beaneater::PoolCommand