perfectqueue 0.8.44.1 → 0.8.45

data/spec/runner_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe PerfectQueue::Runner do
+  describe '#new' do
+    it 'creates with task' do
+      expect(PerfectQueue::Runner.new(double('task'))).to be_a(PerfectQueue::Runner)
+    end
+  end
+
+  describe '#task' do
+    let (:task) { double('task') }
+    let (:runner) { PerfectQueue::Runner.new(task) }
+    it 'returns given task' do
+      expect(runner.task).to eq(task)
+    end
+  end
+
+  describe '#queue' do
+    let (:runner) { PerfectQueue::Runner.new(double('task', client: 1)) }
+    it 'returns a queue' do
+      queue = runner.queue
+      expect(queue).to be_a(PerfectQueue::Queue)
+    end
+  end
+
+  describe '#kill' do
+    let (:runner) { PerfectQueue::Runner.new(double('task')) }
+    it 'always returns nil' do
+      expect(runner.kill(nil)).to be_nil
+    end
+  end
+end

data/spec/signal_thread_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe SignalThread do
+  before(:each) do
+    @th = SignalThread.new
+  end
+
+  after(:each) do
+    @th.trap('SIGUSR1')
+    @th.stop
+    @th.join
+  end
+
+  context('trap') do
+    it 'ignores Signal' do
+      old = @th.trap('SIGUSR1', 'IGNORE')
+      expect(old).to be_nil
+      expect(@th.handlers).to eq({})
+    end
+
+    it 'traps Signal' do
+      flag = false
+      pr = proc{flag=1;raise}
+      expect(@th.trap('SIGUSR1', &pr)).to be_nil
+      expect(@th.handlers).to eq({USR1: pr})
+      allow(STDERR).to receive(:write).at_least(:once)
+      Process.kill(:USR1, Process.pid)
+      Thread.pass until flag
+    expect(flag).to eq(1)
+    end
+  end
+
+  it 'queues signal' do
+    flag = false
+    pr = proc{flag=1;raise}
+    allow(@th).to receive(:enqueue){flag=2;raise}
+    expect(@th.trap('SIGUSR1', &pr)).to be_nil
+    allow(STDERR).to receive(:write).at_least(:once)
+    Process.kill(:USR1, Process.pid)
+    Thread.pass until flag
+    expect(flag).to eq(2)
+  end
+end

data/spec/stress.rb

@@ -21,7 +21,7 @@ describe Queue do
     loop_num.times do |i|
       queue.submit("#{thread_id}-#{i}", "type01", {}, :now=>now-10)
       task = queue.poll(:now=>now, :alive_time=>60)
-      task.should_not == nil
+      expect(task).not_to eq(nil)
       task.heartbeat!(:now=>now, :alive_time=>70)
       task.finish!(:now=>now, :retention_time=>80)
     end

data/spec/supervisor_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 class TestHandler < PerfectQueue::Application::Base
   def run
-    puts "TestHandler: #{task}"
+    #puts "TestHandler: #{task}"
     if task.data['raise_error']
       raise "expected error test"
     end
     if num = task.data['sleep']
       sleep num
     end
-    puts "Task finished"
+    #puts "Task finished"
   end
 
   def kill(reason)
@@ -30,47 +30,202 @@ end
 
 describe Supervisor do
   include QueueTest
-
+  let (:logger) { double('logger').as_null_object }
   before do
-    @sv = Supervisor.new(TestApp, queue_config)
-    @thread = Thread.new {
-      @sv.run
-    }
+    object_double('PerfectQueue::DaemonsLogger', new: logger).as_stubbed_const
   end
 
-  after do
-    @sv.stop(true)
-    @thread.join
+  context 'normal routing' do
+    before do
+      @sv = Supervisor.new(TestApp, queue_config)
+      @thread = Thread.new {
+        @sv.run
+      }
+    end
+
+    after do
+      @sv.stop(true)
+      @thread.join
+    end
+
+    it 'route' do
+      expect_any_instance_of(TestHandler).to receive(:run).once
+      expect_any_instance_of(RegexpHandler).to receive(:run).once
+      queue.submit('task01', 'test', {})
+      queue.submit('task02', 'reg01', {})
+      sleep 2
+    end
   end
 
