perfectsched 0.8.10 → 0.8.11

data/spec/runner_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Runner do
+  let (:client){ double('client') }
+  let (:task){ double('task', client: client) }
+  let (:runner){ Runner.new(task) }
+  describe '.new' do
+    subject { runner }
+    it { is_expected.to be_an_instance_of(Runner) }
+  end
+  describe '#task' do
+    subject { runner.task }
+    it { is_expected.to eq task }
+  end
+  describe '#schedules' do
+    subject { runner.schedules }
+    it do
+      schedule_collection = double('schedule_collection')
+      expect(ScheduleCollection).to receive(:new).with(client).and_return(schedule_collection)
+      is_expected.to eq schedule_collection
+    end
+  end
+end

data/spec/schedule_collection_spec.rb

@@ -9,7 +9,7 @@ describe ScheduleCollection do
   end
 
   it 'is a ScheduleCollection' do
-    sc.class.should == PerfectSched::ScheduleCollection
+    expect(sc.class).to eq(PerfectSched::ScheduleCollection)
   end
 
   it 'succeess add' do
@@ -19,9 +19,9 @@ describe ScheduleCollection do
   it 'fail duplicated add' do
     sc.add('sched01', 't01', {:cron=>'* * * * *', :timezone=>'UTC'})
 
-    lambda {
+    expect {
       sc.add('sched01', 't01', {:cron=>'* * * * *', :timezone=>'UTC'})
-    }.should raise_error AlreadyExistsError
+    }.to raise_error AlreadyExistsError
 
     sc['sched01'].delete!
 
@@ -34,25 +34,25 @@ describe ScheduleCollection do
     s01 = sc.add('sched01', 't01', :cron=>"* * * * *", :data=>{'k'=>1}, :next_time=>time)
 
     t01 = sc.poll(:alive_time=>120, :now=>time)
-    t01.key.should == 'sched01'
-    t01.type.should == 't01'
-    t01.cron.should == "* * * * *"
-    t01.delay.should == 0
-    t01.data.should == {'k'=>1}
-    t01.scheduled_time.should == time
+    expect(t01.key).to eq('sched01')
+    expect(t01.type).to eq('t01')
+    expect(t01.cron).to eq("* * * * *")
+    expect(t01.delay).to eq(0)
+    expect(t01.data).to eq({'k'=>1})
+    expect(t01.scheduled_time).to eq(time)
 
     t02 = sc.poll(:alive_time=>120, :now=>time+60)
-    t02.should == nil
+    expect(t02).to eq(nil)
 
     t01.finish!
 
     t04 = sc.poll(:alive_time=>120, :now=>time+60)
-    t04.key.should == 'sched01'
-    t01.type.should == 't01'
-    t04.cron.should == "* * * * *"
-    t04.delay.should == 0
-    t04.data.should == {'k'=>1}
-    t04.scheduled_time.should == time+60
+    expect(t04.key).to eq('sched01')
+    expect(t01.type).to eq('t01')
+    expect(t04.cron).to eq("* * * * *")
+    expect(t04.delay).to eq(0)
+    expect(t04.data).to eq({'k'=>1})
+    expect(t04.scheduled_time).to eq(time+60)
   end
 
   it 'timezone' do
@@ -67,16 +67,16 @@ describe ScheduleCollection do
     #s02.key.should == 'sched02'
 
     t01 = sc.poll(:alive_time=>86400, :now=>time)
-    t01.class.should == Task
-    t01.key.should == 'sched01'
-    t01.type.should == 't01'
-    t01.scheduled_time.should == time
+    expect(t01.class).to eq(Task)
+    expect(t01.key).to eq('sched01')
+    expect(t01.type).to eq('t01')
+    expect(t01.scheduled_time).to eq(time)
 
     t02 = sc.poll(:alive_time=>86400, :now=>time+54000)
-    t02.class.should == Task
-    t02.key.should == 'sched02'
-    t02.type.should == 't01'
-    t02.scheduled_time.should == time+54000
+    expect(t02.class).to eq(Task)
+    expect(t02.key).to eq('sched02')
+    expect(t02.type).to eq('t01')
+    expect(t02.scheduled_time).to eq(time+54000)
   end
 
   it 'delay' do
