sidejob 4.0.2 → 4.1.0

data/spec/sidejob/port_spec.rb

@@ -119,8 +119,8 @@ describe SideJob::Port do
 
     it 'can return null default value' do
       @port1.default = nil
-      expect(@port1.default).to be nil
-      expect(@port1.default?).to be true
+      expect(@port1.default).to eq nil
+      expect(@port1.default?).to eq true
     end
   end
 
@@ -150,22 +150,65 @@ describe SideJob::Port do
     end
   end
 
+  describe '#channels, #channels=' do
+    before do
+      @channels = ['abc123', 'def456']
+    end
+
+    it 'can set and return channels for inport' do
+      expect(@port1.channels).to eq []
+      @channels.each do |ch|
+        expect(SideJob.redis.smembers("channel:#{ch}")).to eq []
+      end
+      @port1.channels = @channels
+      expect(@port1.channels).to match_array(@channels)
+      @channels.each do |ch|
+        expect(SideJob.redis.smembers("channel:#{ch}")).to eq [@port1.job.id.to_s]
+      end
+      @port1.channels = []
+      expect(@port1.channels).to eq []
+      @channels.each do |ch|
+        # We don't remove old jobs until we publish to the channel
+        expect(SideJob.redis.smembers("channel:#{ch}")).to eq [@port1.job.id.to_s]
+      end
+    end
+
+    it 'can set and return channels for outport' do
+      expect(@out1.channels).to eq []
+      @out1.channels = @channels
+      @channels.each do |ch|
+        expect(SideJob.redis.smembers("channel:#{ch}")).to eq []
+      end
+      expect(@out1.channels).to match_array(@channels)
+      @channels.each do |ch|
+        expect(SideJob.redis.smembers("channel:#{ch}")).to eq []
+      end
+      @out1.channels = []
+      expect(@out1.channels).to eq []
+    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}]'])
+      data = ['abc', 123, true, false, nil, {'abc' => 123}, [1, {'foo' => true}]]
+      data.each {|x| @port1.write x}
+      expect(@port1.entries).to eq(data)
     end
 
     it 'logs writes' do
-      now = Time.now
-      allow(Time).to receive(:now) { now }
-      SideJob::Port.log_group do
+      expect(SideJob).to receive(:log).with({read: [], write: [{job: @port1.job.id, inport: :port1, data: ['abc', 123]}]})
+      SideJob::Port.group do
         @port1.write 'abc'
         @port1.write 123
       end
-      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp, 'read' => [],
-                                   'write' => ['job' => @job.id, 'inport' => 'port1', 'data' => ['abc', 123]]}]
+    end
+
+    it 'can disable logging for both reading and writing' do
+      expect(SideJob).not_to receive(:log)
+      SideJob::Port.group(log: false) do
+        @port1.write 'abc'
+      end
+      expect(@port1.read).to eq 'abc'
     end
 
     it 'raises error if port does not exist' do
@@ -191,6 +234,34 @@ describe SideJob::Port do
       expect(@job.status).to eq 'completed'
       expect(parent.status).to eq 'queued'
     end
+
+    it 'can disable running job' do
+      parent = SideJob.queue('testq', 'TestWorker')
+      parent.adopt(@job, 'child')
+      parent.status = 'completed'
+      @job.status = 'completed'
+      SideJob::Port.group(notify: false) do
+        @port1.write 3
+        @out1.write 3
+      end
+      expect(@job.status).to eq 'completed'
+      expect(parent.status).to eq 'completed'
+    end
+
+    it 'publishes writes to associated output port channel' do
+      data = {'abc' => [1,2]}
+      @out1.channels = ['mychannel']
+      expect(SideJob).to receive(:publish).with('mychannel', data)
+      expect(SideJob).to receive(:publish)
+      @out1.write data
+    end
+
+    it 'does not publish writes to associated input port channel' do
+      data = {'abc' => [1,2]}
+      @port1.channels = ['mychannel']
+      expect(SideJob).not_to receive(:publish).with('mychannel', data)
+      @port1.write data
+    end
   end
 
   describe '#read' do
@@ -225,21 +296,25 @@ describe SideJob::Port do
 
     it 'can use false default value' do
       port = @job.input(:default_false)
-      expect(port.read).to be false
+      expect(port.read).to eq false
     end
 
     it 'logs reads' do
-      now = Time.now
-      allow(Time).to receive(:now) { now }
       ['abc', 123].each {|x| @port1.write x}
-      SideJob.logs
-      SideJob::Port.log_group do
+      expect(SideJob).to receive(:log).with({read: [{job: @port1.job.id, inport: :port1, data: ['abc', 123]}], write: []})
+      SideJob::Port.group do
+        expect(@port1.read).to eq('abc')
+        expect(@port1.read).to eq(123)
+      end
+    end
+
+    it 'can disable read logging' do
+      ['abc', 123].each {|x| @port1.write x}
+      expect(SideJob).not_to receive(:log)
+      SideJob::Port.group(log: false) do
         expect(@port1.read).to eq('abc')
         expect(@port1.read).to eq(123)
       end
