beaneater 0.3.3 → 1.0.0

data/test/tube_test.rb

@@ -4,8 +4,8 @@ require File.expand_path('../test_helper', __FILE__)
 
 describe Beaneater::Tube do
   before do
-    @pool = Beaneater::Pool.new(['localhost'])
-    @tube = Beaneater::Tube.new(@pool, 'baz')
+    @beanstalk = Beaneater.new('localhost')
+    @tube = Beaneater::Tube.new(@beanstalk, 'baz')
   end
 
   describe "for #put" do
@@ -26,22 +26,15 @@ describe Beaneater::Tube do
       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}" }
+    it "should support custom serializer" do
+      Beaneater.configure.job_serializer = lambda { |b| JSON.dump(b) }
+      @tube.put({ foo: "bar"})
+      assert_equal '{"foo":"bar"}', @tube.peek(:ready).body
     end
 
     after do
       Beaneater::Connection.any_instance.unstub(:transmit)
+      Beaneater.configure.job_serializer = lambda { |b| b }
     end
   end # put
 
@@ -140,7 +133,7 @@ describe Beaneater::Tube do
   describe "for #pause" do
     before do
       @time = Time.now.to_i
-      @tube = Beaneater::Tube.new(@pool, 'bam')
+      @tube = Beaneater::Tube.new(@beanstalk, 'bam')
       @tube.put "foo pause #{@time}"
     end
 
@@ -164,7 +157,7 @@ describe Beaneater::Tube do
     end
 
     it "should raise error for empty tube" do
-      assert_raises(Beaneater::NotFoundError) { @pool.tubes.find('fake_tube').stats }
+      assert_raises(Beaneater::NotFoundError) { @beanstalk.tubes.find('fake_tube').stats }
     end
   end # stats
 
@@ -202,8 +195,4 @@ describe Beaneater::Tube do
       assert_equal [0, 0, 0], tube_counts.call
     end
   end # clear
-
-  after do
-    cleanup_tubes!(['baz'])
-  end
 end # Beaneater::Tube

data/test/tubes_test.rb

@@ -5,8 +5,8 @@ require File.expand_path('../test_helper', __FILE__)
 describe Beaneater::Tubes do
   describe "for #find" do
     before do
-      @pool  = stub
-      @tubes = Beaneater::Tubes.new(@pool)
+      @beanstalk  = stub
+      @tubes = Beaneater::Tubes.new(@beanstalk)
     end
 
     it("should return Tube obj") { assert_kind_of Beaneater::Tube, @tubes.find(:foo) }
@@ -16,143 +16,148 @@ describe Beaneater::Tubes do
 
   describe "for #use" do
     before do
-      @pool = Beaneater::Pool.new(['localhost'])
+      @beanstalk = Beaneater.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
+      tube = Beaneater::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(Beaneater::InvalidTubeName) { @pool.tubes.use('; ') }
+      assert_raises(Beaneater::InvalidTubeName) { @beanstalk.tubes.use('; ') }
     end
   end # use
 
   describe "for #watch & #watched" do
     before do
