beanpicker 0.1.0

data/lib/beanpicker/job_server.rb

@@ -0,0 +1,374 @@
+require File.expand_path( File.join(File.dirname(__FILE__), "..", "beanpicker") )
+require File.expand_path( File.join(File.dirname(__FILE__), "process") )
+
+# Used by Beanpicker to kill childs and bury jobs
+BEANPICKER_FORK = { :child_every => false, :child_master => false, :child_pid => 0 }
+
+module Beanpicker
+
+  # Used by combine to run a server of jobs
+  class Server
+
+    include MsgLogger
+
+    # expect a list of files to load or pick from ARGV
+    def initialize(args=ARGV)
+      @args = args
+    end
+
+    # Create all workers and verify if exists any Worker or Worker::Child to start a loop.
+    # If no only exit
+    def run
+      debug "Hiring workers..."
+      for arg in @args
+        Worker.new arg
+      end
+
+      w = c = 0
+      for worker in Beanpicker::workers
+        w += 1
+        m = "Worker: #{worker.name} hired to do"
+        f = {}
+        for child in worker.childs
+          c += 1
+          f[child.job_name] ||= 0
+          f[child.job_name] += 1
+        end
+        for job in f.keys.sort
+          m << " #{job}##{f[job]}"
+        end
+        debug m
+      end
+
+      if w == 0
+        fatal ["NOBODY WANT TO WORK TO YOU!!",
+               "Have you specified a file?",
+               "e.g. #{$0} lib/my_file_with_jobs.rb"].join("\n")
+        exit
+      end
+
+      if c == 0
+        fatal ["ALL YOUR #{w} WORKER#{"S" if w > 1} ARE LAZY AND DON'T WANT TO DO ANYTHING!!",
+               "Have you specified a job in any of yous files?",
+               "e.g. job('no.lazy.worker') { |args| puts args[:my_money] }"].join("\n")
+        exit
+      end
+
+      debug "#{w} worker#{"s" if w > 1} hired to do #{c} job#{"s" if c > 1}, counting the money..."
+      
+      loop { sleep 1 }
+    end
+
+    # Use the Beanpicker::log_handler to log messages
+    def log_handler
+      Beanpicker::log_handler
+    end
+
+  end
+
+  # Worker is the class used to create jobs
+  class Worker
+
+    include MsgLogger
+
+    # The name of worker. Pick from args[:name] or from the name of file(if passed)
+    attr_reader :name
+    # The list of childs
+    attr_reader :childs
+
+    # Accept a file and/or a block with jobs and add itself to workers list
+    def initialize(filepath=nil, args={}, &blk)
+      @childs = []
+      @name   = args[:name] rescue nil
+      if filepath
+        @name = filepath.split(/[\\\/]/)[-1].gsub(/\.[^\.]+$/,'').split(/[_\.]/).map do |x|
+          x.capitalize
+        end.join if @name.nil?
+
+        begin
+          instance_eval File.read(filepath)
+        rescue => e
+          error Beanpicker::exception_message(e, "when loading file #{filepath}")
+        end
+      end
+
+      if block_given?
+        begin
+          instance_eval(&blk)
+        rescue => e
+          error Beanpicker::exception_message(e, "when evaluating block")
+        end
+      end
+
+      @name = "BeanpickerWorker without name" unless @name
+      Beanpicker::add_worker(self)
+    end
+
+    # Pass the job to Child::process and add the return to childs list
+    def job(name, args={}, &blk)
+      @childs << Child.process(name, args, self, &blk)
+      @childs.flatten!
+    end
+
+    # Use it own log_handler or global if not defined
+    def log_handler
+      @log_handler || Beanpicker::log_handler
+    end
+
+    # Shortcut to log_handler=
+    def log_file(f)
+      #without self call don't call log_handler= of this class Oo
+      self.log_handler = f
+    end
+
+    # Child is the class that handle the job.
+    # Every job can be one or more childs
+    class Child
+
+      include MsgLogger
+
+      # Process job.
+      # Use opts[:childs] or Beanpicker::default_childs_number to determine how many childs should be created
+      def self.process(job, opts={}, worker=nil, &blk)
+        (opts[:childs] || Beanpicker::default_childs_number).times.map do |i|
+          Child.new(job, opts, i, worker, &blk)
+        end
+      end
+
+
+      # The name of job
+      attr_reader :job_name
+      # The number of job(generated by Child::process)
+      attr_reader :number
+      # Should fork every job?
+      attr_reader :fork_every
+      # Should fork the child process?
+      attr_reader :fork_master
+      # The pid of running job
+      attr_reader :fork_every_pid
+      # The pid of forked child process
+      attr_reader :fork_master_pid
+      # The default options merged with argument options
+      attr_reader :opts
+      # The Worker (father?) or nil
+      attr_reader :worker
+
+      # Create a new job, start a fork if @opts[:fork_master] and start the work
+      def initialize(job, opts={}, number=0, worker=nil, &blk)
+        @job_name    = job
+        @opts        = {
+          :childs      => Beanpicker::default_childs_number,
+          :fork_every  => Beanpicker::default_fork_every,
+          :fork_master => Beanpicker::default_fork_master
+        }.merge(opts)
+        @number      = number
+        @blk         = blk
+        @loop        = nil
+        @beanstalk   = Beanpicker::new_beanstalk
+        @run         = true
+        @job         = nil
+        @worker      = worker
+        if @opts[:fork]
+          _fork_every  = @opts[:fork].to_s == 'every'
+          _fork_master = @opts[:fork].to_s == 'master'
+        else
+          _fork_every  = !!@opts[:fork_every]
+          _fork_master = !!@opts[:fork_master]
+        end
+        #really need self
+        self.log_handler = @opts[:log_file] unless @opts[:log_file].nil?
+        @fork_every  = Beanpicker::fork_every.nil?  ? _fork_every  : Beanpicker::fork_every
+        @fork_master = Beanpicker::fork_master.nil? ? _fork_master : Beanpicker::fork_master
+        @fork_master_pid = nil
+        @fork_every_pid  = nil
+        start_watch
+        start_loop
+      end
+
+      # Return the beanstalk connection(Child don't use the global connection)
+      def beanstalk
+        @beanstalk
+      end
+
+      # Watch the tube with job name and ignore all others
+      def start_watch
+        beanstalk.watch(@job_name)
+        beanstalk.list_tubes_watched.each do |server, tubes|
+          tubes.each { |tube| beanstalk.ignore(tube) unless tube == @job_name }
+        end
+      end
+
+      # Start the loop, fork if needed
+      def start_loop
+        return false if @loop and @loop.alive?
+        if @fork_master
+          fork_master_child_and_monitor
+        else
+          @loop = Thread.new(self) do |child|
+            work_loop(child)
+          end
+        end
+      end
+
+      # call start_work passing itself(child) while @run
+      def work_loop(child)
+        start_work(child) while @run
+      end
+
+      # Here is all the magic :)
+      #
+      # Call fork and start the job and delete on end, bury the job if a error is raised
+      def start_work(child=self)
+        fork do
+          begin
+            @job = child.beanstalk.reserve
+            BEANPICKER_FORK[:job] = @job if BEANPICKER_FORK[:child_every]
+            data  = @job.ybody
+
+            if not data.is_a?(Hash) or [:args, :next_jobs] - data.keys != []
+              data = { :args => data, :next_jobs => [] }
+            end
+
+            t=Time.now
+            debug "Running #{@job_name}##{@number} with args #{data[:args]}; next jobs #{data[:next_jobs]}"
+            r = @blk.call(data[:args].clone)
+            debug "Job #{@job_name}##{@number} finished in #{Time.now-t} seconds with return #{r}"
+            data[:args].merge!(r) if r.is_a?(Hash) and data[:args].is_a?(Hash)
+
+            @job.delete
+
+            Beanpicker.enqueue(data[:next_jobs], data[:args]) if r and not data[:next_jobs].empty?
+          rescue => e
+            fatal Beanpicker::exception_message(e, "in loop of #{@job_name}##{@number} with pid #{Process.pid}")
+            if BEANPICKER_FORK[:child_every]
+              exit
+            else
+              Thread.new(@job) { |j| j.bury rescue nil }
+            end
+          ensure
+            @job = nil
+          end
+        end
+      end
+
+      # Fork the process if @fork_every and wait or only call the block
+      def fork(&blk)
+        if @fork_every
+          @fork_every_pid = pid = Kernel.fork do
+            BEANPICKER_FORK[:child_every] = true
+            Process.die_with_parent
+            at_exit_to_every_child_fork
+            $0 = "Beanpicker job child #{@job_name}##{@number} of #{Process.ppid}"
+            blk.call
+          end
+          if BEANPICKER_FORK[:child_master]
+            BEANPICKER_FORK[:child_pid] = pid
+            Process.waitpid pid
+            BEANPICKER_FORK[:child_pid] = nil
+          else
+            Process.waitpid pid
+          end
+          @fork_every_pid = nil
+        else
+          blk.call
+        end
+      end
+
+      # The child still working?
+      def running?
+        @run
+      end
+
+      # Stop running, kill the thread and kill master os every process
+      def die!
+        @run = false
+        @loop.kill if @loop and @loop.alive?
+
+        kill_pid = nil
+        if @fork_master
+          kill_pid = @fork_master_pid
+        elsif @fork_every
+          kill_pid = @fork_every_pid
+        end
+
+        if kill_pid and kill_pid.is_a?(Integer) and Process.running?(kill_pid)
+          debug "Killing child with pid #{kill_pid}"
+          Process.kill "TERM", kill_pid
+        end
+
+      end
+
+      # Crete a new fork, change the name and create a thread to restart the fork if it die
+      #
+      # Called by start_loop when fork_master
+      def fork_master_child_and_monitor
+        @fork_master_pid = Kernel.fork do
+          at_exit_to_master_child_fork
+          Process.die_with_parent
+          BEANPICKER_FORK[:child_master] = true
+          $0 = "Beanpicker master child #{@job_name}##{@number}"
+          work_loop(self)
+        end
+        @loop = Thread.new(self) do |child|
+          Process.waitpid @fork_master_pid
+          child.fork_master_child_and_monitor if child.running?
+        end
+      end
+
+      # Create a at_exit to kill the child(if any)
+      #
+      # Used by fork_master_child_and_monitor
+      def at_exit_to_master_child_fork
+        at_exit do
+          pid = BEANPICKER_FORK[:child_pid]
+          if pid and pid > 0
+            if Process.running?(pid)
+              Process.kill "TERM", pid
+              sleep 0.1
+              if Process.running?(pid)
+                sleep 2
+                Process.kill "KILL", pid if Process.running?(pid)
+              end
+            end
+          end
+          Kernel.exit!
+        end
+      end
+
+      # Create a at_exit to bury the job(if any) and exit
+      #
+      # Used by fork
+      def at_exit_to_every_child_fork
+        at_exit do
+          Thread.new do
+            sleep 1
+            Kernel.exit!
+          end
+          BEANPICKER_FORK[:job].bury rescue nil if BEANPICKER_FORK[:job]
+        end
+      end
+
+      # Return the own log_handler, or the Worker log_handler or the global log_handler
+      def log_handler
+        #'@log_handler || ' go to worker/global log_handler even if @log_handler is defined
+        defined?(@log_handler) ? @log_handler : @worker.nil? ? Beanpicker::log_handler : @worker.log_handler
+      end
+
+    end
+
+  end
+
+end
+
+# kill childs or stop jobs
+at_exit do
+  if not BEANPICKER_FORK[:child_master] and not BEANPICKER_FORK[:child_every]
+    Beanpicker::debug "Laying off workers..." if Beanpicker::workers.count > 0
+    Beanpicker::stop_workers
+  end
+end
+
+# hide errors throwed with ctrl+c
+trap("INT") {
+  exit
+}

