dynflow 1.8.2 → 1.8.3

data/test/executor_test.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'mocha/minitest'
 
@@ -11,11 +12,13 @@ require 'dynflow/executors/sidekiq/core'
 
 module RedisMocks
   def release_orchestrator_lock; end
+
   def wait_for_orchestrator_lock; end
+
   def reacquire_orchestrator_lock; end
 end
 
-::Dynflow::Executors::Sidekiq::Core.send(:prepend, RedisMocks)
+::Dynflow::Executors::Sidekiq::Core.prepend RedisMocks
 
 module Dynflow
   module ExecutorTest
@@ -71,9 +74,7 @@ module Dynflow
         end
 
         describe "execution plan state" do
-
           describe "after successful planning" do
-
             let :execution_plan do
               world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
             end
@@ -100,7 +101,6 @@ module Dynflow
           end
 
           describe "after error in planning" do
-
             class FailingAction < Dynflow::Action
               def plan
                 raise "I failed"
@@ -114,7 +114,6 @@ module Dynflow
             it "is stopped" do
               _(execution_plan.state).must_equal :stopped
             end
-
           end
 
           describe "when being executed" do
@@ -166,7 +165,6 @@ module Dynflow
         end
 
         describe "execution of run flow" do
-
           before do
             TestExecutionLog.setup
           end
@@ -230,8 +228,8 @@ module Dynflow
             describe 'handling errors in setup' do
               let :execution_plan do
                 world.plan(Support::DummyExample::Polling,
-                           external_task_id: '123',
-                           text:             'troll setup')
+                  external_task_id: '123',
+                  text:             'troll setup')
               end
 
               it 'fails' do
@@ -310,8 +308,8 @@ module Dynflow
               describe 'plan with one action' do
                 let :execution_plan do
                   world.plan(Support::DummyExample::Polling,
-                             { external_task_id: '123',
-                               text:             'pause in progress 20%' })
+                    { external_task_id: '123',
+                      text:             'pause in progress 20%' })
                 end
 
                 it 'determines the progress of the execution plan in percents' do
@@ -325,8 +323,8 @@ module Dynflow
               describe 'plan with more action' do
                 let :execution_plan do
                   world.plan(Support::DummyExample::WeightedPolling,
-                             { external_task_id: '123',
-                               text:             'pause in progress 20%' })
+                    { external_task_id: '123',
+                      text:             'pause in progress 20%' })
                 end
 
                 it 'takes the steps weight in account' do
@@ -341,8 +339,8 @@ module Dynflow
             describe 'works when resumed after error' do
               let :execution_plan do
                 world.plan(Support::DummyExample::Polling,
-                           { external_task_id: '123',
-                             text:             'troll progress' })
+                  { external_task_id: '123',
+                    text:             'troll progress' })
               end
 
               specify do
@@ -356,11 +354,9 @@ module Dynflow
                 assert_equal :success, ep.run_steps.first.state
               end
             end
-
           end
 
           describe "action with empty flows" do
-
             let :execution_plan do
               world.plan(Support::CodeWorkflowExample::Dummy, { :text => "dummy" }).tap do |plan|
                 assert_equal plan.run_flow.size, 0
@@ -379,11 +375,9 @@ module Dynflow
               world.execute(execution_plan.id)
               assert_raises(Dynflow::Error) { world.execute(execution_plan.id).value! }
             end
-
           end
 
           describe 'action with empty run flow but some finalize flow' do
-
             let :execution_plan do
               world.plan(Support::CodeWorkflowExample::DummyWithFinalize, { :text => "dummy" }).tap do |plan|
                 assert_equal plan.run_flow.size, 0
@@ -395,7 +389,6 @@ module Dynflow
               _(result.result).must_equal :success
               _(result.state).must_equal :stopped
             end
-
           end
 
           describe 'running' do
@@ -417,7 +410,6 @@ module Dynflow
               EXECUTED_RUN_FLOW
             end
           end
-
         end
 
         describe "execution of finalize flow" do
@@ -438,10 +430,10 @@ module Dynflow
 
             it "runs all the steps in the finalize flow" do
               assert_finalized(Support::CodeWorkflowExample::IncomingIssues,
-                               { "issues" => [{ "author" => "Peter Smith", "text" => "Failing test" },
-                                              { "author" => "John Doe", "text" => "Internal server error" }] })
+                { "issues" => [{ "author" => "Peter Smith", "text" => "Failing test" },
+                               { "author" => "John Doe", "text" => "Internal server error" }] })
               assert_finalized(Support::CodeWorkflowExample::Triage,
-                               { "author" => "Peter Smith", "text" => "Failing test" })
+                { "author" => "Peter Smith", "text" => "Failing test" })
             end
           end
 