-      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp,
-                                   'read' => ['job' => @job.id, 'inport' => 'port1', 'data' => ['abc', 123]],
-                                   'write' => []}]
     end
   end
 
@@ -320,34 +395,29 @@ describe SideJob::Port do
     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)
+      expect(SideJob).to receive(:log).with({read: [{job: @out1.job.id, outport: :out1, data: [1,[2,3]]}], write: [{job: @out1.job.id, inport: :port1, data: [1,[2,3]]}]})
       @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 use SideJob.log_context to specify additional metadata' do
-      now = Time.now
-      allow(Time).to receive(:now) { now }
-      @out1.write 1
-      @out1.write [2,3]
-      SideJob.logs(clear: true)
-      SideJob.log_context(user: 'test') do
-        @out1.connect_to(@port1)
-      end
-      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
+      expect(SideJob).not_to receive(:publish)
       @out1.connect_to(@port1)
-      expect(SideJob.logs).to eq([])
+    end
+
+    it 'publishes to associated outport channels' do
+      dest = [@port1, @out1]
+      @out1.channels = ['channel1']
+      @port1.channels = ['channel2']
+      @default.channels = ['channel3']
+      @default.write 1
+      @default.write [2,3]
+
+      allow(SideJob).to receive(:publish)
+      expect(SideJob).to receive(:publish).with('channel1', 1)
+      expect(SideJob).to receive(:publish).with('channel1', [2,3])
+      @default.connect_to dest
     end
   end
 
@@ -400,67 +470,137 @@ describe SideJob::Port do
     end
   end
 
-  describe '.log_group' do
-    before do
-      now = Time.now
-      allow(Time).to receive(:now) { now }
-    end
-
+  describe '.group' do
     it 'does not log anything if no port operations occur within the block' do
-      SideJob::Port.log_group {}
-      expect(SideJob.logs.length).to eq 0
+      expect(SideJob).not_to receive(:log)
+      SideJob::Port.group {}
     end
 
     it 'groups all port logs within the block' do
-      SideJob::Port.log_group do
+      expect(SideJob).to receive(:log).with({
+          read: [{job: @port1.job.id, inport: :port1, data: ['abc']}],
+          write: [{job: @port1.job.id, inport: :port1, data: ['abc', 'def']},
+                  {job: @out1.job.id, outport: :out1, data: ['xyz']}],
+      })
+      SideJob::Port.group do
         @port1.write 'abc'
         @port1.read
         @port1.write 'def'
         @out1.write 'xyz'
       end
-      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp,
-                                    'read' => [{'job' => @port1.job.id, 'inport' => 'port1', 'data' => ['abc']}],
-                                    'write' => [{'job' => @port1.job.id, 'inport' => 'port1', 'data' => ['abc', 'def']}, {'job' => @out1.job.id, 'outport' => 'out1', 'data' => ['xyz']} ]}]
     end
 
     it 'does not write out log until the end of outermost group' do
-      SideJob::Port.log_group do
+      expect(SideJob).to receive(:log).with({
+          read: [],
+          write: [{job: @port1.job.id, inport: :port1, data: ['hello', 2]}],
+      })
+      SideJob::Port.group do
         @port1.write 'hello'
-        SideJob::Port.log_group do
+        SideJob::Port.group do
           @port1.write 2
         end
-        expect(SideJob.logs.length).to eq 0
       end
-      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp,
-                                   'read' => [],
-                                   'write' => [{'job' => @port1.job.id, 'inport' => 'port1', 'data' => ['hello', 2]}]}]
     end
 
-    it 'works with SideJob.log_context' do
-      SideJob.log_context(user: 'foo') do
-        SideJob::Port.log_group do
+    it 'works with SideJob.context' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      allow(SideJob).to receive(:publish)
+      expect(SideJob).to receive(:publish).with('/sidejob/log', {
+          user: 'foo',
+          read: [{job: @port1.job.id, inport: :port1, data: ['abc']}],
+          write: [{job: @port1.job.id, inport: :port1, data: ['abc']}],
+          timestamp: SideJob.timestamp})
+      SideJob.context(user: 'foo') do
+        SideJob::Port.group do
           @port1.write 'abc'
           @port1.read
         end
       end
-      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp, 'user' => 'foo',
-                                    'read' => [{'job' => @port1.job.id, 'inport' => 'port1', 'data' => ['abc']}],
-                                    'write' => [{'job' => @port1.job.id, 'inport' => 'port1', 'data' => ['abc']}]}]
     end
 
     it 'logs correctly even if data is changed' do
+      expect(SideJob).to receive(:log).with({
+          read: [{job: @port1.job.id, inport: :port1, data: [{'x' => [1,2]},{'x' => [1,2,3]}]}],
+          write: [{job: @port1.job.id, inport: :port1, data: [{'x' => [1,2]},{'x' => [1,2,3]}]}],
+      })
       data = {'x' => [1,2]}
-      SideJob::Port.log_group do
+      SideJob::Port.group do
         @port1.write data
         expect(@port1.read).to eq data
         data['x'].push 3
         @port1.write data
         expect(@port1.read).to eq data
       end
