gush 0.0.1

data/spec/lib/gush/null_logger_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Gush::NullLogger do
+  let(:logger) { Gush::NullLogger.new }
+
+  it 'responds to logger methods and ignores them' do
+    [:info, :debug, :error, :fatal].each do |method|
+      logger.send(method, "message")
+    end
+  end
+
+  it 'works when block with message is passed' do
+    logger.info("progname") { "message" }
+  end
+end

data/spec/lib/gush/worker_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Gush::Worker do
+  let(:workflow_id) { '1234'                        }
+  let(:workflow)    { TestWorkflow.new(workflow_id) }
+  let(:job)         { workflow.find_job("Prepare")  }
+  let(:config)      { client.configuration.to_json  }
+
+  before :each do
+    allow(client).to receive(:find_workflow).with(workflow_id).and_return(workflow)
+    allow(Gush::Client).to receive(:new).and_return(client)
+  end
+
+  describe "#perform" do
+    context "when job fails" do
+      before :each do
+        expect(job).to receive(:work).and_raise(StandardError)
+        job.enqueue!
+        job.start!
+      end
+
+      it "should mark it as failed" do
+        allow(client).to receive(:persist_job)
+        Gush::Worker.new.perform(workflow_id, "Prepare", config)
+
+        expect(client).to have_received(:persist_job).with(workflow_id, job).at_least(1).times do |_, job|
+          expect(job).to be_failed
+        end
+
+      end
+
+      it "reports that job failed" do
+        allow(client).to receive(:worker_report)
+        Gush::Worker.new.perform(workflow_id, "Prepare", config)
+        expect(client).to have_received(:worker_report).with(hash_including(status: :failed))
+      end
+
+      it "logs the exception" do
+        logger = TestLogger.new(1234, 'Prepare')
+        expect(logger).to receive(:<<).with(instance_of(String)).at_least(1).times
+        expect(workflow).to receive(:build_logger_for_job).and_return(logger)
+
+        Gush::Worker.new.perform(workflow_id, "Prepare", config)
+      end
+    end
+
+    context "when job completes successfully" do
+      it "should mark it as succedeed" do
+        allow(client).to receive(:persist_job)
+
+        Gush::Worker.new.perform(workflow_id, "Prepare", config)
+
+        expect(client).to have_received(:persist_job).at_least(1).times.with(workflow_id, job) do |_, job|
+          expect(job).to be_succeeded
+        end
+      end
+
+      it "reports that job succedeed" do
+        allow(client).to receive(:worker_report)
+        Gush::Worker.new.perform(workflow_id, "Prepare", config)
+
+        expect(client).to have_received(:worker_report).with(hash_including(status: :finished))
+      end
+    end
+
+    [:before_work, :work, :after_work].each do |method|
+      it "calls job.#{method} hook" do
+        expect(job).to receive(method)
+        Gush::Worker.new.perform(workflow_id, "Prepare", config)
+      end
+    end
+
+    it "sets up a logger for the job" do
+      Gush::Worker.new.perform(workflow_id, "Prepare", config)
+      job.start!
+      expect(job.logger).to be_a TestLogger
+    end
+
+    it "sets a job id" do
+      job_id = 1234
+      worker = Gush::Worker.new
+
+      allow(worker).to receive(:jid).and_return(job_id)
+
+      worker.perform(workflow_id, "Prepare", config)
+      job.enqueue!
+      expect(job.jid).to eq job_id
+    end
+
+    it "reports when the job is started" do
+      allow(client).to receive(:worker_report)
+      Gush::Worker.new.perform(workflow_id, "Prepare", config)
+      expect(client).to have_received(:worker_report).with(hash_including(status: :started))
+    end
+  end
+end