@@ -454,7 +446,6 @@ module Dynflow
               _(TestExecutionLog.finalize.size).must_equal 0
             end
           end
-
         end
 
         describe "re-execution of run flow after fix in run phase" do
@@ -493,13 +484,11 @@ module Dynflow
             13: Triage(success) {\"author\"=>\"John Doe\", \"text\"=>\"ok\"} --> {\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}
             16: UpdateIssue(success) {\"author\"=>\"John Doe\", \"text\"=>\"trolling\", \"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"} --> {}
             18: NotifyAssignee(success) {\"triage\"=>{\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}} --> {}
-          EXECUTED_RUN_FLOW
+            EXECUTED_RUN_FLOW
           end
-
         end
 
         describe "re-execution of run flow after fix in finalize phase" do
-
           after do
             TestExecutionLog.teardown
           end
@@ -532,13 +521,11 @@ module Dynflow
               14: Triage(success) {\"author\"=>\"John Doe\", \"text\"=>\"ok\"} --> {\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}
               19: NotifyAssignee(success) {\"triage\"=>{\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}} --> {}
               20: IncomingIssues(success) {\"issues\"=>[{\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"}, {\"author\"=>\"John Doe\", \"text\"=>\"trolling in finalize\"}]} --> {}
-          EXECUTED_RUN_FLOW
+            EXECUTED_RUN_FLOW
           end
-
         end
 
         describe "re-execution of run flow after skipping" do
-
           after do
             TestExecutionLog.teardown
           end
@@ -571,7 +558,7 @@ module Dynflow
             13: Triage(skipped) {\"author\"=>\"John Doe\", \"text\"=>\"trolling\"} --> {}
             16: UpdateIssue(skipped) {\"author\"=>\"John Doe\", \"text\"=>\"trolling\", \"assignee\"=>Step(13).output[:classification][:assignee], \"severity\"=>Step(13).output[:classification][:severity]} --> {}
             18: NotifyAssignee(skipped) {\"triage\"=>Step(13).output} --> {}
-          EXECUTED_RUN_FLOW
+            EXECUTED_RUN_FLOW
 
             assert_finalize_flow <<-FINALIZE_FLOW, resumed_execution_plan
         Dynflow::Flows::Sequence
@@ -580,8 +567,7 @@ module Dynflow
           14: Triage(skipped) {\"author\"=>\"John Doe\", \"text\"=>\"trolling\"} --> {}
           19: NotifyAssignee(skipped) {\"triage\"=>Step(13).output} --> {}
           20: IncomingIssues(success) {\"issues\"=>[{\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"}, {\"author\"=>\"John Doe\", \"text\"=>\"trolling\"}]} --> {}
-          FINALIZE_FLOW
-
+            FINALIZE_FLOW
           end
         end
 
@@ -617,7 +603,6 @@ module Dynflow
           end
 
           describe 'what_is_next with errors' do
-
             it "doesn't return next steps if requirements failed" do
               assert_next_steps([4, 13])
               assert_next_steps([], 4, false)
@@ -631,7 +616,6 @@ module Dynflow
               assert manager.done?
             end
           end
-
         end
 
         describe 'Pool::JobStorage' do
@@ -673,7 +657,6 @@ module Dynflow
             assert_nil storage.pop
           end
         end
-
       end
 
       describe 'termination' do
@@ -682,7 +665,7 @@ module Dynflow
         it 'waits for currently running actions' do
           $slow_actions_done = 0
           running = world.trigger(Support::DummyExample::Slow, 1)
-          suspended = world.trigger(Support::DummyExample::DeprecatedEventedAction, :timeout => 3 )
+          suspended = world.trigger(Support::DummyExample::DeprecatedEventedAction, :timeout => 3)
           sleep 0.2
           world.terminate.wait
           _($slow_actions_done).must_equal 1

data/test/extensions_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'active_support/time'
 

data/test/flows_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'mocha/minitest'
 
 module Dynflow
   describe 'flow' do
-
     class TestRegistry < Flows::Registry
       class << self
         def reset!
@@ -22,7 +22,7 @@ module Dynflow
         TestRegistry.register!(TestRegistry, 'TS')
         TestRegistry.register!(Integer, 'I')
         map = TestRegistry.instance_variable_get("@serialization_map")
-        _(map).must_equal({'TS' => TestRegistry, 'I' => Integer})
+        _(map).must_equal({ 'TS' => TestRegistry, 'I' => Integer })
       end
 
       it "prevents overwriting values" do

data/test/future_execution_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
@@ -9,7 +10,6 @@ module Dynflow
       include Dynflow::Testing::Factories
 
       describe 'action scheduling' do
-
         before do
           @start_at = Time.now.utc + 180
           world.persistence.delete_delayed_plans({})
@@ -98,10 +98,9 @@ module Dynflow
           delayed_plan.timeout
           _(execution_plan.state).must_equal :stopped
           _(execution_plan.result).must_equal :error
-          _(execution_plan.errors.first.message).must_match /could not be started before set time/
+          _(execution_plan.errors.first.message).must_match(/could not be started before set time/)
           _(history_names.call(execution_plan)).must_equal %W(delay timeout)
         end
-
       end
 
       describe 'polling delayed executor' do

data/test/memory_cosumption_watcher_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'fileutils'
 require 'dynflow/watchers/memory_consumption_watcher'

data/test/middleware_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
   module MiddlewareTest
-
     describe 'Middleware' do
       let(:world) { WorldFactory.create_world }
       let(:log) { Support::MiddlewareExample::LogMiddleware.log }
@@ -77,8 +77,7 @@ module Dynflow
           let(:world_with_middleware) do
             WorldFactory.create_world.tap do |world|
               world.middleware.use(Support::MiddlewareExample::AnotherLogRunMiddleware,
-                                   after: Support::MiddlewareExample::LogRunMiddleware)
-
+                after: Support::MiddlewareExample::LogRunMiddleware)
             end
           end
 
@@ -112,7 +111,7 @@ module Dynflow
       it "allows access the running action" do
         world = WorldFactory.create_world
         world.middleware.use(Support::MiddlewareExample::ObservingMiddleware,
-                             replace: Support::MiddlewareExample::LogRunMiddleware)
+          replace: Support::MiddlewareExample::LogRunMiddleware)
         world.trigger(Support::MiddlewareExample::Action, message: 'hello').finished.wait
         _(log).must_equal %w[input#message:hello
                              run
@@ -122,7 +121,7 @@ module Dynflow
       it "allows modification of the running action when delaying execution" do
         world = WorldFactory.create_world
         world.middleware.use(Support::MiddlewareExample::AnotherObservingMiddleware,
-                             replace: Support::MiddlewareExample::LogRunMiddleware)
+          replace: Support::MiddlewareExample::LogRunMiddleware)
         delay = world.delay(Support::MiddlewareExample::Action, { :start_at => Time.now - 60 })
         plan = world.persistence.load_delayed_plan delay.execution_plan_id
         plan.plan
@@ -183,7 +182,6 @@ module Dynflow
           _(presenter_without_middleware.input['text']).must_equal('Lord Voldemort is comming')
         end
       end
-
     end
   end
 end

data/test/persistence_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'tmpdir'
 require 'ostruct'
@@ -6,7 +7,6 @@ require 'ostruct'
 module Dynflow
   module PersistenceTest
     describe 'persistence adapters' do
-
       let :execution_plans_data do
         [{ id: 'plan1', :label => 'test1', root_plan_step_id: 1, class: 'Dynflow::ExecutionPlan', state: 'paused' },
          { id: 'plan2', :label => 'test2', root_plan_step_id: 1, class: 'Dynflow::ExecutionPlan', state: 'stopped' },
@@ -20,8 +20,8 @@ module Dynflow
          caller_execution_plan_id: nil,
          caller_action_id: nil,
          class: 'Dynflow::Action',
-         input: {key: 'value'},
-         output: {something: 'else'},
+         input: { key: 'value' },
+         output: { something: 'else' },
          plan_step_id: 1,
          run_step_id: 2,
          finalize_step_id: 3
@@ -150,9 +150,9 @@ module Dynflow
               _(loaded_plans).must_be_empty
 
               adapter.save_delayed_plan('plan1',
-                                        :execution_plan_uuid => 'plan1',
-                                        :start_at => format_time(Time.now + 60),
-                                        :start_before => format_time(Time.now - 60))
+                :execution_plan_uuid => 'plan1',
+                :start_at => format_time(Time.now + 60),
+                :start_before => format_time(Time.now - 60))
               loaded_plans = adapter.find_execution_plans(filters: { label: ['test1'], :delayed => true })
               _(loaded_plans.map { |h| h[:id] }).must_equal ['plan1']
             end
@@ -169,29 +169,29 @@ module Dynflow
             prepare_and_save_plans
             if adapter.ordering_by.include?('state')
               loaded_plans = adapter.find_execution_plan_statuses(filters: { label: ['test1'] })
-              _(loaded_plans).must_equal({ 'plan1' => { state: 'paused', result: nil} })
+              _(loaded_plans).must_equal({ 'plan1' => { state: 'paused', result: nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['paused'] })
-              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
-                                          "plan3"=>{:state=>"paused", :result=>nil},
-                                          "plan4"=>{:state=>"paused", :result=>nil}})
+              _(loaded_plans).must_equal({ "plan1" => { :state => "paused", :result => nil },
+                                          "plan3" => { :state => "paused", :result => nil },
+                                          "plan4" => { :state => "paused", :result => nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['stopped'] })
-              _(loaded_plans).must_equal({"plan2"=>{:state=>"stopped", :result=>nil}})
+              _(loaded_plans).must_equal({ "plan2" => { :state => "stopped", :result => nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { state: [] })
               _(loaded_plans).must_equal({})
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['stopped', 'paused'] })
-              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
-                                          "plan2"=>{:state=>"stopped", :result=>nil},
-                                          "plan3"=>{:state=>"paused", :result=>nil}, "plan4"=>{:state=>"paused", :result=>nil}})
+              _(loaded_plans).must_equal({ "plan1" => { :state => "paused", :result => nil },
+                                          "plan2" => { :state => "stopped", :result => nil },
+                                          "plan3" => { :state => "paused", :result => nil }, "plan4" => { :state => "paused", :result => nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { 'state' => ['stopped', 'paused'] })
-              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
-                                          "plan2"=>{:state=>"stopped", :result=>nil},
-                                          "plan3"=>{:state=>"paused", :result=>nil},
-                                          "plan4"=>{:state=>"paused", :result=>nil}})
+              _(loaded_plans).must_equal({ "plan1" => { :state => "paused", :result => nil },
+                                          "plan2" => { :state => "stopped", :result => nil },
+                                          "plan3" => { :state => "paused", :result => nil },
+                                          "plan4" => { :state => "paused", :result => nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { label: ['test1'], :delayed => true })
               _(loaded_plans).must_equal({})
@@ -229,9 +229,9 @@ module Dynflow
               _(loaded_plans).must_equal 0
 
               adapter.save_delayed_plan('plan1',
-                                        :execution_plan_uuid => 'plan1',
-                                        :start_at => format_time(Time.now + 60),
-                                        :start_before => format_time(Time.now - 60))
+                :execution_plan_uuid => 'plan1',
+                :start_at => format_time(Time.now + 60),
+                :start_before => format_time(Time.now - 60))
               loaded_plans = adapter.find_execution_plan_counts(filters: { label: ['test1'], :delayed => true })
               _(loaded_plans).must_equal 1
             end
@@ -276,14 +276,14 @@ module Dynflow
           it 'creates backup dir and produce backup including steps and actions' do
             prepare_plans_with_steps
             Dir.mktmpdir do |backup_dir|
-              _(adapter.delete_execution_plans({'uuid' => 'plan1'}, 100, backup_dir)).must_equal 1
+              _(adapter.delete_execution_plans({ 'uuid' => 'plan1' }, 100, backup_dir)).must_equal 1
               plans = CSV.read(backup_dir + "/execution_plans.csv", :headers => true)
               assert_equal 1, plans.count
               assert_equal 'plan1', plans.first.to_hash['uuid']
               actions = CSV.read(backup_dir + "/actions.csv", :headers => true)
               assert_equal 1, actions.count
               assert_equal 'plan1', actions.first.to_hash['execution_plan_uuid']
-              steps = CSV.read(backup_dir +"/steps.csv", :headers => true)
+              steps = CSV.read(backup_dir + "/steps.csv", :headers => true)
               assert_equal 1, steps.count
               assert_equal 'plan1', steps.first.to_hash['execution_plan_uuid']
             end
@@ -376,7 +376,7 @@ module Dynflow
           it 'deletes output chunks' do
             prepare_plans_with_actions
 
-            adapter.save_output_chunks('plan1', 1, [{chunk: "Hello", timestamp: Time.now}, {chunk: "Bye", timestamp: Time.now}])
+            adapter.save_output_chunks('plan1', 1, [{ chunk: "Hello", timestamp: Time.now }, { chunk: "Bye", timestamp: Time.now }])
             chunks = adapter.load_output_chunks('plan1', 1)
             _(chunks.length).must_equal 2
             deleted = adapter.delete_output_chunks('plan1', 1)
@@ -451,7 +451,7 @@ module Dynflow
           envelopes         = [client_envelope, executor_envelope]
 
           envelopes.each { |e| adapter.push_envelope(e) }
-          adapter.insert_coordinator_record({"class"=>"Dynflow::Coordinator::ExecutorWorld",
+          adapter.insert_coordinator_record({ "class" => "Dynflow::Coordinator::ExecutorWorld",
                                              "id" => executor_world_id, "meta" => {}, "active" => true })
 
           assert_equal 1, adapter.prune_undeliverable_envelopes
@@ -526,7 +526,7 @@ module Dynflow
 
           value = 'a' * 1000
 
-          adata = action_data.merge({:output => { :key => value }})
+          adata = action_data.merge({ :output => { :key => value } })
           plan_record = adapter.send(:prepare_record, :execution_plan, plan.merge(:uuid => plan[:id]))
           action_record = adapter.send(:prepare_record, :action, adata.dup)
 

data/test/redis_locking_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'mocha/minitest'
 require 'minitest/stub_const'

data/test/rescue_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
   module RescueTest
     describe 'on error' do
-
       Example = Support::RescueExample
 
       let(:world) { WorldFactory.create_world }
@@ -21,7 +21,6 @@ module Dynflow
 
       describe 'no auto rescue' do
         describe 'of simple skippable action in run phase' do
-
           let :execution_plan do
             execute(Example::ActionWithSkip, 1, :error_on_run)
           end
@@ -36,7 +35,6 @@ module Dynflow
         end
 
         describe 'of simple skippable action in finalize phase' do
-
           let :execution_plan do
             execute(Example::ActionWithSkip, 1, :error_on_finalize)
           end
@@ -51,7 +49,6 @@ module Dynflow
         end
 
         describe 'of complex action with skips in run phase' do
-
           let :execution_plan do
             execute(Example::ComplexActionWithSkip, :error_on_run)
           end
@@ -66,7 +63,6 @@ module Dynflow
         end
 
         describe 'of complex action with skips in finalize phase' do
-
           let :execution_plan do
             execute(Example::ComplexActionWithSkip, :error_on_finalize)
           end
@@ -81,7 +77,6 @@ module Dynflow
         end
 
         describe 'of complex action without skips' do
-
           let :execution_plan do
             execute(Example::ComplexActionWithoutSkip, :error_on_run)
           end
@@ -96,7 +91,6 @@ module Dynflow
         end
 
         describe 'of complex action with fail' do
-
           let :execution_plan do
             execute(Example::ComplexActionWithFail, :error_on_run)
           end
@@ -112,7 +106,6 @@ module Dynflow
       end
 
       describe 'auto rescue' do
-
         let(:world) do
           WorldFactory.create_world do |config|
             config.auto_rescue = true
@@ -127,8 +120,8 @@ module Dynflow
           it 'skips the action and continues' do
             _(rescued_plan.state).must_equal :stopped
             _(rescued_plan.result).must_equal :warning
-            _(rescued_plan.entry_action.output[:message]).
-              must_equal "skipped because some error as you wish"
+            _(rescued_plan.entry_action.output[:message])
+              .must_equal "skipped because some error as you wish"
           end
         end
 
@@ -215,7 +208,6 @@ module Dynflow
             _(execution_plan.execution_history.map { |h| [h.name, h.world_id] }).must_equal(expected_history)
           end
         end
-
       end
     end
   end

data/test/round_robin_test.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow

data/test/semaphores_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
   module SemaphoresTest
     describe ::Dynflow::Semaphores::Stateful do
-
       let(:semaphore_class) { ::Dynflow::Semaphores::Stateful }
       let(:tickets_count) { 5 }
 
@@ -41,7 +41,6 @@ module Dynflow
         waiting = semaphore.get_waiting
         _(waiting).must_equal 3
       end
-
     end
 
     describe ::Dynflow::Semaphores::Dummy do
@@ -71,10 +70,10 @@ module Dynflow
         }
       end
 
-      def assert_semaphore_state(semaphore, state_A, state_B)
-        _(semaphore.children[:child_A].free).must_equal state_A
-        _(semaphore.children[:child_B].free).must_equal state_B
-        _(semaphore.free).must_equal [state_A, state_B].min
+      def assert_semaphore_state(semaphore, state_a, state_b)
+        _(semaphore.children[:child_A].free).must_equal state_a
+        _(semaphore.children[:child_B].free).must_equal state_b
+        _(semaphore.free).must_equal [state_a, state_b].min
       end
 
       it 'can be used as counter' do
@@ -94,6 +93,5 @@ module Dynflow
         assert_semaphore_state semaphore, 0, 0
       end
     end
-
   end
 end