dwf 0.1.3 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0057d6d96f647afa204d1ece11e64444df31b3db21c6ceda3ac92ac73c134105
-  data.tar.gz: f7f1aff90493a9396a7bf13f9e7f6a3c348e32022e73e907ef8571b89c70efd6
+  metadata.gz: fb0f6f6f30b7ed1ba19120a4a1f77e450940e45433153de51f47df9f108d0fae
+  data.tar.gz: e0e86fdd169b7cbcdc811cf62f87b3043fbbd708bdf0f41fb006b392e4ab784b
 SHA512:
-  metadata.gz: 9207d683e57e95e8fd3e555c2a589fb4be793a8a4cafc479e2446fdd1ab3e180b72154b4c4b8f93aca92bd06159ec8eb3df448ffce0b742bd647ec723088ef4d
-  data.tar.gz: 41fdfb04643bdba4e7afda031308c19a347762aebc281fd42ac7f4be6be5d932a8a2fb610d38276338c07ac0b2835e3e12585796b7d39266e3a97976a39a4e7c
+  metadata.gz: 4a3770d4d7f63b7ede02d59e1ce43cb2634b39cbd9e037c920e4f816acb7b393de0f9030fda735e8ea0873f3679da120ff405f725e87c60c1b9eb6a7fbf355e3
+  data.tar.gz: 469e25cdf11441c59c80ff47197dcabcf40e0b086ab06babb6b39a0597483517c479ee9ea65767819b69afebf83db6dcdb5926a9839a2e40d02c03cf39a6eb57

data/.github/workflows/build_gem.yaml

@@ -0,0 +1,37 @@
+name: Ruby Gem
+
+on:
+  # Manually publish
+  workflow_dispatch:
+  # Alternatively, publish whenever changes are merged to the `main` branch.
+  push:
+    branches: [ master ]
+    paths:
+      - 'dwf.gemspec'
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby 3.0.0
+        uses: ruby/setup-ruby@477b21f02be01bcb8030d50f37cfec92bfa615b6
+        with:
+          ruby-version: 3.0.0
+      - run: bundle install
+
+      - name: Publish to RubyGems
+        run: |
+          mkdir -p $HOME/.gem
+          touch $HOME/.gem/credentials
+          chmod 0600 $HOME/.gem/credentials
+          printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+          gem build *.gemspec
+          gem push *.gem
+        env:
+          GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/.github/workflows/test.yaml

@@ -0,0 +1,25 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - 'master'
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@477b21f02be01bcb8030d50f37cfec92bfa615b6
+        with:
+          ruby-version: 3.0.0
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rspec --require spec_helper

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--color
+--format documentation

