perfectqueue 0.8.44.1 → 0.8.45

data/spec/application/dispatch_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe PerfectQueue::Application::Dispatch do
+  describe '.new' do
+    before do
+      router = Application::Dispatch.router
+      handler = double('handler')
+      allow(handler).to receive(:new).and_return(nil)
+      router.add(/\Afoo\z/, handler, nil)
+    end
+    it 'returns a PerfectQueue::Application::Dispatch' do
+      task = double('task', type: 'foo')
+      dispatch = Application::Dispatch.new(task)
+      expect(dispatch).to be_an_instance_of(Application::Dispatch)
+    end
+    it 'raises RuntimeError if the task type doesn\'t match' do
+      task = double('task', type: 'bar')
+      expect(task).to receive(:retry!).exactly(:once)
+      expect{Application::Dispatch.new(task)}.to raise_error(RuntimeError)
+    end
+  end
+end

data/spec/application/router_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe PerfectQueue::Application::Router do
+  describe '.new' do
+    it 'returns a PerfectQueue::Application::Router' do
+      router = Application::Router.new
+      expect(router).to be_an_instance_of(Application::Router)
+    end
+  end
+
+  describe '#add' do
+    let (:router){ Application::Router.new }
+    let (:sym){ double('sym') }
+    it 'accepts Regexp' do
+      router.add(/\Afoo\z/, sym, double)
+      expect(router.patterns[0]).to eq([/\Afoo\z/, sym])
+    end
+    it 'accepts String' do
+      router.add('foo', sym, double)
+      expect(router.patterns[0]).to eq([/\Afoo\z/, sym])
+    end
+    it 'accepts Symbol' do
+      router.add(:foo, sym, double)
+      expect(router.patterns[0]).to eq([/\Afoo\z/, sym])
+    end
+    it 'raises for others' do
+      expect{router.add(nil, nil, nil)}.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#route' do
+    let (:router) do
+      rt = Application::Router.new
+      rt.add(/\Afoo\z/, :TestHandler, double)
+      rt
+    end
+    let (:handler){ double('handler') }
+    before do
+      Application::Router::TestHandler = handler
+    end
+    after do
+      Application::Router.__send__(:remove_const, :TestHandler)
+    end
+    it 'return related handler' do
+      expect(router.route('foo')).to eq(handler)
+    end
+  end
+end

data/spec/backend_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe PerfectQueue::Backend do
+  describe '.new_backend' do
+    it 'raises error if config[:type] is nil' do
+      expect{Backend.new_backend(nil, {})}.to raise_error(ConfigError)
+    end
+  end
+end