-      @pool = Beaneater::Pool.new(['localhost'])
+      @beanstalk = Beaneater.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
+      @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(Beaneater::InvalidTubeName) { @pool.tubes.watch('; ') }
+      assert_raises(Beaneater::InvalidTubeName) { @beanstalk.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'
+      @beanstalk = Beaneater.new('localhost')
+      @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 @pool.tubes.all.map(&:name).include?(t)
+        assert @beanstalk.tubes.all.map(&:name).include?(t)
       end
     end
   end # all
 
+  describe "for Enumerable" do
+    before do
+      @beanstalk = Beaneater.new('localhost')
+      @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
-      @pool = Beaneater::Pool.new(['localhost'])
-      @pool.tubes.find('foo').put 'bar'
-      @pool.tubes.find('bar').put 'foo'
+      @beanstalk = Beaneater.new('localhost')
+      @beanstalk.tubes.find('foo').put 'bar'
+      @beanstalk.tubes.find('bar').put 'foo'
     end
 
     it 'should retrieve used tube' do
-      assert_equal 'bar', @pool.tubes.used.name
+      assert_equal 'bar', @beanstalk.tubes.used.name
     end
 
     it 'should support dashed tubes' do
-      @pool.tubes.find('der-bam').put 'foo'
-      assert_equal 'der-bam', @pool.tubes.used.name
+      @beanstalk.tubes.find('der-bam').put 'foo'
+      assert_equal 'der-bam', @beanstalk.tubes.used.name
     end
   end # used
 
   describe "for #watch!" do
     before do
-      @pool = Beaneater::Pool.new(['localhost'])
+      @beanstalk = Beaneater.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
+      @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
-      @pool = Beaneater::Pool.new(['localhost'])
+      @beanstalk = Beaneater.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
+      @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 #reserve" do
     before do
-      @pool  = Beaneater::Pool.new(['localhost'])
-      @tube  = @pool.tubes.find 'tube'
+      @beanstalk  = Beaneater.new('localhost')
+      @tube  = @beanstalk.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
+      @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
-      @pool.tubes.watch 'tube'
+      @beanstalk.tubes.watch 'tube'
       job = nil
-      @pool.tubes.reserve { |j| job = j; job.delete }
+      @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
-      @pool.tubes.watch 'tube'
+      @beanstalk.tubes.watch 'tube'
       job = nil
-      res = @pool.tubes.reserve(0)  { |j| job = j; job.delete }
+      res = @beanstalk.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)  { |j| job = j; job.delete }
-      assert_raises(Beaneater::TimedOutError) { @pool.tubes.reserve(0) }
+      @beanstalk.tubes.watch 'tube'
+      @beanstalk.tubes.reserve(0)  { |j| job = j; job.delete }
+      assert_raises(Beaneater::TimedOutError) { @beanstalk.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) }
+      @beanstalk.tubes.watch 'tube'
+      @beanstalk.tubes.reserve
+      assert_raises(Beaneater::DeadlineSoonError) { @beanstalk.tubes.reserve(0) }
     end
 
-    after do
-      cleanup_tubes!(['foo', 'tube'])
-    end
   end # reserve
 end # Beaneater::Tubes

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaneater
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Nico Taing
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-17 00:00:00.000000000 Z
+date: 2015-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -105,8 +105,6 @@ files:
 - lib/beaneater/job.rb
 - lib/beaneater/job/collection.rb
 - lib/beaneater/job/record.rb
-- lib/beaneater/pool.rb
-- lib/beaneater/pool_command.rb
 - lib/beaneater/stats.rb
 - lib/beaneater/stats/fast_struct.rb
 - lib/beaneater/stats/stat_struct.rb
@@ -119,8 +117,6 @@ files:
 - test/errors_test.rb
 - test/job_test.rb
 - test/jobs_test.rb
-- test/pool_command_test.rb
-- test/pool_test.rb
 - test/prompt_regexp_test.rb
 - test/stat_struct_test.rb
 - test/stats_test.rb
@@ -157,8 +153,6 @@ test_files:
 - test/errors_test.rb
 - test/job_test.rb
 - test/jobs_test.rb
-- test/pool_command_test.rb
-- test/pool_test.rb
 - test/prompt_regexp_test.rb
 - test/stat_struct_test.rb
 - test/stats_test.rb

data/lib/beaneater/pool.rb

