gush 2.1.0 → 4.0.0

data/spec/gush/client_spec.rb

@@ -19,14 +19,43 @@ describe Gush::Client do
       it "returns Workflow object" do
         expected_workflow = TestWorkflow.create
         workflow = client.find_workflow(expected_workflow.id)
+        dependencies = workflow.dependencies
 
         expect(workflow.id).to eq(expected_workflow.id)
+        expect(workflow.persisted).to eq(true)
         expect(workflow.jobs.map(&:name)).to match_array(expected_workflow.jobs.map(&:name))
+        expect(workflow.dependencies).to eq(dependencies)
       end
 
       context "when workflow has parameters" do
         it "returns Workflow object" do
-          expected_workflow = ParameterTestWorkflow.create(true)
+          expected_workflow = ParameterTestWorkflow.create(true, kwarg: 123)
+          workflow = client.find_workflow(expected_workflow.id)
+
+          expect(workflow.id).to eq(expected_workflow.id)
+          expect(workflow.arguments).to eq([true])
+          expect(workflow.kwargs).to eq({ kwarg: 123 })
+          expect(workflow.jobs.map(&:name)).to match_array(expected_workflow.jobs.map(&:name))
+        end
+      end
+
+      context "when workflow has globals" do
+        it "returns Workflow object" do
+          expected_workflow = TestWorkflow.create(globals: { global1: 'foo' })
+          workflow = client.find_workflow(expected_workflow.id)
+
+          expect(workflow.id).to eq(expected_workflow.id)
+          expect(workflow.globals[:global1]).to eq('foo')
+        end
+      end
+
+      context "when workflow was persisted without job_klasses" do
+        it "returns Workflow object" do
+          expected_workflow = TestWorkflow.create
+
+          json = Gush::JSON.encode(expected_workflow.to_hash.except(:job_klasses))
+          redis.set("gush.workflows.#{expected_workflow.id}", json)
+
           workflow = client.find_workflow(expected_workflow.id)
 
           expect(workflow.id).to eq(expected_workflow.id)
@@ -37,6 +66,18 @@ describe Gush::Client do
   end
 
   describe "#start_workflow" do
