perfectsched 0.8.10 → 0.8.11

data/spec/engine_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe PerfectSched::Engine do
+  let (:logger){ double('logger').as_null_object }
+  let (:runner){ double('runner') }
+  let (:scheds){ double('scheds') }
+  let (:config){ {logger: logger} }
+  let (:engine) do
+    Engine.new(runner, config)
+  end
+  before do
+    expect(PerfectSched).to receive(:open).with(config).and_return(scheds)
+  end
+
+  describe '.new' do
+    it 'returns an Engine' do
+      engine = Engine.new(runner, config)
+      expect(engine).to be_an_instance_of(Engine)
+      expect(engine.instance_variable_get(:@runner)).to eq(runner)
+      expect(engine.instance_variable_get(:@poll_interval)).to eq(1.0)
+      expect(engine.instance_variable_get(:@log)).to eq(logger)
+      expect(engine.instance_variable_get(:@running_flag)).to be_a(BlockingFlag)
+      expect(engine.instance_variable_get(:@finish_flag)).to be_a(BlockingFlag)
+      expect(engine.instance_variable_get(:@scheds)).to be_a(PerfectSched)
+    end
+  end
+
+  describe '#run' do
+    it 'runs until stopped' do
+      rflag = engine.instance_variable_get(:@running_flag)
+      fflag = engine.instance_variable_get(:@finish_flag)
+      task1 = double('task1')
+      task2 = double('task2')
+      allow(scheds).to receive(:poll).and_return(task1, nil, task2)
+      expect(runner).to receive(:new).exactly(:twice) do |task|
+        expect(rflag.set?).to be true
+        r = double('r')
+        case task
+        when task1
+          expect(r).to receive(:run)
+        when task2
+          expect(r).to receive(:run){ fflag.set! }
+        else
+          raise ArgumentError
+        end
+        r
+      end
+      expect(engine.run).to eq(engine)
+      expect(rflag.set?).to be false
+    end
+  end
+
+  describe '#stop' do
+    it 'sets finish_flag' do
+      expect(engine.stop).to eq(engine)
+      expect(engine.instance_variable_get(:@finish_flag).set?).to eq true
+    end
+  end
+
+  describe '#join' do
+    it 'waits running flag is set' do
+      expect(engine.join).to eq(engine)
+      expect(engine.instance_variable_get(:@running_flag).set?).to eq false
+    end
+  end
+
+  describe '#close' do
+    it 'closes scheds' do
+      expect(scheds).to receive(:close)
+      expect(engine.close).to eq(engine)
+    end
+  end
+
+  describe '#shutdown' do
+    it 'calls stop, join, and close' do
+      expect(engine).to receive(:stop)
+      expect(engine).to receive(:join)
+      expect(engine).to receive(:close).and_return(engine)
+      expect(engine.shutdown).to eq(engine)
+    end
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe PerfectSched::Model do
+  let (:config){ double('config') }
+  let (:client){ double('client', config: config) }
+  let (:klass){ Class.new{include PerfectSched::Model} }
+  let (:model){ klass.new(client) }
+  describe '.new' do
+    it 'creates an instance' do
+      expect(model).to be_a(PerfectSched::Model)
+      expect(model.instance_variable_get(:@client)).to eq(client)
+    end
+  end
+  describe '#client' do
+    it 'returns its client' do
+      expect(model.client).to eq(client)
+    end
+  end
+  describe '#config' do
+    it 'returns its client.config' do
+      expect(model.config).to eq(client.config)
+    end
+  end
+end

