gush 0.4.1 → 1.0.0

data/lib/gush/workflow.rb

@@ -102,10 +102,9 @@ module Gush
     end
 
     def run(klass, opts = {})
-      options =
-
-      node = klass.new(self, {
-        name: client.next_free_job_id(id,klass.to_s),
+      node = klass.new({
+        workflow_id: id,
+        name: client.next_free_job_id(id, klass.to_s),
         params: opts.fetch(:params, {})
       })
 
@@ -125,7 +124,12 @@ module Gush
     end
 
     def reload
-      self.class.find(id)
+      flow = self.class.find(id)
+
+      self.jobs = flow.jobs
+      self.stopped = flow.stopped
+
+      self
     end
 
     def initial_jobs

data/spec/features/integration_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
+require 'pry'
 
 describe "Workflows" do
   context "when all jobs finish successfuly" do
     it "marks workflow as completed" do
       flow = TestWorkflow.create
-      flow.start!
-
-      Gush::Worker.drain
+      perform_enqueued_jobs do
+        flow.start!
+      end
 
       flow = flow.reload
       expect(flow).to be_finished
@@ -20,39 +21,39 @@ describe "Workflows" do
 
     expect(Gush::Worker).to have_jobs(flow.id, jobs_with_id(['Prepare']))
 
-    Gush::Worker.perform_one
+    perform_one
     expect(Gush::Worker).to have_jobs(flow.id, jobs_with_id(["FetchFirstJob", "FetchSecondJob"]))
 
-    Gush::Worker.perform_one
+    perform_one
     expect(Gush::Worker).to have_jobs(flow.id, jobs_with_id(["FetchSecondJob", "PersistFirstJob"]))
 
-    Gush::Worker.perform_one
+    perform_one
     expect(Gush::Worker).to have_jobs(flow.id, jobs_with_id(["PersistFirstJob"]))
 
-    Gush::Worker.perform_one
+    perform_one
     expect(Gush::Worker).to have_jobs(flow.id, jobs_with_id(["NormalizeJob"]))
 
-    Gush::Worker.perform_one
+    perform_one
 
-    expect(Gush::Worker.jobs).to be_empty
+    expect(ActiveJob::Base.queue_adapter.enqueued_jobs).to be_empty
   end
 
   it "passes payloads down the workflow" do
     class UpcaseJob < Gush::Job
-      def work
+      def perform
         output params[:input].upcase
       end
     end
 
     class PrefixJob < Gush::Job
-      def work
+      def perform
         output params[:prefix].capitalize
       end
     end
 
     class PrependJob < Gush::Job
-      def work
-        string = "#{payloads['PrefixJob'].first}: #{payloads['UpcaseJob'].first}"
+      def perform
+        string = "#{payloads.find { |j| j[:class] == 'PrefixJob'}[:output]}: #{payloads.find { |j| j[:class] == 'UpcaseJob'}[:output]}"
         output string
       end
     end
@@ -68,13 +69,13 @@ describe "Workflows" do
     flow = PayloadWorkflow.create
     flow.start!
 
-    Gush::Worker.perform_one
+    perform_one
     expect(flow.reload.find_job("UpcaseJob").output_payload).to eq("SOME TEXT")
 
-    Gush::Worker.perform_one
+    perform_one
     expect(flow.reload.find_job("PrefixJob").output_payload).to eq("A prefix")
 
-    Gush::Worker.perform_one
+    perform_one
     expect(flow.reload.find_job("PrependJob").output_payload).to eq("A prefix: SOME TEXT")
 
 
@@ -82,14 +83,14 @@ describe "Workflows" do
 
   it "passes payloads from workflow that runs multiple same class jobs with nameized payloads" do
     class RepetitiveJob < Gush::Job
-      def work
+      def perform
         output params[:input]
       end
     end
 
     class SummaryJob < Gush::Job
-      def work
-        output payloads['RepetitiveJob']
+      def perform
+        output payloads.map { |payload| payload[:output] }
       end
     end
 
@@ -106,17 +107,55 @@ describe "Workflows" do
     flow = PayloadWorkflow.create
     flow.start!
 
-    Gush::Worker.perform_one
+    perform_one
     expect(flow.reload.find_job(flow.jobs[0].name).output_payload).to eq('first')
 
-    Gush::Worker.perform_one
+    perform_one
     expect(flow.reload.find_job(flow.jobs[1].name).output_payload).to eq('second')
 
-    Gush::Worker.perform_one
+    perform_one
     expect(flow.reload.find_job(flow.jobs[2].name).output_payload).to eq('third')
 
-    Gush::Worker.perform_one
+    perform_one
     expect(flow.reload.find_job(flow.jobs[3].name).output_payload).to eq(%w(first second third))
+  end
+
+  it "does not execute `configure` on each job for huge workflows" do
+    INTERNAL_SPY = double('spy')
+    INTERNAL_CONFIGURE_SPY = double('configure spy')
+    expect(INTERNAL_SPY).to receive(:some_method).exactly(110).times
+
+    # One time when persisting, second time when reloading in the spec
+    expect(INTERNAL_CONFIGURE_SPY).to receive(:some_method).exactly(2).times
+
+    class SimpleJob < Gush::Job
+      def perform
+        INTERNAL_SPY.some_method
+      end
+    end
+
+    class GiganticWorkflow < Gush::Workflow
+      def configure
+        INTERNAL_CONFIGURE_SPY.some_method
+
+        10.times do
+          main = run(SimpleJob)
+          10.times do
+            run(SimpleJob, after: main)
+          end
+        end
+      end
+    end
+
+    flow = GiganticWorkflow.create
+    flow.start!
+
+    110.times do
+      perform_one
+    end
 
+    flow = flow.reload
+    expect(flow).to be_finished
+    expect(flow).to_not be_failed
   end
 end

data/spec/gush/client_spec.rb

@@ -41,7 +41,7 @@ describe Gush::Client do
       workflow = TestWorkflow.create
       expect {
         client.start_workflow(workflow)
-      }.to change{Gush::Worker.jobs.count}.from(0).to(1)
+      }.to change{ActiveJob::Base.queue_adapter.enqueued_jobs.size}.from(0).to(1)
     end
 
     it "removes stopped flag when the workflow is started" do

data/spec/gush/configuration_spec.rb

@@ -8,7 +8,6 @@ describe Gush::Configuration do
     expect(subject.concurrency).to eq(5)
     expect(subject.namespace).to eq('gush')
     expect(subject.gushfile).to eq(GUSHFILE.realpath)
-    expect(subject.environment).to eq('development')
   end
 
   describe "#configure" do
@@ -16,12 +15,10 @@ describe Gush::Configuration do
       Gush.configure do |config|
         config.redis_url = "redis://localhost"
         config.concurrency = 25
-        config.environment = 'production'
       end
 
       expect(Gush.configuration.redis_url).to eq("redis://localhost")
       expect(Gush.configuration.concurrency).to eq(25)
-      expect(Gush.configuration.environment).to eq('production')
     end
   end
 end

data/spec/gush/job_spec.rb

@@ -62,7 +62,7 @@ describe Gush::Job do
   describe "#as_json" do
     context "finished and enqueued set to true" do
       it "returns correct hash" do
-        job = described_class.new(double('flow'), name: "a-job", finished_at: 123, enqueued_at: 120)
+        job = described_class.new(workflow_id: 123, name: "a-job", finished_at: 123, enqueued_at: 120)
         expected = {
           name: "a-job",
           klass: "Gush::Job",
@@ -73,7 +73,8 @@ describe Gush::Job do
           finished_at: 123,
           enqueued_at: 120,
           params: {},
-          output_payload: nil
+          output_payload: nil,
+          workflow_id: 123
         }
         expect(job.as_json).to eq(expected)
       end
@@ -83,7 +84,6 @@ describe Gush::Job do
   describe ".from_hash" do
     it "properly restores state of the job from hash" do
       job = described_class.from_hash(
-        double('flow'),
         {
           klass: 'Gush::Job',
           name: 'gob',

data/spec/gush/worker_spec.rb

@@ -4,68 +4,60 @@ describe Gush::Worker do
   subject { described_class.new }
 
   let!(:workflow)   { TestWorkflow.create }
-  let(:job)         { workflow.find_job("Prepare")  }
+  let!(:job)        { client.find_job(workflow.id, "Prepare")  }
   let(:config)      { Gush.configuration.to_json  }
-  let!(:client)     { double("client") }
-
-  before :each do
-    allow(subject).to receive(:client).and_return(client)
-    allow(subject).to receive(:enqueue_outgoing_jobs)
-
-    allow(client).to receive(:find_workflow).with(workflow.id).and_return(workflow)
-    expect(client).to receive(:persist_job).at_least(1).times
-    expect(client).to receive(:worker_report).with(hash_including(status: :started)).ordered
-  end
+  let!(:client)     { Gush::Client.new }
 
   describe "#perform" do
     context "when job fails" do
       it "should mark it as failed" do
-        allow(job).to receive(:work).and_raise(StandardError)
-        expect(client).to receive(:worker_report).with(hash_including(status: :failed)).ordered
-
-        expect do
-          subject.perform(workflow.id, "Prepare")
-        end.to raise_error(StandardError)
-        expect(workflow.find_job("Prepare")).to be_failed
-      end
-
-      it "reports that job failed" do
-        allow(job).to receive(:work).and_raise(StandardError)
-        expect(client).to receive(:worker_report).with(hash_including(status: :failed)).ordered
-
+        class FailingJob < Gush::Job
+          def perform
+            invalid.code_to_raise.error
+          end
+        end
+
+        class FailingWorkflow < Gush::Workflow
+          def configure
+            run FailingJob
+          end
+        end
+
+        workflow = FailingWorkflow.create
         expect do
-          subject.perform(workflow.id, "Prepare")
-        end.to raise_error(StandardError)
+          subject.perform(workflow.id, "FailingJob")
+        end.to raise_error(NameError)
+        expect(client.find_job(workflow.id, "FailingJob")).to be_failed
       end
     end
 
     context "when job completes successfully" do
       it "should mark it as succedeed" do
         expect(subject).to receive(:mark_as_finished)
-        expect(client).to receive(:worker_report).with(hash_including(status: :finished)).ordered
 
         subject.perform(workflow.id, "Prepare")
       end
+    end
 
-      it "reports that job succedeed" do
-        expect(client).to receive(:worker_report).with(hash_including(status: :finished)).ordered
+    it "calls job.perform method" do
+      SPY = double()
+      expect(SPY).to receive(:some_method)
 
-        subject.perform(workflow.id, "Prepare")
+      class OkayJob < Gush::Job
+        def perform
+          SPY.some_method
+        end
       end
-    end
 
-    it "calls job.work method" do
-      expect(job).to receive(:work)
-      expect(client).to receive(:worker_report).with(hash_including(status: :finished)).ordered
-
-      subject.perform(workflow.id, "Prepare")
-    end
+      class OkayWorkflow < Gush::Workflow
+        def configure
+          run OkayJob
+        end
+      end
 
-    it "reports when the job is started" do
-      allow(client).to receive(:worker_report)
-      expect(client).to receive(:worker_report).with(hash_including(status: :finished)).ordered
+      workflow = OkayWorkflow.create
 
-      subject.perform(workflow.id, "Prepare")
+      subject.perform(workflow.id, 'OkayJob')
     end
   end
 end

data/spec/gush/workflow_spec.rb

@@ -114,7 +114,8 @@ describe Gush::Workflow do
                   "enqueued_at"=>nil,
                   "failed_at"=>nil,
                   "params" => {},
-                  "output_payload" => nil
+                  "output_payload" => nil,
+                  "workflow_id" => an_instance_of(String)
               },
               {
                   "name"=>a_string_starting_with('PersistFirstJob'),
@@ -126,7 +127,8 @@ describe Gush::Workflow do
                   "enqueued_at"=>nil,
                   "failed_at"=>nil,
                   "params" => {},
-                  "output_payload" => nil
+                  "output_payload" => nil,
+                  "workflow_id" => an_instance_of(String)
               }
           ]
       }