data/spec/blocking_flag_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe PerfectQueue::BlockingFlag do
+  describe '.new' do
+    it 'returns a BlockingFlag' do
+      flag = BlockingFlag.new
+      expect(flag).to be_an_instance_of(BlockingFlag)
+    end
+  end
+
+  describe '#set!' do
+    let (:flag){ BlockingFlag.new }
+    it 'returns true if it was false' do
+      expect(flag.set?).to eq false
+      expect(flag.set!).to eq true
+      expect(flag.set?).to eq true
+    end
+    it 'returns false if it was already true' do
+      flag.set!
+      expect(flag.set?).to eq true
+      expect(flag.set!).to eq false
+      expect(flag.set?).to eq true
+    end
+  end
+
+  describe '#reset!' do
+    let (:flag){ BlockingFlag.new }
+    it 'returns false if it was already false' do
+      expect(flag.set?).to eq false
+      expect(flag.reset!).to eq false
+      expect(flag.set?).to eq false
+    end
+    it 'returns false if it was true' do
+      flag.set!
+      expect(flag.set?).to eq true
+      expect(flag.reset!).to eq true
+      expect(flag.set?).to eq false
+    end
+  end
+
+  describe '#set_region' do
+    let (:flag){ BlockingFlag.new }
+    it 'set in the block and reset it was set' do
+      flag.set!
+      flag.set_region do
+        expect(flag.set?).to eq true
+      end
+      expect(flag.set?).to eq false
+    end
+    it 'set in the block and reset if it was reset' do
+      flag.reset!
+      flag.set_region do
+        expect(flag.set?).to eq true
+      end
+      expect(flag.set?).to eq false
+    end
+    it 'set in the block and reset even if it raiess error' do
+      flag.set_region do
+        expect(flag.set?).to eq true
+        raise
+      end rescue nil
+      expect(flag.set?).to eq false
+    end
+  end
+
+  describe '#reset_region' do
+    let (:flag){ BlockingFlag.new }
+    it 'reset in the block and set it was set' do
+      flag.set!
+      flag.reset_region do
+        expect(flag.set?).to eq false
+      end
+      expect(flag.set?).to eq true
+    end
+    it 'reset in the block and set if it was reset' do
+      flag.reset!
+      flag.reset_region do
+        expect(flag.set?).to eq false
+      end
+      expect(flag.set?).to eq true
+    end
+    it 'set in the block and reset even if it raiess error' do
+      flag.reset_region do
+        expect(flag.set?).to eq false
+        raise
+      end rescue nil
+      expect(flag.set?).to eq true
+    end
+  end
+
+  describe '#wait' do
+    let (:flag){ BlockingFlag.new }
+    it 'wait until a thread set/reset the flag' do
+      th1 = Thread.start do
+        flag.wait(5)
+        expect(flag.set?).to eq true
+      end
+      Thread.pass until th1.stop?
+      flag.set!
+      th1.join(2)
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe PerfectQueue::Client do
+  describe '#preempt' do
+    it '(key)' do
+      backend = double('backend')
+      alive_time = double('alive_time')
+      object_double('PerfectQueue::Backend', new_backend: backend).as_stubbed_const
+      client = Client.new({alive_time: alive_time})
+      ret = double('ret')
+      key = double('key')
+      expect(backend).to receive(:preempt).with(key, alive_time, {}).and_return(ret)
+      expect(client.preempt(key)).to eq(ret)
+    end
+
+    it '(key, options)' do
+      backend = double('backend')
+      alive_time = double('alive_time')
+      object_double('PerfectQueue::Backend', new_backend: backend).as_stubbed_const
+      client = Client.new({alive_time: alive_time})
+      ret = double('ret')
+      key = double('key')
+      options = {alive_time: alive_time}
+      expect(backend).to receive(:preempt).with(key, alive_time, options).and_return(ret)
+      expect(client.preempt(key, options)).to eq(ret)
+    end
+  end
+end

data/spec/daemons_logger_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe DaemonsLogger do
+  context 'new' do
+    it 'creates logger with path string' do
+      Tempfile.open('daemons_logger') do |io|
+        logger = DaemonsLogger.new(io.path)
+        expect(logger.class).to eq(DaemonsLogger)
+        logger.close
+        logger.close
+      end
+    end
+
+    it 'creates logger with IO object' do
+      io = double('dummy io', write: nil, close: nil)
+      expect(DaemonsLogger.new(io).class).to eq(DaemonsLogger)
+    end
+  end
+
+  context 'reopen' do
+    it 'reopens IOs' do
+      Tempfile.open('daemons_logger') do |f|
+        logger = DaemonsLogger.new(f.path)
+        expect(STDOUT).to receive(:reopen).twice
+        logger.hook_stdout!
+        expect(STDERR).to receive(:reopen).twice
+        logger.hook_stderr!
+        logger.reopen
+        io = logger.instance_variable_get(:@log)
+        allow(logger).to receive(:reopen!) { raise }
+        logger.reopen
+      end
+    end
+  end
+end