data/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+## 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
+
+## 0.1.5
+### Added
+- add github action with build and public gem flow
+
+## 0.1.4
+### Added
+- Add testes
+- add github action
+
+### Fixed
+- Remove Sidekiq pro by default
+
+---
+## 0.1.3
+### Added
+- Support both build in and [Sidekiq batches](https://github.com/mperham/sidekiq/wiki/Batches) callback
+- Update readme
+
+### Fixed
+- Fix bug require development gem
+
+---
+## 0.1.2
+### Added
+- Support [Sidekiq batches](https://github.com/mperham/sidekiq/wiki/Batches) callback
+- Update readme
+
+### Fixed
+- fix typo and remove development gem
+
+---
+## 0.1.0
+### Added
+- init app with basic idea following [Gush](https://github.com/chaps-io/gush) concept
+- Support build in callback

data/Gemfile

@@ -2,7 +2,7 @@ source "https://rubygems.org"
 
 gemspec
 
-source "https://gems.contribsys.com/" do
-  gem 'sidekiq-pro'
-end
+# source "https://gems.contribsys.com/" do
+  # gem 'sidekiq-pro'
+# end
 

data/README.md

@@ -2,11 +2,12 @@
 [Gush](https://github.com/chaps-io/gush) cloned without [ActiveJob](https://guides.rubyonrails.org/active_job_basics.html) but requried [Sidekiq](https://github.com/mperham/sidekiq). This project is for researching DSL purpose
 
 # Installation
+## 1. Add `dwf` to Gemfile
 ```ruby
-gem 'dwf', '~> 0.1.2'
+gem 'dwf', '~> 0.1.6'
 ```
-# Execute flow
-## Declare jobs
+## 2. Execute flow
+### Declare jobs
 
 ```ruby
 require 'dwf'
@@ -21,7 +22,7 @@ class A < Dwf::Item
 end
 ```
 
-## Declare flow
+### Declare flow
 ```ruby
 require 'dwf'
 
@@ -35,18 +36,22 @@ class TestWf < Dwf::Workflow
     run F, params: 'F say hello'
   end
 end
-
-wf = TestWf.create
-wf.start!
-
 ```
 
+
 ### Execute flow
 ```ruby
-wf = TestWf.create
+wf = TestWf.create(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
+- `Dwf::Workflow::SK_BATCH` is [sidekiq batch](https://github.com/mperham/sidekiq/wiki/Batches) callback which required [`sidekiq-pro`](https://sidekiq.org/products/pro.html)
+
+By default `dwf` will use `Dwf::Workflow::BUILD_IN` callback.
+
 ### Output
 ```
 A Working
@@ -66,13 +71,28 @@ D say hello
 D Finished
 ```
 
+# Config redis and default queue
+```ruby
+Dwf.config do |config|
+  SENTINELS = [
+    { host: "127.0.0.1", port: 26380 },
+    { host: "127.0.0.1", port: 26381 }
+  ]
+  config.opts = { host: 'mymaster', sentinels: SENTINELS, role: :master }
+  config.namespace = 'dwf'
+end
+```
+
+
 # Todo
 - [x] Make it work
 - [x] Support pass params
-- [ ] Support with build-in callback
-- [ ] Test
-- [ ] Add github workflow
+- [x] Support with build-in callback
+- [x] Add github workflow
+- [x] Redis configurable
+- [ ] [WIP] Test
 - [ ] Transfer output through each node
+- [ ] Support [Resque](https://github.com/resque/resque)
 
 # References
 - https://github.com/chaps-io/gush

data/dwf.gemspec

@@ -3,10 +3,11 @@
 
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require_relative 'lib/dwf/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "dwf"
-  spec.version       = '0.1.3'
+  spec.version       = Dwf::VERSION
   spec.authors       = ["dthtien"]
   spec.email         = ["tiendt2311@gmail.com"]
 
@@ -27,5 +28,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,8 +1,10 @@
-require 'sidekiq-pro'
+# 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']
@@ -13,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)
@@ -22,25 +24,45 @@ 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.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: processing_job_names,
+        names: jobs.map(&:klass),
         workflow_id: workflow_id
       )
-
       batch.jobs do
-        processing_job_names.each { |job_name| perform_job(job_name, workflow_id) }
+        jobs.each { |job| job.persist_and_perform_async! if job.ready_to_start? }
       end
     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?
+    def classify_jobs(jobs)
+      hash = {}
+      jobs.each do |job|
+        outgoing_jobs = job.outgoing
+        key = outgoing_jobs.empty? ? DEFAULT_KEY : outgoing_jobs.join
+        hash[key] = hash[key].nil? ? [job] : hash[key].push(job)
       end
+
+      hash
+    end
+
+    def fetch_jobs(processing_job_names, workflow_id)
+      processing_job_names.map do |job_name|
+        client.find_job(workflow_id, job_name)
+      end.compact
     end
 
     def with_lock(workflow_id, job_name)

data/lib/dwf/client.rb

@@ -1,5 +1,11 @@
 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
@@ -94,7 +100,7 @@ module Dwf
     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_url, REDIS_OPTS)
+    end
+  end
+end

data/lib/dwf/item.rb

@@ -1,19 +1,22 @@
+# frozen_string_literal: true
+
 require_relative 'client'
 
 module Dwf
   class Item
     attr_reader :workflow_id, :id, :params, :queue, :klass, :started_at,
       :enqueued_at, :finished_at, :failed_at, :callback_type
-    attr_accessor :incomming, :outgoing
+    attr_accessor :incoming, :outgoing
 
     def initialize(options = {})
       @workflow_id = options[:workflow_id]
       @id = options[:id]
       @params = options[:params]
-      @queue = options[:queue] || 'default'
-      @incomming = options[:incoming] || []
+      @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]
@@ -37,7 +40,8 @@ module Dwf
     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
@@ -45,11 +49,11 @@ module Dwf
     end
 
     def no_dependencies?
-      incomming.empty?
+      incoming.empty?
     end
 
     def parents_succeeded?
-      incomming.all? do |name|
+      incoming.all? do |name|
         client.find_job(workflow_id, name).succeeded?
       end
     end
@@ -130,7 +134,7 @@ module Dwf
         id: id,
         klass: klass.to_s,
         queue: queue,
-        incoming: incomming,
+        incoming: incoming,
         outgoing: outgoing,
         finished_at: finished_at,
         enqueued_at: enqueued_at,

data/lib/dwf/version.rb

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

data/lib/dwf/worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sidekiq'
 require_relative 'client'
 

data/lib/dwf/workflow.rb

@@ -157,7 +157,7 @@ module Dwf
         from = find_job(dependency[:from])
         to   = find_job(dependency[:to])
 
-        to.incomming << dependency[:from]
+        to.incoming << dependency[:from]
         from.outgoing << dependency[:to]
       end
     end

data/lib/dwf.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
+
 require "bundler/setup"
 
 require 'sidekiq'
 require 'json'
 require 'redis'
+# require 'sidekiq-pro'
 
 require_relative 'dwf/utils'
 require_relative 'dwf/workflow'
@@ -11,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.0'
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.config
+    yield configuration
+  end
 end
 

data/spec/dwf/client_spec.rb

@@ -0,0 +1,154 @@
+# 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 '#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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Dwf::Item, item: true do
+  let!(:id) { SecureRandom.uuid }
+  let!(:workflow_id) { SecureRandom.uuid }
+  let(:incoming) { [] }
+  let(:outgoing) { [] }
+  let(:started_at) { nil }
+  let(:finished_at) { nil }
+  let(:options) do
+    {
+      workflow_id: workflow_id,
+      id: id,
+      params: {},
+      incoming: incoming,
+      outgoing: outgoing,
+      queue: Dwf::Configuration::NAMESPACE,
+      klass: 'Dwf::Item',
+      started_at: started_at,
+      finished_at: finished_at,
+      callback_type: Dwf::Workflow::BUILD_IN
+    }
+  end
+  let!(:item) { described_class.new(options) }
+
+  describe 'self.from_hash' do
+    let!(:item) { described_class.from_hash(options) }
+    it { expect(item.to_hash.compact).to eq options.compact }
+  end
+
+  describe '#persist_and_perform_async!' do
+    let(:worker_double) { double(perform_async: nil) }
+    let(:client_double) { double(persist_job: nil) }
+
+    before do
+      allow(Dwf::Client).to receive(:new).and_return client_double
+      allow(Dwf::Worker).to receive(:set).and_return worker_double
+      item.persist_and_perform_async!
+    end
+
+    it do
+      expect(worker_double)
+        .to have_received(:perform_async)
+        .with(item.workflow_id, item.name)
+      expect(client_double).to have_received(:persist_job).with(item)
+      expect(item.enqueued_at).not_to be_nil
+    end
+  end
+
+  describe '#cb_build_in?' do
+    it { expect(item.cb_build_in?).to be_truthy }
+  end
+
+  describe '#perform_async' do
+    let(:worker_double) { double(perform_async: nil) }
+    before do
+      allow(Dwf::Worker).to receive(:set).and_return worker_double
+      item.perform_async
+    end
+
+    it do
+      expect(worker_double)
+        .to have_received(:perform_async)
+        .with(item.workflow_id, item.name)
+    end
+  end
+
+  describe '#name' do
+    it { expect(item.name).to eq "#{described_class}|#{id}" }
+  end
+
+  describe '#no_dependencies?' do
+    it { expect(item.no_dependencies?).to be_truthy }
+  end
+
+  describe '#parents_succeeded?' 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
+      )
+    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
+
+    context 'parent jobs already finished' do
+      let(:finished_at) { Time.now.to_i }
+
+      it do
+        expect(item.parents_succeeded?).to be_truthy
+        expect(client_double)
+          .to have_received(:find_job)
+          .with(workflow_id, incoming.first)
+      end
+    end
+
+    context 'parent jobs havent finished yet' do
+      let(:finished_at) { nil }
+
+      it do
+        expect(item.parents_succeeded?).to be_falsy
+        expect(client_double)
+          .to have_received(:find_job)
+          .with(workflow_id, incoming.first)
+      end
+    end
+  end
+
+  describe '#enqueue!' do
+    before { item.enqueue! }
+
+    it { expect(item.enqueued_at).not_to be_nil }
+  end
+
+  describe '#mark_as_started' do
+    let(:client_double) { double(persist_job: nil) }
+    before do
+      allow(Dwf::Client).to receive(:new).and_return client_double
+      item.mark_as_started
+    end
+
+    it do
+      expect(client_double).to have_received(:persist_job).with item
+      expect(item.started_at).not_to be_nil
+    end
+  end
+
+  describe '#mark_as_finished' do
+    let(:client_double) { double(persist_job: nil) }
+    before do
+      allow(Dwf::Client).to receive(:new).and_return client_double
+      item.mark_as_finished
+    end
+
+    it do
+      expect(client_double).to have_received(:persist_job).with item
+      expect(item.finished_at).not_to be_nil
+    end
+  end
+
+  describe '#enqueue_outgoing_jobs' do
+    let(:outgoing) { ["A|#{SecureRandom.uuid}"] }
+    let(:client_double) do
+      double(
+        find_job: nil,
+        check_or_lock: nil,
+        release_lock: nil
+      )
+    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!) }
+    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
+end

data/spec/dwf/utils_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Dwf::Utils, utils: true do
+  describe '#symbolize_keys' do
+    let(:expected) do
+      {
+        incoming: ['S'],
+        outgoing: %w[A B],
+        klass: 'H'
+      }
+    end
+
+    let(:hash) do
+      {
+        'incoming' => ['S'],
+        'outgoing' => %w[A B],
+        'klass' => 'H'
+      }
+    end
+
+    it { expect(described_class.symbolize_keys(hash)).to eq expected }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,101 @@
+require 'dwf'
+# 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
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dwf
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.7
 platform: ruby
 authors:
 - dthtien
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-04 00:00:00.000000000 Z
+date: 2021-09-08 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
@@ -73,8 +87,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/build_gem.yaml"
+- ".github/workflows/test.yaml"
 - ".gitignore"
+- ".rspec"
 - ".ruby-version"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -82,15 +100,22 @@ files:
 - lib/dwf.rb
 - lib/dwf/callback.rb
 - lib/dwf/client.rb
+- lib/dwf/configuration.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/spec_helper.rb
 homepage: https://github.com/dthtien/wf
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -106,8 +131,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.2.3
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Gush cloned without ActiveJob but requried Sidekiq. This project is for researching
   DSL purpose
-test_files: []
+test_files:
+- spec/dwf/client_spec.rb
+- spec/dwf/configuration_spec.rb
+- spec/dwf/item_spec.rb
+- spec/dwf/utils_spec.rb
+- spec/spec_helper.rb