foreman_remote_execution 4.6.0 → 5.0.1

data/package.json

@@ -21,18 +21,20 @@
   },
   "devDependencies": {
     "@babel/core": "^7.7.0",
-    "@theforeman/builder": "^4.14.0",
-    "@theforeman/eslint-plugin-foreman": "^4.14.0",
-    "@theforeman/stories": "^4.14.0",
-    "@theforeman/test": "^4.14.0",
-    "@theforeman/vendor-dev": "^4.14.0",
+    "@theforeman/builder": "^8.16.0",
+    "@theforeman/eslint-plugin-foreman": "^8.16.0",
+    "@theforeman/stories": "^8.16.0",
+    "@theforeman/test": "^8.16.0",
+    "@theforeman/vendor-dev": "^8.16.0",
     "babel-eslint": "^10.0.0",
     "eslint": "^6.8.0",
     "prettier": "^1.19.1",
     "@patternfly/react-catalog-view-extension": "^4.8.126",
-    "redux-mock-store": "^1.2.2"
+    "redux-mock-store": "^1.2.2",
+    "graphql-tag": "^2.11.0",
+    "graphql": "^15.5.0"
   },
   "peerDependencies": {
-    "@theforeman/vendor": "^8.3.0"
+    "@theforeman/vendor": "^8.16.0"
   }
 }

data/test/functional/api/v2/job_invocations_controller_test.rb

@@ -90,6 +90,16 @@ module Api
           assert_response :success
         end
 
+        test 'should create with a scheduled recurrence' do
+          @attrs[:scheduling] = { start_at: (Time.now + 1.hour) }
+          @attrs[:recurrence] = { cron_line: '5 * * * *' }
+          post :create, params: { job_invocation: @attrs }
+          invocation = ActiveSupport::JSON.decode(@response.body)
+          assert_equal 'recurring', invocation['mode']
+          assert invocation['start_at']
+          assert_response :success
+        end
+
         context 'with_feature' do
           setup do
             @feature = FactoryBot.create(:remote_execution_feature,
@@ -181,6 +191,11 @@ module Api
                                  host_id: FactoryBot.create(:host).id }
           assert_response :missing
         end
+
+        test 'should not break when taxonomy parameters are provided' do
+          get :output, params: { :job_invocation_id => @invocation.id, :host_id => host.id, :organization_id => host.organization_id, :location_id => host.location_id }
+          assert_response :success
+        end
       end
 
       describe '#outputs' do
@@ -233,6 +248,11 @@ module Api
           assert_response :success
         end
 
+        test 'should not break when taxonomy parameters are provided' do
+          get :raw_output, params: { :job_invocation_id => @invocation.id, :host_id => host.id, :organization_id => host.organization_id, :location_id => host.location_id }
+          assert_response :success
+        end
+
         test 'should provide raw output for delayed task' do
           start_time = Time.now
           JobInvocation.any_instance

data/test/functional/cockpit_controller_test.rb

@@ -2,7 +2,6 @@ require 'test_plugin_helper'
 
 class CockpitControllerTest < ActionController::TestCase
   def setup
-    Setting::RemoteExecution.load_defaults
     as_admin do
       @host = FactoryBot.create(:host)
     end

data/test/graphql/mutations/job_invocations/create.rb

