sidejob 3.0.1 → 4.0.1

data/spec/sidejob/port_spec.rb

@@ -4,23 +4,19 @@ 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
 
@@ -32,9 +28,24 @@ describe SideJob::Port do
     it 'raises error if name is empty' do
       expect { SideJob::Port.new(@job, :in, '')}.to raise_error
     end
+
+    it 'raises error on non-existent port' do
+      expect { SideJob::Port.new(@job, :in, 'missing')}.to raise_error
+    end
+
+    it 'can dynamically create a port' do
+      @job.inports = {
+          '*' => { default: 123 },
+      }
+      expect(@job.input('abc').default).to eq 123
+    end
   end
 
   describe '#==, #eql?' do
+    before do
+      @job.inports = { '*' => {}}
+    end
+
     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)
@@ -58,57 +69,6 @@ describe SideJob::Port do
     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
@@ -142,29 +102,23 @@ describe SideJob::Port do
       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
+    it 'returns true 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]}
+      @port1.default = [1,2]
       expect(@port1.default).to eq [1,2]
     end
 
+    it 'returns None for no default' do
+      expect(@port1.default).to be SideJob::Port::None
+    end
+
     it 'can return null default value' do
-      @port1.options = {default: nil}
+      @port1.default = nil
       expect(@port1.default).to be nil
       expect(@port1.default?).to be true
     end
@@ -175,17 +129,24 @@ describe SideJob::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
+    it 'returns true for port with default value' do
+      @defaults.each {|port| expect(port.default?).to be true }
     end
+  end
 
-    it 'returns true for memory port after writing data' do
-      @memory.write 1
-      expect(@memory.default?).to be true
+  describe '#default=' do
+    it 'can set and overwrite the default' do
+      [true, false, nil, 123, 'abc', {'xyz' => [1,2]}, [5,6]].each do |val|
+        @port1.default = val
+        expect(@port1.default).to eq(val)
+      end
     end
 
-    it 'returns true for port with default value' do
-      @defaults.each {|port| expect(port.default?).to be true }
+    it 'can clear the default' do
+      @port1.default = 1234
+      expect(@port1.default?).to be true
+      @port1.default = SideJob::Port::None
+      expect(@port1.default?).to be false
     end
   end
 
@@ -196,22 +157,14 @@ describe SideJob::Port do
       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
+      SideJob::Port.log_group do
         @port1.write 'abc'
         @port1.write 123
       end
-      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp, 'job' => @job.id, 'read' => [],
+      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp, 'read' => [],
                                    'write' => ['job' => @job.id, 'inport' => 'port1', 'data' => ['abc', 123]]}]
     end
 
@@ -219,36 +172,30 @@ describe SideJob::Port 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)
+      parent = SideJob.queue('testq', 'TestWorker')
+      parent.adopt(@job, 'child')
+      parent.status = 'completed'
+      @job.status = 'completed'
       @port1.write 3
+      expect(@job.status).to eq 'queued'
+      expect(parent.status).to eq 'completed'
     end
 
-    it 'does not run the job if it is an output port' do
-      expect(@out1.job).not_to receive(:run)
+    it 'runs the parent job if it is an output port' do
+      parent = SideJob.queue('testq', 'TestWorker')
+      parent.adopt(@job, 'child')
+      parent.status = 'completed'
+      @job.status = 'completed'
       @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
+      expect(@job.status).to eq 'completed'
+      expect(parent.status).to eq 'queued'
     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)
+    it 'can read different kinds of data' do
+      expect(@port1.read).to eq SideJob::Port::None
       ['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')
@@ -258,22 +205,16 @@ describe SideJob::Port do
       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.read).to eq SideJob::Port::None
       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 }
+        3.times { expect(port.read).to eq port.default }
       end
     end
 
@@ -292,11 +233,11 @@ describe SideJob::Port do
       allow(Time).to receive(:now) { now }
       ['abc', 123].each {|x| @port1.write x}
       SideJob.logs
-      @job.group_port_logs do
+      SideJob::Port.log_group 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,
+      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp,
                                    'read' => ['job' => @job.id, 'inport' => 'port1', 'data' => ['abc', 123]],
                                    'write' => []}]
     end
@@ -319,52 +260,65 @@ describe SideJob::Port do
     end
 
     it 'sends data to all destination ports' do
-      dest = [@port1, @memory, @default]
+      dest = [@port1, @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]
+      dest = [@port1, @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
+    it 'runs job if the default value has changed' do
       expect(@port1.job).to receive(:run)
+      @default.connect_to @port1
+    end
+
+    it 'does not run job if the default value has not changed' do
+      @default.connect_to @port1
+      expect(@port1.job).not_to receive(:run)
+      @default.connect_to @port1
+    end
+
+    it 'runs job for normal input port' do
       @out1.write true
+      expect(@port1.job).to receive(:run)
       @out1.connect_to @port1
     end
 
+    it 'runs parent job for outport' do
+      parent = SideJob.queue('testq', 'TestWorker')
+      parent.adopt(@job, 'child')
+      parent.status = 'completed'
+      @job.status = 'completed'
+      j2 = SideJob.queue('testq', 'TestWorker', inports: {in: {}})
+      j2.input(:in).write true
+      j2.input(:in).connect_to @out1
+      expect(@job.status).to eq 'completed'
+      expect(parent.status).to eq 'queued'
+    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 }
@@ -377,21 +331,21 @@ describe SideJob::Port do
                                    'write' => [{'job' => @job.id, 'inport' => 'port1', 'data' => [1,[2,3]]}] }])
     end
 
-    it 'can specify additional metadata to add to log' do
+    it 'can use SideJob.log_context to specify additional metadata' 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')
+      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
-      job2 = SideJob.queue('testq', 'TestWorker')
       @out1.connect_to(@port1)
       expect(SideJob.logs).to eq([])
     end
@@ -419,11 +373,7 @@ describe SideJob::Port 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
+        expect(port.entries).to eq ['mydata']
       end
     end
   end
@@ -449,4 +399,68 @@ describe SideJob::Port do
       expect(h[@port1]).to be(3)
     end
   end
+
+  describe '.log_group' do
+    before do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+    end
+
+    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
+    end
+
+    it 'groups all port logs within the block' do
+      SideJob::Port.log_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
+        @port1.write 'hello'
+        SideJob::Port.log_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
+          @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
+      data = {'x' => [1,2]}
+      SideJob::Port.log_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
+  end
 end