data/spec/lib/gush/workflow_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe Gush::Workflow do
+  subject { TestWorkflow.new("test-workflow") }
+
+  describe "#initialize" do
+    context "when configure option is true" do
+      it "runs #configure method " do
+        expect_any_instance_of(TestWorkflow).to receive(:configure)
+        TestWorkflow.new("name", configure: true)
+      end
+    end
+  end
+
+  describe "#stop!" do
+    it "marks workflow as stopped" do
+      expect{ subject.stop! }.to change{subject.stopped?}.from(false).to(true)
+    end
+  end
+
+  describe "#start!" do
+    it "removes stopped flag" do
+      subject.stopped = true
+      expect{ subject.start! }.to change{subject.stopped?}.from(true).to(false)
+    end
+  end
+
+  describe "#to_json" do
+    it "returns correct hash" do
+
+      klass = Class.new(Gush::Workflow) do
+        def configure
+          run FetchFirstJob
+          run PersistFirstJob, after: FetchFirstJob
+        end
+      end
+
+      result = JSON.parse(klass.new("workflow").to_json)
+      expected = {
+        "id"=>"workflow",
+        "name" => klass.to_s,
+        "klass" => klass.to_s,
+        "status" => "Pending",
+        "total" => 2,
+        "finished" => 0,
+        "started_at" => nil,
+        "finished_at" => nil,
+        "stopped" => false,
+        "logger_builder" => "Gush::LoggerBuilder",
+        "nodes" => [
+          {
+            "name"=>"FetchFirstJob", "klass"=>"FetchFirstJob", "finished"=>false, "enqueued"=>false, "failed"=>false,
+            "incoming"=>[], "outgoing"=>["PersistFirstJob"], "finished_at"=>nil, "started_at"=>nil, "failed_at"=>nil,
+            "running" => false
+          },
+          {
+            "name"=>"PersistFirstJob", "klass"=>"PersistFirstJob", "finished"=>false, "enqueued"=>false, "failed"=>false,
+            "incoming"=>["FetchFirstJob"], "outgoing"=>[], "finished_at"=>nil, "started_at"=>nil, "failed_at"=>nil,
+            "running" => false
+          }
+        ]
+      }
+      expect(result).to eq(expected)
+    end
+  end
+
+  describe "#find_job" do
+    it "finds job by its name" do
+      expect(TestWorkflow.new("test").find_job("PersistFirstJob")).to be_instance_of(PersistFirstJob)
+    end
+  end
+
+  describe "#run" do
+    context "when graph is empty" do
+      it "adds new job with the given class as a node" do
+        flow = Gush::Workflow.new("workflow")
+        flow.run(Gush::Job)
+        expect(flow.nodes.first).to be_instance_of(Gush::Job)
+      end
+    end
+
+    context "when last node is a job" do
+      it "attaches job as a child of the last inserted job" do
+        tree = Gush::Workflow.new("workflow")
+        klass1 = Class.new(Gush::Job)
+        klass2 = Class.new(Gush::Job)
+        tree.run(klass1)
+        tree.run(klass2, after: klass1)
+        tree.create_dependencies
+        expect(tree.nodes.first).to be_an_instance_of(klass1)
+        expect(tree.nodes.first.outgoing.first).to eq(klass2.to_s)
+      end
+    end
+  end
+
+  describe "#logger_builder" do
+    it 'sets logger builder for workflow' do
+      tree = Gush::Workflow.new("workflow")
+      tree.logger_builder(TestLoggerBuilder)
+      expect(tree.instance_variable_get(:@logger_builder)).to eq(TestLoggerBuilder)
+    end
+  end
+
+  describe "#build_logger_for_job" do
+    it 'builds a logger' do
+      job = double('job')
+      allow(job).to receive(:name) { 'a-job' }
+
+      tree = Gush::Workflow.new("workflow")
+      tree.logger_builder(TestLoggerBuilder)
+
+      logger = tree.build_logger_for_job(job, :jid)
+      expect(logger).to be_a(TestLogger)
+      expect(logger.jid).to eq(:jid)
+      expect(logger.name).to eq('a-job')
+    end
+  end
+
+  describe "#failed?" do
+    context "when one of the jobs failed" do
+      it "returns true" do
+        subject.find_job('Prepare').failed = true
+        expect(subject.failed?).to be_truthy
+      end
+    end
+
+    context "when no jobs failed" do
+      it "returns true" do
+        expect(subject.failed?).to be_falsy
+      end
+    end
+  end
+
+  describe "#running?" do
+    context "when no enqueued or running jobs" do
+      it "returns false" do
+        expect(subject.running?).to be_falsy
+      end
+    end
+
+    context "when some jobs are enqueued" do
+      it "returns true" do
+        subject.find_job('Prepare').enqueued = true
+        expect(subject.running?).to be_truthy
+      end
+    end
+
+    context "when some jobs are running" do
+      it "returns true" do
+        subject.find_job('Prepare').running = true
+        expect(subject.running?).to be_truthy
+      end
+    end
+  end
+
+  describe "#finished?" do
+    it "returns false if any jobs are unfinished" do
+      expect(subject.finished?).to be_falsy
+    end
+
+    it "returns true if all jobs are finished" do
+      subject.nodes.each {|n| n.finished = true }
+      expect(subject.finished?).to be_truthy
+    end
+  end
+
+  describe "#next_jobs" do
+    context "when one of the dependent jobs failed" do
+      it "returns only jobs with satisfied dependencies" do
+        subject.find_job('Prepare').finished = true
+        subject.find_job('FetchFirstJob').failed = true
+        expect(subject.next_jobs.map(&:name)).to match_array(["FetchSecondJob"])
+      end
+    end
+
+    it "returns next non-queued and unfinished jobs" do
+      expect(subject.next_jobs.map(&:name)).to match_array(["Prepare"])
+    end
+
+    it "returns all parallel non-queued and unfinished jobs" do
+      subject.find_job('Prepare').finished = true
+      expect(subject.next_jobs.map(&:name)).to match_array(["FetchFirstJob", "FetchSecondJob"])
+    end
+
+    it "returns empty array when there are enqueued but unfinished jobs" do
+      subject.find_job('Prepare').enqueued = true
+      expect(subject.next_jobs).to match_array([])
+    end
+
+    it "returns only unfinished and non-queued jobs from a parallel level" do
+      subject.find_job('Prepare').finished = true
+      subject.find_job('FetchFirstJob').finished = true
+      expect(subject.next_jobs.map(&:name)).to match_array(["PersistFirstJob", "FetchSecondJob"])
+    end
+
+    it "returns next level of unfished jobs after finished parallel level" do
+      subject.find_job('Prepare').finished = true
+      subject.find_job('PersistFirstJob').finished = true
+      subject.find_job('FetchFirstJob').finished = true
+      subject.find_job('FetchSecondJob').finished = true
+      expect(subject.next_jobs.map(&:name)).to match_array(["NormalizeJob"])
+    end
+
+    context "when mixing parallel tasks with synchronous" do
+      it "properly orders nested synchronous flows inside concurrent" do
+        flow = Gush::Workflow.new("workflow")
+
+        flow.run Prepare
+        flow.run NormalizeJob
+
+        flow.run FetchFirstJob, after: Prepare
+        flow.run PersistFirstJob, after: FetchFirstJob, before: NormalizeJob
+        flow.run FetchSecondJob, after: Prepare
+        flow.run PersistSecondJob, after: FetchSecondJob, before: NormalizeJob
+
+        flow.create_dependencies
+        expect(flow.next_jobs.map(&:name)).to match_array(["Prepare"])
+        flow.find_job("Prepare").finished = true
+        expect(flow.next_jobs.map(&:name)).to match_array(["FetchFirstJob", "FetchSecondJob"])
+        flow.find_job("FetchFirstJob").finished = true
+        expect(flow.next_jobs.map(&:name)).to match_array(["FetchSecondJob", "PersistFirstJob"])
+        flow.find_job("FetchSecondJob").finished = true
+        expect(flow.next_jobs.map(&:name)).to match_array(["PersistFirstJob", "PersistSecondJob"])
+        flow.find_job("PersistFirstJob").finished = true
+        expect(flow.next_jobs.map(&:name)).to match_array(["PersistSecondJob"])
+        flow.find_job("PersistSecondJob").finished = true
+        expect(flow.next_jobs.map(&:name)).to match_array(["NormalizeJob"])
+      end
+    end
+
+    it "fails when dependency resolution recurses too deep" do
+      flow = Gush::Workflow.new("workflow")
+      klass1 = Class.new(Gush::Job)
+      klass2 = Class.new(Gush::Job)
+      klass3 = Class.new(Gush::Job)
+      flow.run(klass1, after: klass3)
+      flow.run(klass2, after: klass1)
+      flow.run(klass3, after: klass2)
+      flow.create_dependencies
+
+      expect {
+        flow.next_jobs
+      }.to raise_error(DependencyLevelTooDeep)
+    end
+  end
+end