data/spec/gush_spec.rb

@@ -4,16 +4,16 @@ describe Gush do
   describe ".gushfile" do
     let(:path) { Pathname("/tmp/Gushfile.rb") }
 
-    context "Gushfile.rb is missing from pwd" do
-      it "raises an exception" do
+    context "Gushfile is missing from pwd" do
+      it "returns nil" do
         path.delete if path.exist?
         Gush.configuration.gushfile = path
 
-        expect { Gush.gushfile }.to raise_error(Errno::ENOENT)
+        expect(Gush.gushfile).to eq(nil)
       end
     end
 
-    context "Gushfile.rb exists" do
+    context "Gushfile exists" do
       it "returns Pathname to it" do
         FileUtils.touch(path)
         Gush.configuration.gushfile = path

data/spec/spec_helper.rb

@@ -1,9 +1,10 @@
 require 'gush'
 require 'fakeredis'
-require 'sidekiq/testing'
+require 'json'
+require 'pry'
 
-Sidekiq::Testing.fake!
-Sidekiq::Logging.logger = nil
+ActiveJob::Base.queue_adapter = :test
+ActiveJob::Base.logger = nil
 
 class Prepare < Gush::Job; end
 class FetchFirstJob < Gush::Job; end
@@ -13,7 +14,7 @@ class PersistSecondJob < Gush::Job; end
 class NormalizeJob < Gush::Job; end
 class BobJob < Gush::Job; end
 