@@ -85,43 +85,43 @@ describe ScheduleCollection do
     s01 = sc.add('sched01', 't01', :cron=>"0 * * * *", :delay=>30, :next_time=>time, :timezone=>'UTC')
 
     t01 = sc.poll(:alive_time=>86400, :now=>time)
-    t01.should == nil
+    expect(t01).to eq(nil)
 
     t02 = sc.poll(:alive_time=>86400, :now=>time+30)
-    t02.class.should == Task
-    t02.key.should == 'sched01'
-    t02.type.should == 't01'
-    t02.scheduled_time.should == time
-    t02.delay.should == 30
+    expect(t02.class).to eq(Task)
+    expect(t02.key).to eq('sched01')
+    expect(t02.type).to eq('t01')
+    expect(t02.scheduled_time).to eq(time)
+    expect(t02.delay).to eq(30)
 
     t02.finish!
 
     t03 = sc.poll(:alive_time=>86400, :now=>time+3600)
-    t03.should == nil
+    expect(t03).to eq(nil)
 
     t04 = sc.poll(:alive_time=>86400, :now=>time+3630)
-    t04.class.should == Task
-    t04.key.should == 'sched01'
-    t04.type.should == 't01'
-    t04.scheduled_time.should == time+3600
-    t04.delay.should == 30
+    expect(t04.class).to eq(Task)
+    expect(t04.key).to eq('sched01')
+    expect(t04.type).to eq('t01')
+    expect(t04.scheduled_time).to eq(time+3600)
+    expect(t04.delay).to eq(30)
   end
 
   it 'invalid cron format' do
-    lambda {
+    expect {
       sc.add('sched01', 't01', :cron=>'???')
-    }.should raise_error ArgumentError
+    }.to raise_error StandardError
 
-    lambda {
+    expect {
       sc.add('sched01', 't01', :cron=>'* * * * * *')
-    }.should raise_error ArgumentError
+    }.to raise_error StandardError
   end
 
   it 'fail duplicated add' do
     sc.add('sched01', 't01', :cron=>"0 * * * *")
-    lambda {
+    expect {
       sc.add('sched01', 't01', :cron=>"0 * * * *")
-    }.should raise_error AlreadyExistsError
+    }.to raise_error AlreadyExistsError
 
     sc['sched01'].delete!
 
@@ -142,31 +142,31 @@ describe ScheduleCollection do
     a.sort_by! {|s| s.key }
 
     s01 = a.shift
-    s01.class.should == ScheduleWithMetadata
-    s01.key.should == 'sched01'
-    s01.type.should == 't01'
-    s01.cron.should == '0 * * * *'
-    s01.delay.should == 1
-    s01.next_time.should == time
-    s01.next_run_time.should == time+1
+    expect(s01.class).to eq(ScheduleWithMetadata)
+    expect(s01.key).to eq('sched01')
+    expect(s01.type).to eq('t01')
+    expect(s01.cron).to eq('0 * * * *')
+    expect(s01.delay).to eq(1)
+    expect(s01.next_time).to eq(time)
+    expect(s01.next_run_time).to eq(time+1)
 
     s02 = a.shift
-    s02.class.should == ScheduleWithMetadata
-    s02.key.should == 'sched02'
-    s02.type.should == 't02'
-    s02.cron.should == '0 * * * *'
-    s02.delay.should == 2
-    s02.next_time.should == time
-    s02.next_run_time.should == time+2
+    expect(s02.class).to eq(ScheduleWithMetadata)
+    expect(s02.key).to eq('sched02')
+    expect(s02.type).to eq('t02')
+    expect(s02.cron).to eq('0 * * * *')
+    expect(s02.delay).to eq(2)
+    expect(s02.next_time).to eq(time)
+    expect(s02.next_run_time).to eq(time+2)
 
     s03 = a.shift
-    s03.class.should == ScheduleWithMetadata
-    s03.key.should == 'sched03'
-    s03.type.should == 't03'
-    s03.cron.should == '0 * * * *'
-    s03.delay.should == 3
-    s03.next_time.should == time
-    s03.next_run_time.should == time+3600
+    expect(s03.class).to eq(ScheduleWithMetadata)
+    expect(s03.key).to eq('sched03')
+    expect(s03.type).to eq('t03')
+    expect(s03.cron).to eq('0 * * * *')
+    expect(s03.delay).to eq(3)
+    expect(s03.next_time).to eq(time)
+    expect(s03.next_run_time).to eq(time+3600)
   end
 end
 