data/spec/lib/gush_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+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
+        path.delete if path.exist?
+        Gush.configuration.gushfile = path
+
+        expect { Gush.gushfile }.to raise_error(Thor::Error)
+      end
+    end
+
+    context "Gushfile.rb exists" do
+      it "returns Pathname to it" do
+        FileUtils.touch(path)
+        Gush.configuration.gushfile = path
+        expect(Gush.gushfile).to eq(path.realpath)
+        path.delete
+      end
+    end
+  end
+
+  describe ".root" do
+    it "returns root directory of Gush" do
+      expected = Pathname.new(__FILE__).parent.parent.parent
+      expect(Gush.root).to eq(expected)
+    end
+  end
+
+  describe ".configure" do
+    it "runs block with config instance passed" do
+      expect { |b| Gush.configure(&b) }.to yield_with_args(Gush.configuration)
+    end
+  end
+
+end

data/spec/redis.conf

@@ -0,0 +1,2 @@
+port 33333
+bind 127.0.0.1

data/spec/spec_helper.rb

@@ -0,0 +1,79 @@
+require 'gush'
+require 'pry'
+require 'sidekiq/testing'
+require 'bbq/spawn'
+
+Sidekiq::Logging.logger = nil
+
+class Prepare < Gush::Job;  end
+class FetchFirstJob < Gush::Job; end
+class FetchSecondJob < Gush::Job; end
+class PersistFirstJob < Gush::Job; end
+class PersistSecondJob < Gush::Job; end
+class NormalizeJob < Gush::Job; end
+
+GUSHFILE  = Pathname.new(__FILE__).parent.join("Gushfile.rb")
+
+TestLogger = Struct.new(:jid, :name) do
+  def <<(msg)
+  end
+end
+
+class TestLoggerBuilder < Gush::LoggerBuilder
+  def build
+    TestLogger.new(jid, job.name)
+  end
+end
+
+class TestWorkflow < Gush::Workflow
+  def configure
+    logger_builder TestLoggerBuilder
+
+    run Prepare
+
+    run NormalizeJob
+
+    run FetchFirstJob,   after: Prepare
+    run PersistFirstJob, after: FetchFirstJob, before: NormalizeJob
+
+    run FetchSecondJob,  after: Prepare, before: NormalizeJob
+  end
+end
+
+module GushHelpers
+  REDIS_URL = "redis://localhost:33333/"
+
+  def redis
+    @redis ||= Redis.new(url: REDIS_URL)
+  end
+
+  def client
+    @client ||= Gush::Client.new(Gush::Configuration.new(gushfile: GUSHFILE, redis_url: REDIS_URL))
+  end
+end
+
+RSpec.configure do |config|
+  config.include GushHelpers
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  orchestrator = Bbq::Spawn::Orchestrator.new
+
+  config.before(:suite) do
+    config_path = Pathname.pwd + "spec/redis.conf"
+    executor = Bbq::Spawn::Executor.new("redis-server", config_path.to_path)
+    orchestrator.coordinate(executor, host: '127.0.0.1', port: 33333)
+    orchestrator.start
+  end
+
+  config.after(:suite) do
+    orchestrator.stop
+  end
+
+  config.after(:each) do
+    Sidekiq::Worker.clear_all
+    redis.flushdb
+  end
+end