sidejob 3.0.0

data/spec/sidejob/port_spec.rb

@@ -0,0 +1,452 @@
+require 'spec_helper'
+
+describe SideJob::Port do
+  before do
+    @job = SideJob.queue('testq', 'TestWorker', inports: {
+        port1: {},
+        memory: { mode: :memory },
+        default: { default: 'default' },
+        default_null: { default: nil },
+        default_false: { default: false},
+        memory_with_default: { mode: :memory, default: 'memory default' },
+    }, outports: {
+        out1: {},
+    })
+    @port1 = @job.input(:port1)
+    @out1 = @job.output(:out1)
+    @memory = @job.input(:memory)
+    @default = @job.input(:default)
+    @defaults = [
+        @default,
+        @job.input(:default_null),
+        @job.input(:default_false),
+        @job.input(:memory_with_default)
+    ]
+  end
+
+  describe '#initialize' do
+    it 'raises error if name is invalid' do
+      expect { SideJob::Port.new(@job, :in, 'PORT.1')}.to raise_error
+    end
+
+    it 'raises error if name is empty' do
+      expect { SideJob::Port.new(@job, :in, '')}.to raise_error
+    end
+  end
+
+  describe '#==, #eql?' do
+    it 'two ports with the same job, type, and name are eq' do
+      expect(SideJob::Port.new(@job, :in, :port1)).to eq(@port1)
+      expect(SideJob::Port.new(@job, :in, 'port1')).to eq(@port1)
+      expect(SideJob::Port.new(@job, :in, 'port1')).to eql(@port1)
+    end
+
+    it 'two ports with different names are not eq' do
+      expect(SideJob::Port.new(@job, :in, 'port2')).not_to eq(@port1)
+      expect(SideJob::Port.new(@job, :in, 'port2')).not_to eql(@port1)
+    end
+
+    it 'port names are case sensitive' do
+      expect(SideJob::Port.new(@job, :in, 'PORT1')).not_to eq(@port1)
+      expect(SideJob::Port.new(@job, :in, 'PORT1')).not_to eql(@port1)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the redis key' do
+      expect(SideJob::Port.new(@job, :in, :port1).to_s).to eq "job:#{@job.id}:in:port1"
+    end
+  end
+
+  describe '#options' do
+    it 'returns port options' do
+      expect(@port1.options).to eq({mode: :queue})
+      expect(@memory.options).to eq({mode: :memory})
+      expect(@default.options).to eq({mode: :queue, default: 'default'})
+    end
+  end
+
+  describe '#options=' do
+    it 'can change mode to memory' do
+      expect(@port1.mode).to eq :queue
+      @port1.options = { mode: :memory }
+      expect(@port1.mode).to eq :memory
+    end
+
+    it 'can change mode to queue' do
+      expect(@memory.mode).to eq :memory
+      @memory.options = { mode: :queue }
+      expect(@memory.mode).to eq :queue
+    end
+
+    it 'can set default value' do
+      expect(@port1.default?).to be false
+      @port1.options = { default: [1,2] }
+      expect(@port1.default).to eq [1,2]
+      expect(@port1.read).to eq [1,2]
+    end
+
+    it 'can remove default value' do
+      expect(@default.default?).to be true
+      @default.options = { }
+      expect(@default.default?).to be false
+    end
+  end
+
+  describe '#mode' do
+    it 'returns nil for non-existent ports' do
+      expect(SideJob::Port.new(@job, :in, 'missing').mode).to be nil
+    end
+
+    it 'returns the port mode for queue ports' do
+      expect(@port1.mode).to eq :queue
+      expect(@default.mode).to eq :queue
+    end
+
+    it 'returns the port mode for memory ports' do
+      expect(@memory.mode).to eq :memory
+      expect(@job.input(:memory_with_default).mode).to eq :memory
+    end
+  end
+
+  describe '#size' do
+    it 'returns 0 when the port is empty' do
+      expect(@port1.size).to eq 0
+    end
+
+    it 'number of elements is increased on write' do
+      expect {
+        @port1.write 1
+      }.to change(@port1, :size).by(1)
+    end
+
+    it 'number of elements is decreased on read' do
+      @port1.write 1
+      expect {
+        @port1.read
+      }.to change(@port1, :size).by(-1)
+    end
+
+    it 'returns 0 if there is default value' do
+      @defaults.each {|port| expect(port.size).to eq 0 }
+    end
+  end
+
+  describe '#data?' do
+    it 'returns false when the port is empty' do
+      expect(@port1.data?).to be false
+    end
+
+    it 'returns true when the port has data' do
+      @port1.write 1
+      expect(@port1.data?).to be true
+    end
+
+    it 'works for memory ports' do
+      expect(@memory.data?).to be false
+      @memory.write 1
+      expect(@memory.data?).to be true
+    end
+
+    it 'works when there is a default value on the port' do
+      @defaults.each {|port| expect(port.data?).to be true }
+    end
+  end
+
+  describe '#default' do
+    it 'returns nil for no default' do
+      expect(@port1.default).to be nil
+    end
+
+    it 'returns default value' do
+      @port1.options = {default: [1,2]}
+      expect(@port1.default).to eq [1,2]
+    end
+
+    it 'can return null default value' do
+      @port1.options = {default: nil}
+      expect(@port1.default).to be nil
+      expect(@port1.default?).to be true
+    end
+  end
+
+  describe '#default?' do
+    it 'returns false for normal port' do
+      expect(@port1.default?).to be false
+    end
+
+    it 'returns false for memory port with no data written' do
+      expect(@memory.default?).to be false
+    end
+
+    it 'returns true for memory port after writing data' do
+      @memory.write 1
+      expect(@memory.default?).to be true
+    end
+
+    it 'returns true for port with default value' do
+      @defaults.each {|port| expect(port.default?).to be true }
+    end
+  end
+
+  describe '#write' do
+    it 'can write different types of data to a port' do
+      ['abc', 123, true, false, nil, {abc: 123}, [1, {foo: true}]].each {|x| @port1.write x}
+      data = SideJob.redis.lrange(@port1.redis_key, 0, -1)
+      expect(data).to eq(['"abc"', '123', 'true', 'false', 'null', '{"abc":123}', '[1,{"foo":true}]'])
+    end
+
+    it 'writing to a memory port should only set default value to latest value' do
+      @memory.write 'abc'
+      @memory.write [1, {foo: true}]
+      @memory.write 'latest'
+      expect(@memory.size).to eq 0
+      expect(@memory.default).to eq 'latest'
+    end
+
+    it 'logs writes' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      @job.group_port_logs do
+        @port1.write 'abc'
+        @port1.write 123
+      end
+      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp, 'job' => @job.id, 'read' => [],
+                                   'write' => ['job' => @job.id, 'inport' => 'port1', 'data' => ['abc', 123]]}]
+    end
+
+    it 'raises error if port does not exist' do
+      expect { SideJob::Port.new(@job, :in, 'foo').write true }.to raise_error
+    end
+
+    it 'raises error if port mode is unknown ' do
+      SideJob.redis.hset "#{@job.redis_key}:inports:mode", 'foo', '???'
+      expect { SideJob::Port.new(@job, :in, 'foo').write true }.to raise_error
+    end
+
+    it 'runs the job if it is an input port' do
+      expect(@port1.job).to receive(:run)
+      @port1.write 3
+    end
+
+    it 'does not run the job if it is an output port' do
+      expect(@out1.job).not_to receive(:run)
+      @out1.write 3
+    end
+
+    it 'does not run the job if it is a memory port' do
+      expect(@memory.job).not_to receive(:run)
+      @memory.write 3
+    end
+  end
+
+  describe '#read' do
+    it 'can distinguish reading nil data and no data' do
+      expect { @port1.read }.to raise_error(EOFError)
+      @port1.write nil
+      expect(@port1.read).to be nil
+    end
+
+    it 'can read data from a queue port' do
+      expect { @port1.read }.to raise_error(EOFError)
+      ['abc', 123, true, false, nil, {}, ['data1', 1, {key: 'val'}]].each {|x| @port1.write x}
+      expect(@port1.size).to be(7)
+      expect(@port1.read).to eq('abc')
+      expect(@port1.read).to eq(123)
+      expect(@port1.read).to eq(true)
+      expect(@port1.read).to eq(false)
+      expect(@port1.read).to eq(nil)
+      expect(@port1.read).to eq({})
+      expect(@port1.read).to eq(['data1', 1, {'key' => 'val'}])
+      expect { @port1.read }.to raise_error(EOFError)
+      expect(@port1.size).to be(0)
+    end
+
+    it 'can read data from a memory port' do
+      expect { @memory.read }.to raise_error(EOFError)
+      5.times {|i| @memory.write i }
+      3.times { expect(@memory.read).to eq(4) }
+    end
+
+    it 'can use default value' do
+      @defaults.each do |port|
+        3.times { expect(port.read).to eq port.default }
+        port.write 'mydata'
+        expect(port.read).to eq 'mydata'
+        3.times { expect(port.read).to eq port.mode == :memory ? 'mydata' : port.default }
+      end
+    end
+
+    it 'can use null default value' do
+      port = @job.input(:default_null)
+      expect(port.read).to eq nil
+    end
+
+    it 'can use false default value' do
+      port = @job.input(:default_false)
+      expect(port.read).to be false
+    end
+
+    it 'logs reads' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      ['abc', 123].each {|x| @port1.write x}
+      SideJob.logs
+      @job.group_port_logs do
+        expect(@port1.read).to eq('abc')
+        expect(@port1.read).to eq(123)
+      end
+      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp, 'job' => @job.id,
+                                   'read' => ['job' => @job.id, 'inport' => 'port1', 'data' => ['abc', 123]],
+                                   'write' => []}]
+    end
+  end
+
+  describe '#connect_to' do
+    it 'does nothing on an empty port' do
+      expect(@out1.connect_to(@port1)).to eq []
+      expect(@port1.data?).to be false
+    end
+
+    it 'sends data to a port' do
+      @out1.write 1
+      @out1.write [2,3]
+      expect(@out1.connect_to(@port1)).to eq [1, [2,3]]
+      expect(@out1.data?).to be false
+      expect(@port1.read).to eq 1
+      expect(@port1.read).to eq [2,3]
+      expect(@port1.data?).to be false
+    end
+
+    it 'sends data to all destination ports' do
+      dest = [@port1, @memory, @default]
+      @out1.write 1
+      @out1.write [2,3]
+      @out1.connect_to dest
+      expect(@port1.read).to eq 1
+      expect(@port1.read).to eq [2,3]
+      expect(@port1.data?).to be false
+      expect(@memory.size).to eq 0
+      expect(@memory.read).to eq [2,3]
+      expect(@default.read).to eq 1
+      expect(@default.read).to eq [2,3]
+      expect(@default.read).to eq 'default'
+    end
+
+    it 'passes port default values to all destinations' do
+      dest = [@port1, @memory, @out1]
+      @default.write 1
+      @default.write [2,3]
+      @default.connect_to dest
+      expect(@port1.read).to eq 1
+      expect(@port1.read).to eq [2,3]
+      expect(@port1.default).to eq 'default'
+      expect(@memory.size).to eq 0
+      expect(@memory.default).to eq 'default'
+      expect(@out1.read).to eq 1
+      expect(@out1.read).to eq [2,3]
+      expect(@out1.default).to eq 'default'
+    end
+
+    it 'runs job for normal input port' do
+      expect(@port1.job).to receive(:run)
+      @out1.write true
+      @out1.connect_to @port1
+    end
+
+    it 'does not run job if no data sent' do
+      expect(@port1.job).not_to receive(:run)
+      @out1.connect_to @port1
+    end
+
+    it 'does not run job for memory port' do
+      expect(@memory.job).not_to receive(:run)
+      @out1.write true
+      @out1.connect_to @memory
+    end
+
+    it 'logs data' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      @out1.write 1
+      @out1.write [2,3]
+      SideJob.logs(clear: true)
+      @out1.connect_to(@port1)
+      expect(SideJob.logs).to eq([{'timestamp' => SideJob.timestamp,
+                                   'read' => [{'job' => @job.id, 'outport' => 'out1', 'data' => [1,[2,3]]}],
+                                   'write' => [{'job' => @job.id, 'inport' => 'port1', 'data' => [1,[2,3]]}] }])
+    end
+
+    it 'can specify additional metadata to add to log' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      job2 = SideJob.queue('testq', 'TestWorker')
+      @out1.write 1
+      @out1.write [2,3]
+      SideJob.logs(clear: true)
+      @out1.connect_to(@port1, user: 'test')
+      expect(SideJob.logs).to eq([{'timestamp' => SideJob.timestamp, 'user' => 'test',
+                                   'read' => [{'job' => @job.id, 'outport' => 'out1', 'data' => [1,[2,3]]}],
+                                   'write' => [{'job' => @job.id, 'inport' => 'port1', 'data' => [1,[2,3]]}] }])
+    end
+
+    it 'does not log if no data on port' do
+      job2 = SideJob.queue('testq', 'TestWorker')
+      @out1.connect_to(@port1)
+      expect(SideJob.logs).to eq([])
+    end
+  end
+
+  describe 'is Enumerable' do
+    it 'can iterate over port elements' do
+      10.times {|i| @port1.write i}
+      num = 0
+      @port1.each_with_index do |elem, i|
+        expect(elem).to eq i
+        num += 1
+      end
+      expect(num).to eq 10
+    end
+
+    it '#entries returns all data as an array' do
+      expect(@port1.entries).to eq []
+      10.times {|i| @port1.write i}
+      expect(@port1.entries).to eq Array(0..9)
+      expect(@port1.entries).to eq []
+    end
+
+    it 'default values are not returned' do
+      @defaults.each do |port|
+        expect(port.entries).to eq []
+        port.write 'mydata'
+        if port.mode == :memory
+          expect(port.entries).to eq []
+        else
+          expect(port.entries).to eq ['mydata']
+        end
+      end
+    end
+  end
+
+  describe '#redis_key' do
+    it 'returns key with valid name' do
+      expect(@port1.redis_key).to eq("#{@port1.job.redis_key}:in:port1")
+    end
+  end
+
+  describe '#hash' do
+    it 'uses hash of the redis key' do
+      expect(@port1.hash).to eq(@port1.redis_key.hash)
+    end
+
+    it 'can be used as keys in a hash' do
+      h = {}
+      h[@port1] = 1
+      port2 = SideJob::Port.new(@job, :in, 'port1')
+      expect(@port1.hash).to eq(port2.hash)
+      h[port2] = 3
+      expect(h.keys.length).to be(1)
+      expect(h[@port1]).to be(3)
+    end
+  end
+end

