dwf 0.1.8 → 0.1.12

data/spec/dwf/item_spec.rb

@@ -20,7 +20,8 @@ describe Dwf::Item, item: true do
       klass: 'Dwf::Item',
       started_at: started_at,
       finished_at: finished_at,
-      callback_type: Dwf::Workflow::BUILD_IN
+      callback_type: Dwf::Workflow::BUILD_IN,
+      payloads: nil
     }
   end
   let!(:item) { described_class.new(options) }
@@ -89,7 +90,7 @@ describe Dwf::Item, item: true do
     before do
       allow(Dwf::Client).to receive(:new).and_return client_double
       allow(client_double)
-        .to receive(:find_job).and_return a_item
+        .to receive(:find_node).and_return a_item
     end
 
     context 'parent jobs already finished' do
@@ -98,8 +99,8 @@ describe Dwf::Item, item: true do
       it do
         expect(item.parents_succeeded?).to be_truthy
         expect(client_double)
-          .to have_received(:find_job)
-          .with(workflow_id, incoming.first)
+          .to have_received(:find_node)
+          .with(incoming.first, workflow_id)
       end
     end
 
@@ -109,8 +110,8 @@ describe Dwf::Item, item: true do
       it do
         expect(item.parents_succeeded?).to be_falsy
         expect(client_double)
-          .to have_received(:find_job)
-          .with(workflow_id, incoming.first)
+          .to have_received(:find_node)
+          .with(incoming.first, workflow_id)
       end
     end
   end
@@ -148,37 +149,55 @@ describe Dwf::Item, item: true do
   end
 
   describe '#enqueue_outgoing_jobs' do
-    let(:outgoing) { ["A|#{SecureRandom.uuid}"] }
     let(:client_double) do
       double(
-        find_job: nil,
+        find_node: nil,
         check_or_lock: nil,
-        release_lock: nil
+        release_lock: nil,
+        build_workflow_id: SecureRandom.uuid
       )
     end
-    let(:a_item) do
-      described_class.new(
-        workflow_id: SecureRandom.uuid,
-        id: SecureRandom.uuid,
-        started_at: started_at
-      )
-    end
-    before do
-      allow(Dwf::Client).to receive(:new).and_return client_double
-      allow(a_item).to receive(:persist_and_perform_async!)
-      allow(client_double)
-        .to receive(:find_job).and_return a_item
-      item.enqueue_outgoing_jobs
-    end
 
-    context 'outgoing jobs ready to start' do
-      let(:started_at) { nil }
-      it { expect(a_item).to have_received(:persist_and_perform_async!) }
+    context 'when item is not a leaf' do
+      let(:outgoing) { ["A|#{SecureRandom.uuid}"] }
+      let(:a_item) do
+        described_class.new(
+          workflow_id: SecureRandom.uuid,
+          id: SecureRandom.uuid,
+          started_at: started_at
+        )
+      end
+      before do
+        allow(Dwf::Client).to receive(:new).and_return client_double
+        allow(a_item).to receive(:persist_and_perform_async!)
+        allow(client_double)
+          .to receive(:find_node).and_return a_item
+        item.enqueue_outgoing_jobs
+      end
+
+      context 'outgoing jobs ready to start' do
+        let(:started_at) { nil }
+        it { expect(a_item).to have_received(:persist_and_perform_async!) }
+      end
+
+      context 'outgoing jobs havent ready to start' do
+        let(:started_at) { Time.now.to_i }
+        it { expect(a_item).not_to have_received(:persist_and_perform_async!) }
+      end
     end
 
-    context 'outgoing jobs havent ready to start' do
-      let(:started_at) { Time.now.to_i }
-      it { expect(a_item).not_to have_received(:persist_and_perform_async!) }
+    context 'when item is a leaf' do
+      let(:leaf) { true }
+      let(:workflow) { Dwf::Workflow.new }
+      before do
+        allow(Dwf::Client).to receive(:new).and_return client_double
+        allow(client_double).to receive(:find_workflow).and_return workflow
+        allow(workflow).to receive(:enqueue_outgoing_jobs)
+        item.enqueue_outgoing_jobs
+      end
+
+      let(:started_at) { nil }
+      it { expect(workflow).to have_received(:enqueue_outgoing_jobs) }
     end
   end
 