-  it 'route' do
-    TestHandler.any_instance.should_receive(:run).once
-    RegexpHandler.any_instance.should_receive(:run).once
-    queue.submit('task01', 'test', {})
-    queue.submit('task02', 'reg01', {})
-    sleep 1
+  context 'listen_debug_server' do
+    after do
+      @sv.stop(true)
+      @thread.join
+    end
+
+    it 'listen_debug_server with UNIX Socket' do
+      Tempfile.open('supervisor') do |f|
+        config = queue_config.dup
+        config[:debug] = f.path
+        @sv = Supervisor.new(TestApp, config)
+        @thread = Thread.new {
+          @sv.run
+        }
+        sleep 2
+      end
+    end
+
+    it 'listen_debug_server with TCP with address:port' do
+      config = queue_config.dup
+      config[:debug] = '127.0.0.1:0'
+      @sv = Supervisor.new(TestApp, config)
+      @thread = Thread.new {
+        @sv.run
+      }
+      sleep 2
+    end
+
+    it 'listen_debug_server with TCP with port' do
+      config = queue_config.dup
+      config[:debug] = '0'
+      @sv = Supervisor.new(TestApp, config)
+      @thread = Thread.new {
+        @sv.run
+      }
+      sleep 2
+    end
   end
 
-  it 'term signal' do
-    sleep 1
-    Process.kill(:TERM, Process.pid)
-    puts "finish expected..."
-    @thread.join
+  context 'replace' do
+    before do
+      @sv = Supervisor.new(TestApp, queue_config)
+      @thread = Thread.new {
+        @sv.run
+      }
+      Thread.pass until @sv.engine
+    end
+
+    after do
+      @sv.stop(true)
+      @thread.join
+    end
+
+    it 'replaces immediately' do
+      @sv.replace(true, ':')
+    end
+
+    it 'replaces not immediately' do
+      @sv.replace(false, ':')
+    end
+
+    it 'fails to replace' do
+      Thread.pass until @sv.engine
+      allow(@sv.engine).to receive(:replace) { raise }
+      @sv.replace(false, ':')
+    end
   end
 
-  it 'quit signal' do
-    sleep 1
-    Process.kill(:QUIT, Process.pid)
-    puts "finish expected..."
-    @thread.join
+  context 'signal handling' do
+    before do
+      @sv = Supervisor.new(TestApp, queue_config)
+      @thread = Thread.new {
+        @sv.run
+      }
+    end
+
+    after do
+      @sv.stop(true)
+      @thread.join
+    end
+
+    it 'handles TERM signal' do
+      Thread.pass until @sv.engine
+      Process.kill(:TERM, Process.pid)
+      expect(@thread.join(3)).to eq(@thread)
+    end
+
+    it 'handles INT signal' do
+      Thread.pass until @sv.engine
+      Process.kill(:INT, Process.pid)
+      expect(@thread.join(3)).to eq(@thread)
+    end
+
+    it 'handles QUIT signal' do
+      Thread.pass until @sv.engine
+      Process.kill(:QUIT, Process.pid)
+      #puts "finish expected..."
+      expect(@thread.join(3)).to eq(@thread)
+    end
+
+    it 'handles USR1 signal' do
+      Thread.pass until @sv.engine
+      processors = @sv.engine.processors
+      Process.kill(:USR1, Process.pid)
+      expect(@sv.engine.processors).to eq(processors)
+    end
+
+    it 'handles HUP signal' do
+      Thread.pass until @sv.engine
+      processors = @sv.engine.processors
+      Process.kill(:HUP, Process.pid)
+      expect(@sv.engine.processors).to eq(processors)
+    end
+
+    it 'handles USR2 signal' do
+      Thread.pass until @sv.engine
+      allow(logger).to receive(:reopen!)
+      Process.kill(:USR2, Process.pid)
+    end
+
+    it 'kill reason' do
+      expect_any_instance_of(TestHandler).to receive(:kill).once #.with(kind_of(PerfectQueue::CancelRequestedError))  # FIXME 'with' dead locks
+      queue.submit('task01', 'test', {'sleep'=>4})
+      sleep 2
+      Process.kill(:TERM, Process.pid)
+      expect(@thread.join(3)).to eq(@thread)
+    end
+  end
+
+  describe '.run' do
+    let (:runner) { double('runner') }
+    let (:config) { double('config') }
+    before (:each) do
+      allow(Supervisor).to receive(:new) \
+        .with(runner, config)  do |*args, &block|
+        expect(block).to be_a(Proc)
+        double('supervisor', run: nil)
+      end
+    end
+    it 'calls Supervisor.new.run' do
+      expect(Supervisor.run(runner, config){ }).to be_nil
+    end
   end
 
-  it 'kill reason' do
-    TestHandler.any_instance.should_receive(:kill).once #.with(kind_of(PerfectQueue::CancelRequestedError))  # FIXME 'with' dead locks
-    queue.submit('task01', 'test', {'sleep'=>4})
-    sleep 2
-    Process.kill(:TERM, Process.pid)
-    @thread.join
+  describe '#run' do
+    let (:supervisor) { Supervisor.new(double('runner')){raise} }
+    it 'rescues exception' do
+      expect(supervisor.run).to be_nil
+    end
   end
