tuber 0.0.1 → 0.6.0

data/test/tubes_test.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+# test/tubes_test.rb
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Tuber::Tubes do
+  describe "for #find" do
+    before do
+      @beanstalk  = stub
+      @tubes = Tuber::Tubes.new(@beanstalk)
+    end
+
+    it("should return Tube obj") { assert_kind_of Tuber::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
+      @beanstalk = Tuber.new(tuber_address)
+    end
+
+    it "should switch to used tube for valid name" do
+      Tuber::Tube.new(@beanstalk, 'some_name')
+      @beanstalk.tubes.use('some_name')
+      assert_equal 'some_name', @beanstalk.tubes.used.name
+    end
+
+    it "should raise for invalid tube name" do
+      assert_raises(Tuber::InvalidTubeName) { @beanstalk.tubes.use('; ') }
+    end
+  end # use
+
+  describe "for #watch & #watched" do
+    before do
+      @beanstalk = Tuber.new(tuber_address)
+    end
+
+    it 'should watch specified tubes' do
+      @beanstalk.tubes.watch('foo')
+      @beanstalk.tubes.watch('bar')
+      assert_equal ['default', 'foo', 'bar'].sort, @beanstalk.tubes.watched.map(&:name).sort
+    end
+
+    it 'should raise invalid name for bad tube' do
+      assert_raises(Tuber::InvalidTubeName) { @beanstalk.tubes.watch('; ') }
+    end
+  end # watch! & watched
+
+  describe "for #all" do
+    before do
+      @beanstalk = Tuber.new(tuber_address)
+      @beanstalk.tubes.find('foo').put 'bar'
+      @beanstalk.tubes.find('bar').put 'foo'
+    end
+
+    it 'should retrieve all tubes' do
+      ['default', 'foo', 'bar'].each do |t|
+        assert @beanstalk.tubes.all.map(&:name).include?(t)
+      end
+    end
+  end # all
+
+  describe "for Enumerable" do
+    before do
+      @beanstalk = Tuber.new(tuber_address)
+      @beanstalk.tubes.find('foo').put 'bar'
+      @beanstalk.tubes.find('bar').put 'foo'
+    end
+
+    it 'should map tubes' do
+      ['default', 'foo', 'bar'].each do |t|
+        assert @beanstalk.tubes.map(&:name).include?(t)
+      end
+    end
+  end
+
+  describe "for #used" do
+    before do
+      @beanstalk = Tuber.new(tuber_address)
+      @beanstalk.tubes.find('foo').put 'bar'
+      @beanstalk.tubes.find('bar').put 'foo'
+    end
+
+    it 'should retrieve used tube' do
+      assert_equal 'bar', @beanstalk.tubes.used.name
+    end
+
+    it 'should support dashed tubes' do
+      @beanstalk.tubes.find('der-bam').put 'foo'
+      assert_equal 'der-bam', @beanstalk.tubes.used.name
+    end
+  end # used
+
+  describe "for #watch!" do
+    before do
+      @beanstalk = Tuber.new(tuber_address)
+    end
+
+    it 'should watch specified tubes' do
+      @beanstalk.tubes.watch!(:foo)
+      @beanstalk.tubes.watch!('bar')
+      assert_equal ['bar'].sort, @beanstalk.tubes.watched.map(&:name).sort
+    end
+  end # watch!
+
+  describe "for #ignore" do
+    before do
+      @beanstalk = Tuber.new(tuber_address)
+    end
+
+    it 'should ignore specified tubes' do
+      @beanstalk.tubes.watch('foo')
+      @beanstalk.tubes.watch('bar')
+      @beanstalk.tubes.ignore('foo')
+      assert_equal ['default', 'bar'].sort, @beanstalk.tubes.watched.map(&:name).sort
+    end
+  end # ignore
+
+  describe "for #watch with weight" do
+    before do
+      @beanstalk = stub
+      @connection = stub(tubes_watched: ['default'])
+      @beanstalk.stubs(:connection).returns(@connection)
+      @tubes = Tuber::Tubes.new(@beanstalk)
+    end
+
+    it 'should send watch command with weight' do
+      @connection.expects(:transmit).with("watch foo 4").returns({status: "WATCHING", id: "2"})
+      @connection.expects(:add_to_watched).with("foo", 4)
+      @tubes.watch('foo', weight: 4)
+    end
+
+    it 'should send watch command without weight by default' do
+      @connection.expects(:transmit).with("watch foo").returns({status: "WATCHING", id: "2"})
+      @connection.expects(:add_to_watched).with("foo", nil)
+      @tubes.watch('foo')
+    end
+  end # watch with weight
+
+  describe "for #reserve_mode" do
+    before do
+      @beanstalk = stub
+      @connection = stub
+      @beanstalk.stubs(:connection).returns(@connection)
+      @tubes = Tuber::Tubes.new(@beanstalk)
+    end
+
+    it 'should send reserve-mode weighted command' do
+      @connection.expects(:transmit).with("reserve-mode weighted").returns({status: "USING", id: "weighted"})
+      @connection.expects(:reserve_mode=).with(:weighted)
+      @tubes.reserve_mode(:weighted)
+    end
+
+    it 'should send reserve-mode fifo command' do
+      @connection.expects(:transmit).with("reserve-mode fifo").returns({status: "USING", id: "fifo"})
+      @connection.expects(:reserve_mode=).with(:fifo)
+      @tubes.reserve_mode(:fifo)
+    end
+
+    it 'should record the mode on the connection so a reconnect can replay it' do
+      require_tuber!
+      client = Tuber.new(tuber_address)
+      begin
+        client.tubes.reserve_mode(:weighted)
+        assert_equal :weighted, client.connection.reserve_mode
+      ensure
+        client.close
+      end
+    end
+  end # reserve_mode
+
+  describe "for #reserve" do
+    before do
+      @beanstalk  = Tuber.new(tuber_address)
+      @tube  = @beanstalk.tubes.find 'tube'
+      @time = Time.now.to_i
+      @tube.put "foo reserve #{@time}"
+    end
+
+    it("should reserve job") do
+      @beanstalk.tubes.watch 'tube'
+      job = @beanstalk.tubes.reserve
+      assert_equal "foo reserve #{@time}", job.body
+      job.delete
+    end
+
+    it("should reserve job with block") do
+      @beanstalk.tubes.watch 'tube'
+      job = nil
+      @beanstalk.tubes.reserve { |j| job = j; job.delete }
+      assert_equal "foo reserve #{@time}", job.body
+    end
+
+    it("should reserve job with block and timeout") do
+      @beanstalk.tubes.watch 'tube'
+      job = nil
+      @beanstalk.tubes.reserve(0)  { |j| job = j; job.delete }
+      assert_equal "foo reserve #{@time}", job.body
+    end
+
+    it "should raise TimedOutError with timeout" do
+      @beanstalk.tubes.watch 'tube'
+      @beanstalk.tubes.reserve(0)  { |j| job = j; job.delete }
+      assert_raises(Tuber::TimedOutError) { @beanstalk.tubes.reserve(0) }
+    end
+
+    it "should raise DeadlineSoonError with ttr 1" do
+      @tube.reserve.delete
+      @tube.put "foo reserve #{@time}", :ttr => 1
+      @beanstalk.tubes.watch 'tube'
+      @beanstalk.tubes.reserve
+      assert_raises(Tuber::DeadlineSoonError) { @beanstalk.tubes.reserve(0) }
+    end
+
+  end # reserve
+
+  describe "for #reserve_batch" do
+    before do
+      require_tuber!
+      @beanstalk = Tuber.new(tuber_address)
+      @tube = @beanstalk.tubes.find 'batch_tube'
+    end
+
+    it "should return empty array on empty queue" do
+      @beanstalk.tubes.watch! 'batch_tube'
+      jobs = @beanstalk.tubes.reserve_batch(5)
+      assert_equal 0, jobs.size
+    end
+
+    it "should reserve 1 job" do
+      @tube.put "batch job 1"
+      @beanstalk.tubes.watch! 'batch_tube'
+      jobs = @beanstalk.tubes.reserve_batch(1)
+      assert_equal 1, jobs.size
+      assert_kind_of Tuber::Job, jobs.first
+      assert_equal "batch job 1", jobs.first.body
+      jobs.each(&:delete)
+    end
+
+    it "should reserve N jobs" do
+      3.times { |i| @tube.put "batch job #{i}" }
+      @beanstalk.tubes.watch! 'batch_tube'
+      jobs = @beanstalk.tubes.reserve_batch(3)
+      assert_equal 3, jobs.size
+      jobs.each do |job|
+        assert_kind_of Tuber::Job, job
+        job.delete
+      end
+    end
+
+    it "should return partial results when fewer available than requested" do
+      2.times { |i| @tube.put "partial job #{i}" }
+      @beanstalk.tubes.watch! 'batch_tube'
+      jobs = @beanstalk.tubes.reserve_batch(10)
+      assert_equal 2, jobs.size
+      jobs.each(&:delete)
+    end
+
+    it "should return deletable jobs" do
+      @tube.put "deletable job"
+      @beanstalk.tubes.watch! 'batch_tube'
+      jobs = @beanstalk.tubes.reserve_batch(1)
+      assert_equal 1, jobs.size
+      jobs.first.delete
+      assert_raises(Tuber::NotFoundError) { jobs.first.stats }
+    end
+
+    it "should return empty array when long-poll times out" do
+      @beanstalk.tubes.watch! 'batch_tube'
+      jobs = @beanstalk.tubes.reserve_batch(5, 1)
+      assert_equal 0, jobs.size
+    end
+
+    it "should drain ready jobs with a positive timeout" do
+      2.times { |i| @tube.put "timeout job #{i}" }
+      @beanstalk.tubes.watch! 'batch_tube'
+      jobs = @beanstalk.tubes.reserve_batch(10, 1)
+      assert_equal 2, jobs.size
+      jobs.each(&:delete)
+    end
+
+    it "should block until a job arrives within the timeout" do
+      @beanstalk.tubes.watch! 'batch_tube'
+      Thread.new do
+        sleep 0.2
+        producer = Tuber.new(tuber_address)
+        producer.tubes.find('batch_tube').put "delayed job"
+        producer.close
+      end
+      jobs = @beanstalk.tubes.reserve_batch(5, 3)
+      assert_equal 1, jobs.size
+      assert_equal "delayed job", jobs.first.body
+      jobs.each(&:delete)
+    end
+  end # reserve_batch
+  describe "for #reserve_job" do
+    before do
+      @beanstalk = Tuber.new(tuber_address)
+      @tube = @beanstalk.tubes.find 'reserve_job_tube'
+      @time = Time.now.to_i
+      @tube.put "reserve_job test #{@time}"
+    end
+
+    it "should reserve a specific job by id" do
+      job_id = @tube.peek(:ready).id
+      job = @beanstalk.tubes.reserve_job(job_id)
+      assert_kind_of Tuber::Job, job
+      assert_equal job_id, job.id
+      assert_equal "reserve_job test #{@time}", job.body
+      job.delete
+    end
+
+    it "should return nil for non-existent job" do
+      result = @beanstalk.tubes.reserve_job(999999999)
+      assert_nil result
+    end
+  end # reserve_job
+
+  describe "for #stats_group" do
+    before do
+      require_tuber!
+      @beanstalk = Tuber.new(tuber_address)
+      @tube = @beanstalk.tubes.find 'stats_group_tube'
+      @group_name = "test_group_#{Time.now.to_i}"
+      2.times { @tube.put "group job", grp: @group_name }
+    end
+
+    it "should return stats for a group" do
+      stats = @beanstalk.tubes.stats_group(@group_name)
+      assert_equal @group_name, stats.name
+      assert_equal 2, stats.ready
+      assert_equal 0, stats.reserved
+      assert_equal 0, stats.buried
+    end
+
+    it "should raise NotFoundError for non-existent group" do
+      assert_raises(Tuber::NotFoundError) { @beanstalk.tubes.stats_group("nonexistent_group_xyz") }
+    end
+  end # stats_group
+end # Tuber::Tubes

data/tuber.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tuber/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "tuber"
+  gem.version       = Tuber::VERSION
+  gem.authors       = ["Dan Milne", "Nico Taing"]
+  gem.email         = ["d@nmilne.com"]
+  gem.description   = %q{The Ruby client for the Tuber job queue server: unique jobs, concurrency keys, job group pipelines, batch operations and weighted tubes. Also fully compatible with beanstalkd.}
+  gem.summary       = %q{Ruby client for the Tuber job queue server.}
+  gem.homepage      = "https://github.com/tuberq/tuber-gem"
+  gem.license       = 'MIT'
+
+  gem.required_ruby_version = '>= 2.7.0'
+
+  gem.metadata = {
+    'source_code_uri'   => gem.homepage,
+    'changelog_uri'     => "#{gem.homepage}/blob/main/CHANGELOG.md",
+    'bug_tracker_uri'   => "#{gem.homepage}/issues",
+  }
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+  gem.add_development_dependency 'minitest', "~> 4.1.0"
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'term-ansicolor'
+  gem.add_development_dependency 'json'
+end

metadata

@@ -1,30 +1,135 @@
 --- !ruby/object:Gem::Specification
 name: tuber
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Dan Milne
+- Nico Taing
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
-description: Ruby client for Tuber, a fast beanstalkd-compatible job queue server.
-  This release reserves the gem name; use the russet gem for a full-featured client
-  in the meantime.
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  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: json
+  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: 'The Ruby client for the Tuber job queue server: unique jobs, concurrency
+  keys, job group pipelines, batch operations and weighted tubes. Also fully compatible
+  with beanstalkd.'
 email:
 - d@nmilne.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".yardopts"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
 - README.md
+- Rakefile
+- examples/demo.rb
 - lib/tuber.rb
+- lib/tuber/configuration.rb
+- lib/tuber/connection.rb
+- lib/tuber/errors.rb
+- lib/tuber/job.rb
+- lib/tuber/job/collection.rb
+- lib/tuber/job/record.rb
+- lib/tuber/stats.rb
+- lib/tuber/stats/fast_struct.rb
+- lib/tuber/stats/stat_struct.rb
+- lib/tuber/tube.rb
+- lib/tuber/tube/collection.rb
+- lib/tuber/tube/record.rb
+- lib/tuber/version.rb
+- test/connection_test.rb
+- test/errors_test.rb
+- test/job_test.rb
+- test/jobs_test.rb
+- test/prompt_regexp_test.rb
+- test/stat_struct_test.rb
+- test/stats_test.rb
+- test/test_helper.rb
+- test/tube_test.rb
+- test/tuber_test.rb
+- test/tubes_test.rb
+- tuber.gemspec
 homepage: https://github.com/tuberq/tuber-gem
 licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/tuberq/tuber-gem
+  changelog_uri: https://github.com/tuberq/tuber-gem/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/tuberq/tuber-gem/issues
 rdoc_options: []
 require_paths:
@@ -42,5 +147,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.16
 specification_version: 4
-summary: Ruby client for the Tuber job queue server
+summary: Ruby client for the Tuber job queue server.
 test_files: []