data/spec/perfect_sched_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe PerfectSched do
+  describe '.open' do
+    let (:config){ double('config') }
+    let (:client){ double('client') }
+    let (:schedule_collection){ double('schedule_collection') }
+    before do
+      expect(Client).to receive(:new).with(config).and_return(client)
+      expect(ScheduleCollection).to receive(:new).with(client).and_return(schedule_collection)
+    end
+    it 'returns an instance without block' do
+      expect(client).not_to receive(:close)
+      expect(PerfectSched.open(config)).to eq(schedule_collection)
+    end
+    it 'yields block if given' do
+      ret = double('ret')
+      expect(client).to receive(:close)
+      r = PerfectSched.open(config) do |sc|
+        expect(sc).to eq(schedule_collection)
+        ret
+      end
+      expect(r).to eq(ret)
+    end
+  end
+
+  describe '.cron_time' do
+    it do
+      ts = PerfectSched.cron_time('0 * * * *', 1, nil)
+      expect(ts).to eq 3600
+    end
+    it do
+      expect{PerfectSched.cron_time('0 * * * *', 0, 'JST-9')}.to raise_error(ArgumentError)
+    end
+    it do
+      ts = PerfectSched.cron_time('0,30 * * * *', 1, nil)
+      expect(ts).to eq 1800
+    end
+    it do
+      ts = PerfectSched.cron_time('*/7 * * * *', 1, nil)
+      expect(ts).to eq 420
+    end
+    it 'supports @hourly' do
+      ts = PerfectSched.cron_time('@hourly', 1, nil)
+      expect(ts).to eq 3600
+    end
+    it 'supports @daily' do
+      ts = PerfectSched.cron_time('@daily', 1, nil)
+      expect(ts).to eq 86400
+    end
+    it 'supports @monthly' do
+      ts = PerfectSched.cron_time('@monthly', 1, nil)
+      expect(ts).to eq 2678400
+    end
+  end
+
+  describe '.next_time' do
+    it 'can run hourly cron' do
+      ts = PerfectSched.next_time(' 0 * * * * ', 0, nil)
+      expect(ts).to eq 3600
+    end
+    it 'calculates 4 years quickly' do
+      t = Time.utc(2012,2,29)
+      ts = PerfectSched.next_time('0 0 29 2 *', t.to_i, nil)
+      expect(ts).to eq(Time.utc(2016,2,29).to_i)
+    end
+    it 'raises error on unsupported timezone' do
+      expect{PerfectSched.next_time('0 * * * *', 0, 'JST-9')}.to raise_error(ArgumentError)
+    end
+    it 'returns next run time of given time' do
+      t0 = Time.new(2015, 12,  3,  1,  0,  0,  9*3600)
+      t1 = Time.new(2015, 12,  3,  2,  0,  0,  9*3600)
+      ts = PerfectSched.next_time('0 * * * *', t0.to_i, 'Asia/Tokyo')
+      expect(ts).to eq(t1.to_i)
+    end
+    it 'returns next run time of given time' do
+      t0 = Time.new(2015, 12,  3,  1, 59, 59,  9*3600)
+      t1 = Time.new(2015, 12,  3,  2,  0,  0,  9*3600)
+      ts = PerfectSched.next_time('0 * * * *', t0.to_i, 'Asia/Tokyo')
+      expect(ts).to eq(t1.to_i)
+    end
+    it 'returns next run time with day of week (0=Sun)' do
+      t0 = Time.new(2015, 12,  3,  0,  0,  0,  9*3600)
+      t1 = Time.new(2015, 12,  6,  0,  0,  0,  9*3600)
+      ts = PerfectSched.next_time('0 0 * * 0', t0.to_i, 'Asia/Tokyo')
+      expect(ts).to eq(t1.to_i)
+    end
+    context 'DST 2015' do
+      it 'skips task on 8 Mar because 1:59:59 PST -> 3:00:00 PDT' do
+        t0 = Time.new(2015,  3,  7,  2,  0,  0, -8*3600)
+        # 2015-03-08T02:00:00 doesn't exist
+        t1 = Time.new(2015,  3,  9,  2,  0,  0, -7*3600)
+        ts = PerfectSched.next_time('0 2 * * *', t0.to_i, 'America/Los_Angeles')
+        expect(ts).to eq(t1.to_i)
+      end
+      it 'runs twice on Nov 11 because 1:59:59 PDT -> 1:00:00 PST' do
+        # 2015-11-01T01:00:00 exists twice
+        t0 = Time.new(2015, 11,  1,  1,  0,  0, -7*3600)
+        t1 = Time.new(2015, 11,  1,  1,  0,  0, -8*3600)
+        ts = PerfectSched.next_time('0 1 * * *', t0.to_i, 'America/Los_Angeles')
+        expect(ts).to eq(t1.to_i)
+      end
+    end
+  end
+end