-GUSHFILE  = Pathname.new(__FILE__).parent.join("Gushfile.rb")
+GUSHFILE  = Pathname.new(__FILE__).parent.join("Gushfile")
 
 class TestWorkflow < Gush::Workflow
   def configure
@@ -47,6 +48,15 @@ module GushHelpers
     @redis ||= Redis.new(url: REDIS_URL)
   end
 
+  def perform_one
+    job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
+    if job
+      Gush::Worker.new.perform(*job[:args])
+      ActiveJob::Base.queue_adapter.performed_jobs << job
+      ActiveJob::Base.queue_adapter.enqueued_jobs.shift
+    end
+  end
+
   def jobs_with_id(jobs_array)
     jobs_array.map {|job_name| job_with_id(job_name) }
   end
@@ -59,17 +69,18 @@ end
 RSpec::Matchers.define :have_jobs do |flow, jobs|
   match do |actual|
     expected = jobs.map do |job|
-      hash_including("args" => include(flow, job))
+      hash_including(args: include(flow, job))
     end
-    expect(Gush::Worker.jobs).to match_array(expected)
+    expect(ActiveJob::Base.queue_adapter.enqueued_jobs).to match_array(expected)
   end
 
   failure_message do |actual|
-    "expected queue to have #{jobs}, but instead has: #{actual.jobs.map{ |j| j["args"][1]}}"
+    "expected queue to have #{jobs}, but instead has: #{ActiveJob::Base.queue_adapter.enqueued_jobs.map{ |j| j[:args][1]}}"
   end
 end
 
 RSpec.configure do |config|
+  config.include ActiveJob::TestHelper
   config.include GushHelpers
 
   config.mock_with :rspec do |mocks|
@@ -77,16 +88,19 @@ RSpec.configure do |config|
   end
 
   config.before(:each) do
+    clear_enqueued_jobs
+    clear_performed_jobs
+
     Gush.configure do |config|
       config.redis_url = REDIS_URL
-      config.environment = 'test'
       config.gushfile = GUSHFILE
     end
   end
 
 
   config.after(:each) do
-    Sidekiq::Worker.clear_all
+    clear_enqueued_jobs
+    clear_performed_jobs
     redis.flushdb
   end
 end