sidejob 3.0.0

data/spec/sidejob/testing_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe 'SideJob testing helpers' do
+  class TestLongRunning
+    include SideJob::Worker
+    register
+    def perform
+      sleep 3
+    end
+  end
+
+  class TestFailure
+    include SideJob::Worker
+    register
+    def perform
+      raise 'bad error'
+    end
+  end
+
+  class TestMysteriousFailure
+    include SideJob::Worker
+    register
+    def perform
+      self.status = 'failed'
+    end
+  end
+
+  describe 'SideJob::Worker.drain_queue' do
+    it 'runs jobs' do
+      job = SideJob.queue('testq', 'TestSum')
+      5.times {|i| job.input(:in).write i}
+      job.input(:ready).write 1
+      job2 = SideJob.queue('testq', 'TestSum')
+      6.times {|i| job2.input(:in).write i}
+      job2.input(:ready).write 1
+      expect(job.output(:sum).data?).to be false
+      expect(job2.output(:sum).data?).to be false
+      SideJob::Worker.drain_queue
+      expect(job.output(:sum).read).to eq 10
+      expect(job2.output(:sum).read).to eq 15
+    end
+
+    it 'can specify a timeout' do
+      job = SideJob.queue('testq', 'TestLongRunning')
+      expect { SideJob::Worker.drain_queue(timeout: 0.25) }.to raise_error(Timeout::Error)
+    end
+
+    it 'raises errors by default' do
+      job = SideJob.queue('testq', 'TestFailure')
+      expect { SideJob::Worker.drain_queue }.to raise_error(RuntimeError, 'bad error')
+    end
+
+    it 'raises error if worker mysteriously fails' do
+      job = SideJob.queue('testq', 'TestMysteriousFailure')
+      expect { SideJob::Worker.drain_queue }.to raise_error(RuntimeError)
+    end
+
+    it 'can disable raising of errors' do
+      job = SideJob.queue('testq', 'TestFailure')
+      expect { SideJob::Worker.drain_queue(errors: false) }.not_to raise_error
+    end
+  end
+
+  describe 'SideJob::Job#run_inline' do
+    it 'runs a single job once' do
+      job = SideJob.queue('testq', 'TestSum')
+      5.times {|i| job.input(:in).write i}
+      job.input(:ready).write 1
+      expect(job.output(:sum).data?).to be false
+      job.run_inline
+      expect(job.status).to eq 'completed'
+      expect(job.output(:sum).read).to eq 10
+    end
+
+    it 'queues a non-queued job by default' do
+      job = SideJob.queue('testq', 'TestSum')
+      5.times {|i| job.input(:in).write i}
+      job.input(:ready).write 1
+      job.status = 'suspended'
+      job.run_inline
+      expect(job.output(:sum).read).to eq 10
+    end
+
+    it 'can turn off queuing of a job' do
+      job = SideJob.queue('testq', 'TestSum')
+      5.times {|i| job.input(:in).write i}
+      job.input(:ready).write 1
+      job.status = 'suspended'
+      job.run_inline queue: false
+      expect(job.output(:sum).data?).to be false
+    end
+
+    it 'raises errors by default' do
+      job = SideJob.queue('testq', 'TestFailure')
+      expect { job.run_inline }.to raise_error(RuntimeError, 'bad error')
+    end
+
+    it 'raises error if worker mysteriously fails' do
+      job = SideJob.queue('testq', 'TestMysteriousFailure')
+      expect { job.run_inline }.to raise_error(RuntimeError)
+    end
+
+    it 'can disable raising of errors' do
+      job = SideJob.queue('testq', 'TestFailure')
+      expect { job.run_inline(errors: false) }.not_to raise_error
+    end
+  end
+end