data/spec/rdb_compat_backend_spec.rb

@@ -2,40 +2,300 @@ require 'spec_helper'
 require 'perfectsched/backend/rdb_compat'
 
 describe Backend::RDBCompatBackend do
-  let :sc do
-    FileUtils.rm_f 'spec/test.db'
-    sc = PerfectSched.open({:type=>'rdb_compat', :url=>'sqlite://spec/test.db', :table=>'test_scheds'})
-    sc.client.init_database
-    sc
+  let (:now){ Time.now.to_i }
+  let (:client){ double('client') }
+  let (:config){ {url: 'sqlite://spec/test.db', table: 'test_scheds'} }
+  let (:db) do
+    d = Backend::RDBCompatBackend.new(client, config)
+    s = d.db
+    s.tables.each{|t| s.drop_table(t) }
+    d.init_database(nil)
+    d
   end
 
-  let :client do
-    sc.client
+  context 'compatibility' do
+    let :sc do
+      FileUtils.rm_f 'spec/test.db'
+      sc = PerfectSched.open({:type=>'rdb_compat', :url=>'sqlite://spec/test.db', :table=>'test_scheds'})
+      sc.client.init_database
+      sc
+    end
+
+    let :client do
+      sc.client
+    end
+
+    let :backend do
+      client.backend
+    end
+
+    it 'backward compatibility 1' do
+      backend.db["INSERT INTO test_scheds (id, timeout, next_time, cron, delay, data, timezone) VALUES (?, ?, ?, ?, ?, ?, ?)", "maint_sched.1.do_hourly", 1339812000, 1339812000, "0 * * * *", 0, {"account_id"=>1}.to_json, "UTC"].insert
+      ts = backend.acquire(60, 1, {:now=>1339812003})
+      expect(ts).not_to eq(nil)
+      t = ts[0]
+      expect(t.data).to eq({'account_id'=>1})
+      expect(t.type).to eq('maint_sched')
+      expect(t.key).to eq('maint_sched.1.do_hourly')
+      expect(t.next_time).to eq(1339812000)
+    end
+
+    it 'backward compatibility 2' do
+      backend.db["INSERT INTO test_scheds (id, timeout, next_time, cron, delay, data, timezone) VALUES (?, ?, ?, ?, ?, ?, ?)", "merge", 1339812060, 1339812000, "@hourly", 60, '', "Asia/Tokyo"].insert
+      ts = backend.acquire(60, 1, {:now=>1339812060})
+      t = ts[0]
+      expect(t.data).to eq({})
+      expect(t.type).to eq('merge')
+      expect(t.key).to eq('merge')
+      expect(t.next_time).to eq(1339812000)
+    end
   end
 
-  let :backend do
-    client.backend
+  context '.new' do
+    let (:client){ double('client') }
+    let (:table){ double('table') }
+    it 'raises error unless url' do
+      expect{Backend::RDBCompatBackend.new(client, {})}.to raise_error(ConfigError)
+    end
+    it 'raises error unless table' do
+      expect{Backend::RDBCompatBackend.new(client, {url: ''})}.to raise_error(ConfigError)
+    end
+    it 'supports sqlite' do
+      config = {url: 'sqlite://localhost', table: table}
+      expect(Backend::RDBCompatBackend.new(client, config)).to be_an_instance_of(Backend::RDBCompatBackend)
+    end
+    it 'supports mysql' do
+      config = {url: 'mysql://root:@localhost/perfectsched_test', table: table}
+      expect(Backend::RDBCompatBackend.new(client, config)).to be_an_instance_of(Backend::RDBCompatBackend)
+    end
+    it 'doesn\'t support postgres' do
+      config = {url: 'postgres://localhost', table: table}
+      expect{Backend::RDBCompatBackend.new(client, config)}.to raise_error(ConfigError)
+    end
   end
 
