tuber 0.0.1 → 0.5.1

data/test/connection_test.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+# test/connection_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Tuber::Connection do
+
+  describe 'for #new' do
+    before do
+      @host = 'localhost'
+      @bc = Tuber::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 connection" do
+      assert_kind_of TCPSocket, @bc.connection
+      if @bc.connection.peeraddr[0] == 'AF_INET'
+        assert_equal '127.0.0.1', @bc.connection.peeraddr[3]
+      else
+        assert_equal 'AF_INET6', @bc.connection.peeraddr[0]
+        assert_equal '::1', @bc.connection.peeraddr[3]
+      end
+      assert_equal 11300, @bc.connection.peeraddr[1]
+    end
+
+    it "should raise on invalid connection" do
+      assert_raises(Tuber::NotConnected) { Tuber::Connection.new("localhost:8544") }
+    end
+
+    it "should support array connection to single connection" do
+      @bc2 = Tuber::Connection.new([@host])
+      assert_equal 'localhost', @bc.address
+      assert_equal 'localhost', @bc.host
+      assert_equal 11300, @bc.port
+    end
+
+    it "should use TUBER_URL over BEANSTALKD_URL from env" do
+      ENV['TUBER_URL'] = tuber_address.to_s
+      ENV['BEANSTALKD_URL'] = 'unreachable.invalid:99999'
+      bc = Tuber::Connection.new(nil)
+      assert_equal tuber_address.to_s, bc.address
+    ensure
+      ENV.delete('TUBER_URL')
+      ENV.delete('BEANSTALKD_URL')
+    end
+
+    it "should fall back to BEANSTALKD_URL from env" do
+      ENV['BEANSTALKD_URL'] = tuber_address.to_s
+      bc = Tuber::Connection.new(nil)
+      assert_equal tuber_address.to_s, bc.address
+    ensure
+      ENV.delete('BEANSTALKD_URL')
+    end
+  end # new
+
+  describe 'for timeout configuration' do
+    after do
+      Tuber.configure do |config|
+        config.connect_timeout = nil
+        config.resolv_timeout  = nil
+        config.read_timeout    = nil
+        config.write_timeout   = nil
+      end
+    end
+
+    it "should pass connect_timeout and resolv_timeout to TCPSocket.new on Ruby >= 3.0" do
+      skip("connect_timeout/resolv_timeout kwargs require Ruby >= 3.0") if RUBY_VERSION < "3.0"
+
+      Tuber.configure do |config|
+        config.connect_timeout = 2
+        config.resolv_timeout  = 2
+      end
+
+      real_socket = TCPSocket.new('localhost', 11300)
+      TCPSocket.expects(:new).with('localhost', 11300, connect_timeout: 2, resolv_timeout: 2).returns(real_socket)
+
+      bc = Tuber::Connection.new('localhost')
+      assert_kind_of TCPSocket, bc.connection
+    end
+
+    it "should ignore connect_timeout and resolv_timeout on Ruby < 3.0" do
+      skip("connect_timeout/resolv_timeout kwargs are supported on Ruby >= 3.0") if RUBY_VERSION >= "3.0"
+
+      Tuber.configure do |config|
+        config.connect_timeout = 2
+        config.resolv_timeout  = 4
+      end
+
+      real_socket = TCPSocket.new('localhost', 11300)
+      TCPSocket.expects(:new).with('localhost', 11300).returns(real_socket)
+
+      bc = Tuber::Connection.new('localhost')
+      assert_same real_socket, bc.connection
+    end
+
+    it "should set SO_RCVTIMEO and SO_SNDTIMEO when read/write timeouts are configured" do
+      Tuber.configure do |config|
+        config.read_timeout  = 3
+        config.write_timeout = 5
+      end
+
+      bc = Tuber::Connection.new('localhost')
+      rcv = bc.connection.getsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO).unpack('l_l_')[0]
+      snd = bc.connection.getsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO).unpack('l_l_')[0]
+      assert_equal 3, rcv
+      assert_equal 5, snd
+    end
+
+  end # timeout configuration
+
+  describe 'for #transmit' do
+    before do
+      @host = 'localhost'
+      @bc = Tuber::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
+      res = @bc.transmit "put 0 0 100 1\r\nX"
+      assert res[:id]
+      assert_equal 'INSERTED', res[:status]
+    end
+
+    it "should support dashes in response" do
+      res = @bc.transmit "use foo-bar\r\n"
+      assert_equal 'USING', res[:status]
+      assert_equal 'foo-bar', res[:id]
+    end
+
+    it "should pass crlf through without changing its length" do
+      res = @bc.transmit "put 0 0 100 2\r\n\r\n"
+      assert_equal 'INSERTED', res[:status]
+    end
+
+    it "should handle *any* byte value without changing length" do
+      res = @bc.transmit "put 0 0 100 256\r\n"+(0..255).to_a.pack("c*")
+      assert_equal 'INSERTED', res[:status]
+    end
+
+    it "should retry idempotent command with success after one connection failure" do
+      TCPSocket.any_instance.expects(:readline).times(2).
+        raises(EOFError.new).then.
+        returns("USING foo\n")
+
+      res = @bc.transmit "use foo\r\n"
+      assert_equal 'USING', res[:status]
+    end
+
+    it "should not retransmit delete after a connection failure" do
+      TCPSocket.any_instance.expects(:readline).times(1).raises(EOFError.new)
+
+      assert_raises(EOFError) { @bc.transmit "delete 56\r\n" }
+    end
+
+    it "should not retransmit put after a connection failure" do
+      TCPSocket.any_instance.expects(:readline).times(1).raises(Errno::ECONNRESET.new)
+
+      assert_raises(Errno::ECONNRESET) { @bc.transmit "put 0 0 100 4\r\ndata" }
+    end
+
+    it "heals the connection after a non-retransmitted failure" do
+      $eof_once = false
+      TCPSocket.prepend(Module.new do
+        def readline
+          if $eof_once == false
+            $eof_once = true
+            raise EOFError
+          end
+          super
+        end
+      end)
+
+      assert_raises(EOFError) { @bc.transmit "delete 56\r\n" }
+
+      # The reconnect still happened, so the next command works.
+      res = @bc.transmit "use foo"
+      assert_equal 'USING', res[:status]
+    ensure
+      $eof_once = true
+    end
+
+    it "should fail after exceeding retries with DrainingError" do
+      TCPSocket.any_instance.expects(:readline).times(3).
+        raises(Tuber::UnexpectedResponse.from_status("DRAINING", "delete 56"))
+
+      assert_raises(Tuber::DrainingError) { @bc.transmit "delete 56\r\n" }
+    end
+
+    it "should fail after exceeding reconnect max retries" do
+      # next connection attempts should fail
+      TCPSocket.stubs(:new).times(3).raises(Errno::ECONNREFUSED.new)
+      TCPSocket.any_instance.stubs(:readline).times(1).raises(EOFError.new)
+
+      assert_raises(Tuber::NotConnected) { @bc.transmit "delete 56\r\n" }
+    end
+
+    it "tubes_watched are restored after reconnect" do
+      client = Tuber.new('127.0.0.1:11300')
+      client.tubes.watch! "another"
+
+      $called = false
+      TCPSocket.prepend Module.new {
+        def readline
+          if !$called
+            $called = true
+            raise EOFError
+          end
+
+          super
+        end
+      }
+
+      assert_equal %w[another], client.tubes.watched.map(&:name)
+    ensure
+      # Leave the prepended module inert: with $called reset to nil it would
+      # fire one more EOFError at an arbitrary later readline, which a
+      # non-retransmitted command (delete/put) now surfaces as a failure.
+      $called = true
+    end
+  end # transmit
+
+  describe 'for idempotent insert response' do
+    before do
+      require_tuber!
+      @host = tuber_address
+      @bc = Tuber::Connection.new(@host)
+      @idp_key = "testkey_#{Time.now.to_f}"
+    end
+
+    it "should return state for dedup hit" do
+      @bc.transmit "use idp_test"
+      res1 = @bc.transmit "put 0 0 100 4 idp:#{@idp_key}\r\ndata"
+      assert_equal 'INSERTED', res1[:status]
+      assert_nil res1[:state]
+
+      res2 = @bc.transmit "put 0 0 100 4 idp:#{@idp_key}\r\ndata"
+      assert_equal 'INSERTED', res2[:status]
+      assert_equal res1[:id], res2[:id]
+      assert_equal 'READY', res2[:state]
+    end
+  end # idempotent insert response
+
+  describe 'for #close' do
+    before do
+      @host = 'localhost'
+      @bc = Tuber::Connection.new(@host)
+    end
+
+    it "should clear connection" do
+      assert_kind_of TCPSocket, @bc.connection
+      @bc.close
+      assert_nil @bc.connection
+      assert_raises(Tuber::NotConnected) { @bc.transmit 'stats' }
+    end
+  end # close
+  describe 'for drain and undrain commands' do
+    it "should return DRAINING status for drain command" do
+      @bc = Tuber::Connection.new('localhost')
+      TCPSocket.any_instance.stubs(:write)
+      TCPSocket.any_instance.expects(:readline).returns("DRAINING\r\n")
+      res = @bc.transmit("drain")
+      assert_equal 'DRAINING', res[:status]
+    end
+
+    it "should return NOT_DRAINING status for undrain command" do
+      @bc = Tuber::Connection.new('localhost')
+      TCPSocket.any_instance.stubs(:write)
+      TCPSocket.any_instance.expects(:readline).returns("NOT_DRAINING\r\n")
+      res = @bc.transmit("undrain")
+      assert_equal 'NOT_DRAINING', res[:status]
+    end
+
+    it "should still raise DrainingError for non-drain commands" do
+      @bc = Tuber::Connection.new('localhost')
+      TCPSocket.any_instance.stubs(:write)
+      TCPSocket.any_instance.expects(:readline).times(3).returns("DRAINING\r\n")
+      assert_raises(Tuber::DrainingError) { @bc.transmit("put 0 0 100 4\r\ntest") }
+    end
+  end # drain and undrain
+end # Tuber::Connection

data/test/errors_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# test/errors_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Tuber::Errors" do
+  it 'should raise proper exception for invalid status NOT_FOUND' do
+    @klazz = Tuber::UnexpectedResponse.from_status("NOT_FOUND", "job-stats -1")
+    assert_kind_of(Tuber::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 = Tuber::UnexpectedResponse.from_status("BAD_FORMAT", "FAKE")
+    assert_kind_of(Tuber::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 = Tuber::UnexpectedResponse.from_status("DEADLINE_SOON", "reserve 0")
+    assert_kind_of(Tuber::DeadlineSoonError, @klazz)
+    assert_equal 'reserve 0', @klazz.cmd
+    assert_equal 'DEADLINE_SOON', @klazz.status
+  end
+
+  it 'should raise proper exception for invalid status EXPECTED_CRLF' do
+    @klazz = Tuber::UnexpectedResponse.from_status("EXPECTED_CRLF", "reserve 0")
+    assert_kind_of(Tuber::ExpectedCrlfError, @klazz)
+    assert_equal 'reserve 0', @klazz.cmd
+    assert_equal 'EXPECTED_CRLF', @klazz.status
+  end
+end

data/test/job_test.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+# test/job_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Tuber::Job do
+  before do
+    @beanstalk  = Tuber.new(tuber_address)
+    @tube  = @beanstalk.tubes.find 'tube'
+  end
+
+  describe "for #bury" do
+    before do
+      @tube.clear
+      @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(Tuber::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(Tuber::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(Tuber::JobNotReserved) { job.release }
+    end
+
+    it "should not release if not reserved and buried" do
+      job = @tube.reserve
+      job.bury
+      assert_raises(Tuber::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(Tuber::JobNotReserved) { job.touch }
+    end
+
+    it "should not touch if not reserved and released" do
+      job = @tube.reserve
+      job.release
+      assert_raises(Tuber::JobNotReserved) { job.touch }
+    end
+
+    it "should not touch if reserved and deleted" do
+      job = @tube.reserve
+      job.delete
+      assert_raises(Tuber::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 @beanstalk.stats.version.to_f > 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(Tuber::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(Tuber::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
+
+  describe "for #pri" do
+    before do
+      @tube.put 'bar', :pri => 1
+      @job = @tube.peek(:ready)
+    end
+
+    it("should return pri") do
+      job = @tube.reserve
+      assert_equal 1, job.pri
+      job.release
+    end
+  end # pri
+
+
+  describe "for #ttr" do
+    before do
+      @tube.put 'bar', :ttr => 5
+      @job = @tube.peek(:ready)
+    end
+
+    it("should return ttr") do
+      job = @tube.reserve
+      assert_equal 5, job.ttr
+      job.release
+    end
+  end # ttr
+
+  describe "for #delay" do
+    before do
+      @tube.put 'bar', :delay => 5
+      @job = @tube.peek(:delayed)
+    end
+
+    it("should return delay") do
+      assert_equal 5, @job.delay
+    end
+  end # delay
+end # Tuber::Job