data/spec/schedule_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Schedule do
+  let (:schedule){ Schedule.new(client, key) }
+  let (:client){ double('client') }
+  let (:key){ double('key') }
+  let (:ret){  double('ret') }
+  let (:options){ double('options') }
+  describe '.new' do
+    subject { schedule }
+    it { is_expected.to be_an_instance_of(Schedule) }
+  end
+  describe '#key' do
+    subject { schedule.key }
+    it { is_expected.to eq key }
+  end
+  describe '#delete!' do
+    subject { schedule.delete!(options) }
+    it do
+      expect(client).to receive(:delete).with(key, options).and_return(ret)
+      is_expected.to eq ret
+    end
+  end
+  describe '#metadata' do
+    subject { schedule.metadata(options) }
+    it do
+      expect(client).to receive(:get_schedule_metadata).with(key, options).and_return(ret)
+      is_expected.to eq ret
+    end
+  end
+  describe '#exists?' do
+    subject { schedule.exists?(options) }
+    context 'metadata() works' do
+      it do
+        expect(schedule).to receive(:metadata).with(options)
+        is_expected.to eq true
+      end
+    end
+    context 'metadata() raises NotFoundError' do
+      it do
+        expect(schedule).to receive(:metadata).with(options).and_raise(NotFoundError)
+        is_expected.to be false
+      end
+    end
+  end
+  describe '#inspect' do
+    subject { schedule.inspect }
+    it { is_expected.to eq "#<PerfectSched::Schedule @key=#{key.inspect}>" }
+  end
+end
+
+describe ScheduleWithMetadata do
+  let (:sm){ ScheduleWithMetadata.new(client, key, attributes) }
+  let (:client){ double('client') }
+  let (:key){ double('key') }
+  let (:ret){  double('ret') }
+  let (:attributes){ double('attributes') }
+  describe '.new' do
+    subject { sm }
+    it { is_expected.to be_an_instance_of(ScheduleWithMetadata) }
+  end
+  describe '#inspect' do
+    subject { sm.inspect }
+    it { is_expected.to eq "#<PerfectSched::ScheduleWithMetadata @key=#{key.inspect} @attributes=#{attributes.inspect}>" }
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,5 @@
 $LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
 
-require 'perfectsched'
-
 if ENV['SIMPLE_COV']
   require 'simplecov'
   SimpleCov.start do
@@ -11,6 +9,13 @@ if ENV['SIMPLE_COV']
   end
 end
 
+require 'perfectsched'
+
+if ENV['CI']
+  require 'coveralls'
+  Coveralls.wear!
+end
+
 require 'fileutils'
 
 def test_sched_config

data/spec/task_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe PerfectSched::Task do
+  let (:client){ double('client') }
+  let (:key){ double('key') }
+  let (:attributes){ double('attributes') }
+  let (:scheduled_time){ double('scheduled_time') }
+  let (:task_token){ double('task_token') }
+  let (:task){ Task.new(client, key, attributes, scheduled_time, task_token) }
+
+  describe '.new' do
+    it 'returns a Task' do
+      expect(task).to be_an_instance_of(Task)
+      expect(task.instance_variable_get(:@scheduled_time)).to eq(scheduled_time)
+      expect(task.instance_variable_get(:@task_token)).to eq(task_token)
+    end
+  end
+
+  describe '#scheduled_time' do
+    it 'returns the scheduled_time' do
+      expect(task.scheduled_time).to eq(scheduled_time)
+    end
+  end
+
+  describe '#release!' do
+    it 'calls client.release' do
+      options = double('options')
+      ret = double('ret')
+      expect(client).to receive(:release).with(task_token, options).and_return(ret)
+      expect(task.release!(options)).to eq(ret)
+    end
+  end
+
+  describe '#retry!' do
+    it 'calls client.retry' do
+      options = double('options')
+      ret = double('ret')
+      expect(client).to receive(:retry).with(task_token, options).and_return(ret)
+      expect(task.retry!(options)).to eq(ret)
+    end
+  end
+
+  describe '#finish!' do
+    it 'calls client.finish' do
+      options = double('options')
+      ret = double('ret')
+      expect(client).to receive(:finish).with(task_token, options).and_return(ret)
+      expect(task.finish!(options)).to eq(ret)
+    end
+  end
+end