@@ -189,8 +208,9 @@ describe Dwf::Item, item: true do
   end
 
   describe '#payloads' do
-    let(:incoming) { ["A|#{SecureRandom.uuid}"] }
-    let(:client_double) { double(find_job: nil) }
+    let(:incoming) { ["Dwf::Item|#{SecureRandom.uuid}", "Dwf::Workflow|#{workflow_id}"] }
+    let(:client_double) { double(find_job: nil, build_workflow_id: workflow_id) }
+    let(:workflow) { Dwf::Workflow.new }
     let!(:a_item) do
       described_class.new(
         workflow_id: SecureRandom.uuid,
@@ -203,7 +223,11 @@ describe Dwf::Item, item: true do
     before do
       allow(Dwf::Client).to receive(:new).and_return client_double
       allow(client_double)
-        .to receive(:find_job).and_return a_item
+        .to receive(:find_node)
+        .with(incoming.first, workflow_id).and_return a_item
+      allow(client_double)
+        .to receive(:find_node)
+        .with(incoming.last, workflow_id).and_return workflow
     end
 
     it do
@@ -212,9 +236,42 @@ describe Dwf::Item, item: true do
           class: a_item.class.name,
           id: a_item.name,
           output: 1
+        },
+        {
+          class: workflow.class.name,
+          id: workflow.name,
+          output: []
         }
       ]
-      expect(item.payloads).to eq expected_payload
+      expect(item.payloads).to match_array expected_payload
+    end
+  end
+
+  describe '#start_batch!' do
+    let(:callback_double) { double(start: nil) }
+    let(:client_double) { double(persist_job: nil) }
+
+    before do
+      allow(Dwf::Client).to receive(:new).and_return client_double
+      allow(Dwf::Callback).to receive(:new).and_return callback_double
+      item.start_batch!
+    end
+
+    it do
+      expect(callback_double).to have_received(:start).with(item)
+      expect(item.enqueued_at).not_to be_nil
+    end
+  end
+
+  describe '#leaf?' do
+    context 'when item has outgoing item' do
+      let(:outgoing) { ["Dwf::Item|#{SecureRandom.uuid}"] }
+      it { expect(item.leaf?).to be_falsy }
+    end
+
+    context 'when item does not have outgoing item' do
+      let(:outgoing) { [] }
+      it { expect(item.leaf?).to be_truthy }
     end
   end
 end

data/spec/dwf/utils_spec.rb

@@ -20,4 +20,13 @@ describe Dwf::Utils, utils: true do
 
     it { expect(described_class.symbolize_keys(hash)).to eq expected }
   end
+
+  describe "#workflow_name?" do
+    FirstWorkflow = Class.new(Dwf::Workflow)
+    FirstJob = Class.new(Dwf::Item)
+
+    it { expect(described_class.workflow_name?(Dwf::Workflow.name)).to be_truthy }
+    it { expect(described_class.workflow_name?(FirstWorkflow.name)).to be_truthy }
+    it { expect(described_class.workflow_name?(FirstJob.name)).to be_falsy }
+  end
 end

