dwf 0.1.6 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a08560cdfefa1c9f8e1f42416599e94550de0f0e1492bb5b05424e2bf94a482f
-  data.tar.gz: 84a83b6849b64e7fe5da74f5734e2d8faa96df25eef63a5d0de78229fcc733ba
+  metadata.gz: fba0bf3a5195787db6540ddfe2431a265b09b78859f333ed9295b4e4677d0a25
+  data.tar.gz: 66488a6107dec45933fc1631e713db3fb43a6e31dbd5d5a351a79a6bbb31f1f7
 SHA512:
-  metadata.gz: 6eb847d86872dfa70c1a602a3ae8ef0e0ca166cfa22d0a5e3706454ef0144ac434b48489a916d811e9dc66ebb9ef4979b00b63dee8da4d08c44af6d1bd714dad
-  data.tar.gz: cda011bc87919531f5de78721c3640c2460119cb4dd5668bd4ebb8093e19d46e848d27cfc2112c10021bd41e52e2365ced092f779a25a1509086fdf7095221a9
+  metadata.gz: 88c01767c12ae11ff5f2aaeaf68b08a8c04a54bb909c51babd0f02cd915b1c8d790131c197034bbce46a8ab4d8e0dfa40a0f7afe4f1353bff65d952654438454
+  data.tar.gz: 799827548d718f4ae763c00c4519f636f448eb0aba40e6d5a60f83443cf2f479b3d8fbfd536744e11fc9092d22be3a18a7bb764b25cafcb27eccef3168ab0170

data/.github/workflows/build_gem.yaml

@@ -8,10 +8,6 @@ on:
     branches: [ master ]
     paths:
       - 'dwf.gemspec'
-  pull_request:
-    branches: [ master ]
-    paths:
-      - 'dwf.gemspec'
 
 jobs:
   build:

data/.github/workflows/test.yaml

@@ -3,7 +3,7 @@ name: Test
 on:
   push:
     branches:
-      - '**'
+      - 'master'
   pull_request:
     branches:
       - '**'

data/CHANGELOG.md

@@ -1,5 +1,86 @@
 # Changelog
 All notable changes to this project will be documented in this file.
+## 0.1.10
+### Added
+- Allow to use argument within workflow and update the defining callback way
+```
+class TestWf < Dwf::Workflow
+  def configure(arguments)
+    run A
+    run B, after: A, params: argument
+    run C, after: A, params: argument
+  end
+end
+
+wf = TestWf.create(arguments)
+wf.callback_type = Dwf::Workflow::SK_BATCH
+
+```
+- Support `find` workflow and `reload` workflow
+```
+wf = TestWf.create
+Dwf::Workflow.find(wf.id)
+wf.reload
+```
+
+## 0.1.9
+### Added
+### Fixed
+- fix incorrect argument at configuration
+
+## 0.1.8
+### Added
+- add pinlining feature
+
+```ruby
+class SendOutput < Dwf::Item
+  def perform
+    output('it works')
+  end
+end
+
+```
+
+`output` method used to output data from the job to add outgoing jobs
+
+```ruby
+class ReceiveOutput < Dwf::Item
+  def perform
+    message = payloads.first[:output] # it works
+  end
+end
+```
+
+`payloads` is an array that containing outputs from incoming jobs
+
+```
+[
+  {
+    id: "SendOutput|1849a3f9-5fce-401e-a73a-91fc1048356",
+    class: "SendOutput",
+    output: 'it works'
+  }
+]
+```
+
+```ruby
+Dwf.config do |config|
+  config.opts = { url 'redis://127.0.0.1:6379' }
+  config.namespace = 'dwf'
+end
+```
+
+## 0.1.7
+### Added
+- Allow to config redis and queue
+
+```ruby
+Dwf.config do |config|
+  config.opts = { url 'redis://127.0.0.1:6379' }
+  config.namespace = 'dwf'
+end
+```
+
 ## 0.1.6
 ### Added
 - Sidekiq batch callback: separate batches

data/README.md