data/spec/sidejob/worker_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe SideJob::Worker do
+  before do
+    @job = SideJob.queue('testq', 'TestWorker', inports: {
+        in1: {},
+        in2: {},
+        memory: { mode: :memory },
+        default: { default: 'default' },
+        default_null: { default: nil },
+    }, outports: {out1: {}})
+    @worker = TestWorker.new
+    @worker.jid = @job.id
+    @worker.status = 'running'
+  end
+
+  describe '.register_all' do
+    it 'overwrites existing data with current registry' do
+      spec = {abc: [1, 2]}
+      SideJob.redis.hmset 'workers:q1', 'foo', 'bar'
+      SideJob::Worker.register_all('q1')
+      expect(SideJob.redis.hget('workers:q1', 'foo')).to be nil
+    end
+  end
+
+  describe '.config' do
+    it 'returns nil for a non-existing worker' do
+      expect(SideJob::Worker.config('noq', 'NoWorker')).to be nil
+    end
+
+    it 'returns a worker config that has been registered for the current queue' do
+      expect(SideJob::Worker.config('testq', 'TestWorker')).to eq JSON.parse(SideJob::Worker.registry['TestWorker'].to_json)
+    end
+
+    it 'returns a worker config that has been registered elsewhere' do
+      config = {'abc' => [1, 2]}
+      SideJob.redis.hmset 'workers:q1', 'NewWorker', config.to_json
+      expect(SideJob::Worker.config('q1', 'NewWorker')).to eq config
+    end
+  end
+
+  describe '.register' do
+    class TestWorkerRegister
+      include SideJob::Worker
+      register(
+          my_register_key: [1, 2, 3]
+      )
+      def perform
+      end
+    end
+
+    it 'registers a worker configuration' do
+      expect(SideJob::Worker.registry['TestWorkerRegister']).to eq({my_register_key: [1,2,3]})
+    end
+  end
+
+  it 'includes SideJob::JobMethods' do
+    expect(TestWorker.included_modules).to include(SideJob::JobMethods)
+  end
+
+  it '#suspend raises exception' do
+    expect { @worker.suspend }.to raise_error(SideJob::Worker::Suspended)
+  end
+
+  describe '#queue' do
+    it 'can queue child jobs' do
+      expect(SideJob).to receive(:queue).with('testq', 'TestWorker', args: [1,2], inports: {'myport' => {'mode' => 'memory'}}, parent: @job, name: 'child', by: "job:#{@worker.id}").and_call_original
+      expect {
+        child = @worker.queue('testq', 'TestWorker', args: [1,2], inports: {'myport' => {'mode' => 'memory'}}, name: 'child')
+        expect(child.parent).to eq(@job)
+        expect(@job.children).to eq('child' => child)
+      }.to change {Sidekiq::Stats.new.enqueued}.by(1)
+    end
+
+    it 'queues with by string set to self' do
+      child = @worker.queue('testq', 'TestWorker', name: 'child')
+      expect(child.get(:created_by)).to eq "job:#{@worker.id}"
+    end
+
+    it 'groups initial port data' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      child = @worker.queue('testq', 'TestWorker', name: 'child', inports: {'inport1' => {data: [1,2]}}, outports: {'outport1' => {data: [3,4]}})
+      expect(SideJob.logs).to eq [{'timestamp' => SideJob.timestamp, 'job' => @worker.id,
+                                   'read' => [],
+                                   'write' => [{'job' => child.id, 'inport' => 'inport1', 'data' => [1,2]},
+                                               {'job' => child.id, 'outport' => 'outport1', 'data' => [3,4]},
+                                   ]}]
+    end
+  end
+
+  describe '#for_inputs' do
+    it 'does nothing if no ports provided' do
+      expect {|block| @worker.for_inputs(&block)}.not_to yield_control
+    end
+
+    it 'yields data from input ports' do
+      @job.input(:in1).write 1
+      @job.input(:in1).write 'a'
+      @job.input(:in2).write [2, 3]
+      @job.input(:in2).write foo: 123
+      expect {|block| @worker.for_inputs(:in1, :in2, &block)}.to yield_successive_args([1, [2,3]], ['a', {'foo' => 123}])
+    end
+
+    it 'logs input and output from them' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      @job.input(:in1).write 1
+      @job.input(:in1).write 2
+      @job.input(:in2).write ['a', 'b']
+      @job.input(:in2).write ['c', 'd']
+      SideJob.logs(clear: true)
+      @worker.for_inputs(:in1, :in2) do |in1, in2|
+        @worker.output(:out1).write [in1, in2[0]]
+      end
+      expect(SideJob.logs).to eq([{'timestamp' => SideJob.timestamp, 'job' => @job.id, 'read' => [{'job' => @job.id, 'inport' => 'in1', 'data' => [1]}, {'job' => @job.id, 'inport' => 'in2', 'data' => [['a', 'b']]}], 'write' => [{'job' => @job.id, 'outport' => 'out1', 'data' => [[1, 'a']]}]},
+                                  {'timestamp' => SideJob.timestamp, 'job' => @job.id, 'read' => [{'job' => @job.id, 'inport' => 'in1', 'data' => [2]}, {'job' => @job.id, 'inport' => 'in2', 'data' => [['c', 'd']]}], 'write' => [{'job' => @job.id, 'outport' => 'out1', 'data' => [[2, 'c']]}]},
+                                 ])
+    end
+
+    it 'suspends on partial inputs' do
+      @job.input(:in1).write 1
+      @job.input(:in2).write [2, 3]
+      @job.input(:in2).write 3
+      expect {
+        expect {|block| @worker.for_inputs(:in1, :in2, &block)}.to yield_successive_args([1, [2,3]])
+      }.to raise_error(SideJob::Worker::Suspended)
+    end
+
+    it 'returns data from memory input ports' do
+      @job.input(:memory).write 1
+      @job.input(:in2).write [2, 3]
+      @job.input(:in2).write 3
+      expect {|block| @worker.for_inputs(:memory, :in2, &block)}.to yield_successive_args([1, [2,3]], [1, 3])
+    end
+
+    it 'does not suspend if there is only data on memory port' do
+      @job.input(:memory).write 1
+      expect {|block| @worker.for_inputs(:memory, :in2, &block)}.not_to yield_control
+    end
+
+    it 'allows for null default values' do
+      @job.input(:default_null).write 1
+      @job.input(:in2).write [2, 3]
+      @job.input(:in2).write 3
+      expect {|block| @worker.for_inputs(:default_null, :in2, &block)}.to yield_successive_args([1, [2,3]], [nil, 3])
+    end
+
+    it 'raises error if all ports have defaults' do
+      @job.input(:memory).write true
+      expect {|block| @worker.for_inputs(:memory, :default, &block)}.to raise_error
+    end
+  end
+
+  describe '#set' do
+    it 'can save state in redis' do
+      @worker.set(test: 'data', test2: 123)
+      state = JSON.parse(SideJob.redis.hget('jobs', @worker.id))
+      expect(state['test']).to eq 'data'
+      expect(state['test2']).to eq 123
+
+      # test updating
+      @worker.set(test: 'data2')
+      state = JSON.parse(SideJob.redis.hget('jobs', @worker.id))
+      expect(state['test']).to eq 'data2'
+    end
+
+    it 'can update values' do
+      3.times do |i|
+        @worker.set key: i
+        @worker.reload
+        expect(@worker.get(:key)).to eq i
+        state = JSON.parse(SideJob.redis.hget('jobs', @worker.id))
+        expect(state['key']).to eq i
+      end
+    end
+
+    it 'raises error if job no longer exists' do
+      @worker.status = 'terminated'
+      SideJob.find(@worker.id).delete
+      expect { @worker.set key: 123 }.to raise_error
+    end
+  end
+
+  describe '#unset' do
+    it 'unsets fields' do
+      @worker.set(a: 123, b: 456, c: 789)
+      @worker.unset('a', :b)
+      expect(@worker.get(:a)).to eq nil
+      expect(@worker.get(:b)).to eq nil
+      expect(@worker.get(:c)).to eq 789
+    end
+
+    it 'raises error if job no longer exists' do
+      @worker.status = 'terminated'
+      @worker.set a: 123
+      SideJob.find(@worker.id).delete
+      expect { @worker.unset(:a) }.to raise_error
+    end
+  end
+end