data/spec/dwf/workflow_spec.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mock_redis'
+AItem = Class.new(Dwf::Item)
+BItem = Class.new(Dwf::Item)
+CItem = Class.new(Dwf::Item)
+SWorkflow = Class.new(Dwf::Workflow)
+
+describe Dwf::Workflow, workflow: true do
+  let(:workflow_id) { SecureRandom.uuid }
+  let(:item_id) { SecureRandom.uuid }
+  let(:item) { nil }
+  let(:client) do
+    double(
+      persist_workflow: nil,
+      persist_job: nil,
+      build_workflow_id: workflow_id,
+      build_job_id: item_id,
+      find_workflow: nil,
+      find_node: item,
+      check_or_lock: nil,
+      release_lock: nil
+    )
+  end
+  before do
+    allow(Dwf::Client).to receive(:new).and_return client
+  end
+
+  describe '#create' do
+    it do
+      workflow = described_class.create
+      expect(client).to have_received(:persist_workflow)
+        .with(an_instance_of(described_class))
+      expect(workflow.id).to eq workflow_id
+      expect(workflow.persisted).to be_truthy
+    end
+  end
+
+  describe '#find' do
+    before { Dwf::Workflow.find(workflow_id) }
+
+    it { expect(client).to have_received(:find_workflow).with(workflow_id) }
+  end
+
+  describe '#persist!' do
+    let(:workflow) { described_class.new }
+    let(:job) do
+      Dwf::Item.new(
+        worflow_id: workflow_id,
+        id: item_id
+      )
+    end
+    before do
+      workflow.jobs << job
+      workflow.persist!
+    end
+
+    it do
+      expect(client).to have_received(:persist_workflow)
+        .with(an_instance_of(described_class))
+      expect(client).to have_received(:persist_job).with(job)
+      expect(workflow.id).to eq workflow_id
+      expect(workflow.persisted).to be_truthy
+    end
+  end
+
+  describe '#start' do
+    let(:workflow) { described_class.new }
+    let(:job) do
+      Dwf::Item.new(
+        worflow_id: workflow_id,
+        id: item_id
+      )
+    end
+    before do
+      workflow.jobs << job
+      workflow.persist!
+    end
+
+    it do
+      expect(client).to have_received(:persist_workflow)
+        .with(an_instance_of(described_class))
+      expect(client).to have_received(:persist_job).with(job)
+      expect(workflow.id).to eq workflow_id
+      expect(workflow.persisted).to be_truthy
+      expect(workflow.stopped).to be_falsy
+    end
+  end
+
+  describe '#run' do
+    let!(:workflow) { described_class.new }
+
+    before do
+      workflow.run AItem, after: BItem, before: CItem
+      workflow.run SWorkflow, after: AItem
+    end
+
+    it do
+      expect(workflow.jobs).not_to be_empty
+      expected = [
+        {
+          from: BItem.to_s,
+          to: "AItem|#{item_id}"
+        },
+        {
+          from: "AItem|#{item_id}",
+          to: CItem.to_s
+        },
+        {
+          from: AItem.to_s,
+          to: "SWorkflow|#{workflow_id}"
+        }
+      ]
+      expect(workflow.dependencies).to match_array expected
+    end
+  end
+
+  describe '#find_job' do
+    let!(:workflow) { described_class.new }
+    before do
+      workflow.jobs = [
+        AItem.new,
+        BItem.new(id: item_id),
+        CItem.new
+      ]
+    end
+
+    it 'searches by klass' do
+      job = workflow.find_job('AItem')
+      expect(job).to be_kind_of AItem
+    end
+
+    it 'searches by name' do
+      job = workflow.find_job("BItem|#{item_id}")
+      expect(job).to be_kind_of BItem
+    end
+  end
+
+  describe '#setup' do
+    let!(:workflow) { described_class.new }
+    before do
+      workflow.run AItem
+      workflow.run BItem, after: AItem
+      workflow.run SWorkflow, after: BItem
+      workflow.run CItem, after: SWorkflow
+
+      workflow.send(:setup)
+    end
+
+    it do
+      job_a = workflow.find_job("AItem")
+
+      expect(job_a.incoming).to be_empty
+      expect(job_a.outgoing).to eq ["BItem|#{item_id}"]
+
+      job_b = workflow.find_job('BItem')
+
+      expect(job_b.incoming).to eq ["AItem|#{item_id}"]
+      expect(job_b.outgoing).to eq ["SWorkflow|#{workflow_id}"]
+
+      job_c = workflow.find_job('CItem')
+
+      expect(job_c.incoming).to eq ["SWorkflow|#{workflow_id}"]
+      expect(job_c.outgoing).to be_empty
+    end
+  end
+
+  describe '#callback_type' do
+    let!(:workflow) { described_class.new }
+
+    it do
+      expect(workflow.callback_type).to eq described_class::BUILD_IN
+      workflow.callback_type = described_class::SK_BATCH
+      expect(workflow.callback_type).to eq described_class::SK_BATCH
+    end
+  end
+
+  describe '#reload' do
+    let!(:workflow) do
+      flow = described_class.new
+      flow.id = workflow_id
+      flow
+    end
+
+    before do
+      allow(client).to receive(:find_workflow).and_return workflow
+      workflow.reload
+    end
+
+    it { expect(client).to have_received(:find_workflow).with(workflow_id) }
+  end
+
+  describe '#parents_succeeded?' do
+    let(:incoming) { ["A|#{SecureRandom.uuid}"] }
+    let!(:workflow) do
+      flow = described_class.new
+      flow.parent_id = SecureRandom.uuid
+      flow.incoming = incoming
+      flow
+    end
+    let(:item) do
+      Dwf::Item.new(
+        workflow_id: SecureRandom.uuid,
+        id: SecureRandom.uuid,
+        finished_at: finished_at
+      )
+    end
+
+    context 'parent jobs already finished' do
+      let(:finished_at) { Time.now.to_i }
+
+      it do
+        expect(workflow.parents_succeeded?).to be_truthy
+        expect(client).to have_received(:find_node)
+          .with(incoming.first, workflow.parent_id)
+      end
+    end
+
+    context 'parent jobs havent finished yet' do
+      let(:finished_at) { nil }
+
+      it do
+        expect(workflow.parents_succeeded?).to be_falsy
+        expect(client)
+          .to have_received(:find_node)
+          .with(incoming.first, workflow.parent_id)
+      end
+    end
+  end
+
+  describe '#sub_workflow?' do
+    let!(:workflow) { described_class.new }
+    let!(:sub_workflow) do
+      flow = described_class.new
+      flow.parent_id = workflow.id
+      flow
+    end
+
+    specify do
+      expect(workflow.sub_workflow?).to be_falsy
+      expect(sub_workflow.sub_workflow?).to be_truthy
+    end
+  end
+
+  describe '#payloads' do
+    let!(:item) do
+      Dwf::Item.new(
+        workflow_id: SecureRandom.uuid,
+        id: SecureRandom.uuid,
+        output_payload: 1
+      )
+    end
+    let(:workflow) { described_class.new }
+
+    context 'when workflow is main flow' do
+      it { expect(workflow.payloads).to be_nil }
+    end
+
+    context 'when workflow is sub flow' do
+      before do
+        workflow.incoming = incoming
+        workflow.parent_id = SecureRandom.uuid
+      end
+
+      context 'when incoming blank' do
+        let(:incoming) { [] }
+        it { expect(workflow.payloads).to be_nil }
+      end
+
+      context 'when incoming present' do
+        let(:incoming) { ["Dwf::Item|#{SecureRandom.uuid}", "Dwf::Workflow|#{workflow_id}"] }
+        it do
+          expected_payload = [
+            {
+              class: item.class.name,
+              id: item.name,
+              output: 1
+            }
+          ]
+          expect(workflow.payloads).to eq expected_payload
+          expect(client).to have_received(:find_node).with(incoming.first, workflow.parent_id)
+        end
+      end
+    end
+  end
+
+  describe '#left?' do
+    let(:workflow) { described_class.new }
+    before { workflow.outgoing = outgoing }
+
+    context 'when item has outgoing item' do
+      let(:outgoing) { ["Dwf::Item|#{SecureRandom.uuid}"] }
+      it { expect(workflow.leaf?).to be_falsy }
+    end
+
+    context 'when item does not have outgoing item' do
+      let(:outgoing) { [] }
+      it { expect(workflow.leaf?).to be_truthy }
+    end
+  end
+
+  describe '#leaf_nodes' do
+    let!(:workflow) { described_class.new }
+    before do
+      workflow.run AItem
+      workflow.run BItem, after: AItem
+      workflow.run SWorkflow, after: BItem
+      workflow.run CItem, after: SWorkflow
+
+      workflow.send(:setup)
+    end
+
+    specify do
+      expect(workflow.leaf_nodes.count).to eq 1
+      expect(workflow.leaf_nodes.first).to be_kind_of CItem
+    end
+  end
+
+  describe '#output_payloads' do
+    let!(:workflow) { described_class.new }
+    before do
+      allow_any_instance_of(CItem).to receive(:output_payload).and_return 1
+      workflow.run AItem
+      workflow.run BItem, after: AItem
+      workflow.run SWorkflow, after: BItem
+      workflow.run CItem, after: SWorkflow
+
+      workflow.send(:setup)
+    end
+
+    it { expect(workflow.output_payload).to eq [1] }
+  end
+
+  describe '#callback_type=' do
+    let!(:workflow) { described_class.new }
+    before do
+      workflow.run AItem
+      workflow.run BItem, after: AItem
+
+      workflow.send(:setup)
+      workflow.callback_type = described_class::SK_BATCH
+    end
+
+    specify do
+      expect(workflow.callback_type).to eq described_class::SK_BATCH
+      job_callback_types = workflow.jobs.map(&:callback_type).uniq
+      expect(job_callback_types).to eq [described_class::SK_BATCH]
+    end
+  end
+
+  describe '#enqueue_outgoing_jobs' do
+    let(:outgoing) { ["A|#{SecureRandom.uuid}"] }
+    let!(:workflow) do
+      flow = described_class.new
+      flow.parent_id = SecureRandom.uuid
+      flow.outgoing = outgoing
+      flow
+    end
+    let(:item) do
+      Dwf::Item.new(
+        workflow_id: SecureRandom.uuid,
+        id: SecureRandom.uuid,
+        started_at: started_at
+      )
+    end
+    before do
+      allow(item).to receive(:persist_and_perform_async!)
+      workflow.enqueue_outgoing_jobs
+    end
+
+    context 'outgoing jobs ready to start' do
+      let(:started_at) { nil }
+      it { expect(item).to have_received(:persist_and_perform_async!) }
+    end
+
+    context 'outgoing jobs havent ready to start' do
+      let(:started_at) { Time.now.to_i }
+      it { expect(item).not_to have_received(:persist_and_perform_async!) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,7 @@
 require 'dwf'
+require 'simplecov'
+
+SimpleCov.start
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # The generated `.rspec` file contains `--require spec_helper` which will cause

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dwf
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.12
 platform: ruby
 authors:
 - dthtien
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-09 00:00:00.000000000 Z
+date: 2021-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 11.1.3
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.27.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.27.2
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -53,33 +67,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: mock_redis
+  name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.27.2
-  type: :development
+        version: 6.2.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.27.2
+        version: 6.2.0
 - !ruby/object:Gem::Dependency
-  name: sidekiq
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 6.2.0
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 6.2.0
+        version: '0'
 description: Workflow
 email:
 - tiendt2311@gmail.com
@@ -100,7 +114,9 @@ files:
 - lib/dwf.rb
 - lib/dwf/callback.rb
 - lib/dwf/client.rb
+- lib/dwf/concerns/checkable.rb
 - lib/dwf/configuration.rb
+- lib/dwf/errors.rb
 - lib/dwf/item.rb
 - lib/dwf/utils.rb
 - lib/dwf/version.rb
@@ -111,6 +127,7 @@ files:
 - spec/dwf/item_spec.rb
 - spec/dwf/utils_spec.rb
 - spec/dwf/worker_spec.rb
+- spec/dwf/workflow_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/dthtien/wf
 licenses:
@@ -134,12 +151,12 @@ requirements: []
 rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
-summary: Gush cloned without ActiveJob but requried Sidekiq. This project is for researching
-  DSL purpose
+summary: Distributed workflow runner following Gush interface using Sidekiq and Redis
 test_files:
 - spec/dwf/client_spec.rb
 - spec/dwf/configuration_spec.rb
 - spec/dwf/item_spec.rb
 - spec/dwf/utils_spec.rb
 - spec/dwf/worker_spec.rb
+- spec/dwf/workflow_spec.rb
 - spec/spec_helper.rb