-end
 
+  describe '#stop' do
+    let (:supervisor) { Supervisor.new(double('runner')){} }
+    it 'return nil without engine' do
+      expect(supervisor.run).to be_nil
+    end
+    it 'rescues exception' do
+      supervisor.instance_variable_set(:@engine, true) # dummy
+      expect(supervisor.stop(true)).to be false
+    end
+  end
+
+  describe '#restart' do
+    let (:supervisor) { Supervisor.new(double('runner')){} }
+    it 'return nil without engine' do
+      expect(supervisor.run).to be_nil
+    end
+    it 'rescues exception' do
+      expect(supervisor.restart(true)).to be false
+    end
+  end
+end

data/spec/task_metadata_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe PerfectQueue::TaskMetadata do
+  let (:attributes){ double('attributes', delete: nil) }
+  describe '#task' do
+    it 'returns a task' do
+      client = double('client')
+      key = double('key')
+      tm = TaskMetadata.new(client, key, attributes)
+      task = tm.task
+      expect(task).to be_a(Task)
+      expect(task.client).to eq(client)
+      expect(task.key).to eq(key)
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns inspected string' do
+      client = double('client')
+      key = double('key')
+      tm = TaskMetadata.new(client, key, attributes)
+      expect(tm.inspect).to eq("#<PerfectQueue::TaskMetadata @key=#{key.inspect} @attributes=#{attributes.inspect}>")
+    end
+  end
+
+  describe 'running?' do
+    it 'returns true on running' do
+      tm = TaskMetadata.new(double, double, status: TaskStatus::RUNNING)
+      expect(tm.running?).to be true
+    end
+
+    it 'returns false on finished' do
+      tm = TaskMetadata.new(double, double, status: TaskStatus::FINISHED)
+      expect(tm.running?).to be false
+    end
+  end
+
+  describe 'message' do
+    it 'returns given message' do
+      message = double('message')
+      tm = TaskMetadata.new(double, double, message: message)
+      expect(tm.message).to eq(message)
+    end
+  end
+
+  describe 'user' do
+    it 'returns given user' do
+      user = double('user')
+      tm = TaskMetadata.new(double, double, user: user)
+      expect(tm.user).to eq(user)
+    end
+  end
+
+  describe 'created_at' do
+    it 'returns a time of given created_at' do
+      epoch = 42
+      tm = TaskMetadata.new(double, double, created_at: epoch)
+      expect(tm.created_at).to eq(Time.at(epoch))
+    end
+  end
+
+  describe 'timeout' do
+    it 'returns a time of given timeout' do
+      epoch = 72
+      tm = TaskMetadata.new(double, double, timeout: epoch)
+      expect(tm.timeout).to eq(Time.at(epoch))
+    end
+  end
+end

data/spec/task_monitor_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe PerfectQueue::TaskMonitor do
+  describe '#kill_task' do
+    it 'rescues exception' do
+      tm = PerfectQueue::TaskMonitor.new(logger: double('logger').as_null_object)
+      task = double('task')
+      reason = double('reason')
+      allow(task).to receive_message_chain(:runner, :kill) \
+        .with(no_args).with(reason){raise}
+      tm.instance_variable_set(:@task, task)
+      expect{tm.kill_task(reason)}.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#external_task_heartbeat' do
+    it 'rescues exception' do
+      tm = PerfectQueue::TaskMonitor.new(logger: double('logger').as_null_object)
+      task = double('task')
+      reason = double('reason')
+      allow(task).to receive_message_chain(:runner, :kill) \
+        .with(no_args).with(reason){raise}
+      epoch = double('epoch')
+      allow(Time).to receive_message_chain(:now, :to_i){epoch}
+      ret = double('ret')
+      tm.instance_variable_set(:@task, task)
+      expect(tm.external_task_heartbeat(task){ret}).to eq(ret)
+      expect(tm.instance_variable_get(:@last_task_heartbeat)).to eq(epoch)
+    end
+  end
+
+  describe '#run' do
+    it 'rescues exception' do
+      config = {logger: double('logger').as_null_object}
+      force_stop = double('force_stop')
+      expect(force_stop).to receive(:call).with(no_args).exactly(:once)
+      tm = PerfectQueue::TaskMonitor.new(config, nil, force_stop)
+      allow(Time).to receive(:now){raise}
+      tm.run
+    end
+  end
+end