foreman-tasks 4.1.5 → 5.2.0

data/test/graphql/queries/recurring_logic_test.rb

@@ -0,0 +1,28 @@
+require 'foreman_tasks_test_helper'
+
+module Queries
+  class RecurringLogicTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query($id: String!) {
+        recurringLogic(id: $id) {
+          id
+          cronLine
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:cron_line) { '5 4 3 2 1' }
+    let(:recurring_logic) { FactoryBot.create(:recurring_logic, :cron_line => cron_line) }
+    let(:global_id) { Foreman::GlobalId.for(recurring_logic) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['recurringLogic'] }
+
+    test "should fetch recurring logic" do
+      assert_empty result['errors']
+      assert_equal global_id, data['id']
+      assert_equal cron_line, data['cronLine']
+    end
+  end
+end

data/test/graphql/queries/recurring_logics_query_test.rb

@@ -0,0 +1,30 @@
+require 'foreman_tasks_test_helper'
+
+module Queries
+  class RecurringLogicsTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query {
+        recurringLogics {
+          nodes {
+            id
+            cronLine
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:data) { result['data']['recurringLogics'] }
+
+    setup do
+      FactoryBot.create_list(:recurring_logic, 2)
+    end
+
+    test "should fetch recurring logics" do
+      assert_empty result['errors']
+      expected_count = ::ForemanTasks::RecurringLogic.count
+      assert_not_equal 0, expected_count
+    end
+  end
+end

data/test/graphql/queries/task_query_test.rb

@@ -0,0 +1,33 @@
+require 'foreman_tasks_test_helper'
+
+module Queries
+  class TaskQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        task(id: $id) {
+          id
+          action
+          result
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:res) { 'inconclusive' }
+    let(:task) { FactoryBot.create(:some_task, :result => res) }
+
+    let(:global_id) { Foreman::GlobalId.for(task) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['task'] }
+
+    test 'should fetch task data' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_equal task.result, data['result']
+    end
+  end
+end

data/test/graphql/queries/tasks_query_test.rb

@@ -0,0 +1,31 @@
+require 'foreman_tasks_test_helper'
+
+module Queries
+  class TasksQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query {
+        tasks {
+          nodes {
+            id
+            action
+            result
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:data) { result['data']['tasks'] }
+
+    setup do
+      FactoryBot.create_list(:some_task, 2)
+    end
+
+    test "should fetch recurring logics" do
+      assert_empty result['errors']
+      expected_count = ::ForemanTasks::Task.count
+      assert_not_equal 0, expected_count
+    end
+  end
+end

data/test/support/dummy_proxy_action.rb

@@ -36,6 +36,12 @@ module Support
       def statuses
         { version: DummyProxyVersion.new('1.21.0') }
       end
+
+      def launch_tasks(operation, args = {})
+        @log[:trigger_task] << [operation, args]
+        @task_triggered.fulfill(true)
+        { 'task_id' => @uuid, 'result' => 'success' }
+      end
     end
 
     class ProxySelector < ::ForemanTasks::ProxySelector

data/test/unit/actions/proxy_action_test.rb

@@ -11,12 +11,11 @@ module ForemanTasks
       let(:batch_triggering) { false }
 
       before do
-        Support::DummyProxyAction.any_instance.stubs(:with_batch_triggering?).returns(batch_triggering)
         Support::DummyProxyAction.reset
         RemoteTask.any_instance.stubs(:proxy).returns(Support::DummyProxyAction.proxy)
         Setting.stubs(:[]).with('foreman_tasks_proxy_action_retry_interval')
         Setting.stubs(:[]).with('foreman_tasks_proxy_action_retry_count')
-        Setting.stubs(:[]).with('foreman_tasks_proxy_batch_trigger')
+        Setting.stubs(:[]).with('foreman_tasks_proxy_batch_trigger').returns(batch_triggering)
         @action = create_and_plan_action(Support::DummyProxyAction,
                                          Support::DummyProxyAction.proxy,
                                          'Proxy::DummyAction',
@@ -29,17 +28,18 @@ module ForemanTasks
       describe 'first run' do
         it 'triggers the corresponding action on the proxy' do
           proxy_call = Support::DummyProxyAction.proxy.log[:trigger_task].first
-          expected_call = ['Proxy::DummyAction',
-                           { 'foo' => 'bar',
-                             'secrets' => secrets,
-                             'connection_options' =>
+          expected_call = ['single',
+                           { :action_class => 'Proxy::DummyAction',
+                             :action_input =>
+                             { 'foo' => 'bar',
+                               'secrets' => secrets,
+                               'connection_options' =>
                                { 'retry_interval' => 15, 'retry_count' => 4,
                                  'proxy_batch_triggering' => batch_triggering },
-                             'use_batch_triggering' => batch_triggering,
-                             'proxy_url' => 'proxy.example.com',
-                             'proxy_action_name' => 'Proxy::DummyAction',
-                             "proxy_version" => { "major" => 1, "minor" => 21, "patch" => 0 },
-                             'callback' => { 'task_id' => Support::DummyProxyAction.proxy.uuid, 'step_id' => @action.run_step_id } }]
+                               'use_batch_triggering' => batch_triggering,
+                               'proxy_url' => 'proxy.example.com',
+                               'proxy_action_name' => 'Proxy::DummyAction',
+                               'callback' => { 'task_id' => Support::DummyProxyAction.proxy.uuid, 'step_id' => @action.run_step_id } } }]
           _(proxy_call).must_equal(expected_call)
         end
 

data/test/unit/actions/trigger_proxy_batch_test.rb

@@ -0,0 +1,59 @@
+require 'foreman_tasks_test_helper'
+
+module ForemanTasks
+  class TriggerProxyBatchTest < ActiveSupport::TestCase
+    describe Actions::TriggerProxyBatch do
+      include ::Dynflow::Testing
+
+      let(:batch_size) { 20 }
+      let(:total_count) { 100 }
+      let(:action) { create_and_plan_action(Actions::TriggerProxyBatch, total_count: total_count, batch_size: batch_size) }
+      let(:triggered) { run_action(action) }
+
+      describe 'triggering' do
+        it 'doesnt run anything on trigger' do
+          Actions::TriggerProxyBatch.any_instance.expects(:trigger_remote_tasks_batch).never
+          _(triggered.state).must_equal :suspended
+          _(triggered.output[:planned_count]).must_equal 0
+        end
+
+        it 'triggers remote tasks on TriggerNextBatch' do
+          Actions::TriggerProxyBatch.any_instance.expects(:trigger_remote_tasks_batch).once
+          run_action(triggered, Actions::TriggerProxyBatch::TriggerNextBatch[1])
+        end
+
+        it 'triggers remote tasks on TriggerNextBatch defined number of times' do
+          Actions::TriggerProxyBatch.any_instance.expects(:trigger_remote_tasks_batch).twice
+          run_action(triggered, Actions::TriggerProxyBatch::TriggerNextBatch[2])
+        end
+
+        it 'triggers the last batch on resume' do
+          Actions::TriggerProxyBatch.any_instance.expects(:trigger_remote_tasks_batch).once
+          triggered.output[:planned_count] = ((total_count - 1) / batch_size) * batch_size
+          run_action(triggered)
+        end
+      end
+
+      describe '#trigger_remote_tasks_batch' do
+        let(:proxy_operation_name) { 'ansible_runner' }
+        let(:grouped_remote_batch) { Array.new(batch_size).map { |i| mock("RemoteTask#{i}") } }
+        let(:remote_tasks) do
+          m = mock('RemoteTaskARScope')
+          m.stubs(pending: m, order: m)
+          m.stubs(group_by: { proxy_operation_name => grouped_remote_batch })
+          m
+        end
+
+        it 'fetches batch_size of tasks and triggers them' do
+          remote_tasks.expects(:first).with(batch_size).returns(remote_tasks)
+          remote_tasks.expects(:size).returns(batch_size)
+          triggered.expects(:remote_tasks).returns(remote_tasks)
+          ForemanTasks::RemoteTask.expects(:batch_trigger).with(proxy_operation_name, grouped_remote_batch)
+
+          triggered.trigger_remote_tasks_batch
+          _(triggered.output[:planned_count]).must_equal(batch_size)
+        end
+      end
+    end
+  end
+end

data/test/unit/remote_task_test.rb

@@ -28,14 +28,6 @@ module ForemanTasks
           _(remote_task.remote_task_id).must_equal((remote_task.id + 5).to_s)
         end
       end
-
-      it 'fallbacks to old way when batch trigger gets 404' do
-        fake_proxy = mock
-        fake_proxy.expects(:launch_tasks).raises(RestClient::NotFound.new)
-        remote_tasks.first.expects(:proxy).returns(fake_proxy)
-        remote_tasks.each { |task| task.expects(:trigger) }
-        RemoteTask.batch_trigger('a_operation', remote_tasks)
-      end
     end
   end
 end

data/test/unit/task_test.rb

@@ -296,12 +296,12 @@ class TasksTest < ActiveSupport::TestCase
   end
 
   describe 'search for resource_ids' do
-    it 'finds tasks' do
-      label = 'label1'
-      resource_ids = [1, 2]
-      resource_type = 'restype1'
+    label = 'label1'
+    resource_ids = [1, 2]
+    resource_type = 'restype1'
 
-      task1_old = FactoryBot.create(
+    let(:task1_old) do
+      FactoryBot.create(
         :task_with_links,
         started_at: '2019-10-01 11:15:55',
         ended_at: '2019-10-01 11:15:57',
@@ -309,7 +309,9 @@ class TasksTest < ActiveSupport::TestCase
         label: label,
         resource_type: resource_type
       )
-      task1_new = FactoryBot.create(
+    end
+    let(:task1_new) do
+      FactoryBot.create(
         :task_with_links,
         started_at: '2019-10-02 11:15:55',
         ended_at: '2019-10-02 11:15:57',
@@ -317,7 +319,9 @@ class TasksTest < ActiveSupport::TestCase
         label: label,
         resource_type: resource_type
       )
-      task2 = FactoryBot.create(
+    end
+    let(:task2) do
+      FactoryBot.create(
         :task_with_links,
         started_at: '2019-10-03 11:15:55',
         ended_at: '2019-10-03 11:15:57',
@@ -325,7 +329,9 @@ class TasksTest < ActiveSupport::TestCase
         label: label,
         resource_type: resource_type
       )
-      task3 = FactoryBot.create(
+    end
+    let(:task3) do
+      FactoryBot.create(
         :task_with_links,
         started_at: '2019-10-03 11:15:55',
         ended_at: '2019-10-03 11:15:57',
@@ -333,6 +339,13 @@ class TasksTest < ActiveSupport::TestCase
         label: label,
         resource_type: 'another_type'
       )
+    end
+
+    it 'finds tasks' do
+      task1_old
+      task1_new
+      task2
+      task3
 
       result = ForemanTasks::Task.search_for(
         "resource_id ^ (#{resource_ids.join(',')}) and resource_type = #{resource_type}"
@@ -343,5 +356,23 @@ class TasksTest < ActiveSupport::TestCase
       assert_includes result, task2
       assert_not_includes result, task3
     end
+
+    it 'finds latest task for each resource_id' do
+      task1_old
+      task1_new
+      task2
+      task3
+
+      result = ForemanTasks::Task.latest_tasks_by_resource_ids(
+        label,
+        resource_type,
+        resource_ids
+      )
+      assert_equal 2, result.length
+      assert_equal resource_ids, result.keys.sort
+      assert_equal task1_new, result[1]
+      assert_equal task2, result[2]
+      assert_not_includes result.values, task3
+    end
   end
 end

data/test/unit/triggering_test.rb

@@ -19,6 +19,28 @@ class TriggeringTest < ActiveSupport::TestCase
       triggering.recurring_logic.stubs(:valid?).returns(false)
       _(triggering).wont_be :valid?
     end
+
+    it 'is valid when recurring logic has purpose' do
+      logic = FactoryBot.build(:recurring_logic, :purpose => 'test', :state => 'active')
+      triggering = FactoryBot.build(:triggering, :recurring_logic => logic, :mode => :recurring, :input_type => :cronline, :cronline => '* * * * *')
+      _(triggering).must_be :valid?
+    end
+
+    it 'is invalid when recurring logic with given purpose exists' do
+      FactoryBot.create(:recurring_logic, :purpose => 'test', :state => 'active')
+      logic = FactoryBot.build(:recurring_logic, :purpose => 'test', :state => 'active')
+      triggering = FactoryBot.build(:triggering, :recurring_logic => logic, :mode => :recurring, :input_type => :cronline, :cronline => '* * * * *')
+      _(triggering).wont_be :valid?
+    end
+
+    it 'is valid when recurring logic with given purpose exists and is not active or disabled' do
+      ['finished', 'cancelled', 'failed'].each do |item|
+        FactoryBot.create(:recurring_logic, :purpose => 'test', :state => item)
+      end
+      logic = FactoryBot.build(:recurring_logic, :purpose => 'test')
+      triggering = FactoryBot.build(:triggering, :recurring_logic => logic, :mode => :recurring, :input_type => :cronline, :cronline => '* * * * *')
+      _(triggering).must_be :valid?
+    end
   end
 
   it 'cannot have mode set to arbitrary value' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 4.1.5
+  version: 5.2.0
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-31 00:00:00.000000000 Z
+date: 2021-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.3
-- !ruby/object:Gem::Dependency
-  name: foreman-tasks-core
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: get_process_mem
   requirement: !ruby/object:Gem::Requirement
@@ -147,6 +133,10 @@ files:
 - app/controllers/foreman_tasks/react_controller.rb
 - app/controllers/foreman_tasks/recurring_logics_controller.rb
 - app/controllers/foreman_tasks/tasks_controller.rb
+- app/graphql/mutations/recurring_logics/cancel.rb
+- app/graphql/types/recurring_logic.rb
+- app/graphql/types/task.rb
+- app/graphql/types/triggering.rb
 - app/helpers/foreman_tasks/foreman_tasks_helper.rb
 - app/helpers/foreman_tasks/tasks_helper.rb
 - app/lib/actions/action_with_sub_plans.rb
@@ -176,6 +166,7 @@ files:
 - app/lib/actions/proxy_action.rb
 - app/lib/actions/recurring_action.rb
 - app/lib/actions/serializers/active_record_serializer.rb
+- app/lib/actions/trigger_proxy_batch.rb
 - app/lib/foreman_tasks/concerns/polling_action_extensions.rb
 - app/lib/proxy_api/foreman_dynflow/dynflow_proxy.rb
 - app/models/foreman_tasks/concerns/action_subject.rb
@@ -259,6 +250,7 @@ files:
 - db/migrate/20200517215015_rename_bookmarks_controller.rb
 - db/migrate/20200519093217_drop_dynflow_allow_dangerous_actions_setting.foreman_tasks.rb
 - db/migrate/20200611090846_add_task_lock_index_on_resource_type_and_task_id.rb
+- db/migrate/20210720115251_add_purpose_to_recurring_logic.rb
 - db/seeds.d/20-foreman_tasks_permissions.rb
 - db/seeds.d/30-notification_blueprints.rb
 - db/seeds.d/60-dynflow_proxy_feature.rb
@@ -267,12 +259,15 @@ files:
 - deploy/foreman-tasks.sysconfig
 - extra/dynflow-debug.sh
 - extra/dynflow-executor.example
+- extra/foreman-tasks-cleanup.sh
+- extra/foreman-tasks-export.sh
 - foreman-tasks.gemspec
 - gemfile.d/foreman-tasks.rb
 - lib/foreman-tasks.rb
 - lib/foreman_tasks.rb
 - lib/foreman_tasks/authorizer_ext.rb
 - lib/foreman_tasks/cleaner.rb
+- lib/foreman_tasks/continuous_output.rb
 - lib/foreman_tasks/dynflow.rb
 - lib/foreman_tasks/dynflow/configuration.rb
 - lib/foreman_tasks/dynflow/console_authorizer.rb
@@ -306,14 +301,15 @@ files:
 - test/controllers/api/tasks_controller_test.rb
 - test/controllers/recurring_logics_controller_test.rb
 - test/controllers/tasks_controller_test.rb
-- test/core/unit/dispatcher_test.rb
-- test/core/unit/runner_test.rb
-- test/core/unit/task_launcher_test.rb
 - test/factories/recurring_logic_factory.rb
 - test/factories/task_factory.rb
 - test/factories/triggering_factory.rb
-- test/foreman_tasks_core_test_helper.rb
 - test/foreman_tasks_test_helper.rb
+- test/graphql/mutations/recurring_logics/cancel_mutation_test.rb
+- test/graphql/queries/recurring_logic_test.rb
+- test/graphql/queries/recurring_logics_query_test.rb
+- test/graphql/queries/task_query_test.rb
+- test/graphql/queries/tasks_query_test.rb
 - test/helpers/foreman_tasks/foreman_tasks_helper_test.rb
 - test/helpers/foreman_tasks/tasks_helper_test.rb
 - test/lib/actions/middleware/keep_current_request_id_test.rb
@@ -332,11 +328,11 @@ files:
 - test/unit/actions/bulk_action_test.rb
 - test/unit/actions/proxy_action_test.rb
 - test/unit/actions/recurring_action_test.rb
+- test/unit/actions/trigger_proxy_batch_test.rb
 - test/unit/cleaner_test.rb
 - test/unit/config/environment.rb
 - test/unit/dynflow_console_authorizer_test.rb
 - test/unit/locking_test.rb
-- test/unit/otp_manager_test.rb
 - test/unit/proxy_selector_test.rb
 - test/unit/recurring_logic_test.rb
 - test/unit/remote_task_test.rb
@@ -620,14 +616,15 @@ test_files:
 - test/controllers/api/tasks_controller_test.rb
 - test/controllers/recurring_logics_controller_test.rb
 - test/controllers/tasks_controller_test.rb
-- test/core/unit/dispatcher_test.rb
-- test/core/unit/runner_test.rb
-- test/core/unit/task_launcher_test.rb
 - test/factories/recurring_logic_factory.rb
 - test/factories/task_factory.rb
 - test/factories/triggering_factory.rb
-- test/foreman_tasks_core_test_helper.rb
 - test/foreman_tasks_test_helper.rb
+- test/graphql/mutations/recurring_logics/cancel_mutation_test.rb
+- test/graphql/queries/recurring_logic_test.rb
+- test/graphql/queries/recurring_logics_query_test.rb
+- test/graphql/queries/task_query_test.rb
+- test/graphql/queries/tasks_query_test.rb
 - test/helpers/foreman_tasks/foreman_tasks_helper_test.rb
 - test/helpers/foreman_tasks/tasks_helper_test.rb
 - test/lib/actions/middleware/keep_current_request_id_test.rb
@@ -646,11 +643,11 @@ test_files:
 - test/unit/actions/bulk_action_test.rb
 - test/unit/actions/proxy_action_test.rb
 - test/unit/actions/recurring_action_test.rb
+- test/unit/actions/trigger_proxy_batch_test.rb
 - test/unit/cleaner_test.rb
 - test/unit/config/environment.rb
 - test/unit/dynflow_console_authorizer_test.rb
 - test/unit/locking_test.rb
-- test/unit/otp_manager_test.rb
 - test/unit/proxy_selector_test.rb
 - test/unit/recurring_logic_test.rb
 - test/unit/remote_task_test.rb

data/test/core/unit/dispatcher_test.rb

@@ -1,43 +0,0 @@
-require 'foreman_tasks_core_test_helper'
-require 'foreman_tasks/test_helpers'
-require 'foreman_tasks_core/runner'
-
-module ForemanTasksCore
-  module Runner
-    describe Dispatcher::RunnerActor do
-      include ForemanTasks::TestHelpers::WithInThreadExecutor
-
-      let(:dispatcher) { Dispatcher.instance }
-      let(:suspended_action) { mock }
-      let(:runner) { mock.tap { |r| r.stubs(:id) } }
-      let(:clock) { ForemanTasks.dynflow.world.clock }
-      let(:logger) { mock.tap { |l| l.stubs(:debug) } }
-      let(:actor) do
-        Dispatcher::RunnerActor.new dispatcher, suspended_action, runner, clock, logger
-      end
-
-      it 'delivers all updates to actions' do
-        targets = (0..2).map { mock }.each_with_index { |mock, index| mock.expects(:<<).with(index) }
-        updates = targets.each_with_index.reduce({}) { |acc, (cur, index)| acc.merge(cur => index) }
-        runner.expects(:run_refresh).returns(updates)
-        actor.expects(:plan_next_refresh)
-        actor.refresh_runner
-      end
-
-      it 'plans next refresh' do
-        runner.expects(:run_refresh).returns({})
-        actor.expects(:plan_next_refresh)
-        actor.refresh_runner
-      end
-
-      it 'does not plan next resfresh if done' do
-        update = Update.new(nil, 0)
-        suspended_action.expects(:<<).with(update)
-        runner.expects(:run_refresh).returns(suspended_action => update)
-        dispatcher.expects(:finish)
-        dispatcher.ticker.expects(:tell).never
-        actor.refresh_runner
-      end
-    end
-  end
-end

data/test/core/unit/runner_test.rb

@@ -1,116 +0,0 @@
-require 'foreman_tasks_core_test_helper'
-require 'foreman_tasks/test_helpers'
-require 'foreman_tasks_core/runner'
-require 'ostruct'
-
-module ForemanTasksCore
-  module Runner
-    class RunnerTest < ActiveSupport::TestCase
-      include ForemanTasks::TestHelpers::WithInThreadExecutor
-
-      describe Base do
-        let(:suspended_action) { Class.new }
-        let(:runner) { Base.new suspended_action: suspended_action }
-
-        describe '#generate_updates' do
-          it 'returns empty hash when there are no outputs' do
-            _(runner.generate_updates).must_be :empty?
-          end
-
-          it 'returns a hash with outputs' do
-            message = 'a message'
-            type = 'stdout'
-            runner.publish_data(message, type)
-            updates = runner.generate_updates
-            _(updates.keys).must_equal [suspended_action]
-            update = updates.values.first
-            _(update.exit_status).must_be :nil?
-            _(update.continuous_output.raw_outputs.count).must_equal 1
-          end
-
-          it 'works in compatibility mode' do
-            runner = Base.new
-            message = 'a message'
-            type = 'stdout'
-            runner.publish_data(message, type)
-            updates = runner.generate_updates
-            _(updates.keys).must_equal [nil]
-            update = updates.values.first
-            _(update.exit_status).must_be :nil?
-            _(update.continuous_output.raw_outputs.count).must_equal 1
-          end
-        end
-      end
-
-      describe Parent do
-        let(:suspended_action) { ::Dynflow::Action::Suspended.allocate }
-        let(:runner) { Parent.new targets, suspended_action: suspended_action }
-        let(:targets) do
-          { 'foo' => { 'execution_plan_id' => '123', 'run_step_id' => 2 },
-            'bar' => { 'execution_plan_id' => '456', 'run_step_id' => 2 } }
-        end
-
-        describe '#initialize_continuous_outputs' do
-          it 'initializes outputs for targets and parent' do
-            outputs = runner.initialize_continuous_outputs
-            _(outputs.keys.count).must_equal 2
-            outputs.values.each { |output| _(output).must_be_instance_of ContinuousOutput }
-          end
-        end
-
-        describe '#generate_updates' do
-          it 'returns only updates for hosts with pending outputs' do
-            _(runner.generate_updates).must_equal({})
-            runner.publish_data_for('foo', 'something', 'something')
-            updates = runner.generate_updates
-            _(updates.keys.count).must_equal 1
-          end
-
-          it 'works without compatibility mode' do
-            runner.broadcast_data('something', 'stdout')
-            updates = runner.generate_updates
-            _(updates.keys.count).must_equal 2
-            updates.keys.each do |key|
-              _(key).must_be_instance_of ::Dynflow::Action::Suspended
-            end
-          end
-        end
-
-        describe '#publish_data_for' do
-          it 'publishes data for a single host' do
-            runner.publish_data_for('foo', 'message', 'stdout')
-            _(runner.generate_updates.keys.count).must_equal 1
-          end
-        end
-
-        describe '#broadcast_data' do
-          it 'publishes data for all hosts' do
-            runner.broadcast_data('message', 'stdout')
-            _(runner.generate_updates.keys.count).must_equal 2
-          end
-        end
-
-        describe '#publish_exception' do
-          let(:exception) do
-            exception = RuntimeError.new
-            exception.stubs(:backtrace).returns([])
-            exception
-          end
-
-          before { runner.logger.stubs(:error) }
-
-          it 'broadcasts the exception to all targets' do
-            runner.expects(:publish_exit_status).never
-            runner.publish_exception('general failure', exception, false)
-            _(runner.generate_updates.keys.count).must_equal 2
-          end
-
-          it 'publishes exit status if fatal' do
-            runner.expects(:publish_exit_status)
-            runner.publish_exception('general failure', exception, true)
-          end
-        end
-      end
-    end
-  end
-end