data/spec/engine_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe PerfectQueue::Engine do
+  let (:logger){ double('logger').as_null_object }
+  let (:engine) do
+    config = {logger: logger, processor_type: :thread}
+    Engine.new(double, config)
+  end
+
+  describe '.new' do
+    it 'returns an Engine with ForkProcessor for processor_type: nil' do
+      config = {logger: double('logger'), processor_type: nil}
+      engine = Engine.new(double, config)
+      expect(engine).to be_an_instance_of(Engine)
+      expect(engine.processors).to be_a(Array)
+      expect(engine.processors.size).to eq(1)
+      expect(engine.processors[0]).to be_an_instance_of(Multiprocess::ForkProcessor)
+    end
+    it 'returns an Engine with ForkProcessor for processor_type: :process' do
+      config = {logger: double('logger'), processor_type: :process}
+      engine = Engine.new(double, config)
+      expect(engine).to be_an_instance_of(Engine)
+      expect(engine.processors).to be_a(Array)
+      expect(engine.processors.size).to eq(1)
+      expect(engine.processors[0]).to be_an_instance_of(Multiprocess::ForkProcessor)
+    end
+    it 'returns an Engine with ThreadProcessor for processor_type: :thread' do
+      config = {logger: double('logger'), processor_type: :thread}
+      engine = Engine.new(double, config)
+      expect(engine).to be_an_instance_of(Engine)
+      expect(engine.processors).to be_a(Array)
+      expect(engine.processors.size).to eq(1)
+      expect(engine.processors[0]).to be_an_instance_of(Multiprocess::ThreadProcessor)
+    end
+    it 'returns an Engine with ForkProcessor for processor_type: :invalid' do
+      config = {logger: double('logger'), processor_type: :invalid}
+      expect{Engine.new(double, config)}.to raise_error(ConfigError)
+    end
+  end
+
+  describe '#run' do
+    before do
+      processor_klass = (PerfectQueue::Multiprocess::ThreadProcessor)
+      allow(processor_klass).to receive(:new) do
+        processor = double('processor')
+        expect(processor).to receive(:keepalive).exactly(:twice)
+        expect(processor).to receive(:stop)
+        expect(processor).to receive(:join)
+        processor
+      end
+      expect(engine).to receive(:sleep).with(0...2)
+    end
+    it 'runs until stopped' do
+      Thread.start{sleep 1; engine.stop(true) }
+      engine.run
+    end
+  end
+
+  describe '#restart' do
+    context 'previous num_processors is small' do
+      it 'increase the number of processors' do
+        config = {logger: logger, processor_type: :thread}
+        engine = Engine.new(double, config)
+        expect(engine.processors.size).to eq(1)
+        config[:processors] = 3
+        expect(engine.restart(true, config)).to eq(engine)
+        expect(engine.processors.size).to eq(3)
+      end
+    end
+    context 'previous num_processors is large' do
+      it 'decrease the number of processors' do
+        config = {logger: logger, processor_type: :thread, processors: 2}
+        engine = Engine.new(double, config)
+        config[:processors] = 1
+        expect(engine.restart(true, config)).to eq(engine)
+        expect(engine.processors.size).to eq(1)
+      end
+    end
+    context 'same number of processors' do
+      it 'decrease the number of processors' do
+        config = {logger: logger, processor_type: :thread}
+        engine = Engine.new(double, config)
+        expect(engine.restart(true, config)).to eq(engine)
+        expect(engine.processors.size).to eq(1)
+      end
+    end
+  end
+
+  describe '#stop' do
+    let (:immediate){ double('immediate') }
+    before do
+      engine.processors.each do |c|
+        expect(c).to receive(:stop).with(immediate)
+      end
+    end
+    it '@processors.each {|c| c.stop(immediate) }' do
+      expect(engine.stop(immediate)).to eq(engine)
+      expect(engine.instance_variable_get(:@finish_flag).set?).to be true
+    end
+  end
+
+  describe '#join' do
+    before do
+      engine.processors.each do |c|
+        expect(c).to receive(:join)
+      end
+    end
+    it '@processors.each {|c| c.join }' do
+      expect(engine.join).to eq(engine)
+    end
+  end
+
+  describe '#shutdown' do
+    it 'calls stop and join' do
+      immediate = double('immediate')
+      expect(engine).to receive(:stop).with(immediate)
+      expect(engine).to receive(:join)
+      engine.shutdown(immediate)
+    end
+  end
+
+  describe '#replace' do
+    context 'already replaced' do
+      before do
+        engine.instance_variable_set(:@replaced_pid, double)
+      end
+      it 'returns nil' do
+        expect(engine).not_to receive(:stop)
+        expect(engine.replace(double, double)).to be_nil
+      end
+    end
+    context 'not replaced yet' do
+      it 'calls spawn with [$0]+ARGV' do
+        immediate = double('immediate')
+        expect(engine).to receive(:stop).with(immediate)
+        expect(Process).to receive(:spawn).with(*([$0]+ARGV))
+        engine.replace(immediate)
+      end
+      it 'calls spawn with given command' do
+        immediate = double('immediate')
+        command = double('command')
+        expect(engine).to receive(:stop).with(immediate)
+        expect(Process).to receive(:spawn).with(command)
+        engine.replace(immediate, command)
+      end
+    end
+  end
+
+  describe '#logrotated' do
+    before do
+      engine.processors.each do |c|
+        expect(c).to receive(:logrotated)
+      end
+    end
+    it '@processors.each {|c| c.logrotated }' do
+      engine.logrotated
+    end
+  end
+end