data/spec/sidejob_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe SideJob do
+  describe '.redis' do
+    it 'returns Redis instance via Sidekiq' do
+      r1 = SideJob.redis {|redis| redis}
+      r2 = Sidekiq.redis {|redis| redis}
+      expect(r1).to be(r2)
+    end
+
+    it 'returns Redis without block' do
+      expect(SideJob.redis {|redis| redis}).to be(SideJob.redis)
+    end
+  end
+
+  describe '.redis=' do
+    it 'sets redis url' do
+      original = SideJob.redis.client.options[:url]
+      SideJob.redis = {url: 'redis://myredis:1234/10'}
+      expect(SideJob.redis.client.options[:url]).to eq('redis://myredis:1234/10')
+      expect(SideJob.redis.client.options[:host]).to eq('myredis')
+      expect(SideJob.redis.client.options[:port]).to eq(1234)
+      expect(SideJob.redis.client.options[:db]).to eq(10)
+      SideJob.redis = {url: original}
+    end
+  end
+
+  describe '.queue' do
+    it 'raises an error if no worker registered for specified queue/class' do
+      expect { SideJob.queue('unknownq', 'TestWorker') }.to raise_error
+      expect { SideJob.queue('testq', 'UnknownWorker') }.to raise_error
+    end
+
+    it 'queues a sidekiq job' do
+      expect {
+        job = SideJob.queue('testq', 'TestWorker')
+        expect(job.exists?).to be true
+        expect(job.status).to eq 'queued'
+        job = Sidekiq::Queue.new('testq').find_job(job.id)
+        expect(job.queue).to eq('testq')
+        expect(job.klass).to eq('TestWorker')
+        expect(job.args).to eq([])
+      }.to change {Sidekiq::Stats.new.enqueued}.by(1)
+    end
+
+    it 'generates an incrementing job id from 1' do
+      job = SideJob.queue('testq', 'TestWorker')
+      expect(job.id).to eq('1')
+      job = SideJob.queue('testq', 'TestWorker')
+      expect(job.id).to eq('2')
+    end
+
+    it 'stores created at timestamp' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      job = SideJob.queue('testq', 'TestWorker')
+      expect(job.get(:created_at)).to eq(SideJob.timestamp)
+    end
+
+    it 'can specify job args' do
+      job = SideJob.queue('testq', 'TestWorker', args: [1,2])
+      expect(job.status).to eq 'queued'
+      expect(job.get(:args)).to eq [1,2]
+      expect_any_instance_of(TestWorker).to receive(:perform).with(1, 2)
+      SideJob::Worker.drain_queue
+    end
+
+    it 'can specify job parent' do
+      expect {
+        parent = SideJob.queue('testq', 'TestWorker')
+        job = SideJob.queue('testq', 'TestWorker', parent: parent, name: 'child1')
+        expect(job.status).to eq 'queued'
+        expect(job.parent).to eq(parent)
+        expect(parent.child('child1')).to eq job
+        expect(SideJob.redis.lrange("#{job.redis_key}:ancestors", 0, -1)).to eq([parent.id])
+      }.to change {Sidekiq::Stats.new.enqueued}.by(2)
+    end
+
+    it 'raises an error if name: option not specified with parent' do
+      parent = SideJob.queue('testq', 'TestWorker')
+      expect { SideJob.queue('testq', 'TestWorker', parent: parent) }.to raise_error
+    end
+
+    it 'raises an error if name: name is not unique' do
+      parent = SideJob.queue('testq', 'TestWorker')
+      SideJob.queue('testq', 'TestWorker', parent: parent, name: 'child')
+      expect { SideJob.queue('testq', 'TestWorker', parent: parent, name: 'child') }.to raise_error
+    end
+
+    it 'sets ancestor tree correctly' do
+      j1 = SideJob.queue('testq', 'TestWorker')
+      j2 = SideJob.queue('testq', 'TestWorker', parent: j1, name: 'child1')
+      j3 = SideJob.queue('testq', 'TestWorker', parent: j2, name: 'child1')
+      expect(SideJob.redis.lrange("#{j3.redis_key}:ancestors", 0, -1)).to eq([j2.id, j1.id])
+    end
+
+    it 'can add a port via inports configuration' do
+      job = SideJob.queue('testq', 'TestWorker', inports: {myport: {default: [1,2]}})
+      expect(job.status).to eq 'queued'
+      expect(job.input(:myport).read).to eq [1, 2]
+    end
+
+    it 'can set the port mode via inports configuration' do
+      job = SideJob.queue('testq', 'TestWorker', inports: {queue: {mode: 'queue'}})
+      expect(job.status).to eq 'queued'
+      expect(job.input(:queue).mode).to be :queue
+    end
+
+    it 'can add a port via outports configuration' do
+      job = SideJob.queue('testq', 'TestWorker', outports: {myport: {}})
+      expect(job.status).to eq 'queued'
+      expect(job.outports.map(&:name).include?(:myport)).to be true
+    end
+
+    it 'can specify a job time' do
+      at = Time.now.to_f + 1000
+      expect {
+        job = SideJob.queue('testq', 'TestWorker', at: at)
+        expect(job.status).to eq 'queued'
+        expect(Sidekiq::ScheduledSet.new.find_job(job.id).at).to eq(Time.at(at))
+      }.to change {Sidekiq::Stats.new.scheduled_size}.by(1)
+    end
+
+    it 'can specify a by string' do
+      job = SideJob.queue('testq', 'TestWorker', by: 'test:sidejob')
+      expect(job.get(:created_by)).to eq 'test:sidejob'
+    end
+
+    it 'defaults to empty by string' do
+      job = SideJob.queue('testq', 'TestWorker')
+      expect(job.get(:created_by)).to be nil
+    end
+  end
+
+  describe '.find' do
+    it 'returns a job object by id' do
+      job = SideJob.queue('testq', 'TestWorker')
+      expect(SideJob.find(job.id)).to eq(job)
+    end
+
+    it 'returns nil if the job does not exist' do
+      expect(SideJob.find('job')).to be_nil
+    end
+  end
+
+  describe '.timestamp' do
+    it 'returns subseconds' do
+      expect(SideJob.timestamp).to match /T\d\d:\d\d:\d\d\./
+    end
+  end
+
+  describe '.log' do
+    it 'adds a timestamp to log entries' do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      SideJob.log({abc: 123})
+      log = SideJob.redis.rpop 'jobs:logs'
+      expect(JSON.parse(log)).to eq({'abc' => 123, 'timestamp' => SideJob.timestamp})
+    end
+  end
+
+  describe '.logs' do
+    before do
+      now = Time.now
+      allow(Time).to receive(:now) { now }
+      SideJob.log({abc: 123})
+    end
+
+    it 'returns and clears all logs' do
+      expect(SideJob.logs).to eq([{'abc' => 123, 'timestamp' => SideJob.timestamp}])
+      SideJob.log({xyz: 456})
+      expect(SideJob.logs).to eq([{'xyz' => 456, 'timestamp' => SideJob.timestamp}])
+    end
+
+    it 'returns and leaves logs' do
+      expect(SideJob.logs(clear: false)).to eq([{'abc' => 123, 'timestamp' => SideJob.timestamp}])
+      SideJob.log({xyz: 456})
+      expect(SideJob.logs(clear: false)).to eq([{'abc' => 123, 'timestamp' => SideJob.timestamp},
+                                                {'xyz' => 456, 'timestamp' => SideJob.timestamp},])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'bundler/setup'
+require 'rspec/core'
+require 'pry'
+require 'sidejob'
+require 'sidejob/testing'
+
+# set default redis to something other than database 0 to avoid accidentally clearing a redis with valuable data
+SideJob.redis = {url: 'redis://localhost:6379/6'}
+
+Dir[File.dirname(__FILE__) + '/support/*.rb'].each {|file| require file }
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.before do
+    SideJob.redis.flushdb
+    SideJob::Worker.register_all 'testq'
+  end
+end