@@ -0,0 +1,58 @@
+require 'test_plugin_helper'
+
+module Mutations
+  module JobInvocations
+    class CreateMutationTest < ActiveSupport::TestCase
+      let(:host) { FactoryBot.create(:host) }
+      let(:job_template) { FactoryBot.create(:job_template, :with_input) }
+      let(:cron_line) { '5 * * * *' }
+      let(:purpose) { 'test' }
+      let(:variables) do
+        {
+          jobInvocation: {
+            hostIds: [host.id],
+            jobTemplateId: job_template.id,
+            targetingType: 'static_query',
+            inputs: { job_template.template_inputs.first.name => "bar" },
+            recurrence: {
+              cronLine: cron_line,
+              purpose:  purpose,
+            },
+          },
+        }
+      end
+
+      let(:query) do
+        <<-GRAPHQL
+          mutation CreateJobInvocation($jobInvocation: JobInvocationInput!) {
+              createJobInvocation(input: { jobInvocation: $jobInvocation }) {
+                jobInvocation {
+                  id
+                  description
+                  recurringLogic {
+                    cronLine
+                    purpose
+                  }
+                }
+              }
+            }
+        GRAPHQL
+      end
+
+      context 'with admin user' do
+        let(:user) { FactoryBot.create(:user, :admin) }
+        let(:context) { { current_user: user } }
+
+        test 'create a job invocation' do
+          assert_difference('JobInvocation.count', +1) do
+            result = ForemanGraphqlSchema.execute(query, variables: variables, context: context)
+            assert_empty result['errors']
+            assert_empty result['data']['createJobInvocation']['jobInvocation']['errors']
+            assert_equal cron_line, result['data']['createJobInvocation']['jobInvocation']['recurringLogic']['cronLine']
+            assert_equal purpose, result['data']['createJobInvocation']['jobInvocation']['recurringLogic']['purpose']
+          end
+        end
+      end
+    end
+  end
+end

data/test/graphql/queries/job_invocation_query_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Queries
+  class JobInvocationQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        jobInvocation(id: $id) {
+          id
+          jobCategory
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:job_invocation) { FactoryBot.create(:job_invocation) }
+
+    let(:global_id) { Foreman::GlobalId.for(job_invocation) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['jobInvocation'] }
+
+    test 'fetching job invocation attributes' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_equal job_invocation.job_category, data['jobCategory']
+    end
+  end
+end

data/test/graphql/queries/job_invocations_query_test.rb