data/spec/multiprocess/child_process_monitor_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+
+describe PerfectQueue::Multiprocess::ChildProcessMonitor do
+  let (:rpipe){ double('rpipe') }
+  let (:last_heartbeat){ 42 }
+  let (:last_kill_time){ 42 }
+  let (:processor_id){ double('processor_id') }
+  let (:log){ double('log').as_null_object }
+  let (:cpm) {
+    cpm = Multiprocess::ChildProcessMonitor.new(log, processor_id, rpipe)
+    cpm.instance_variable_set(:@last_heartbeat, last_heartbeat)
+    cpm
+  }
+  let (:now){ 72 }
+  describe '.new' do
+    it 'returns a PerfectQueue::Multiprocess::ChildProcessMonitor' do
+      processor = Multiprocess::ChildProcessMonitor.new(log, processor_id, rpipe)
+      expect(processor).to be_an_instance_of(Multiprocess::ChildProcessMonitor)
+    end
+  end
+
+  describe '#check_heartbeat' do
+    before do
+      allow(object_double('Time').as_stubbed_const).to \
+        receive_message_chain(:now, :to_i).and_return(now)
+    end
+    context 'rpipe returns value' do
+      before do
+        expect(rpipe).to receive(:read_nonblock)
+      end
+      it 'returns true' do
+        limit = double('limit')
+        expect(cpm.check_heartbeat(limit)).to be true
+        expect(cpm.instance_variable_get(:@last_heartbeat)).to eq(now)
+      end
+    end
+    context 'rpipe.read_nonblock raises EINTR' do
+      before do
+        expect(rpipe).to receive(:read_nonblock).and_raise(Errno::EINTR)
+      end
+      it 'returns false if last_heartbeat is too old on interupt' do
+        expect(cpm.check_heartbeat(now-last_heartbeat-1)).to be false
+        expect(cpm.instance_variable_get(:@last_heartbeat)).to eq(last_heartbeat)
+      end
+      it 'returns true if last_heartbeat is enough new on interupt' do
+        expect(cpm.check_heartbeat(now-last_heartbeat)).to be true
+        expect(cpm.instance_variable_get(:@last_heartbeat)).to eq(last_heartbeat)
+      end
+    end
+  end
+
+  describe '#start_killing' do
+    before do
+      allow(object_double('Time').as_stubbed_const).to \
+        receive_message_chain(:now, :to_i).and_return(now)
+    end
+    context 'initial state' do
+      it 'calls kill_children immediately if immediate: true' do
+        expect(cpm).to receive(:kill_children).with(now, nil).exactly(:once)
+        cpm.start_killing(true)
+        expect(cpm.instance_variable_get(:@kill_immediate)).to eq(true)
+        expect(cpm.instance_variable_get(:@last_kill_time)).to eq(now)
+        expect(cpm.instance_variable_get(:@kill_start_time)).to eq(now)
+      end
+      it 'sets @last_kill_time if immediate: true, delay!=0' do
+        delay = 3
+        expect(cpm).not_to receive(:kill_children)
+        cpm.start_killing(true, delay)
+        expect(cpm.instance_variable_get(:@kill_immediate)).to eq(true)
+        expect(cpm.instance_variable_get(:@last_kill_time)).to eq(now+delay)
+        expect(cpm.instance_variable_get(:@kill_start_time)).to eq(now+delay)
+      end
+    end
+    context 'already killed immediately' do
+      before do
+        cpm.instance_variable_set(:@kill_immediate, true)
+        cpm.instance_variable_set(:@last_kill_time, now)
+        cpm.instance_variable_set(:@kill_start_time, now)
+      end
+      it 'returns without do anything if immediate: true' do
+        expect(cpm).not_to receive(:kill_children)
+        cpm.start_killing(true)
+      end
+      it 'returns without do anything if immediate: false' do
+        expect(cpm).not_to receive(:kill_children)
+        cpm.start_killing(false)
+      end
+    end
+    context 'already started killing' do
+      before do
+        cpm.instance_variable_set(:@kill_start_time, double)
+      end
+      it 'return with do nothing if immediate: false' do
+        cpm.start_killing(false, double)
+      end
+    end
+  end
+
+  describe '#killing_status' do
+    context '@kill_start_time: nil' do
+      before { cpm.instance_variable_set(:@kill_start_time, nil) }
+      it 'returns nil' do
+        expect(cpm.killing_status).to be_nil
+      end
+    end
+    context '@kill_start_time: <time>' do
+      before { cpm.instance_variable_set(:@kill_start_time, double) }
+      context '@kill_immediate: true' do
+        before { cpm.instance_variable_set(:@kill_immediate, true) }
+        it 'returns nil' do
+          expect(cpm.killing_status).to be true
+        end
+      end
+      context '@kill_immediate: false' do
+        before { cpm.instance_variable_set(:@kill_immediate, false) }
+        it 'returns nil' do
+          expect(cpm.killing_status).to be false
+        end
+      end
+    end
+  end
+
+  describe '#try_join' do
+    context 'not killed yet' do
+      it 'returns nil' do
+        expect(cpm).not_to receive(:kill_children)
+        expect(cpm.try_join(double, double)).to be_nil
+      end
+    end
+    context 'killing' do
+      let (:cProcess) do
+        allow(Process).to receive(:waitpid).with(processor_id, Process::WNOHANG)
+      end
+      before do
+        cpm.instance_variable_set(:@kill_start_time, double)
+      end
+      context 'waitpid returns pid' do
+        before do
+          cProcess.and_return(processor_id)
+          expect(cpm).not_to receive(:kill_children)
+        end
+        it 'returns true' do
+          expect(cpm.try_join(double, double)).to be true
+        end
+      end
+      context 'waitpid raises ECHILD' do
+        before do
+          cProcess.and_raise(Errno::ECHILD)
+          expect(cpm).not_to receive(:kill_children)
+        end
+        it 'returns true' do
+          expect(cpm.try_join(double, double)).to be true
+        end
+      end
+      context 'waitpid returns nil' do
+        before do
+          cProcess.and_return(nil)
+          allow(object_double('Time').as_stubbed_const).to \
+            receive_message_chain(:now, :to_i).and_return(now)
+          cpm.instance_variable_set(:@last_kill_time, last_kill_time)
+        end
+        it 'returns true if last_kill_time is new' do
+          graceful_kill_limit = double('graceful_kill_limit')
+          expect(cpm).to receive(:kill_children).with(now, graceful_kill_limit).exactly(:once)
+          expect(cpm.try_join(30, graceful_kill_limit)).to be false
+          expect(cpm.instance_variable_get(:@last_kill_time)).to eq(now)
+        end
+        it 'returns false if last_kill_time is old' do
+          expect(cpm).not_to receive(:kill_children)
+          expect(cpm.try_join(31, double)).to be false
+        end
+      end
+    end
+  end
+
+  describe '#cleanup' do
+    context 'rpipe is open' do
+      it 'closes rpipe' do
+        allow(rpipe).to receive(:closed?).and_return(false)
+        expect(rpipe).to receive(:close).exactly(:once)
+        cpm.cleanup
+      end
+    end
+    context 'rpipe is closed' do
+      it 'doesn\'t close rpipe' do
+        allow(rpipe).to receive(:closed?).and_return(true)
+        expect(rpipe).not_to receive(:close)
+        cpm.cleanup
+      end
+    end
+  end
+
+  describe '#send_signal' do
+    let (:sig){ double('sig') }
+    let (:cProcess) do
+      allow(Process).to receive(:kill).with(sig, processor_id)
+    end
+    context 'kill returnes pid' do
+      before do
+        cProcess.and_return(processor_id)
+      end
+      it { cpm.send_signal(sig) }
+    end
+    context 'kill raises ESRCH' do
+      before{ cProcess.and_raise(Errno::ESRCH) }
+      it { cpm.send_signal(sig) }
+    end
+    context 'kill raises EPERM' do
+      before{ cProcess.and_raise(Errno::EPERM) }
+      it { cpm.send_signal(sig) }
+    end
+  end
+
+  describe '#kill_children' do
+    context '@kill_start_time: nil' do
+      # don't happen
+    end
+    context '@kill_start_time: <time>' do
+      before do
+        cpm.instance_variable_set(:@kill_start_time, 42)
+      end
+      context '@kill_immediate: true' do
+        before do
+          cpm.instance_variable_set(:@kill_immediate, true)
+          expect(cpm).to receive(:get_ppid_pids_map).with(no_args).and_return({1=>processor_id}).exactly(:once)
+          expect(cpm).to receive(:collect_child_pids).with({1=>processor_id}, [processor_id], processor_id) \
+            .and_return([processor_id]).exactly(:once)
+          expect(cpm).to receive(:kill_process).with(processor_id, true)
+        end
+        it 'calls kill_process immediately' do
+          cpm.__send__(:kill_children, now, double)
+        end
+      end
+      context '@kill_immediate: false' do
+        before do
+          cpm.instance_variable_set(:@kill_immediate, false)
+        end
+        it 'calls kill_process immediately' do
+          expect(cpm).to receive(:get_ppid_pids_map).with(no_args).and_return({1=>processor_id}).exactly(:once)
+          expect(cpm).to receive(:collect_child_pids).with({1=>processor_id}, [processor_id], processor_id) \
+            .and_return([processor_id]).exactly(:once)
+          expect(cpm).to receive(:kill_process).with(processor_id, true)
+          cpm.__send__(:kill_children, now, 29)
+        end
+        it 'calls kill_process' do
+          expect(cpm).not_to receive(:get_ppid_pids_map)
+          expect(cpm).not_to receive(:collect_child_pids)
+          expect(cpm).to receive(:kill_process).with(processor_id, false)
+          cpm.__send__(:kill_children, now, 30)
+        end
+      end
+    end
+  end
+
+  describe '#get_ppid_pids_map' do
+    before do
+      expect(cpm).to receive(:`).with('ps axo pid,ppid') \
+        .and_return <<eom
+  PID  PPID
+      1     0
+      2     1
+      3     1
+      4     2
+      5     3
+eom
+    end
+    it 'returns a tree of hash' do
+      expect(cpm.__send__(:get_ppid_pids_map)).to eq({0=>[1], 1=>[2, 3], 2=>[4], 3=>[5]})
+    end
+  end
+
+  describe '#collect_child_pids' do
+    it 'returns a flat array of given children' do
+      ppid_pids = {0=>[1], 1=>[2, 3], 2=>[4], 3=>[5]}
+      parent_pid = 1
+      results = cpm.__send__(:collect_child_pids, ppid_pids, [parent_pid], parent_pid)
+      expect(results).to eq([1, 2, 4, 3, 5])
+    end
+  end
+
+  describe '#kill_process' do
+    let (:pid){ double('pid') }
+    it  'kill(:KILL, pid) for immediate:true' do
+      expect(Process).to receive(:kill).with(:KILL, pid).and_return(pid).exactly(:once)
+      expect(cpm.__send__(:kill_process, pid, true)).to eq(pid)
+    end
+    it  'kill(:TERM, pid) for immediate:false' do
+      expect(Process).to receive(:kill).with(:TERM, pid).and_return(pid).exactly(:once)
+      expect(cpm.__send__(:kill_process, pid, false)).to eq(pid)
+    end
+    it 'rescues ESRCH' do
+      expect(Process).to receive(:kill).with(:KILL, pid).and_raise(Errno::ESRCH).exactly(:once)
+      expect(cpm.__send__(:kill_process, pid, true)).to be_nil
+    end
+    it 'rescues EPERM' do
+      expect(Process).to receive(:kill).with(:KILL, pid).and_raise(Errno::EPERM).exactly(:once)
+      expect(cpm.__send__(:kill_process, pid, true)).to be_nil
+    end
+  end
+end