dwf 0.1.5 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cfd1989fd7228daec1f81759e249cb3a0d6e920e465b38f1f6998239c78f6c7
-  data.tar.gz: 0e4139ec4372ef7f5fb91b61cae9b2131e7e5b5983e25219a213b3edb821c9c6
+  metadata.gz: d37bac690df59157001462d6017a8a63d3956a280689de789d9a99163a476832
+  data.tar.gz: 935d76e99ff5ca109f00be80c01950c20272969f556fc70d0e1ef5c026c024e4
 SHA512:
-  metadata.gz: 38b96a776878ddce8df1757ecdba3452a833f117536b9a3f44a07dc801ce71be7ac7cfac997622cd3e172c1a2929ac333f50e4823f901cb844149189c18563de
-  data.tar.gz: 3a32f7469c5a7009e8f04a1d1c9e35fcd8de4fb322593f8e3c9f90fa617fe96eda8dc768dd97c5a3f7bb9044a2eaa87632970fcdddfd6bb57e96c6d72446951b
+  metadata.gz: c105d178cd44f12577ee9eeed5065768a23adc508da7d686e50c46d26e4eed9c160dc71b10942ab8041e38f6c732384742f40fa9d3076e0a924fbdfb1cd62845
+  data.tar.gz: ad9c6f1041f092847364e91408887be311435be62e0502ab54f2b408c92fc598a879792eabb00c81b05d5c97fb37ea4a19136765d54b0d4efe9dbdb9ad2f64b5

data/.github/workflows/build_gem.yaml

@@ -6,8 +6,8 @@ on:
   # Alternatively, publish whenever changes are merged to the `main` branch.
   push:
     branches: [ master ]
-  pull_request:
-    branches: [ master ]
+    paths:
+      - 'dwf.gemspec'
 
 jobs:
   build:

data/.github/workflows/test.yaml

@@ -1,9 +1,9 @@
-name: dwf
+name: Test
 
 on:
   push:
     branches:
-      - '**'
+      - 'master'
   pull_request:
     branches:
       - '**'

data/CHANGELOG.md

@@ -0,0 +1,99 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+## 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
+
+## 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/README.md

@@ -4,7 +4,7 @@
 # Installation
 ## 1. Add `dwf` to Gemfile
 ```ruby
-gem 'dwf', '~> 0.1.3'
+gem 'dwf', '~> 0.1.9'
 ```
 ## 2. Execute flow
 ### Declare jobs
@@ -38,19 +38,20 @@ class TestWf < Dwf::Workflow
 end
 ```
 
-#### Note
-`dwf` supports 2 type of callback `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.
 
 ### 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
@@ -70,13 +71,62 @@ 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
-- [ ] [WIF] Test
-- [ ] Transfer output through each node
+- [x] Redis configurable
+- [x] Pinelining
+- [ ] [WIP] Test
+- [ ] Support [Resque](https://github.com/resque/resque)
 
 # 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.5'
+  spec.version       = '0.1.9'
   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,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_opts, REDIS_OPTS)
+    end
+  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.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.3'
+  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

@@ -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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dwf
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.9
 platform: ruby
 authors:
 - dthtien
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-05 00:00:00.000000000 Z
+date: 2021-09-10 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
@@ -78,6 +92,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".ruby-version"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -85,12 +100,17 @@ 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/dwf/worker_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/dthtien/wf
 licenses:
@@ -117,6 +137,9 @@ 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/spec_helper.rb