Don’t give up workflow when task returns false anymore

lib/pallets/worker.rb

@@ -76,17 +76,13 @@ def process(job)
       task_class = Pallets::Util.constantize(job_hash["task_class"])
       task = task_class.new(context)
       begin
-        task_result = middleware.invoke(self, job_hash, context) do
+        middleware.invoke(self, job_hash, context) do
           task.run
         end
       rescue => ex
         handle_job_error(ex, job, job_hash)
       else
-        if task_result == false
-          handle_job_return_false(job, job_hash)
-        else
-          handle_job_success(context, job, job_hash)
-        end
+        handle_job_success(context, job, job_hash)
       end
     end
 
@@ -107,14 +103,6 @@ def handle_job_error(ex, job, job_hash)
       end
     end
 
-    def handle_job_return_false(job, job_hash)
-      new_job = serializer.dump(job_hash.merge(
-        'given_up_at' => Time.now.to_f,
-        'reason' => 'returned_false'
-      ))
-      backend.give_up(new_job, job)
-    end
-
     def handle_job_success(context, job, job_hash)
       backend.save(job_hash['wfid'], job, serializer.dump_context(context.buffer))
     end

spec/worker_spec.rb

@@ -201,7 +201,6 @@ def run
       # Stub middleware invocation, but call the provided block
       allow(middleware).to receive(:invoke) { |&block| block.call }
       allow(subject).to receive(:handle_job_error)
-      allow(subject).to receive(:handle_job_return_false)
       allow(subject).to receive(:handle_job_success)
     end
 
@@ -241,7 +240,6 @@ def run
       it 'does not invoke any handler' do
         subject.send(:process, job)
         expect(subject).not_to have_received(:handle_job_error)
-        expect(subject).not_to have_received(:handle_job_return_false)
         expect(subject).not_to have_received(:handle_job_success)
       end
     end
@@ -285,17 +283,6 @@ def run
       end
     end
 
-    context 'when the task returns false' do
-      before do
-        allow(task).to receive(:run).and_return(false)
-      end
-
-      it 'calls the return false handler' do
-        subject.send(:process, job)
-        expect(subject).to have_received(:handle_job_return_false).with(job, job_hash)
-      end
-    end
-
     context 'when the task is run successfully' do
       it 'calls the success handler' do
         subject.send(:process, job)
@@ -402,42 +389,6 @@ def run
     end
   end
 
-  describe '#handle_job_return_false' do
-    let(:backend) { instance_spy('Pallets::Backends::Base') }
-    let(:serializer) { instance_spy('Pallets::Serializers::Base', dump: 'foobar') }
-    let(:job) { double }
-    let(:job_hash) do
-      {
-        'wfid' => 'qux',
-        'jid' => 'quxqux',
-        'task_class' => 'Foo',
-        'max_failures' => 15
-      }
-    end
-
-    before do
-      allow(subject).to receive(:backend).and_return(backend)
-      allow(subject).to receive(:serializer).and_return(serializer)
-    end
-
-    it 'builds a new job and uses the serializer to dump it' do
-      Timecop.freeze do
-        subject.send(:handle_job_return_false, job, job_hash)
-        expect(serializer).to have_received(:dump).with(job_hash.merge(
-          'given_up_at' => Time.now.to_f,
-          'reason' => 'returned_false'
-        ))
-      end
-    end
-
-    it 'tells the backend to give up the job' do
-      Timecop.freeze do
-        subject.send(:handle_job_return_false, job, job_hash)
-        expect(backend).to have_received(:give_up).with('foobar', job)
-      end
-    end
-  end
-
   describe '#handle_job_success' do
     let(:backend) { instance_spy('Pallets::Backends::Base') }
     let(:serializer) { instance_spy('Pallets::Serializers::Base') }