data/spec/worker_spec.rb

@@ -1,58 +1,201 @@
 require 'spec_helper'
 
-class TestHandler < PerfectSched::Application::Base
-  def run
-    puts "TestHandler: #{task}"
-    if task.data['raise_error']
-      raise "expected error test"
+describe Worker do
+  let (:logger){ double('logger').as_null_object }
+  let (:runner){ double('runner') }
+  let (:config){ {} }
+  let (:worker){ Worker.new(runner, config) }
+  before do
+    allow(DaemonsLogger).to receive(:new).and_return(logger)
+  end
+
+  describe '.run' do
+    it 'calls Worker.new.run without block' do
+      expect(worker).to receive(:run).with(no_args)
+      expect(Worker).to receive(:new).with(runner, config) do |*args, &block|
+        expect(block).to be_nil
+        worker
+      end
+      Worker.run(runner, config)
     end
-    if num = task.data['sleep']
-      sleep num
+    it 'calls Worker.new.run with block' do
+      expect(worker).to receive(:run).with(no_args)
+      expect(Worker).to receive(:new).with(runner, nil) do |*args, &block|
+        expect(block).to be_a(Proc)
+        worker
+      end
+      Worker.run(runner){ }
     end
-    puts "Task finished"
   end
 
-  def kill(reason)
-    puts "kill: #{reason.class}: #{reason}"
+  describe '.new' do
+    it 'creates a Worker without block' do
+      expect(worker).to be_an_instance_of(Worker)
+      expect(worker.instance_variable_get(:@runner)).to eq(runner)
+      expect(worker.instance_variable_get(:@config_load_proc)).to be_an_instance_of(Proc)
+      expect(worker.instance_variable_get(:@finished)).to be false
+    end
+    it 'creates a Worker with block' do
+      worker = Worker.new(runner){ }
+      expect(worker).to be_an_instance_of(Worker)
+      expect(worker.instance_variable_get(:@runner)).to eq(runner)
+      expect(worker.instance_variable_get(:@config_load_proc)).to be_an_instance_of(Proc)
+      expect(worker.instance_variable_get(:@finished)).to be false
+    end
   end
-end
-
-class TestApp < PerfectSched::Application::Dispatch
-  route 'test' => TestHandler
-end
 
-describe Worker do
-  before do
-    create_test_sched.close
-    @worker = Worker.new(TestApp, test_sched_config)
-    @thread = Thread.new {
-      @worker.run
-    }
+  describe '#run' do
+    let (:sig) do
+      sig = double('sig')
+      expect(sig).to receive(:stop)
+      sig
+    end
+    let (:engine) do
+      engine = double('engine')
+      expect(engine).to receive(:run){ worker.instance_variable_set(:@finished, true) }
+      expect(engine).to receive(:shutdown)
+      engine
+    end
+    it 'creates a Worker without block' do
+      expect(worker).to receive(:install_signal_handlers).and_return(sig)
+      expect(Engine).to receive(:new).with(runner, kind_of(Hash)).and_return(engine)
+      expect(worker.instance_variable_get(:@runner)).to eq(runner)
+      expect(worker.instance_variable_get(:@config_load_proc)).to be_an_instance_of(Proc)
+      expect(worker.instance_variable_get(:@finished)).to be false
+      expect(worker.run).to be_nil
+    end
+    it 'rescues error' do
+      allow(worker).to receive(:install_signal_handlers).and_raise(RuntimeError)
+      expect(worker.run).to be_nil
+    end
   end
 
-  after do
-    @worker.stop
-    @thread.join
+  describe '#stop' do
+    context 'engine is not set' do
+      it 'returns true' do
+        expect(worker.stop).to be true
+        expect(worker.instance_variable_get(:@finished)).to be true
+      end
+    end
+    context 'engine is set' do
+      let (:engine){ double('engine') }
+      before do
+        worker.instance_variable_set(:@engine, engine)
+      end
+      context 'succeed to stop engine' do
+        before do
+          expect(engine).to receive(:stop)
+        end
+        it 'returns true' do
+          expect(worker.stop).to be true
+          expect(worker.instance_variable_get(:@finished)).to be true
+        end
+      end
+      context 'fail to stop engine' do
+        before do
+          expect(engine).to receive(:stop).and_raise(RuntimeError)
+        end
+        it 'returns false' do
+          expect(worker.stop).to be false
+          expect(worker.instance_variable_get(:@finished)).to be true
+        end
+      end
+    end
   end
 