@@ -0,0 +1,35 @@
+require 'test_plugin_helper'
+
+module Queries
+  class JobInvocationsQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query {
+        jobInvocations {
+          totalCount
+          nodes {
+            id
+            jobCategory
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:data) { result['data']['jobInvocations'] }
+
+    setup do
+      FactoryBot.create_list(:job_invocation, 2)
+    end
+
+    test 'should fetch job invocations' do
+      assert_empty result['errors']
+
+      expected_count = JobInvocation.count
+
+      assert_not_equal 0, expected_count
+      assert_equal expected_count, data['totalCount']
+      assert_equal expected_count, data['nodes'].count
+    end
+  end
+end

data/test/helpers/remote_execution_helper_test.rb

@@ -26,7 +26,6 @@ class RemoteExecutionHelperTest < ActionView::TestCase
 
   describe 'test correct setting' do
     it 'should found correct template from setting' do
-      Setting::RemoteExecution.load_defaults
       template_name = 'Job Invocation Report Template'
       setting_key = 'remote_execution_job_invocation_report_template'
       template = FactoryBot.create(:report_template, name: template_name)

data/test/unit/actions/run_host_job_test.rb

@@ -36,6 +36,27 @@ module ForemanRemoteExecution
       end
     end
 
+    describe '#verify_permission' do
+      let(:job_invocation) { FactoryBot.create(:job_invocation, :with_task) }
+      let(:template_invocation) { job_invocation.template_invocations.first }
+
+      before { job_invocation }
+
+      it 'raises an exception when run against an infrastructure host' do
+        template_invocation.host = FactoryBot.create(:host, :with_infrastructure_facet)
+
+        setup_user('view', 'hosts')
+        setup_user('view', 'job_templates')
+        setup_user('create', 'template_invocations')
+
+        action = Actions::RemoteExecution::RunHostJob.allocate
+        exception = assert_raises do
+          action.send(:verify_permissions, template_invocation.host, template_invocation)
+        end
+        _(exception.message).must_include "infrastructure host #{template_invocation.host.name}"
+      end
+    end
+
     describe '#finalize' do
       let(:host) { FactoryBot.create(:host, :with_execution) }
 

data/test/unit/actions/run_hosts_job_test.rb

@@ -5,6 +5,16 @@ module ForemanRemoteExecution
   class RunHostsJobTest < ActiveSupport::TestCase
     include Dynflow::Testing
 
+    # Adding run_step_id wich is needed in RunHostsJob as a quick fix
+    # it will be added to dynflow in the future see https://github.com/Dynflow/dynflow/pull/391
+    # rubocop:disable Style/ClassAndModuleChildren
+    class Dynflow::Testing::DummyPlannedAction
+      def run_step_id
+        Dynflow::Testing.get_id
+      end
+    end
+    # rubocop:enable Style/ClassAndModuleChildren
+
     let(:host) { FactoryBot.create(:host, :with_execution) }
     let(:proxy) { host.remote_execution_proxies('SSH')[:subnet].first }
     let(:targeting) { FactoryBot.create(:targeting, :search_query => "name = #{host.name}", :user => User.current) }
@@ -94,6 +104,22 @@ module ForemanRemoteExecution
       planned # To make the expectations happy
     end
 
+    describe '#proxy_batch_size' do
+      it 'defaults to Setting[foreman_tasks_proxy_batch_size]' do
+        Setting.expects(:[]).with('foreman_tasks_proxy_batch_size').returns(14)
+        planned
+        _(planned.proxy_batch_size).must_equal 14
+      end
+
+      it 'gets the provider value' do
+        provider = mock('provider')
+        provider.expects(:proxy_batch_size).returns(15)
+        JobTemplate.any_instance.expects(:provider).returns(provider)
+
+        _(planned.proxy_batch_size).must_equal 15
+      end
+    end
+
     describe 'concurrency control' do
       let(:level) { 5 }
       let(:span) { 60 }
@@ -127,10 +153,79 @@ module ForemanRemoteExecution
     end
 
     describe 'notifications' do
-      it 'creates notification on sucess run' do
-        FactoryBot.create(:notification_blueprint, :name => 'rex_job_succeeded')
-        assert_difference 'NotificationRecipient.where(:user_id => targeting.user.id).count' do
-          finalize_action planned
+      it 'creates drawer notification on succeess' do
+        blueprint = planned.job_invocation.build_notification
+        blueprint.expects(:deliver!)
+        planned.job_invocation.expects(:build_notification).returns(blueprint)
+        planned.notify_on_success(nil)
+      end
+
+      it 'creates drawer notification on failure' do
+        blueprint = planned.job_invocation.build_notification
+        blueprint.expects(:deliver!)
+        planned.job_invocation.expects(:build_notification).returns(blueprint)
+        planned.notify_on_failure(nil)
+      end
+
+      describe 'ignoring drawer notification' do
+        before do
+          blueprint = planned.job_invocation.build_notification
+          blueprint.expects(:deliver!)
+          planned.job_invocation.expects(:build_notification).returns(blueprint)
+        end
+
+        let(:mail) do
+          object = mock
+          object.stubs(:deliver_now)
+          object
+        end
+
+        describe 'for user subscribed to all' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::ALL_JOBS))
+          end
+
+          it 'sends the mail notification on success' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_success(nil)
+          end
+
+          it 'sends the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_failure(nil)
+          end
+        end
+
+        describe 'for user subscribed to failures' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::FAILED_JOBS))
+          end
+
+          it 'it does not send the mail notification on success' do
+            RexJobMailer.expects(:job_finished).never
+            planned.notify_on_success(nil)
+          end
+
+          it 'sends the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_failure(nil)
+          end
+        end
+
+        describe 'for user subscribed to successful jobs' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::SUCCEEDED_JOBS))
+          end
+
+          it 'sends the mail notification on success' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_success(nil)
+          end
+
+          it 'does not send the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).never
+            planned.notify_on_failure(nil)
+          end
         end
       end
     end

data/test/unit/concerns/host_extensions_test.rb

@@ -1,9 +1,6 @@
 require 'test_plugin_helper'
 
 class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
-  before do
-    Setting::RemoteExecution.load_defaults
-  end
   let(:provider) { 'SSH' }
 
   before { User.current = FactoryBot.build(:user, :admin) }