data/lib/beanpicker/process.rb

@@ -0,0 +1,23 @@
+# Process Premium Version + Crack + Serial + two new methods
+module Process
+
+  # Verify if a process is running
+  def self.running?(pid)
+    begin
+      Process.kill 0, pid
+      return true
+    rescue Errno::ESRCH, Errno::EPERM
+      return false
+    end
+  end
+
+  # Create a thread to kill the current process if the parent process die
+  def self.die_with_parent
+    Thread.new do
+      while Process.running?(Process.ppid)
+        sleep 1
+      end
+      Kernel.exit
+    end
+  end
+end

data/lib/beanpicker/version.rb

@@ -0,0 +1,9 @@
+module Beanpicker
+
+  # A array with the version [MAJOR, MINOR, PATCH]
+  VERSION = [0, 1, 0]
+
+  # A string of the array joined by "."
+  VERSION_STRING = VERSION.join(".")
+
+end

data/spec/beanpicker_spec.rb

@@ -0,0 +1,478 @@
+require 'spec_helper'
+
+describe Beanpicker do
+
+  before(:all) do
+    Beanpicker::default_fork_every = false
+    Beanpicker::default_fork_master = false
+  end
+
+  before(:each) do
+    @beanstalk = Beanpicker::beanstalk
+    @ms = { :values => {}, :methods => [:default_fork_every,
+                                       :default_fork_master,
+                                       :fork_every,
+                                       :fork_master,
+                                       :default_childs_number] }
+    for m in @ms[:methods]
+      @ms[:values][m] = Beanpicker.send(m)
+    end
+
+    Thread.stub!(:new)
+    Kernel.stub!(:fork)
+    Process.stub!(:waitpid)
+  end
+
+  after(:each) do
+    for m in @ms[:methods]
+      Beanpicker.send("#{m}=", @ms[:values][m])
+    end
+    Beanpicker::workers.replace []
+  end
+
+  context "Getters and Setters" do
+    
+    describe "log_handler" do
+
+      it "should use STDOUT by default" do
+        Logger.should_receive(:new).with(STDOUT).once
+        Beanpicker::log_handler
+      end
+
+      it "should use string as a argument to Logger" do
+        Logger.should_receive(:new).with("/dev/null").once
+        Beanpicker::log_handler = "/dev/null"
+      end
+
+      it "should use IO as a argument to Logger" do
+        Logger.should_receive(:new).with(STDERR).once
+        Beanpicker::log_handler = STDERR
+      end
+
+      it "should use anything that isn't IO/String and respond to 5 log methods as a logger" do
+        l=Logger.new(STDOUT)
+        Beanpicker::log_handler = l
+        Beanpicker::log_handler.should be_equal(l)
+      end
+
+      it "should not use anything that ins't IO/String and don't respond to 5 log methods as a logger" do
+        Beanpicker.should_receive(:error).once
+        l = Beanpicker::log_handler
+        Beanpicker::log_handler = :foo
+        Beanpicker::log_handler.should be_equal(l)
+      end
+
+    end
+
+    it "default_pri" do
+      Beanpicker::default_pri = 10
+      Beanpicker::default_pri.should be_equal(10)
+    end
+
+    it "default_delay" do
+      Beanpicker::default_delay = 10
+      Beanpicker::default_delay.should be_equal(10)
+    end
+
+    it "default_ttr" do
+      Beanpicker::default_ttr = 10
+      Beanpicker::default_ttr.should be_equal(10)
+    end
+
+    it "default_childs_number" do
+      Beanpicker::default_childs_number = 10
+      Beanpicker::default_childs_number.should be_equal(10)
+    end
+
+    it "default_fork_every" do
+      Beanpicker::default_fork_every = true
+      Beanpicker::default_fork_every.should be_true
+      Beanpicker::default_fork_every = false
+      Beanpicker::default_fork_every.should be_false
+    end
+
+    it "default_fork_master" do
+      Beanpicker::default_fork_master = true
+      Beanpicker::default_fork_master.should be_true
+      Beanpicker::default_fork_master = false
+      Beanpicker::default_fork_master.should be_false
+    end
+
+    it "fork_every" do
+      Beanpicker::fork_every = true
+      Beanpicker::fork_every.should be_true
+      Beanpicker::fork_every = false
+      Beanpicker::fork_every.should be_false
+    end
+
+    it "fork_master" do
+      Beanpicker::fork_master = true
+      Beanpicker::fork_master.should be_true
+      Beanpicker::fork_master = false
+      Beanpicker::fork_master.should be_false
+    end
+
+  end
+
+  describe "enqueue" do
+
+    it "should use job name as tube and send via yput" do
+      @beanstalk.should_receive(:use).once.with("foo.bar")
+      @beanstalk.should_receive(:yput).once.with({ :args => { :foo => :bar }, :next_jobs => [] }, 1, 2, 3)
+      Beanpicker.enqueue("foo.bar", { :foo => :bar }, { :pri => 1, :delay => 2, :ttr => 3 })
+    end
+
+    it "should use default pri, delay and ttr and argument as a empty hash" do
+      @beanstalk.should_receive(:yput).once.with({ :args => {}, :next_jobs => [] },
+                                            Beanpicker::default_pri,
+                                            Beanpicker::default_delay,
+                                            Beanpicker::default_ttr)
+      Beanpicker::enqueue("foo.bar")
+    end
+
+    it "should understand chain jobs" do
+      @beanstalk.should_receive(:yput).once.with({ :args => {}, :next_jobs => ["foo.bar2", "foo.bar3"]}, 1, 2, 3)
+      @beanstalk.should_receive(:use).once.with("foo.bar")
+      Beanpicker::enqueue(["foo.bar", "foo.bar2", "foo.bar3"], {},
+                          { :pri => 1, :delay => 2, :ttr => 3 })
+    end
+
+    it "should handle connection error and retry" do
+      Beanpicker::beanstalk.should be_equal(@beanstalk)
+      @beanstalk.close
+      b = Beanpicker::new_beanstalk
+      TCPSocket.fail_times(1)
+      Beanpicker.should_receive(:new_beanstalk).and_return(b)
+      Beanpicker.should_receive(:exception_message).once.with(an_instance_of(Beanstalk::NotConnected), an_instance_of(String))
+      Beanpicker.should_receive(:error).once
+      Beanpicker.enqueue("foo.bar")
+    end
+
+    it "should raise a exeption if a retry don't work" do
+      @beanstalk.close
+      TCPSocket.fail_times 2
+      Beanpicker.should_receive(:error).once
+      expect { Beanpicker::enqueue("foo.bar") }.should raise_error(Beanstalk::NotConnected)
+      TCPSocket.fail_times 0
+    end
+    
+
+  end
+
+  context "new beanstalk" do
+
+    it "new_beanstalk should create a new instance of Beanstalk::Pool every time" do
+      Beanpicker::new_beanstalk.should_not be_equal(Beanpicker::new_beanstalk)
+    end
+
+    it "new_beanstalk_should use beanstalk_urls and return [localhost:11300] by default" do
+      Beanpicker::beanstalk_urls.should include("localhost:11300")
+      Beanpicker.should_receive(:beanstalk_urls).and_return(["localhost:11300"])
+      Beanpicker::new_beanstalk
+    end
+
+    it "beanstalk_urls should read ENV['BEANSTALK_URL'] and ENV['BEANSTALK_URLS']" do
+      ENV.should_receive(:[]).with("BEANSTALK_URL").and_return("localhost:3000")
+      ENV.should_receive(:[]).with("BEANSTALK_URLS").and_return("localhost:1500,beanstalk://www.foo.bar.net:4500")
+      urls = Beanpicker::beanstalk_urls
+      urls.should include("localhost:3000")
+      urls.should include("localhost:1500")
+      urls.should include("www.foo.bar.net:4500")
+      urls.should_not include("localhost:11300")
+    end
+
+  end
+
+  it "add_worker should add a worker(duh!)" do
+    expect { Beanpicker::add_worker 1 }.should change(Beanpicker::workers, :size).by(1)
+  end
+
+  it "stop_workers should kill childs of workers" do
+    child  = mock(Beanpicker::Worker::Child)
+    worker = mock(Beanpicker::Worker)
+    worker.should_receive(:childs).and_return([child])
+    child.should_receive(:die!)
+    Beanpicker::workers.should_receive(:clear)
+    Beanpicker::add_worker worker
+    Beanpicker::stop_workers
+  end
+
+  describe Beanpicker::Worker do
+
+    it "should handle a error when loading a file" do
+      pending "don't know how make"
+      Beanpicker::Worker.should_receive(:error)
+      Beanpicker::Worker.new("/foo/bar/lol.rb")
+    end
+
+    it "should handle a error when evaluating a block" do
+      pending "don't know how make"
+      Beanpicker::Worker.new do
+        foo
+      end
+    end
+
+    it "should add itself to workers list" do
+      expect { Beanpicker::Worker.new }.should change(Beanpicker::workers, :count).by(1)
+      Beanpicker::workers.should include(Beanpicker::Worker.new)
+    end
+
+    it "job should call Child.process" do
+      w=Beanpicker::Worker.new
+      Beanpicker::Worker::Child.should_receive(:process).and_return([1])
+      expect { w.job("foo.bar") }.should change(w.childs, :count).by(1)
+    end
+
+    context "log_handler" do
+
+      it "should use global log_handler if haven't it own defined" do
+        l = Logger.new(STDOUT)
+        Beanpicker.should_receive(:log_handler).twice.and_return(l)
+        l.should_receive(:debug)
+        w = Beanpicker::Worker.new
+        w.log_handler.should be_equal(l)
+        w.debug("foo!")
+      end
+
+      it "should use it own log_handler if defined" do
+        w=Beanpicker::Worker.new
+        w.should_receive(:debug)
+        w.log_handler = STDOUT
+        w.debug("foo!")
+      end
+
+      it "should use log_file as a mirror to log_handler" do
+        w=Beanpicker::Worker.new
+        w.should_receive(:log_handler=)
+        w.log_file 'foo'
+      end
+
+    end
+
+  end
+
+  describe Beanpicker::Worker::Child do
+
+
+    def c(*a, &blk)
+      Beanpicker::Worker::Child.new(*a, &blk)
+    end
+
+    context "Child.process"do
+
+      it "should create one child by default" do
+        Beanpicker::Worker::Child.process("foo").count.should be_equal(1)
+      end
+
+      it "should respect default_childs_number if no option :childs is passed" do
+        Beanpicker::default_childs_number = 3
+        Beanpicker::Worker::Child.process("foo").count.should be_equal(3)
+      end
+
+      it "should respect :childs if passed" do
+        Beanpicker::Worker::Child.process("foo", { :childs => 3 }).count.should be_equal(3)
+      end
+
+    end
+
+    context "new" do
+
+      it "should create it own beanstalk instance" do
+        b = Beanpicker::new_beanstalk
+        Beanpicker.should_receive(:new_beanstalk).and_return(b)
+        c("foo", {}, 1)
+      end
+
+      it "should define job_name, number and opts and worker" do
+        j = "foo"
+        n = 1
+        o = { :foo => :bar }
+        w = mock("Worker")
+        child = c(j, o, n, w)
+        child.job_name.should be_equal(j)
+        child.number.should be_equal(n)
+        child.opts.should_not be_equal(o)
+        child.opts[:foo].should be_equal(o[:foo])
+        child.worker.should be_equal(w)
+      end
+
+      it "should understand :fork_every and :fork_master" do
+        c = c("foo", { :fork_every => true, :fork_master => true })
+        c.fork_every.should be_true
+        c.fork_master.should be_true
+      end
+
+      it "should overwrite :fork_every and :fork_master with :fork" do
+        c1 = c("foo", { :fork_every => false, :fork_master => true, :fork => :every })
+        c2 = c("foo", { :fork_every => true, :fork_master => false, :fork => :master })
+        c1.fork_every.should be_true
+        c1.fork_master.should be_false
+        c2.fork_every.should be_false
+        c2.fork_master.should be_true
+      end
+
+      it "should create it own log_handler if :log_file is passed and is a String or a IO" do
+        l = Logger.new STDOUT
+        Beanpicker.should_receive(:log_handler).exactly(0).times
+        c1=c("foo", { :log_file => l })
+        c2=c("foo", { :log_file => "/dev/null" })
+        c1.log_handler.should be_equal(l)
+        c2.log_handler
+      end
+
+    end
+
+    it "should watch only the tube with job_name" do
+      c = c("foo")
+      b = c.beanstalk
+      b.watch("bar")
+      b.should_receive(:watch).with("foo")
+      b.should_receive(:ignore).with("bar")
+      c.start_watch
+    end
+
+    context "start_loop" do
+
+      it "should call fork_master_child_and_monitor if have fork_master" do
+        c=c("foo", :fork_master => true)
+        c.should_receive(:fork_master_child_and_monitor)
+        c.start_loop
+      end
+
+      it "should call Thread.new if haven't fork_master" do
+        Thread.should_receive(:new)
+        c=c("foo", :fork_master => false)
+      end
+
+    end
+
+    context "fork" do
+
+      it "should call Kernel.fork if have fork_every" do
+        c=c("foo", :fork_every => true)
+        Kernel.should_receive(:fork).once.and_return(0)
+        c.fork {}
+      end
+
+      it "should call only block if haven't fork_every" do
+        c=c("foo", :fork_every => false)
+        b = proc {}
+        Kernel.should_receive(:fork).exactly(0).times
+        b.should_receive(:call).once
+        c.fork(&b)
+      end
+
+    end
+
+    context "start_work" do
+
+      before(:each) do
+        @beanstalk.yput({ :args => { :foo => :bar }})
+        @job = @beanstalk.reserve
+      end
+
+      it "should reserve and delete a job" do
+        c=c("foo"){}
+        c.beanstalk.should_receive(:reserve).once.and_return(@job)
+        @job.should_receive(:ybody).once.and_return({})
+        @job.should_receive(:delete).once
+        c.should_receive(:fatal).exactly(0).times
+        c.start_work
+      end
+
+      it "should bury the job if got a eror" do
+        c=c("foo"){ raise RuntimeError }
+        @job.should_receive(:delete).exactly(0).times
+        @job.should_receive(:bury).once
+        c.beanstalk.should_receive(:reserve).and_return(@job)
+        Thread.should_receive(:new).once.with(@job).and_yield(@job)
+        c.start_work
+      end
+
+      it "should not do chain jobs if receive false from block" do
+        c=c("foo"){ false }
+        @job.ybody[:next_jobs] = ["foo"]
+        Beanpicker.should_receive(:enqueue).exactly(0).times
+        c.beanstalk.should_receive(:reserve).and_return(@job)
+        c.start_work
+      end
+
+      it "should not do chain jobs if receive nil from block" do
+        c=c("foo"){ nil }
+        @job.ybody[:next_jobs] = ["foo"]
+        Beanpicker.should_receive(:enqueue).exactly(0).times
+        c.beanstalk.should_receive(:reserve).and_return(@job)
+        c.start_work
+      end
+
+      it "should do chain jobs if receive a positive return from block" do
+        c=c("foo"){ true }
+        @job.ybody[:next_jobs] = ["foo"]
+        Beanpicker.should_receive(:enqueue).once.with(@job.ybody[:next_jobs], @job.ybody[:args])
+        c.beanstalk.should_receive(:reserve).and_return(@job)
+        c.start_work
+      end
+
+      it "should do chain jobs with merged args if receive a hash from block" do
+        c=c("foo"){ { :lol => :bar } }
+        @job.ybody[:next_jobs] = ["foo"]
+        Beanpicker.should_receive(:enqueue).once.with(@job.ybody[:next_jobs], hash_including(@job.ybody[:args].merge({ :lol => :bar })))
+        c.beanstalk.should_receive(:reserve).and_return(@job)
+        c.start_work
+      end
+
+    end
+
+    context "die!" do
+
+      it "should call Process.kill if have a forked child" do
+        pending "with die! call it two times Oo"
+        c=c("foo", { :fork_every => true }){}
+        Kernel.should_receive(:fork).once.and_return(1234)
+        Process.should_receive(:waitpid).once.with { c.die!; 1234 }
+        Process.should_receive(:running?).once.with(1234).and_return(true)
+        Process.should_receive(:kill).once.with("TERM", 1234)
+        c.fork
+      end
+
+      it "should not call Process.kill if haven't a forked child" do
+        c=c("foo", { :fork_every => false }){}
+        Process.should_receive(:running?).exactly(0).times
+        Process.should_receive(:kill).exactly(0).times
+        c.fork { c.die! }
+      end
+
+    end
+
+    context "fork_master_child_and_monitor"
+    context "at_exit_to_master_child"
+    context "at_exit_to_every_child_fork"
+
+    context "log_handler" do
+
+      it "should call worker log_handler if haven't it own" do
+        worker = mock("Worker")
+        worker.should_receive(:log_handler).and_return(123)
+        Beanpicker.should_receive(:log_handler).exactly(0).times
+        c=c("foo", {}, 0, worker)
+        c.log_handler.should be_equal(123)        
+      end
+
+      it "should call Beanpicker::log_handler if haven't it own nor worker" do
+        Beanpicker.should_receive(:log_handler).and_return(123)
+        c("foo").log_handler.should be_equal(123)
+      end
+
+      it "should call it own log_handler if exists" do
+        Beanpicker.should_receive(:log_handler).exactly(0).times
+        c=c("foo")
+        c.log_handler = STDOUT
+        c.log_handler
+      end
+
+    end
+
+  end
+
+end
+