-  it 'backward compatibility 1' do
-    backend.db["INSERT INTO test_scheds (id, timeout, next_time, cron, delay, data, timezone) VALUES (?, ?, ?, ?, ?, ?, ?)", "maint_sched.1.do_hourly", 1339812000, 1339812000, "0 * * * *", 0, {"account_id"=>1}.to_json, "UTC"].insert
-    ts = backend.acquire(60, 1, {:now=>1339812003})
-    ts.should_not == nil
-    t = ts[0]
-    t.data.should == {'account_id'=>1}
-    t.type.should == 'maint_sched'
-    t.key.should == 'maint_sched.1.do_hourly'
-    t.next_time.should == 1339812000
+  context '#init_database' do
+    it 'creates the table' do
+      db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+    end
   end
 
-  it 'backward compatibility 2' do
-    backend.db["INSERT INTO test_scheds (id, timeout, next_time, cron, delay, data, timezone) VALUES (?, ?, ?, ?, ?, ?, ?)", "merge", 1339812060, 1339812000, "@hourly", 60, '', "Asia/Tokyo"].insert
-    ts = backend.acquire(60, 1, {:now=>1339812060})
-    t = ts[0]
-    t.data.should == {}
-    t.type.should == 'merge'
-    t.key.should == 'merge'
-    t.next_time.should == 1339812000
+  context '#get_schedule_metadata' do
+    before do
+      db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+    end
+    it 'fetches a metadata' do
+      expect(db.get_schedule_metadata('key')).to be_an_instance_of(ScheduleWithMetadata)
+    end
+    it 'raises error if non exist key' do
+      expect{db.get_schedule_metadata('nonexistent')}.to raise_error(NotFoundError)
+    end
+  end
+
+  context '#list' do
+    before do
+      db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+    end
+    it 'lists a metadata' do
+      db.list(nil) do |x|
+        expect(x).to be_an_instance_of(PerfectSched::ScheduleWithMetadata)
+        expect(x.key).to eq('key')
+      end
+    end
+  end
+
+  context '#add' do
+    it 'adds schedules' do
+      db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+      expect{db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})}.to raise_error(IdempotentAlreadyExistsError)
+    end
   end
-end
 