@@ -4,7 +4,7 @@
 # Installation
 ## 1. Add `dwf` to Gemfile
 ```ruby
-gem 'dwf', '~> 0.1.5'
+gem 'dwf', '~> 0.1.9'
 ```
 ## 2. Execute flow
 ### Declare jobs
@@ -38,6 +38,14 @@ class TestWf < Dwf::Workflow
 end
 ```
 
+
+### Execute flow
+```ruby
+wf = TestWf.create
+wf.callback_type = Dwf::Workflow::SK_BATCH
+wf.start!
+```
+
 #### Note
 `dwf` supports 2 callback types `Dwf::Workflow::BUILD_IN` and `Dwf::Workflow::SK_BATCH`
 - `Dwf::Workflow::BUILD_IN` is a build-in callback
@@ -45,12 +53,6 @@ end
 
 By default `dwf` will use `Dwf::Workflow::BUILD_IN` callback.
 
-### Execute flow
-```ruby
-wf = TestWf.create(callback_type: Dwf::Workflow::SK_BATCH)
-wf.start!
-```
-
 ### Output
 ```
 A Working
@@ -70,14 +72,65 @@ D say hello
 D Finished
 ```
 
+# Config redis and default queue
+`dwf` uses redis as the key value stograge through [redis-rb](https://github.com/redis/redis-rb), So you can pass redis configuration by `redis_opts`
+```ruby
+Dwf.config do |config|
+  SENTINELS = [
+    { host: "127.0.0.1", port: 26380 },
+    { host: "127.0.0.1", port: 26381 }
+  ]
+  config.redis_opts = { host: 'mymaster', sentinels: SENTINELS, role: :master }
+  config.namespace = 'dwf'
+end
+```
+
+# Pinelining
+You can pass jobs result to next nodes
+
+```ruby
+class SendOutput < Dwf::Item
+  def perform
+    output('it works')
+  end
+end
+
+```
+
+`output` method used to output data from the job to add outgoing jobs
+
+```ruby
+class ReceiveOutput < Dwf::Item
+  def perform
+    message = payloads.first[:output] # it works
+  end
+end
+```
+
+`payloads` is an array that containing outputs from incoming jobs
+
+```ruby
+[
+  {
+    id: "SendOutput|1849a3f9-5fce-401e-a73a-91fc1048356",
+    class: "SendOutput",
+    output: 'it works'
+  }
+]
+```
+
 # Todo
 - [x] Make it work
 - [x] Support pass params
 - [x] Support with build-in callback
 - [x] Add github workflow
-- [ ] [WIP] Test
-- [ ] Transfer output through each node
+- [x] Redis configurable
+- [x] Pinelining
+- [X] Test
+- [ ] Consistent item name
 - [ ] Support [Resque](https://github.com/resque/resque)
+- [ ] Key value store plugable
+  - [ ] research https://github.com/moneta-rb/moneta
 
 # References
 - https://github.com/chaps-io/gush

data/dwf.gemspec

@@ -6,7 +6,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "dwf"
-  spec.version       = '0.1.6'
+  spec.version       = '0.1.10'
   spec.authors       = ["dthtien"]
   spec.email         = ["tiendt2311@gmail.com"]
 
@@ -27,5 +27,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'byebug', '~> 11.1.3'
   spec.add_dependency 'redis', '~> 4.2.0'
   spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'mock_redis', '~> 0.27.2'
   spec.add_dependency 'sidekiq', '~> 6.2.0'
 end

data/lib/dwf/callback.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
 require_relative 'client'
 
 module Dwf
   class Callback
+    DEFAULT_KEY = 'default_key'
+
     def process_next_step(status, options)
       previous_job_names = options['names']
       workflow_id = options['workflow_id']
@@ -12,7 +15,7 @@ module Dwf
       return if processing_job_names.empty?
 
       overall = Sidekiq::Batch.new(status.parent_bid)
-      overall.jobs { setup_batch(processing_job_names, workflow_id) }
+      overall.jobs { setup_batches(processing_job_names, workflow_id) }
     end
 
     def start(job)
@@ -21,38 +24,36 @@ module Dwf
 
     private
 
-    def setup_batch(processing_job_names, workflow_id)
+    def setup_batches(processing_job_names, workflow_id)
       jobs = fetch_jobs(processing_job_names, workflow_id)
       jobs_classification = classify_jobs jobs
 
-      jobs_classification.values.each do |batch_jobs|
-        batch = Sidekiq::Batch.new
-        batch.on(
-          :success,
-          'Dwf::Callback#process_next_step',
-          names: batch_jobs.map(&:klass),
-          workflow_id: workflow_id
-        )
-
-        batch.jobs do
-          batch_jobs.each do |job|
-            job.persist_and_perform_async! if job.ready_to_start?
-          end
+      jobs_classification.each do |key, batch_jobs|
+        with_lock workflow_id, key do
+          setup_batch(batch_jobs, workflow_id)
         end
       end
     end
 
+    def setup_batch(jobs, workflow_id)
+      batch = Sidekiq::Batch.new
+      batch.on(
+        :success,
+        'Dwf::Callback#process_next_step',
+        names: jobs.map(&:klass),
+        workflow_id: workflow_id
+      )
+      batch.jobs do
+        jobs.each { |job| job.persist_and_perform_async! if job.ready_to_start? }
+      end
+    end
+
     def classify_jobs(jobs)
       hash = {}
       jobs.each do |job|
         outgoing_jobs = job.outgoing
-        key = outgoing_jobs.empty? ? 'default_key' : outgoing_jobs.join
-
-        if hash[key].nil?
-          hash[key] = [job]
-        else
-          hash[key] = hash[key].push(job)
-        end
+        key = outgoing_jobs.empty? ? DEFAULT_KEY : outgoing_jobs.join
+        hash[key] = hash[key].nil? ? [job] : hash[key].push(job)
       end
 
       hash
@@ -64,13 +65,6 @@ module Dwf
       end.compact
     end
 
-    def perform_job(job_name, workflow_id)
-      with_lock workflow_id, job_name do
-        job = client.find_job(workflow_id, job_name)
-        job.persist_and_perform_async! if job.ready_to_start?
-      end
-    end
-
     def with_lock(workflow_id, job_name)
       client.check_or_lock(workflow_id, job_name)
       yield

data/lib/dwf/client.rb

@@ -1,5 +1,13 @@
+require_relative 'errors'
+
 module Dwf
   class Client
+    attr_reader :config
+
+    def initialize(config = Dwf.configuration)
+      @config = config
+    end
+
     def find_job(workflow_id, job_name)
       job_name_match = /(?<klass>\w*[^-])-(?<identifier>.*)/.match(job_name)
       data = if job_name_match
@@ -14,6 +22,16 @@ module Dwf
       Dwf::Item.from_hash(Dwf::Utils.symbolize_keys(data))
     end
 
+    def find_workflow(id)
+      data = redis.get("dwf.workflows.#{id}")
+      raise WorkflowNotFound, "Workflow with given id doesn't exist" if data.nil?
+
+      hash = JSON.parse(data)
+      hash = Dwf::Utils.symbolize_keys(hash)
+      nodes = parse_nodes(id)
+      workflow_from_hash(hash, nodes)
+    end
+
     def persist_job(job)
       redis.hset("dwf.jobs.#{job.workflow_id}.#{job.klass}", job.id, job.as_json)
     end
@@ -93,8 +111,30 @@ module Dwf
       job
     end
 
+    def parse_nodes(id)
+      keys = redis.scan_each(match: "dwf.jobs.#{id}.*")
+
+      keys.map do |key|
+        redis.hvals(key).map do |json|
+          Dwf::Utils.symbolize_keys JSON.parse(json)
+        end
+      end.flatten
+    end
+
+    def workflow_from_hash(hash, nodes = [])
+      flow = Module.const_get(hash[:klass]).new(*hash[:arguments])
+      flow.jobs = []
+      flow.stopped = hash.fetch(:stopped, false)
+      flow.id = hash[:id]
+      flow.jobs = nodes.map do |node|
+        Dwf::Item.from_hash(node)
+      end
+
+      flow
+    end
+
     def redis
-      @redis ||= Redis.new
+      @redis ||= Redis.new(config.redis_opts)
     end
   end
 end

data/lib/dwf/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Dwf
+  class Configuration
+    NAMESPACE = 'dwf'
+    REDIS_OPTS = { url: 'redis://localhost:6379' }.freeze
+
+    attr_accessor :redis_opts, :namespace
+
+    def initialize(hash = {})
+      @namespace = hash.fetch(:namespace, NAMESPACE)
+      @redis_opts = hash.fetch(:redis_opts, REDIS_OPTS)
+    end
+  end
+end

data/lib/dwf/errors.rb

@@ -0,0 +1,3 @@
+module Dwf
+    class WorkflowNotFound < StandardError; end
+end

data/lib/dwf/item.rb

@@ -1,27 +1,15 @@
 # frozen_string_literal: true
+
 require_relative 'client'
 
 module Dwf
   class Item
-    DEFAULT_QUEUE = 'default'
-
     attr_reader :workflow_id, :id, :params, :queue, :klass, :started_at,
-      :enqueued_at, :finished_at, :failed_at, :callback_type
+      :enqueued_at, :finished_at, :failed_at, :callback_type, :output_payload
     attr_accessor :incoming, :outgoing
 
     def initialize(options = {})
-      @workflow_id = options[:workflow_id]
-      @id = options[:id]
-      @params = options[:params]
-      @queue = options[:queue] || DEFAULT_QUEUE
-      @incoming = options[:incoming] || []
-      @outgoing = options[:outgoing] || []
-      @klass = options[:klass] || self.class
-      @failed_at = options[:failed_at]
-      @finished_at = options[:finished_at]
-      @enqueued_at = options[:enqueued_at]
-      @started_at = options[:started_at]
-      @callback_type = options[:callback_type]
+      assign_attributes(options)
     end
 
     def self.from_hash(hash)
@@ -40,14 +28,24 @@ module Dwf
       callback_type == Dwf::Workflow::BUILD_IN
     end
 
+    def reload
+      item = client.find_job(workflow_id, name)
+      assign_attributes(item.to_hash)
+    end
+
     def perform_async
-      Dwf::Worker.set(queue: queue).perform_async(workflow_id, name)
+      Dwf::Worker.set(queue: queue || client.config.namespace)
+                 .perform_async(workflow_id, name)
     end
 
     def name
       @name ||= "#{klass}|#{id}"
     end
 
+    def output(data)
+      @output_payload = data
+    end
+
     def no_dependencies?
       incoming.empty?
     end
@@ -58,6 +56,17 @@ module Dwf
       end
     end
 
+    def payloads
+      incoming.map do |job_name|
+        job = client.find_job(workflow_id, job_name)
+        {
+          id: job.name,
+          class: job.klass.to_s,
+          output: job.output_payload
+        }
+      end
+    end
+
     def enqueue!
       @enqueued_at = current_timestamp
       @started_at = nil
@@ -142,7 +151,8 @@ module Dwf
         failed_at: failed_at,
         params: params,
         workflow_id: workflow_id,
-        callback_type: callback_type
+        callback_type: callback_type,
+        output_payload: output_payload
       }
     end
 
@@ -159,5 +169,21 @@ module Dwf
     def client
       @client ||= Dwf::Client.new
     end
+
+    def assign_attributes(options)
+      @workflow_id = options[:workflow_id]
+      @id = options[:id]
+      @params = options[:params]
+      @queue = options[:queue]
+      @incoming = options[:incoming] || []
+      @outgoing = options[:outgoing] || []
+      @klass = options[:klass] || self.class
+      @failed_at = options[:failed_at]
+      @finished_at = options[:finished_at]
+      @enqueued_at = options[:enqueued_at]
+      @started_at = options[:started_at]
+      @callback_type = options[:callback_type]
+      @output_payload = options[:output_payload]
+    end
   end
 end

data/lib/dwf/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Dwf
+  VERSION = '0.1.8'
+end

data/lib/dwf/worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sidekiq'
 require_relative 'client'
 
@@ -7,7 +9,7 @@ module Dwf
 
     def perform(workflow_id, job_name)
       job = client.find_job(workflow_id, job_name)
-      return job.enqueue_outgoing_jobs if job. succeeded?
+      return job.enqueue_outgoing_jobs if job.succeeded?
 
       job.mark_as_started
       job.perform

data/lib/dwf/workflow.rb

@@ -10,8 +10,8 @@ module Dwf
       BUILD_IN = 'build-in',
       SK_BATCH = 'sk-batch'
     ].freeze
-    attr_reader :dependencies, :jobs, :started_at, :finished_at, :persisted, :stopped,
-                :callback_type
+    attr_accessor :jobs, :callback_type, :stopped, :id
+    attr_reader :dependencies, :started_at, :finished_at, :persisted, :arguments
 
     class << self
       def create(*args)
@@ -19,41 +19,58 @@ module Dwf
         flow.save
         flow
       end
+
+      def find(id)
+        Dwf::Client.new.find_workflow(id)
+      end
     end
 
-    def initialize(options = {})
+    def initialize(*args)
       @dependencies = []
-      @id = id
+      @id = build_id
       @jobs = []
       @persisted = false
       @stopped = false
-      @callback_type = options[:callback_type] || BUILD_IN
+      @arguments = args
+      @callback_type = BUILD_IN
 
       setup
     end
 
+    def persist!
+      client.persist_workflow(self)
+      jobs.each(&:persist!)
+      mark_as_persisted
+      true
+    end
+
+    alias save persist!
+
     def start!
+      mark_as_started
+      persist!
       initial_jobs.each do |job|
         cb_build_in? ? job.persist_and_perform_async! : Dwf::Callback.new.start(job)
       end
     end
 
-    def save
-      client.persist_workflow(self)
-      jobs.each(&:persist!)
-      mark_as_persisted
-      true
+    def reload
+      flow = self.class.find(id)
+      self.stopped = flow.stopped
+      self.jobs = flow.jobs
+
+      self
     end
 
     def cb_build_in?
       callback_type == BUILD_IN
     end
 
-    def id
-      @id ||= client.build_workflow_id
+    def build_id
+      client.build_workflow_id
     end
 
-    def configure; end
+    def configure(*arguments); end
 
     def run(klass, options = {})
       node = klass.new(
@@ -140,7 +157,6 @@ module Dwf
       @stopped = false
     end
 
-
     private
 
     def initial_jobs
@@ -148,7 +164,7 @@ module Dwf
     end
 
     def setup
-      configure
+      configure(*arguments)
       resolve_dependencies
     end
 

data/lib/dwf.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "bundler/setup"
 
 require 'sidekiq'
@@ -12,8 +13,15 @@ require_relative 'dwf/item'
 require_relative 'dwf/client'
 require_relative 'dwf/worker'
 require_relative 'dwf/callback'
+require_relative 'dwf/configuration'
 
 module Dwf
-  VERSION = '0.1.6'
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.config
+    yield configuration
+  end
 end
 

data/spec/dwf/client_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mock_redis'
+
+describe Dwf::Client, client: true do
+  let(:client) { described_class.new }
+  let(:workflow_id) { SecureRandom.uuid }
+  let(:id) { SecureRandom.uuid }
+  let(:redis) { Redis.new }
+  before do
+    redis_instance = MockRedis.new
+    allow(Redis).to receive(:new).and_return redis_instance
+  end
+
+  describe '#find_job' do
+    let!(:job) do
+      j = Dwf::Item.new(workflow_id: workflow_id, id: id)
+      j.persist!
+      j
+    end
+
+    context 'find by item class name' do
+      it {
+        item = client.find_job(workflow_id, Dwf::Item.name)
+        expect(item.workflow_id).to eq workflow_id
+        expect(item.id).to eq id
+        expect(item.name).to eq job.name
+      }
+    end
+
+    context 'find by item name' do
+      it {
+        item = client.find_job(workflow_id, job.name)
+        expect(item.workflow_id).to eq workflow_id
+        expect(item.id).to eq id
+        expect(item.name).to eq job.name
+      }
+    end
+  end
+
+  describe '#find_workflow' do
+    before do
+      wf = Dwf::Workflow.new
+      wf.id = workflow_id
+      wf.save
+      j = Dwf::Item.new(id: id, workflow_id: workflow_id)
+      j.persist!
+    end
+
+    it do
+      wf = client.find_workflow(workflow_id)
+
+      expect(wf).not_to be_nil
+      expect(wf.jobs.first).to be_kind_of(Dwf::Item)
+    end
+
+    it do
+      expect do
+        client.find_workflow(SecureRandom.uuid)
+      end.to raise_error Dwf::WorkflowNotFound
+    end
+  end
+
+  describe '#persist_job' do
+    let!(:job) { Dwf::Item.new(workflow_id: workflow_id, id: id) }
+
+    it do
+      expect(redis.exists?("dwf.jobs.#{job.workflow_id}.#{job.klass}"))
+        .to be_falsy
+
+      client.persist_job(job)
+
+      expect(redis.exists?("dwf.jobs.#{job.workflow_id}.#{job.klass}"))
+        .to be_truthy
+    end
+  end
+
+  describe '#persist_workflow' do
+    let(:workflow) { Dwf::Workflow.new }
+
+    it do
+      expect(redis.exists?("dwf.workflows.#{workflow.id}")).to be_falsy
+      client.persist_workflow(workflow)
+      expect(redis.exists?("dwf.workflows.#{workflow.id}")).to be_truthy
+    end
+  end
+
+  describe '#check_or_lock' do
+    before do
+      allow_any_instance_of(described_class).to receive(:sleep)
+    end
+
+    context 'job is running' do
+      let(:job_name) { 'ahihi' }
+
+      before do
+        allow(client).to receive(:set)
+        redis.set("wf_enqueue_outgoing_jobs_#{workflow_id}-#{job_name}", 'running')
+        client.check_or_lock(workflow_id, job_name)
+      end
+
+      it { expect(client).not_to have_received(:set) }
+    end
+
+    context 'job is not running' do
+      let(:job_name) { 'ahihi' }
+
+      before do
+        allow(redis).to receive(:set)
+        client.check_or_lock(workflow_id, job_name)
+      end
+
+      it do
+        expect(redis).to have_received(:set)
+          .with("wf_enqueue_outgoing_jobs_#{workflow_id}-#{job_name}", 'running')
+      end
+    end
+  end
+
+  describe '#release_lock' do
+    before do
+      allow(redis).to receive(:del)
+      client.release_lock(workflow_id, 'ahihi')
+    end
+
+    it do
+      expect(redis).to have_received(:del)
+        .with("dwf_enqueue_outgoing_jobs_#{workflow_id}-ahihi")
+    end
+  end
+
+  describe '#build_job_id' do
+    before do
+      allow(redis).to receive(:hexists)
+      client.build_job_id(workflow_id, 'ahihi')
+    end
+
+    it { expect(redis).to have_received(:hexists) }
+  end
+
+  describe '#build_workflow_id' do
+    before do
+      allow(redis).to receive(:exists?)
+      client.build_workflow_id
+    end
+
+    it { expect(redis).to have_received(:exists?) }
+  end
+
+  describe '#key_exists?' do
+    before do
+      allow(redis).to receive(:exists?)
+      client.key_exists?('ahihi')
+    end
+
+    it { expect(redis).to have_received(:exists?).with('ahihi') }
+  end
+
+  describe '#set' do
+    before do
+      allow(redis).to receive(:set)
+      client.set('ahihi', 'a')
+    end
+
+    it { expect(redis).to have_received(:set).with('ahihi', 'a') }
+  end
+
+  describe '#delete' do
+    before do
+      allow(redis).to receive(:del)
+      client.delete('ahihi')
+    end
+
+    it { expect(redis).to have_received(:del).with('ahihi') }
+  end
+end

data/spec/dwf/configuration_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Dwf::Configuration, configuration: true do
+  let(:configuration) { described_class.new }
+
+  specify do
+    expect(configuration.namespace).to eq described_class::NAMESPACE
+    expect(configuration.redis_opts).to eq described_class::REDIS_OPTS
+  end
+end

data/spec/dwf/item_spec.rb

@@ -16,7 +16,7 @@ describe Dwf::Item, item: true do
       params: {},
       incoming: incoming,
       outgoing: outgoing,
-      queue: Dwf::Item::DEFAULT_QUEUE,
+      queue: Dwf::Configuration::NAMESPACE,
       klass: 'Dwf::Item',
       started_at: started_at,
       finished_at: finished_at,
@@ -181,4 +181,40 @@ describe Dwf::Item, item: true do
       it { expect(a_item).not_to have_received(:persist_and_perform_async!) }
     end
   end
+
+  describe '#output' do
+    before { item.output(1) }
+
+    it { expect(item.output_payload).to eq 1 }
+  end
+
+  describe '#payloads' do
+    let(:incoming) { ["A|#{SecureRandom.uuid}"] }
+    let(:client_double) { double(find_job: nil) }
+    let!(:a_item) do
+      described_class.new(
+        workflow_id: SecureRandom.uuid,
+        id: SecureRandom.uuid,
+        finished_at: finished_at,
+        output_payload: 1
+      )
+    end
+
+    before do
+      allow(Dwf::Client).to receive(:new).and_return client_double
+      allow(client_double)
+        .to receive(:find_job).and_return a_item
+    end
+
+    it do
+      expected_payload = [
+        {
+          class: a_item.class.name,
+          id: a_item.name,
+          output: 1
+        }
+      ]
+      expect(item.payloads).to eq expected_payload
+    end
+  end
 end

data/spec/dwf/worker_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mock_redis'
+require 'sidekiq/testing'
+
+describe Dwf::Worker, client: true do
+  let(:workflow_id) { SecureRandom.uuid }
+  let(:id) { SecureRandom.uuid }
+  let(:redis) { Redis.new }
+  let(:worker) { described_class.perform_async(workflow_id, job.name) }
+  before do
+    redis_instance = MockRedis.new
+    allow(Redis).to receive(:new).and_return redis_instance
+  end
+
+  describe '#find_job' do
+    let!(:job) do
+      j = Dwf::Item.new(workflow_id: workflow_id, id: id)
+      j.persist!
+      j
+    end
+
+    before do
+      worker
+      Sidekiq::Worker.drain_all
+      job.reload
+    end
+
+    it { expect(job.finished?).to be_truthy }
+  end
+end

data/spec/dwf/workflow_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mock_redis'
+class AItem < Dwf::Item; end
+
+class BItem < Dwf::Item; end
+
+class CItem < Dwf::Item; end
+
+describe Dwf::Workflow, workflow: true do
+  let(:workflow_id) { SecureRandom.uuid }
+  let(:item_id) { SecureRandom.uuid }
+  let(:client) do
+    double(
+      persist_workflow: nil,
+      persist_job: nil,
+      build_workflow_id: workflow_id,
+      build_job_id: item_id,
+      find_workflow: 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
+    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
+        }
+      ]
+      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 CItem, after: BItem
+
+      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']
+      expect(job_b.outgoing).to eq ["CItem|#{item_id}"]
+
+      job_c = workflow.find_job('CItem')
+
+      expect(job_c.incoming).to eq ['BItem']
+      expect(job_c.outgoing).to be_empty
+    end
+  end
+
+  describe '#callback_type' do
+    let!(:workflow) { described_class.new }
+
+    it {
+      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
+
+  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
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dwf
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.10
 platform: ruby
 authors:
 - dthtien
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-06 00:00:00.000000000 Z
+date: 2021-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !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: sidekiq
   requirement: !ruby/object:Gem::Requirement
@@ -86,12 +100,19 @@ files:
 - lib/dwf.rb
 - lib/dwf/callback.rb
 - lib/dwf/client.rb
+- lib/dwf/configuration.rb
+- lib/dwf/errors.rb
 - lib/dwf/item.rb
 - lib/dwf/utils.rb
+- lib/dwf/version.rb
 - lib/dwf/worker.rb
 - lib/dwf/workflow.rb
+- 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
 homepage: https://github.com/dthtien/wf
 licenses:
@@ -118,6 +139,10 @@ specification_version: 4
 summary: Gush cloned without ActiveJob but requried Sidekiq. This project is for researching
   DSL purpose
 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