@@ -131,23 +128,23 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
     end
 
     context 'fallback strategy' do
-      let(:host) { FactoryBot.build(:host, :with_puppet) }
+      let(:host) { FactoryBot.build(:host, :with_tftp_subnet) }
 
       context 'enabled' do
         before do
           Setting[:remote_execution_fallback_proxy] = true
-          host.puppet_proxy.features << FactoryBot.create(:feature, :ssh)
+          host.subnet.tftp.features << FactoryBot.create(:feature, :ssh)
         end
 
         it 'returns a fallback proxy' do
-          host.remote_execution_proxies(provider)[:fallback].must_include host.puppet_proxy
+          host.remote_execution_proxies(provider)[:fallback].must_include host.subnet.tftp
         end
       end
 
       context 'disabled' do
         before do
           Setting[:remote_execution_fallback_proxy] = false
-          host.puppet_proxy.features << FactoryBot.create(:feature, :ssh)
+          host.subnet.tftp.features << FactoryBot.create(:feature, :ssh)
         end
 
         it 'returns no proxy' do
@@ -182,4 +179,40 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
       end
     end
   end
+
+  describe '#execution_scope' do
+    let(:host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
+
+    before do
+      host
+      infra_host
+    end
+
+    context 'without infrastructure host permission' do
+      it 'omits the infrastructure host' do
+        setup_user('view', 'hosts')
+
+        hosts = ::Host::Managed.execution_scope
+        hosts.must_include host
+        hosts.wont_include infra_host
+      end
+    end
+
+    context 'with infrastructure host permission' do
+      it 'finds the host as admin' do
+        assert User.current.admin?
+        hosts = ::Host::Managed.execution_scope
+        hosts.must_include host
+        hosts.must_include infra_host
+      end
+
+      it 'finds the host as user with needed permissions' do
+        setup_user('execute_jobs_on', 'infrastructure_hosts')
+        hosts = ::Host::Managed.execution_scope
+        hosts.must_include host
+        hosts.must_include infra_host
+      end
+    end
+  end
 end

data/test/unit/input_template_renderer_test.rb

@@ -446,8 +446,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           before { User.current = FactoryBot.build(:user, :admin) }
           after { User.current = nil }
 
-          let(:environment) { FactoryBot.create(:environment) }
-          before { renderer.host = FactoryBot.create(:host, :environment => environment) }
+          before { renderer.host = FactoryBot.create(:host) }
 
           describe 'rendering' do
             it 'can\'t render the content without host since we don\'t have variable value in classification' do
@@ -497,91 +496,4 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
       end
     end
   end
-
-  context 'renderer for template with puppet parameter input used' do
-    let(:template) { FactoryBot.build(:job_template, :template => 'echo "This is WebServer with nginx <%= input("nginx_version") -%>" > /etc/motd') }
-    let(:renderer) { InputTemplateRenderer.new(template) }
-
-    context 'with matching input defined' do
-      before do
-        renderer.template.template_inputs<< FactoryBot.build(:template_input,
-          :name => 'nginx_version',
-          :input_type => 'puppet_parameter',
-          :puppet_parameter_name => 'version',
-          :puppet_class_name => 'nginx')
-      end
-      let(:result) { renderer.render }
-
-      describe 'rendering' do
-        it 'can\'t render the content without host since we don\'t have host so no classification' do
-          assert_not result
-        end
-
-        it 'registers an error' do
-          result # let is lazy
-          _(renderer.error_message).wont_be_nil
-          _(renderer.error_message).wont_be_empty
-        end
-
-        context 'with host specified' do
-          let(:environment) { FactoryBot.create(:environment) }
-          before { renderer.host = FactoryBot.create(:host, :environment => environment) }
-
-          describe 'rendering' do
-            it 'can\'t render the content without host since we don\'t have puppet parameter in classification' do
-              assert_not result
-            end
-
-            it 'registers an error' do
-              result # let is lazy
-              _(renderer.error_message).wont_be_nil
-              _(renderer.error_message).wont_be_empty
-            end
-          end
-
-          describe 'preview' do
-            it 'should render preview' do
-              _(renderer.preview).must_equal 'echo "This is WebServer with nginx $PUPPET_PARAMETER_INPUT[nginx_version]" > /etc/motd'
-            end
-          end
-
-          context 'with existing puppet parameter with matching override' do
-            let(:puppet_class) do
-              puppetclass = FactoryBot.create(:puppetclass, :environments => [environment], :name => 'nginx')
-              puppetclass.update_attribute(:hosts, [renderer.host])
-              puppetclass
-            end
-            let(:lookup_key) do
-              FactoryBot.create(:puppetclass_lookup_key, :as_smart_class_param,
-                :key => 'version',
-                :puppetclass => puppet_class,
-                :path => 'fqdn',
-                :override => true,
-                :overrides => {"fqdn=#{renderer.host.fqdn}" => '1.4.7'})
-            end
-
-            describe 'rendering' do
-              it 'renders the value from puppet parameter' do
-                lookup_key
-                _(result).must_equal 'echo "This is WebServer with nginx 1.4.7" > /etc/motd'
-              end
-            end
-
-            describe 'preview' do
-              it 'should render preview' do
-                lookup_key
-                _(renderer.preview).must_equal 'echo "This is WebServer with nginx 1.4.7" > /etc/motd'
-              end
-            end
-          end
-        end
-
-        describe 'preview' do
-          it 'should render preview' do
-            _(renderer.preview).must_equal 'echo "This is WebServer with nginx $PUPPET_PARAMETER_INPUT[nginx_version]" > /etc/motd'
-          end
-        end
-      end
-    end
-  end
 end

data/test/unit/job_invocation_composer_test.rb

@@ -270,10 +270,6 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
           composer.pattern_template_invocations.first
         end
 
-        before do
-          Setting::RemoteExecution.load_defaults
-        end
-
         context 'when overridable and provided' do
           let(:overridable) { true }
           let(:invocation_effective_user) { 'invocation user' }
@@ -350,12 +346,6 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
       end
 
       describe '#available_bookmarks' do
-        it 'obeys authorization' do
-          composer
-          Bookmark.expects(:authorized).with(:view_bookmarks).returns(Bookmark.where({}))
-          composer.available_bookmarks
-        end
-
         context 'there are hostgroups and hosts bookmark' do
           let(:hostgroups) { Bookmark.create(:name => 'hostgroups', :query => 'name = x', :controller => 'hostgroups') }
           let(:hosts) { Bookmark.create(:name => 'hosts', :query => 'name = x', :controller => 'hosts') }
@@ -376,8 +366,10 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
         let(:host) { FactoryBot.create(:host) }
 
         it 'obeys authorization' do
+          fake_scope = mock
           composer.stubs(:displayed_search_query => "name = #{host.name}")
-          Host.expects(:authorized).with(:view_hosts, Host).returns(Host.where({}))
+          Host.expects(:execution_scope).returns(fake_scope)
+          fake_scope.expects(:authorized).with(:view_hosts, Host).returns(Host.where({}))
           composer.targeted_hosts_count
         end
 
@@ -864,7 +856,9 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
     it 'marks targeting as resolved if static' do
       created = JobInvocationComposer.from_job_invocation(job_invocation).job_invocation
       assert created.targeting.resolved?
-      assert_equal job_invocation.template_invocations_host_ids, created.targeting.host_ids
+      created.targeting.save
+      created.targeting.reload
+      assert_equal job_invocation.template_invocations_host_ids, created.targeting.targeting_hosts.pluck(:host_id)
     end
 
     it 'takes randomized_ordering from the original job invocation when rerunning failed' do
@@ -874,6 +868,17 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
       composer = JobInvocationComposer.from_job_invocation(job_invocation, :host_ids => host_ids)
       assert composer.job_invocation.targeting.randomized_ordering
     end
+
+    it 'works with invalid hosts' do
+      host = job_invocation.targeting.hosts.first
+      ::Host::Managed.any_instance.stubs(:valid?).returns(false)
+      composer = JobInvocationComposer.from_job_invocation(job_invocation, {})
+      targeting = composer.compose.job_invocation.targeting
+      targeting.save!
+      targeting.reload
+      assert targeting.valid?
+      assert_equal targeting.hosts.pluck(:id), [host.id]
+    end
   end
 
   describe '.for_feature' do
@@ -918,12 +923,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
 
     context 'with template in setting present' do
       before do
-        FactoryBot.create(
-          :setting,
-          :name => 'remote_execution_form_job_template',
-          :category => 'Setting::RemoteExecution',
-          :value => setting_template.name
-        )
+        Setting[:remote_execution_form_job_template] = setting_template.name
       end
 
       it 'should resolve category to the setting value' do

data/test/unit/job_invocation_report_template_test.rb

@@ -19,7 +19,7 @@ class JobReportTemplateTest < ActiveSupport::TestCase
       it 'in settings includes only report templates with job_id input' do
         FactoryBot.create(:report_template, name: 'Template 1')
         job_invocation_template
-        templates = Setting::RemoteExecution.job_invocation_report_templates_select
+        templates = ForemanRemoteExecution.job_invocation_report_templates_select
 
         assert_include templates, 'Job Invocation Report Template'
       end
@@ -28,15 +28,16 @@ class JobReportTemplateTest < ActiveSupport::TestCase
     describe 'task reporting' do
       let(:fake_outputs) do
         [
-          { 'output_type' => 'stderr', 'output' => "error", 'timestamp' => Time.new(2020, 12, 1, 0, 0, 0).utc },
-          { 'output_type' => 'stdout', 'output' => "output", 'timestamp' => Time.new(2020, 12, 1, 0, 0, 0).utc },
-          { 'output_type' => 'stdebug', 'output' => "debug", 'timestamp' => Time.new(2020, 12, 1, 0, 0, 0).utc },
+          { 'output_type' => 'stderr', 'output' => "error" },
+          { 'output_type' => 'stdout', 'output' => "output" },
+          { 'output_type' => 'debug', 'output' => "debug" },
         ]
       end
-      let(:fake_task) { FakeTask.new(result: 'success', action_continuous_output: fake_outputs) }
+      let(:fake_task) { FakeTask.new(result: 'success', action_continuous_output: fake_outputs, :ended_at => Time.new(2020, 12, 1, 0, 0, 0).utc) }
+      let(:job_invocation) { FactoryBot.create(:job_invocation, :with_task) }
+      let(:host) { job_invocation.template_invocations.first.host }
 
       it 'should render task outputs' do
-        job_invocation = FactoryBot.create(:job_invocation, :with_task)
         JobInvocation.any_instance.expects(:sub_task_for_host).returns(fake_task)
 
         input = job_invocation_template.template_inputs.first
@@ -44,13 +45,15 @@ class JobReportTemplateTest < ActiveSupport::TestCase
         result = ReportComposer.new(composer_params).render
 
         # parsing the CSV result
-        CSV.parse(result.strip, headers: true).each_with_index do |row, i|
-          row_hash = row.to_h
-          assert_equal 'success', row_hash['result']
-          assert_equal fake_outputs[i]['output_type'], row_hash['type']
-          assert_equal fake_outputs[i]['output'], row_hash['message']
-          assert_kind_of Time, Time.zone.parse(row_hash['time']), 'Parsing of time column failed'
-        end
+        rows = CSV.parse(result.strip, headers: true)
+        assert_equal 1, rows.count
+        row = rows.first
+        assert_equal host.name, row['Host']
+        assert_equal 'success', row['Result']
+        assert_equal 'error', row['stderr']
+        assert_equal 'output', row['stdout']
+        assert_equal 'debug', row['debug']
+        assert_kind_of Time, Time.zone.parse(row['Finished']), 'Parsing of time column failed'
       end
     end
   end