data/spec/sidejob/server_middleware_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper'
+
+describe SideJob::ServerMiddleware do
+  class TestWorkerShutdown
+    include SideJob::Worker
+    register
+    attr_accessor :shutdown_called
+    def shutdown
+      @shutdown_called = true
+    end
+    def perform
+    end
+  end
+
+  class TestWorkerShutdownError
+    include SideJob::Worker
+    register
+    def shutdown
+      raise 'shutdown error'
+    end
+    def perform
+    end
+  end
+
+  before do
+    @queue = 'testq'
+    @job = SideJob.queue(@queue, 'TestWorker')
+  end
+
+  def process(job)
+    chain = Sidekiq::Middleware::Chain.new
+    chain.add SideJob::ServerMiddleware
+    msg = Sidekiq::Queue.new(@queue).find_job(job.id)
+    worker = msg.klass.constantize.new
+    worker.jid = job.id
+    chain.invoke(worker, msg, @queue) { yield worker }
+    job.reload
+    worker
+  end
+
+  %w{running suspended completed failed terminated}.each do |status|
+    it "does not run if status is #{status}" do
+      @job.status = status
+      @run = false
+      process(@job) { @run = true}
+      expect(@run).to be false
+      expect(@job.status).to eq status
+    end
+  end
+
+  it 'does not run if job has been deleted' do
+    @job.status = 'terminated'
+    @job.delete
+    @run = false
+    process(@job) { @run = true}
+    expect(@run).to be false
+  end
+
+  describe 'handles a normal run' do
+    it 'sets status to running on start and completed on completion' do
+      process(@job) { |worker| @status = worker.status }
+      expect(@status).to eq 'running'
+      expect(@job.status).to eq 'completed'
+    end
+
+    it 'runs the parent job' do
+      @job.status = 'suspended'
+      child = SideJob.queue(@queue, 'TestWorker', parent: @job, name: 'child')
+      expect(@job.status).to eq 'suspended'
+      expect {
+        child.run_inline
+      }.to change {Sidekiq::Stats.new.enqueued}.by(1)
+      @job.reload
+      expect(@job.status).to eq 'queued'
+    end
+
+    it 'sets the ran_at time at the beginning of the run' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      process(@job) { |worker| @ran_at = worker.get(:ran_at) }
+      expect(@ran_at).to eq SideJob.timestamp
+      expect(@job.status).to eq 'completed'
+    end
+  end
+
+  describe 'prevents multiple threads running the same job' do
+    it 'sets the job lock to the current time' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      process(@job) { @lock = SideJob.redis.get("#{@job.redis_key}:lock").to_f }
+      expect(@lock).to eq(now.to_f)
+      expect(SideJob.redis.exists("#{@job.redis_key}:lock")).to be false
+    end
+
+    it 'sets the job lock to the current time and does not run if already locked' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      @run = false
+      SideJob.redis.set "#{@job.redis_key}:lock", (now-10).to_f
+      process(@job) { @run = true }
+      expect(@run).to be false
+      expect(SideJob.redis.get("#{@job.redis_key}:lock").to_f).to eq now.to_f
+    end
+
+    it 'does not do anything if the enqueued_at time is before the ran_at' do
+      process(@job) {|worker| worker.set ran_at: SideJob.timestamp}
+      @run = false
+      process(@job) {@run = true}
+      expect(@run).to be false
+    end
+
+    it 'does not restart the worker unless another worker was locked out during the run' do
+      expect {
+        process(@job) {}
+      }.to change {Sidekiq::Stats.new.enqueued}.by(0)
+      expect(@job.status).to eq 'completed'
+    end
+
+    it 'restarts the worker if another worker was locked out during the run' do
+      expect {
+        process(@job) { SideJob.redis.set "#{@job.redis_key}:lock", Time.now.to_f }
+      }.to change {Sidekiq::Stats.new.enqueued}.by(1)
+      expect(@job.status).to eq 'queued'
+    end
+  end
+
+  describe 'prevents job loops' do
+    it 'does not run if called too many times in a minute' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      key = "#{@job.redis_key}:rate:#{Time.now.to_i/60}"
+      SideJob.redis.set key, SideJob::ServerMiddleware::CONFIGURATION[:max_runs_per_minute]
+      @run = false
+      process(@job) { @run = true }
+      expect(@run).to be false
+      expect(@job.status).to eq 'terminated'
+    end
+
+    it 'does run if not called too many times in a minute' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      key = "#{@job.redis_key}:rate:#{Time.now.to_i/60}"
+      SideJob.redis.set key, SideJob::ServerMiddleware::CONFIGURATION[:max_runs_per_minute]-1
+      @run = false
+      process(@job) { @run = true }
+      expect(@run).to be true
+      expect(@job.status).to eq 'completed'
+    end
+
+    it 'does not run if job is too deep' do
+      (SideJob::ServerMiddleware::CONFIGURATION[:max_depth]+1).times do |i|
+        @job = SideJob.queue(@queue, 'TestWorker', parent: @job, name: 'child')
+      end
+      @run = false
+      process(@job) { @run = true }
+      expect(@run).to be false
+      expect(@job.status).to eq 'terminated'
+    end
+
+    it 'does run if job is not too deep' do
+      SideJob::ServerMiddleware::CONFIGURATION[:max_depth].times do |i|
+        @job = SideJob.queue(@queue, 'TestWorker', parent: @job, name: 'child')
+      end
+      @run = false
+      process(@job) { @run = true }
+      expect(@run).to be true
+      expect(@job.status).to eq 'completed'
+    end
+  end
+
+  describe 'handles worker exceptions' do
+    it 'sets status to failed on exception and logs error' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      process(@job) { raise 'oops' }
+      expect(@job.status).to eq 'failed'
+
+      log = SideJob.logs.select {|log| log['error'] }
+      expect(log.size).to eq(1)
+      expect(log[0]['job']).to eq @job.id
+      expect(log[0]['error']).to eq('oops')
+      # check that we trim down backtrace to remove sidekiq lines
+      expect(log[0]['backtrace']).to_not match(/sidekiq/)
+    end
+
+    it 'does not set status to failed if status is not running' do
+      process(@job) do |worker|
+        worker.run
+        raise 'oops'
+      end
+      expect(@job.status).to eq 'queued'
+    end
+
+    it 'runs the parent job' do
+      @job.status = 'suspended'
+      child = SideJob.queue(@queue, 'TestWorker', parent: @job, name: 'child')
+      expect {
+        process(child) { raise 'oops' }
+      }.to change {Sidekiq::Stats.new.enqueued}.by(1)
+      @job.reload
+      expect(@job.status).to eq 'queued'
+    end
+  end
+
+  describe 'handles worker suspend' do
+    it 'sets status to suspended' do
+      process(@job) { |worker| worker.suspend }
+      expect(@job.status).to eq 'suspended'
+    end
+
+    it 'does not set status to suspended if job was requeued' do
+      process(@job) do |worker|
+        worker.run
+        worker.suspend
+      end
+      expect(@job.status).to eq 'queued'
+    end
+  end
+
+  describe 'handles job termination' do
+    it 'sets status to terminated upon run' do
+      @job.status = 'terminating'
+      process(@job) { raise 'should not be called' }
+      expect(@job.status).to eq 'terminated'
+      errors = SideJob.logs.select {|log| log['type'] == 'error'}
+      expect(errors.size).to eq 0
+    end
+
+    it 'runs parent' do
+      child = SideJob.queue(@queue, 'TestWorker', parent: @job, name: 'child')
+      child.status = 'terminating'
+      process(child) { raise 'should not be called' }
+      expect(child.status).to eq 'terminated'
+      expect(@job.status).to eq 'queued'
+    end
+
+    it 'calls worker shutdown method' do
+      @job = SideJob.queue(@queue, 'TestWorkerShutdown')
+      @job.status = 'terminating'
+      worker = process(@job) { raise 'not reached' }
+      expect(worker.shutdown_called).to be true
+    end
+
+    it 'logs but ignores exceptions thrown during shutdown' do
+      @job = SideJob.queue(@queue, 'TestWorkerShutdownError')
+      @job.status = 'terminating'
+      worker = process(@job) { raise 'not reached' }
+      logs = SideJob.logs.select {|log| log['error']}
+      expect(logs.size).to eq 1
+      expect(logs[0]['job']).to eq @job.id
+      expect(logs[0]['error']).to eq 'shutdown error'
+    end
+  end
+end