+  context '#delete' do
+    before do
+      db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+    end
+    it 'deletes schedules' do
+      db.delete('key', nil)
+      expect{db.delete('key', nil)}.to raise_error(IdempotentNotFoundError)
+    end
+  end
+
+  context '#modify' do
+    before do
+      db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+    end
+    it 'returns nil if no keys' do
+      expect(db.modify('key', {})).to be_nil
+    end
+    it 'modifies schedules' do
+      db.modify('key', {delay: 1})
+    end
+    it 'raises if nonexistent' do
+      expect{db.modify('nonexistent', {delay: 0})}.to raise_error(NotFoundError)
+    end
+  end
+
+  context '#acquire' do
+    context 'no tasks' do
+      it 'returns nil' do
+        expect(db.acquire(0, nil, {})).to be_nil
+      end
+    end
+    context 'some tasks' do
+      before do
+        db.add('key1', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+      end
+      it 'returns a task' do
+        ary = db.acquire(0, nil, {})
+        expect(ary).to be_an_instance_of(Array)
+        expect(ary[0]).to be_an_instance_of(Task)
+      end
+    end
+    context 'some tasks but conflict with another process' do
+      before do
+        db.add('key1', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+        db.add('key2', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+        db.add('key3', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, now, now, {})
+      end
+      it 'returns nil' do
+        data_set = double('data_set', update: 0)
+        allow(db.db).to receive(:[]).and_return(data_set)
+        expect(db.acquire(0, nil, {})).to be_nil
+      end
+    end
+  end
+
+  context '#heartbeat' do
+    let (:next_time){ now }
+    let (:task_token){ Backend::RDBCompatBackend::Token.new('key', next_time, '* * * * *', 0, 'Asia/Tokyo') }
+    context 'have a scheduled task' do
+      before do
+        db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, next_time, next_time, {})
+      end
+      it 'returns nil if next_run_time is not updated' do
+        expect(db.heartbeat(task_token, 0, {now: next_time})).to be_nil
+      end
+      it 'returns nil even if next_run_time is updated' do
+        expect(db.heartbeat(task_token, 1, {})).to be_nil
+      end
+    end
+    context 'no tasks' do
+      it 'raises PreemptedError' do
+        expect{db.heartbeat(task_token, 0, {})}.to raise_error(PreemptedError)
+      end
+    end
+  end
+
+  context '#finish' do
+    let (:next_time){ now }
+    let (:task_token){ Backend::RDBCompatBackend::Token.new('key', next_time, '* * * * *', 0, 'Asia/Tokyo') }
+    context 'have the task' do
+      before do
+        db.add('key', 'test', '* * * * *', 0, 'Asia/Tokyo', {}, next_time, next_time, {})
+      end
+      it 'returns nil' do
+        expect(db.finish(task_token, nil)).to be_nil
+      end
+    end
+    context 'already finished' do
+      it 'raises IdempotentAlreadyFinishedError' do
+        expect{db.finish(task_token, nil)}.to raise_error(IdempotentAlreadyFinishedError)
+      end
+    end
+  end
+
+  context '#connect' do
+    context 'normal' do
+      let (:ret){ double('ret') }
+      it 'returns block result' do
+        expect(db.__send__(:connect){ ret }).to eq(ret)
+      end
+    end
+    context 'error' do
+      it 'returns block result' do
+        expect(RuntimeError).to receive(:new).exactly(Backend::RDBCompatBackend::MAX_RETRY).and_call_original
+        allow(STDERR).to receive(:puts)
+        allow(db).to receive(:sleep)
+        expect do
+          db.__send__(:connect) do
+            raise RuntimeError.new('try restarting transaction')
+          end
+        end.to raise_error(RuntimeError)
+      end
+    end
+  end
+
+  context '#create_attributes' do
+    let (:data){ Hash.new }
+    let (:row) do
+      r = double('row')
+      allow(r).to receive(:[]){|k| data[k] }
+      r
+    end
+    it 'returns a hash consisting the data of the row' do
+      data[:timezone] = timezone = double('timezone')
+      data[:delay] = delay = double('delay')
+      data[:cron] = cron = double('cron')
+      data[:next_time] = next_time = double('next_time')
+      data[:timeout] = timeout = double('timeout')
+      data[:data] = '{"type":"foo.bar","a":"b"}'
+      data[:id] = 'hoge'
+      expect(db.__send__(:create_attributes, row)).to eq(
+        timezone: timezone,
+        delay: delay,
+        cron: cron,
+        data: {"a"=>"b"},
+        next_time: next_time,
+        next_run_time: timeout,
+        type: 'foo.bar',
+        message: nil,
+        node: nil,
+      )
+    end
+    it 'returns {} if data\'s JSON is broken' do
+      data[:data] = '}{'
+      data[:id] = 'foo.bar.baz'
+      expect(db.__send__(:create_attributes, row)).to eq(
+        timezone: 'UTC',
+        delay: 0,
+        cron: nil,
+        data: {},
+        next_time: nil,
+        next_run_time: nil,
+        type: 'foo',
+        message: nil,
+        node: nil,
+      )
+    end
+    it 'uses id[/\A[^.]*/] if type is empty string' do
+      data[:data] = '{"type":""}'
+      data[:id] = 'foo.bar.baz'
+      expect(db.__send__(:create_attributes, row)).to eq(
+        timezone: 'UTC',
+        delay: 0,
+        cron: nil,
+        data: {},
+        next_time: nil,
+        next_run_time: nil,
+        type: 'foo',
+        message: nil,
+        node: nil,
+      )
+    end
+    it 'uses id[/\A[^.]*/] if type is nil' do
+      data[:id] = 'foo.bar.baz'
+      expect(db.__send__(:create_attributes, row)).to eq(
+        timezone: 'UTC',
+        delay: 0,
+        cron: nil,
+        data: {},
+        next_time: nil,
+        next_run_time: nil,
+        type: 'foo',
+        message: nil,
+        node: nil,
+      )
+    end
+  end
+end