data/spec/support/test_sum.rb

@@ -0,0 +1,17 @@
+class TestSum
+  include SideJob::Worker
+  register(
+      inports: {
+          ready: {},
+          in: {},
+      },
+      outports: {
+          sum: {},
+      }
+  )
+  def perform
+    suspend unless input(:ready).data?
+    sum = input(:in).inject(&:+)
+    output(:sum).write sum
+  end
+end

data/spec/support/test_worker.rb

@@ -0,0 +1,6 @@
+class TestWorker
+  include SideJob::Worker
+  register
+  def perform(*args)
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: sidejob
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Austin Che
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.5
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- austin@ginkgobioworks.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/build
+- bin/console
+- lib/sidejob.rb
+- lib/sidejob/job.rb
+- lib/sidejob/port.rb
+- lib/sidejob/server_middleware.rb
+- lib/sidejob/testing.rb
+- lib/sidejob/version.rb
+- lib/sidejob/worker.rb
+- sidejob.gemspec
+- spec/integration/fib_spec.rb
+- spec/integration/sum_spec.rb
+- spec/sidejob/job_spec.rb
+- spec/sidejob/port_spec.rb
+- spec/sidejob/server_middleware_spec.rb
+- spec/sidejob/testing_spec.rb
+- spec/sidejob/worker_spec.rb
+- spec/sidejob_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_sum.rb
+- spec/support/test_worker.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Use SideJob to run sidekiq jobs with a flow-based model
+test_files: []
+has_rdoc: