tuber 0.0.1 → 0.6.0

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

data/test/jobs_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# test/jobs_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Tuber::Jobs do
+  before do
+    @beanstalk = Tuber.new(tuber_address)
+    @jobs = Tuber::Jobs.new(@beanstalk)
+    @tube = @beanstalk.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 negative id" do
+      assert_nil @jobs.find(10000) 
+    end
+
+    it "should return nil for invalid negative id" do
+      assert_raises(Tuber::BadFormatError) { @jobs.find(-1) }
+    end
+  end # find
+
+  describe "for #touch_all" do
+    before do
+      require_tuber!
+      @touch_tube = @beanstalk.tubes.find('touch_all_tube')
+      @beanstalk.tubes.watch! 'touch_all_tube'
+    end
+
+    after do
+      cleanup_tubes!(['touch_all_tube'], @beanstalk)
+    end
+
+    it "should return 0 when no jobs are held" do
+      assert_equal 0, @beanstalk.jobs.touch_all
+    end
+
+    it "should count every job held by the connection" do
+      3.times { |i| @touch_tube.put "touch all #{i}", :ttr => 5 }
+      jobs = @beanstalk.tubes.reserve_batch(3)
+      assert_equal 3, jobs.size
+      assert_equal 3, @beanstalk.jobs.touch_all
+      jobs.each(&:delete)
+    end
+
+    it "should exclude jobs the worker no longer holds" do
+      2.times { |i| @touch_tube.put "touch all drop #{i}", :ttr => 5 }
+      jobs = @beanstalk.tubes.reserve_batch(2)
+      jobs.first.delete
+      assert_equal 1, @beanstalk.jobs.touch_all
+      jobs.last.delete
+      assert_equal 0, @beanstalk.jobs.touch_all
+    end
+
+    it "should extend the ttr of held jobs" do
+      @touch_tube.put "touch all ttr", :ttr => 3
+      job = @beanstalk.tubes.reserve
+      sleep 2
+      assert_equal 1, @beanstalk.jobs.touch_all
+      sleep 2
+      assert_equal 'reserved', job.stats.state
+      job.delete
+    end
+  end # touch_all
+
+  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 Tuber::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'])
+
+      @beanstalk.tubes.find('tube_success').put("success abort", :pri => 2**31 + 1)
+      @beanstalk.tubes.find('tube_success').put("success 2", :pri => 1)
+      @beanstalk.tubes.find('tube_release').put("released")
+      @beanstalk.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, @beanstalk.tubes.find('tube_success').stats.current_jobs_ready
+      assert_equal 1, @beanstalk.tubes.find('tube_success').stats.current_jobs_buried
+      assert_equal 0, @beanstalk.tubes.find('tube_success').stats.current_jobs_reserved
+    end
+
+    it "should retry release jobs 2 times" do
+      assert_equal 2, @beanstalk.tubes.find('tube_release').peek(:buried).stats.releases
+    end
+
+    it "should bury unexpected exception" do
+      assert_equal 1, @beanstalk.tubes.find('tube_buried').stats.current_jobs_buried
+    end
+  end # for_process!
+end # Tuber::Jobs

data/test/prompt_regexp_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# test/prompt_regexp_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+require 'socket'
+
+describe "Reading from socket client" do
+  before do
+    @fake_port = 11301
+    @tube_name = 'tube.to.test'
+
+    @fake_server = Thread.start do
+      server = TCPServer.new(@fake_port)
+      loop do
+        IO.select([server])
+        client = server.accept_nonblock
+        while line = client.gets
+          case line
+          when /list-tubes-watched/i
+            client.print "OK #{7+@tube_name.size}\r\n---\n- #{@tube_name}\n\r\n"
+          when /watch #{@tube_name}/i
+            client.print "WATCHING 1\r\n"
+          when /reserve/i
+            client.print "RESERVED 17 25\r\n"
+            client.print "[first part]"
+            # Emulate network delay
+            sleep 0.5
+            client.print "[second part]\r\n"
+          else
+            client.print "ERROR\r\n"
+          end
+        end
+      end
+    end
+
+    slept = 0
+    while @beanstalk.nil?
+      begin
+        @beanstalk = Tuber.new("localhost:#{@fake_port}")
+      rescue Tuber::NotConnected
+        raise 'Could not connect to fake beanstalkd server' if slept > 1
+        sleep 0.1
+        slept += 0.1
+      end
+    end
+
+  end
+
+  it 'should reserve job with full body' do
+    job = @beanstalk.tubes[@tube_name].reserve
+    assert_equal '[first part][second part]', job.body
+  end
+
+  after do
+    @beanstalk.close
+    @fake_server.kill
+  end
+end