-  def add(*args)
-    sc = get_test_sched
-    sc.add(*args)
-    sc.close
+  describe '#restart' do
+    let (:engine){ double('engine') }
+    let (:old_engine){ double('old_engine') }
+    before do
+      worker.instance_variable_set(:@engine, old_engine)
+      expect(Engine).to receive(:new).with(runner, kind_of(Hash)).and_return(engine)
+    end
+    context 'succeed to shutdown old engine' do
+      before do
+        expect(old_engine).to receive(:shutdown)
+      end
+      it 'returns true' do
+        expect(worker.restart).to be true
+      end
+    end
+    context 'fail to shutdown old engine' do
+      before do
+        expect(old_engine).to receive(:shutdown).and_raise(RuntimeError)
+      end
+      it 'returns false' do
+        expect(worker.restart).to be false
+      end
+    end
   end
 
-  it 'run' do
-    TestHandler.any_instance.should_receive(:run).once
-    add('key', 'test', {:cron=>'* * * * *', :next_time=>Time.now.to_i-60})
-    sleep 2
+  describe '#replace' do
+    context 'called at the first time' do
+      let (:pid){ double('pid') }
+      it 'returns self' do
+        expect(Process).to receive(:spawn).with(*([$0]+ARGV)).and_return(pid)
+        expect(worker).to receive(:stop)
+        expect(worker.replace).to eq(worker)
+      end
+      it 'returns self' do
+        command = double('command')
+        expect(Process).to receive(:spawn).with(command).and_return(pid)
+        expect(worker).to receive(:stop)
+        expect(worker.replace(command)).to eq(worker)
+      end
+    end
+    context 'already called' do
+      it 'returns true' do
+        expect(worker).to receive(:stop).and_raise(RuntimeError)
+        expect(worker.replace(double)).to be false
+      end
+    end
   end
 
-  it 'term signal' do
-    sleep 1
-    Process.kill(:TERM, Process.pid)
-    puts "finish expected..."
-    @thread.join
+  describe '#logrotated' do
+    it 'returns true' do
+      expect(logger).to receive(:reopen!)
+      expect(worker.logrotated).to be true
+    end
+    it 'rescues error and returns false' do
+      expect(logger).to receive(:reopen!).and_raise(RuntimeError)
+      expect(worker.logrotated).to be false
+    end
   end
 
+  describe 'install_signal_handlers' do
+    let (:engine){ double('engine', shutdown: nil) }
+    before do
+      expect(Engine).to receive(:new).with(runner, kind_of(Hash)).and_return(engine)
+    end
+    it 'traps TERM and stop the worker' do
+      allow(engine).to receive(:run){ Process.kill(:TERM, $$) }
+      expect(worker).to receive(:stop).and_call_original
+      worker.run
+    end
+    it 'traps INT and stop the worker' do
+      allow(engine).to receive(:run){ Process.kill(:INT, $$) }
+      expect(worker).to receive(:stop).and_call_original
+      worker.run
+    end
+    it 'traps QUIT and stop the worker' do
+      allow(engine).to receive(:run){ Process.kill(:QUIT, $$) }
+      expect(worker).to receive(:stop).and_call_original
+      worker.run
+    end
+    it 'traps USR1 and restart the worker' do
+      allow(engine).to receive(:run){ Process.kill(:USR1, $$) }
+      expect(worker).to receive(:restart){ worker.stop }
+      worker.run
+    end
+    it 'traps HUP and restart the worker' do
+      allow(engine).to receive(:run){ Process.kill(:HUP, $$) }
+      expect(worker).to receive(:restart){ worker.stop }
+      worker.run
+    end
+    it 'traps USR2 and logrotated' do
+      allow(engine).to receive(:run){ Process.kill(:USR2, $$) }
+      expect(worker).to receive(:logrotated){ worker.stop }
+      worker.run
+    end
+  end
 end
-