+    context "when there is wait parameter configured" do
+      let(:freeze_time) { Time.utc(2023, 01, 21, 14, 36, 0) }
+
+      it "schedules job execution" do
+        travel_to freeze_time do
+          workflow = WaitableTestWorkflow.create
+          client.start_workflow(workflow)
+          expect(Gush::Worker).to have_a_job_enqueued_at(workflow.id, job_with_id("Prepare"), 5.minutes)
+        end
+      end
+    end
+
     it "enqueues next jobs from the workflow" do
       workflow = TestWorkflow.create
       expect {
@@ -70,42 +111,222 @@ describe Gush::Client do
     end
   end
 
+  describe "#next_free_job_id" do
+    it "returns an id" do
+      expect(client.next_free_job_id('123', Prepare.to_s)).to match(/^\h{8}-\h{4}-(\h{4})-\h{4}-\h{12}$/)
+    end
+
+    it "returns an id that doesn't match an existing job id" do
+      workflow = TestWorkflow.create
+      job = workflow.jobs.first
+
+      second_try_id = '1234'
+      allow(SecureRandom).to receive(:uuid).and_return(job.id, second_try_id)
+
+      expect(client.next_free_job_id(workflow.id, job.class.to_s)).to eq(second_try_id)
+    end
+  end
+
+  describe "#next_free_workflow_id" do
+    it "returns an id" do
+      expect(client.next_free_workflow_id).to match(/^\h{8}-\h{4}-(\h{4})-\h{4}-\h{12}$/)
+    end
+
+    it "returns an id that doesn't match an existing workflow id" do
+      workflow = TestWorkflow.create
+
+      second_try_id = '1234'
+      allow(SecureRandom).to receive(:uuid).and_return(workflow.id, second_try_id)
+
+      expect(client.next_free_workflow_id).to eq(second_try_id)
+    end
+  end
+
   describe "#persist_workflow" do
     it "persists JSON dump of the Workflow and its jobs" do
       job = double("job", to_json: 'json')
       workflow = double("workflow", id: 'abcd', jobs: [job, job, job], to_json: '"json"')
-      expect(client).to receive(:persist_job).exactly(3).times.with(workflow.id, job)
+      expect(client).to receive(:persist_job).exactly(3).times.with(workflow.id, job, expires_at: nil)
       expect(workflow).to receive(:mark_as_persisted)
       client.persist_workflow(workflow)
       expect(redis.keys("gush.workflows.abcd").length).to eq(1)
     end
+
+    it "sets created_at index" do
+      workflow = double("workflow", id: 'abcd', jobs: [], to_json: '"json"')
+      expect(workflow).to receive(:mark_as_persisted).twice
+
+      freeze_time = Time.now.round # travel_to doesn't support fractions of a second
+      travel_to(freeze_time) do
+        client.persist_workflow(workflow)
+      end
+
+      expect(redis.zrange("gush.idx.workflows.created_at", 0, -1, with_scores: true))
+        .to eq([[workflow.id, freeze_time.to_f]])
+
+      # Persisting the workflow again should not affect its created_at index score
+      client.persist_workflow(workflow)
+      expect(redis.zrange("gush.idx.workflows.created_at", 0, -1, with_scores: true))
+        .to eq([[workflow.id, freeze_time.to_f]])
+    end
+
+    it "sets expires_at index when there is a ttl configured" do
+      allow_any_instance_of(Gush::Configuration).to receive(:ttl).and_return(1000)
+
+      workflow = double("workflow", id: 'abcd', jobs: [], to_json: '"json"')
+      expect(workflow).to receive(:mark_as_persisted).twice
+
+      freeze_time = Time.now.round # travel_to doesn't support fractions of a second
+      travel_to(freeze_time) do
+        client.persist_workflow(workflow)
+      end
+
+      expires_at = freeze_time + 1000
+      expect(redis.zrange("gush.idx.workflows.expires_at", 0, -1, with_scores: true))
+        .to eq([[workflow.id, expires_at.to_f]])
+
+      # Persisting the workflow again should not affect its expires_at index score
+      client.persist_workflow(workflow)
+      expect(redis.zrange("gush.idx.workflows.expires_at", 0, -1, with_scores: true))
+        .to eq([[workflow.id, expires_at.to_f]])
+    end
+
+    it "does not set expires_at index when there is no ttl configured" do
+      workflow = double("workflow", id: 'abcd', jobs: [], to_json: '"json"')
+      expect(workflow).to receive(:mark_as_persisted)
+      client.persist_workflow(workflow)
+
+      expect(redis.zcard("gush.idx.workflows.expires_at")).to eq(0)
+    end
+
+    it "does not set expires_at index when updating a pre-existing workflow without a ttl" do
+      allow_any_instance_of(Gush::Configuration).to receive(:ttl).and_return(1000)
+
+      workflow = double("workflow", id: 'abcd', jobs: [], to_json: '"json"')
+      expect(workflow).to receive(:mark_as_persisted).twice
+
+      client.persist_workflow(workflow)
+
+      client.expire_workflow(workflow, -1)
+      expect(redis.zcard("gush.idx.workflows.expires_at")).to eq(0)
+
+      client.persist_workflow(workflow)
+      expect(redis.zcard("gush.idx.workflows.expires_at")).to eq(0)
+    end
+
+    it "does not change expires_at index when updating a pre-existing workflow with a non-standard ttl" do
+      allow_any_instance_of(Gush::Configuration).to receive(:ttl).and_return(1000)
+
+      workflow = double("workflow", id: 'abcd', jobs: [], to_json: '"json"')
+      expect(workflow).to receive(:mark_as_persisted).twice
+
+      freeze_time = Time.now.round # travel_to doesn't support fractions of a second
+      travel_to(freeze_time) do
+        client.persist_workflow(workflow)
+
+        expires_at = freeze_time.to_i + 1234
+        client.expire_workflow(workflow, 1234)
+        expect(redis.zscore("gush.idx.workflows.expires_at", workflow.id)).to eq(expires_at)
+
+        client.persist_workflow(workflow)
+        expect(redis.zscore("gush.idx.workflows.expires_at", workflow.id)).to eq(expires_at)
+      end
+    end
   end
 
   describe "#destroy_workflow" do
     it "removes all Redis keys related to the workflow" do
+      allow_any_instance_of(Gush::Configuration).to receive(:ttl).and_return(1000)
+
       workflow = TestWorkflow.create
       expect(redis.keys("gush.workflows.#{workflow.id}").length).to eq(1)
       expect(redis.keys("gush.jobs.#{workflow.id}.*").length).to eq(5)
+      expect(redis.zcard("gush.idx.workflows.created_at")).to eq(1)
+      expect(redis.zcard("gush.idx.workflows.expires_at")).to eq(1)
+      expect(redis.zcard("gush.idx.jobs.expires_at")).to eq(5)
 
       client.destroy_workflow(workflow)
 
       expect(redis.keys("gush.workflows.#{workflow.id}").length).to eq(0)
       expect(redis.keys("gush.jobs.#{workflow.id}.*").length).to eq(0)
+      expect(redis.zcard("gush.idx.workflows.created_at")).to eq(0)
+      expect(redis.zcard("gush.idx.workflows.expires_at")).to eq(0)
+      expect(redis.zcard("gush.idx.jobs.expires_at")).to eq(0)
+    end
+  end
+
+  describe "#expire_workflows" do
+    it "removes auto-expired workflows" do
+      allow_any_instance_of(Gush::Configuration).to receive(:ttl).and_return(1000)
+
+      workflow = TestWorkflow.create
+
+      # before workflow's expiration time
+      client.expire_workflows
+
+      expect(redis.keys("gush.workflows.*").length).to eq(1)
+
+      # after workflow's expiration time
+      client.expire_workflows(Time.now.to_f + 1001)
+
+      expect(redis.keys("gush.workflows.#{workflow.id}").length).to eq(0)
+      expect(redis.keys("gush.jobs.#{workflow.id}.*").length).to eq(0)
+      expect(redis.zcard("gush.idx.workflows.created_at")).to eq(0)
+      expect(redis.zcard("gush.idx.workflows.expires_at")).to eq(0)
+      expect(redis.zcard("gush.idx.jobs.expires_at")).to eq(0)
+    end
+
+    it "removes manually-expired workflows" do
+      workflow = TestWorkflow.create
+
+      # workflow hasn't been expired
+      client.expire_workflows(Time.now.to_f + 100_000)
+
+      expect(redis.keys("gush.workflows.*").length).to eq(1)
+
+      client.expire_workflow(workflow, 10)
+
+      # after workflow's expiration time
+      client.expire_workflows(Time.now.to_f + 20)
+
+      expect(redis.keys("gush.workflows.#{workflow.id}").length).to eq(0)
+      expect(redis.keys("gush.jobs.#{workflow.id}.*").length).to eq(0)
+      expect(redis.zcard("gush.idx.workflows.created_at")).to eq(0)
+      expect(redis.zcard("gush.idx.workflows.expires_at")).to eq(0)
+      expect(redis.zcard("gush.idx.jobs.expires_at")).to eq(0)
     end
   end
 
   describe "#expire_workflow" do
     let(:ttl) { 2000 }
 
-    it "sets TTL for all Redis keys related to the workflow" do
+    it "sets an expiration time for the workflow" do
+      workflow = TestWorkflow.create
+
+      freeze_time = Time.now.round # travel_to doesn't support fractions of a second
+      expires_at = freeze_time.to_f + ttl
+      travel_to(freeze_time) do
+        client.expire_workflow(workflow, ttl)
+      end
+
+      expect(redis.zscore("gush.idx.workflows.expires_at", workflow.id)).to eq(expires_at)
+
+      workflow.jobs.each do |job|
+        expect(redis.zscore("gush.idx.jobs.expires_at", "#{workflow.id}.#{job.klass}")).to eq(expires_at)
+      end
+    end
+
+    it "clears an expiration time for the workflow when given -1" do
       workflow = TestWorkflow.create
 
-      client.expire_workflow(workflow, ttl)
+      client.expire_workflow(workflow, 100)
+      expect(redis.zscore("gush.idx.workflows.expires_at", workflow.id)).to be > 0
 
-      expect(redis.ttl("gush.workflows.#{workflow.id}")).to eq(ttl)
+      client.expire_workflow(workflow, -1)
+      expect(redis.zscore("gush.idx.workflows.expires_at", workflow.id)).to eq(nil)
 
       workflow.jobs.each do |job|
-        expect(redis.ttl("gush.jobs.#{workflow.id}.#{job.klass}")).to eq(ttl)
+        expect(redis.zscore("gush.idx.jobs.expires_at", "#{workflow.id}.#{job.klass}")).to eq(nil)
       end
     end
   end
@@ -113,11 +334,99 @@ describe Gush::Client do
   describe "#persist_job" do
     it "persists JSON dump of the job in Redis" do
 
-      job = BobJob.new(name: 'bob')
+      job = BobJob.new(name: 'bob', id: 'abcd123')
 
       client.persist_job('deadbeef', job)
       expect(redis.keys("gush.jobs.deadbeef.*").length).to eq(1)
     end
+
+    it "sets expires_at index when expires_at is provided" do
+      job = BobJob.new(name: 'bob', id: 'abcd123')
+
+      freeze_time = Time.now.round # travel_to doesn't support fractions of a second
+      expires_at = freeze_time.to_f + 1000
+
+      travel_to(freeze_time) do
+        client.persist_job('deadbeef', job, expires_at: expires_at)
+      end
+
+      expect(redis.zrange("gush.idx.jobs.expires_at", 0, -1, with_scores: true))
+        .to eq([["deadbeef.#{job.klass}", expires_at]])
+
+      # Persisting the workflow again should not affect its expires_at index score
+      client.persist_job('deadbeef', job)
+      expect(redis.zrange("gush.idx.jobs.expires_at", 0, -1, with_scores: true))
+        .to eq([["deadbeef.#{job.klass}", expires_at]])
+    end
+
+    it "does not set expires_at index when there is no ttl configured" do
+      job = BobJob.new(name: 'bob', id: 'abcd123')
+      client.persist_job('deadbeef', job)
+
+      expect(redis.zcard("gush.idx.jobs.expires_at")).to eq(0)
+    end
+  end
+
+  describe "#workflow_ids" do
+    it "returns a page of registered workflow ids" do
+      workflow = TestWorkflow.create
+      ids = client.workflow_ids
+      expect(ids).to eq([workflow.id])
+    end
+
+    it "sorts workflow ids by created time or reverse created time" do
+      ids = 3.times.map { TestWorkflow.create }.map(&:id)
+
+      expect(client.workflow_ids).to eq(ids)
+      expect(client.workflow_ids(order: :asc)).to eq(ids)
+      expect(client.workflow_ids(order: :desc)).to eq(ids.reverse)
+    end
+
+    it "supports start and stop params" do
+      ids = 3.times.map { TestWorkflow.create }.map(&:id)
+
+      expect(client.workflow_ids(0, 1)).to eq(ids.slice(0..1))
+      expect(client.workflow_ids(1, 1)).to eq(ids.slice(1..1))
+      expect(client.workflow_ids(1, 10)).to eq(ids.slice(1..2))
+      expect(client.workflow_ids(0, -1)).to eq(ids)
+    end
+
+    it "supports start and stop params using created timestamps" do
+      times = [100, 200, 300]
+      ids = []
+
+      times.each do |t|
+        travel_to Time.at(t) do
+          ids << TestWorkflow.create.id
+        end
+      end
+
+      expect(client.workflow_ids(0, 1, by_ts: true)).to be_empty
+      expect(client.workflow_ids(50, 150, by_ts: true)).to eq(ids.slice(0..0))
+      expect(client.workflow_ids(150, 50, by_ts: true, order: :desc)).to eq(ids.slice(0..0))
+      expect(client.workflow_ids("-inf", "inf", by_ts: true)).to eq(ids)
+    end
+  end
+
+  describe "#workflows" do
+    it "returns a page of registered workflows" do
+      workflow = TestWorkflow.create
+      expect(client.workflows.map(&:id)).to eq([workflow.id])
+    end
+  end
+
+  describe "#workflows_count" do
+    it "returns a count of registered workflows" do
+      allow_any_instance_of(Gush::Configuration).to receive(:ttl).and_return(1000)
+
+      expect(client.workflows_count).to eq(0)
+
+      workflow = TestWorkflow.create
+      expect(client.workflows_count).to eq(1)
+
+      client.expire_workflows(Time.now.to_f + 1001)
+      expect(client.workflows_count).to eq(0)
+    end
   end
 
   describe "#all_workflows" do

data/spec/gush/job_spec.rb

@@ -49,6 +49,45 @@ describe Gush::Job do
     end
   end
 
+  describe "#enqueue_worker!" do
+    it "enqueues the job using Gush::Worker" do
+      job = described_class.new(name: "a-job", workflow_id: 123)
+
+      expect {
+        job.enqueue_worker!
+      }.to change{ActiveJob::Base.queue_adapter.enqueued_jobs.size}.from(0).to(1)
+    end
+
+    it "handles ActiveJob.set options" do
+      freeze_time = Time.utc(2023, 01, 21, 14, 36, 0)
+
+      travel_to freeze_time do
+        job = described_class.new(name: "a-job", workflow_id: 123)
+        job.enqueue_worker!(wait_until: freeze_time + 5.minutes)
+        expect(Gush::Worker).to have_a_job_enqueued_at(123, job_with_id(job.class.name), 5.minutes)
+      end
+    end
+  end
+
+  describe "#worker_options" do
+    it "returns a blank options hash by default" do
+      job = described_class.new
+      expect(job.worker_options).to eq({})
+    end
+
+    it "returns a hash with the queue setting" do
+      job = described_class.new
+      job.queue = 'my-queue'
+      expect(job.worker_options).to eq({ queue: 'my-queue' })
+    end
+
+    it "returns a hash with the wait setting" do
+      job = described_class.new
+      job.wait = 123
+      expect(job.worker_options).to eq({ wait: 123 })
+    end
+  end
+
   describe "#start!" do
     it "resets flags and marks as running" do
       job = described_class.new(name: "a-job")
@@ -70,7 +109,13 @@ 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(workflow_id: 123, id: "702bced5-bb72-4bba-8f6f-15a3afa358bd", finished_at: 123, enqueued_at: 120)
+        job = described_class.new(
+          workflow_id: 123,
+          id: '702bced5-bb72-4bba-8f6f-15a3afa358bd',
+          finished_at: 123,
+          enqueued_at: 120,
+          wait: 300
+        )
         expected = {
           id: '702bced5-bb72-4bba-8f6f-15a3afa358bd',
           klass: "Gush::Job",
@@ -83,7 +128,8 @@ describe Gush::Job do
           params: {},
           queue: nil,
           output_payload: nil,
-          workflow_id: 123
+          workflow_id: 123,
+          wait: 300
         }
         expect(job.as_json).to eq(expected)
       end

data/spec/gush/migrate/1_create_gush_workflows_created_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'gush/migrate/1_create_gush_workflows_created'
+
+describe Gush::IndexWorkflowsByCreatedAtAndExpiresAt do
+
+  describe "#up" do
+    it "adds existing workflows to created_at index, but not expires_at index" do
+      TestWorkflow.create
+      redis.del("gush.idx.workflows.created_at")
+
+      allow_any_instance_of(Gush::Configuration).to receive(:ttl).and_return(1000)
+
+      subject.migrate
+
+      expect(redis.zcard("gush.idx.workflows.created_at")).to eq(1)
+      expect(redis.zcard("gush.idx.workflows.expires_at")).to eq(0)
+      expect(redis.zcard("gush.idx.jobs.expires_at")).to eq(0)
+    end
+
+    it "adds expiring workflows to expires_at index" do
+      workflow = TestWorkflow.create
+      redis.del("gush.idx.workflows.created_at")
+
+      freeze_time = Time.now.round # travel_to doesn't support fractions of a second
+      travel_to(freeze_time) do
+        redis.expire("gush.workflows.#{workflow.id}", 1234)
+        expires_at = freeze_time.to_f + 1234
+
+        allow_any_instance_of(Gush::Configuration).to receive(:ttl).and_return(1000)
+
+        subject.migrate
+
+        expect(redis.ttl("gush.workflows.#{workflow.id}")).to eq(-1)
+        expect(redis.ttl("gush.jobs.#{workflow.id}.#{workflow.jobs.first.class.name}")).to eq(-1)
+
+        expect(redis.zrange("gush.idx.workflows.expires_at", 0, -1, with_scores: true))
+          .to eq([[workflow.id, expires_at]])
+        expect(redis.zcard("gush.idx.jobs.expires_at")).to eq(5)
+      end
+    end
+  end
+end

data/spec/gush/migration_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Gush::Migration do
+
+  describe "#migrate" do
+    it "applies a migration once" do
+      class TestMigration < Gush::Migration
+        def self.version
+          123
+        end
+      end
+
+      migration = TestMigration.new
+      expect(migration).to receive(:up).once
+
+      expect(migration.migrated?).to be(false)
+      migration.migrate
+
+      expect(migration.migrated?).to be(true)
+      migration.migrate
+    end
+  end
+end

data/spec/gush/workflow_spec.rb

@@ -15,16 +15,68 @@ describe Gush::Workflow do
       expect_any_instance_of(klass).to receive(:configure).with("arg1", "arg2")
       klass.new("arg1", "arg2")
     end
-  end
 
-  describe "#status" do
-    context "when failed" do
-      it "returns :failed" do
-        flow = TestWorkflow.create
-        flow.find_job("Prepare").fail!
-        flow.persist!
-        expect(flow.reload.status).to eq(:failed)
+    it "passes constructor keyword arguments to the method" do
+      klass = Class.new(Gush::Workflow) do
+        def configure(*args, **kwargs)
+          run FetchFirstJob
+          run PersistFirstJob, after: FetchFirstJob
+        end
+      end
+
+      expect_any_instance_of(klass).to receive(:configure).with("arg1", "arg2", arg3: 123)
+      klass.new("arg1", "arg2", arg3: 123)
+    end
+
+    it "accepts globals" do
+      flow = TestWorkflow.new(globals: { global1: 'foo' })
+      expect(flow.globals[:global1]).to eq('foo')
+    end
+
+    it "accepts internal_state" do
+      flow = TestWorkflow.new
+
+      internal_state = {
+        id: flow.id,
+        jobs: flow.jobs,
+        dependencies: flow.dependencies,
+        persisted: true,
+        stopped: true
+      }
+
+      flow_copy = TestWorkflow.new(internal_state: internal_state)
+
+      expect(flow_copy.id).to eq(flow.id)
+      expect(flow_copy.jobs).to eq(flow.jobs)
+      expect(flow_copy.dependencies).to eq(flow.dependencies)
+      expect(flow_copy.persisted).to eq(true)
+      expect(flow_copy.stopped).to eq(true)
+    end
+
+    it "does not call #configure if needs_setup is false" do
+      INTERNAL_SETUP_SPY = double('configure spy')
+      klass = Class.new(Gush::Workflow) do
+        def configure(*args)
+          INTERNAL_SETUP_SPY.some_method
+        end
       end
+
+      expect(INTERNAL_SETUP_SPY).not_to receive(:some_method)
+
+      flow = TestWorkflow.new(internal_state: { needs_setup: false })
+    end
+  end
+
+  describe "#find" do
+    it "fiends a workflow by id" do
+      expect(Gush::Workflow.find(subject.id).id).to eq(subject.id)
+    end
+  end
+
+  describe "#page" do
+    it "returns a page of registered workflows" do
+      flow = TestWorkflow.create
+      expect(Gush::Workflow.page.map(&:id)).to eq([flow.id])
     end
   end
 
@@ -81,6 +133,41 @@ describe Gush::Workflow do
     end
   end
 
+  describe "#status" do
+    context "when failed" do
+      it "returns :failed" do
+        flow = TestWorkflow.create
+        flow.find_job("Prepare").fail!
+        flow.persist!
+        expect(flow.reload.status).to eq(:failed)
+      end
+    end
+
+    it "returns failed" do
+      subject.find_job('Prepare').fail!
+      expect(subject.status).to eq(:failed)
+    end
+
+    it "returns running" do
+      subject.find_job('Prepare').start!
+      expect(subject.status).to eq(:running)
+    end
+
+    it "returns finished" do
+      subject.jobs.each {|n| n.finish! }
+      expect(subject.status).to eq(:finished)
+    end
+
+    it "returns stopped" do
+      subject.stopped = true
+      expect(subject.status).to eq(:stopped)
+    end
+
+    it "returns pending" do
+      expect(subject.status).to eq(:pending)
+    end
+  end
+
   describe "#to_json" do
     it "returns correct hash" do
       klass = Class.new(Gush::Workflow) do
@@ -90,18 +177,25 @@ describe Gush::Workflow do
         end
       end
 
-      result = JSON.parse(klass.create("arg1", "arg2").to_json)
+      result = JSON.parse(klass.create("arg1", "arg2", arg3: 123).to_json)
       expected = {
           "id" => an_instance_of(String),
           "name" => klass.to_s,
           "klass" => klass.to_s,
-          "status" => "running",
+          "job_klasses" => ["FetchFirstJob", "PersistFirstJob"],
+          "status" => "pending",
           "total" => 2,
           "finished" => 0,
           "started_at" => nil,
           "finished_at" => nil,
           "stopped" => false,
-          "arguments" => ["arg1", "arg2"]
+          "dependencies" => [{
+            "from" => "FetchFirstJob",
+            "to" => job_with_id("PersistFirstJob")
+          }],
+          "arguments" => ["arg1", "arg2"],
+          "kwargs" => {"arg3" => 123},
+          "globals" => {}
       }
       expect(result).to match(expected)
     end
@@ -118,7 +212,21 @@ describe Gush::Workflow do
       flow = Gush::Workflow.new
       flow.run(Gush::Job, params: { something: 1 })
       flow.save
-      expect(flow.jobs.first.params).to eq ({ something: 1 })
+      expect(flow.jobs.first.params).to eq({ something: 1 })
+    end
+
+    it "merges globals with params and passes them to the job, with job param taking precedence" do
+      flow = Gush::Workflow.new(globals: { something: 2, global1: 123 })
+      flow.run(Gush::Job, params: { something: 1 })
+      flow.save
+      expect(flow.jobs.first.params).to eq({ something: 1, global1: 123 })
+    end
+
+    it "allows passing wait param to the job" do
+      flow = Gush::Workflow.new
+      flow.run(Gush::Job, wait: 5.seconds)
+      flow.save
+      expect(flow.jobs.first.wait).to eq(5.seconds)
     end
 
     context "when graph is empty" do