data/test/stat_struct_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# test/stat_struct_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Tuber::StatStruct do
+  before do
+    @hash = { :foo => "bar", :bar => "baz", :baz => "foo", :"under-score" => "demo" }
+    @struct = Tuber::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
+
+    it "should look up hyphenated beanstalkd keys" do
+      assert_equal 'demo', @struct['under-score']
+      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'].sort, @struct.keys.sort
+    end
+  end # keys
+
+  describe "for #to_h" do
+    it "should return 4 keys / values" do
+      assert_equal 4, @struct.to_h.size
+    end
+
+    it "should return expect hash" do
+      assert_equal [['foo', 'bar'], ['bar', 'baz'], ['baz', 'foo'], ['under_score', 'demo']].sort, @struct.to_h.sort
+    end
+  end # to_h
+end # Tuber::StatStruct

data/test/stats_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# test/stats_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Tuber::Stats do
+  before do
+    connection = stub(:transmit => { :body => { 'uptime' => 1, 'cmd-use' => 2 }, :status => "OK"})
+    @beanstalk = stub(:connection => connection)
+    @stats = Tuber::Stats.new(@beanstalk)
+  end
+
+  describe 'for #[]' do
+    it "should return stats by key" do
+      assert_equal 1, @stats[:uptime]
+    end
+
+    it "should return stats by underscore key" do
+      assert_equal 2, @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 1, @stats.uptime
+    end
+
+    it "should return stats by underscore key" do
+      assert_equal 2, @stats.cmd_use
+    end
+
+    it "should raise NoMethodError" do
+      assert_raises(NoMethodError) { @stats.cmd }
+    end
+  end # method_missing
+end # Tuber::Stats

data/test/test_helper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+ENV["TEST"] = 'true'
+require 'rubygems'
+require 'coveralls'
+Coveralls.wear!
+require 'minitest/autorun'
+$:.unshift File.expand_path("../../lib")
+require 'tuber'
+require 'timeout'
+begin
+  require 'mocha/minitest'
+rescue LoadError
+  require 'mocha'
+end
+require 'json'
+
+class MiniTest::Unit::TestCase
+
+  # Address of the server the integration-style tests talk to. Override with
+  # TUBER_TEST_ADDRESS when localhost:11300 isn't the server you mean
+  # (e.g. TUBER_TEST_ADDRESS=127.0.0.1 when another queue holds the IPv6 port).
+  def tuber_address
+    ENV.fetch('TUBER_TEST_ADDRESS', 'localhost')
+  end
+
+  # True when the server under test is Tuber rather than stock beanstalkd.
+  def tuber_server?
+    if $tuber_server.nil?
+      client = Tuber.new(tuber_address)
+      begin
+        $tuber_server = client.connection.transmit('stats')[:body]['version'].to_s.include?('tuber')
+      ensure
+        client.close
+      end
+    end
+    $tuber_server
+  end
+
+  # Skips the current test unless the server speaks Tuber's extended protocol
+  # (reserve-batch, touch-all, flush-buried, ...).
+  def require_tuber!
+    skip "requires a Tuber server, not stock beanstalkd" unless tuber_server?
+  end
+
+  # Cleans up all jobs from specific tubes
+  #
+  # @example
+  #   cleanup_tubes!(['foo'], @beanstalk)
+  #
+  def cleanup_tubes!(tubes, client=nil)
+    client ||= @beanstalk
+    tubes.each do |name|
+      client.tubes.find(name).clear
+    end
+  end
+
+  # Cleans up all jobs from all tubes known to the connection
+  def flush_all(client=nil)
+    client ||= @beanstalk
+
+    # Do not continue if it is a mock or the connection has been closed
+    return if !client.is_a?(Tuber) || !client.connection.connection
+
+    client.tubes.all.each do |tube|
+      tube.clear
+    end
+  end
+
+  # Run clean up after each test to ensure clean state in all tests
+  def teardown
+    flush_all
+  end
+end