@@ -1,166 +0,0 @@
-# Simple ruby client for interacting with beanstalkd.
-module Beaneater
-  # Represents collection of beanstalkd connections.
-  class Pool
-    # Default number of retries to send a command to a connection
-    MAX_RETRIES = 3
-
-    # @!attribute connections
-    #   @return [Array<Beaneater::Connection>] returns Collection of connections
-    attr_reader :connections
-
-    # Initialize new connection
-    #
-    # @param [Array<String>] addresses Array of beanstalkd server addresses
-    # @example
-    #   Beaneater::Pool.new(['localhost:11300', '127.0.0.1:11300'])
-    #
-    #   ENV['BEANSTALKD_URL'] = 'localhost:11300,127.0.0.1:11300'
-    #   @bp = Beaneater::Pool.new
-    #   @bp.connections.first.host # => 'localhost'
-    #   @bp.connections.last.host # => '127.0.0.1'
-    #
-    def initialize(addresses=nil)
-      addresses = addresses || host_from_env || Beaneater.configuration.beanstalkd_url
-      @connections = Array(addresses).map { |a| Connection.new(a) }
-    end
-
-    # Returns Beaneater::Stats object for accessing beanstalk stats.
-    #
-    # @return [Beaneater::Stats] stats object
-    # @api public
-    def stats
-      @stats ||= Stats.new(self)
-    end
-
-    # Returns Beaneater::Jobs object for accessing job related functions.
-    #
-    # @return [Beaneater::Jobs] jobs object
-    # @api public
-    def jobs
-      @jobs ||= Jobs.new(self)
-    end
-
-    # Returns Beaneater::Tubes object for accessing tube related functions.
-    #
-    # @return [Beaneater::Tubes] tubes object
-    # @api public
-    def tubes
-      @tubes ||= Tubes.new(self)
-    end
-
-    # Sends command to every beanstalkd server set in the pool.
-    #
-    # @param [String] command Beanstalkd command
-    # @param [Hash{String => String, Boolean}] options socket connections options
-    # @param [Proc] block Block passed to socket connection during transmit
-    # @return [Array<Hash{String => String, Number}>] Beanstalkd command response from each instance
-    # @example
-    #   @pool.transmit_to_all("stats")
-    #
-    def transmit_to_all(command, options={}, &block)
-      res_exception = nil
-      res = connections.map { |conn|
-        begin
-          safe_transmit { conn.transmit(command, options, &block) }
-        rescue UnexpectedResponse => ex # not the correct status
-          res_exception = ex
-          nil
-        end
-      }.compact
-      raise res_exception if res.none? && res_exception
-      res
-    end
-
-    # Send command to each beanstalkd servers until getting response expected
-    #
-    # @param [String] command Beanstalkd command
-    # @param [Hash{String => String, Boolean}] options socket connections options
-    # @param [Proc] block Block passed in socket connection object
-    # @return [Array<Hash{String => String, Number}>] Beanstalkd command response from the instance
-    # @example
-    #   @pool.transmit_until_res('peek-ready', :status => "FOUND", &block)
-    #
-    def transmit_until_res(command, options={}, &block)
-      status_expected  = options.delete(:status)
-      res_exception = nil
-      connections.each do |conn|
-        begin
-          res = safe_transmit { conn.transmit(command, options, &block) }
-          return res if res[:status] == status_expected
-        rescue UnexpectedResponse => ex # not the correct status
-          res_exception = ex
-          next
-        end
-      end
-      raise res_exception if res_exception
-    end
-
-    # Sends command to a random beanstalkd server in the pool.
-    #
-    # @param [String] command Beanstalkd command
-    # @param [Hash{String => String,Boolean}] options socket connections options
-    # @param [Proc] block Block passed in socket connection object
-    # @return [Array<Hash{String => String, Number}>] Beanstalkd command response from the instance
-    # @example
-    #   @pool.transmit_to_rand("stats", :match => /\n/)
-    #
-    def transmit_to_rand(command, options={}, &block)
-      safe_transmit do
-        conn = connections.respond_to?(:sample) ? connections.sample : connections.choice
-        conn.transmit(command, options, &block)
-      end
-    end
-
-    # Closes all connections within the pool.
-    #
-    # @example
-    #  @pool.close
-    #
-    def close
-      while @connections.any?
-        conn = @connections.pop
-        conn.close
-      end
-    end
-
-    protected
-
-    # Transmit command to beanstalk connections safely handling failed connections
-    #
-    # @param [Proc] block The command to execute.
-    # @return [Object] Result of the block passed
-    # @raise [Beaneater::DrainingError,Beaneater::NotConnected] Could not connect to Beanstalk client
-    # @example
-    #  safe_transmit { conn.transmit('foo') }
-    #   # => "result of foo command from beanstalk"
-    #
-    def safe_transmit(&block)
-      retries = 1
-      begin
-        yield
-      rescue DrainingError, EOFError, Errno::ECONNRESET, Errno::EPIPE => ex
-        # TODO remove faulty connections from pool?
-        # https://github.com/kr/beanstalk-client-ruby/blob/master/lib/beanstalk-client/connection.rb#L405-410
-        if retries < MAX_RETRIES
-          retries += 1
-          retry
-        else # finished retrying, fail out
-          ex.is_a?(DrainingError) ? raise(ex) : raise(NotConnected, "Could not connect!")
-        end
-      end
-    end # transmit_call
-
-    # The hosts provided by BEANSTALKD_URL environment variable, if available.
-    #
-    # @return [Array] Set of beanstalkd host addresses
-    # @example
-    #  ENV['BEANSTALKD_URL'] = "localhost:1212,localhost:2424"
-    #   # => ['localhost:1212', 'localhost:2424']
-    #
-    def host_from_env
-      ENV['BEANSTALKD_URL'].respond_to?(:length) && ENV['BEANSTALKD_URL'].length > 0 && ENV['BEANSTALKD_URL'].split(',').map(&:strip)
-    end
-
-  end # Pool
-end # Beaneater