-      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp,
-                                   'read' => [{'job' => @port1.job.id, 'inport' => 'port1', 'data' => [{'x' => [1,2]},{'x' => [1,2,3]}]}],
-                                   'write' => [{'job' => @port1.job.id, 'inport' => 'port1', 'data' => [{'x' => [1,2]},{'x' => [1,2,3]}]}],
-                                 }]
+    end
+
+    it 'can set options' do
+      SideJob::Port.group(log: true, notify: false, set_default: true) do
+        expect(Thread.current[:sidejob_port_group][:options]).to eq({log: true, notify: false, set_default: true})
+      end
+      expect(Thread.current[:sidejob_port_group]).to be nil
+    end
+
+    it 'can merge options in nested groups' do
+      SideJob::Port.group(log: false) do
+        expect(Thread.current[:sidejob_port_group][:options]).to eq({log: false})
+        SideJob::Port.group(notify: true) do
+          expect(Thread.current[:sidejob_port_group][:options]).to eq({log: false, notify: true})
+        end
+        expect(Thread.current[:sidejob_port_group][:options]).to eq({log: false})
+      end
+      expect(Thread.current[:sidejob_port_group]).to be nil
+    end
+  end
+
+  describe '.encode_data' do
+    it 'encodes data with no context' do
+      expect(JSON.parse(SideJob::Port.encode_data(5))).to eq({ 'data' => 5 })
+    end
+
+    it 'handles context' do
+      SideJob.context({xyz: 456}) do
+        expect(JSON.parse(SideJob::Port.encode_data([1,2]))).to eq({ 'context' => {'xyz' => 456}, 'data' => [1,2] })
+      end
+    end
+
+    it 'handles port group options' do
+      SideJob::Port.group(log: true, notify: false) do
+        expect(JSON.parse(SideJob::Port.encode_data([1,2]))).to eq({ 'options' => {'log' => true, 'notify' => false}, 'data' => [1,2] })
+      end
+    end
+  end
+
+  describe '.decode_data' do
+    it 'returns None if no data' do
+      expect(SideJob::Port.decode_data(nil)).to be SideJob::Port::None
+    end
+
+    it 'decodes object with no context' do
+      x = SideJob::Port.decode_data(SideJob::Port.encode_data(1.23))
+      expect(x.sidejob_context).to eq({})
+    end
+
+    it 'handles context' do
+      SideJob.context({abc: 'foo'}) do
+        SideJob.context({xyz: 456}) do
+          x = SideJob::Port.decode_data(SideJob::Port.encode_data(nil))
+          expect(x.sidejob_context).to eq({'abc' => 'foo', 'xyz' => 456})
+        end
+      end
+    end
+
+    it 'handles port group options' do
+      SideJob::Port.group(log: true, notify: false) do
+        expect(SideJob::Port.decode_data(SideJob::Port.encode_data([1,2])).sidejob_options).to eq({ 'log' => true, 'notify' => false})
+      end
+    end
+
+    it 'decoded data should equal original data' do
+      ['abc', [1,2], {'abc' => [1,2]}, 1, 1.23, true, false, nil].each do |x|
+        expect(SideJob::Port.decode_data(SideJob::Port.encode_data(x))).to eq x
+      end
     end
   end
 end

data/spec/sidejob/server_middleware_spec.rb

@@ -1,6 +1,17 @@
 require 'spec_helper'
 
 describe SideJob::ServerMiddleware do
+  class TestWorkerStartup
+    include SideJob::Worker
+    register
+    attr_accessor :startup_called
+    def startup
+      @startup_called = true
+    end
+    def perform
+    end
+  end
+
   class TestWorkerShutdown
     include SideJob::Worker
     register
@@ -73,7 +84,7 @@ describe SideJob::ServerMiddleware do
     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) }
+      process(@job) { |worker| @ran_at = worker.info[:ran_at] }
       expect(@ran_at).to eq SideJob.timestamp
       expect(@job.status).to eq 'completed'
     end
@@ -147,15 +158,11 @@ describe SideJob::ServerMiddleware 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' }
+      SideJob::ServerMiddleware.raise_errors = false
+      exception = RuntimeError.new('oops')
+      expect(SideJob).to receive(:log).with(exception)
+      process(@job) { raise exception }
       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 terminating' do
@@ -190,13 +197,19 @@ describe SideJob::ServerMiddleware do
     end
   end
 
+  describe 'handles job startup' do
+    it 'calls worker startup method' do
+      @job = SideJob.queue(@queue, 'TestWorkerStartup')
+      worker = process(@job) { }
+      expect(worker.startup_called).to be true
+    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
@@ -217,11 +230,13 @@ describe SideJob::ServerMiddleware do
     it 'logs but ignores exceptions thrown during shutdown' do
       @job = SideJob.queue(@queue, 'TestWorkerShutdownError')
       @job.status = 'terminating'
+      logged = false
+      expect(SideJob).to receive(:log) do |exception|
+        expect(exception.message).to eq 'shutdown error'
+        logged = true
+      end
       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'
+      expect(logged).to be true
     end
   end
 end