foreman_remote_execution 4.2.2 → 4.5.0

data/test/unit/job_invocation_composer_test.rb

@@ -16,16 +16,34 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
     setup_user('create', 'hosts')
   end
 
+  class AnsibleInputs < RemoteExecutionProvider
+    class << self
+      def provider_input_namespace
+        :ansible
+      end
+
+      def provider_inputs
+        [
+          ForemanRemoteExecution::ProviderInput.new(name: 'tags', label: 'Tags', value: 'fooo', value_type: 'plain'),
+          ForemanRemoteExecution::ProviderInput.new(name: 'tags_flag', label: 'Tags Flag', value: '--tags', options: "--tags\n--skip-tags"),
+        ]
+      end
+    end
+  end
+  RemoteExecutionProvider.register(:AnsibleInputs, AnsibleInputs)
+
   let(:trying_job_template_1) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying1', :provider_type => 'SSH') }
   let(:trying_job_template_2) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_2', :name => 'trying2', :provider_type => 'Mcollective') }
   let(:trying_job_template_3) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying3', :provider_type => 'SSH') }
   let(:unauthorized_job_template_1) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'unauth1', :provider_type => 'SSH') }
   let(:unauthorized_job_template_2) { FactoryBot.create(:job_template, :job_category => 'unauthorized_job_template_2', :name => 'unauth2', :provider_type => 'Ansible') }
 
+  let(:provider_inputs_job_template) { FactoryBot.create(:job_template, :job_category => 'trying_test_inputs', :name => 'trying provider inputs', :provider_type => 'AnsibleInputs') }
 
   let(:input1) { FactoryBot.create(:template_input, :template => trying_job_template_1, :input_type => 'user') }
   let(:input2) { FactoryBot.create(:template_input, :template => trying_job_template_3, :input_type => 'user') }
   let(:input3) { FactoryBot.create(:template_input, :template => trying_job_template_1, :input_type => 'user', :required => true) }
+  let(:input4) { FactoryBot.create(:template_input, :template => provider_inputs_job_template, :input_type => 'user') }
   let(:unauthorized_input1) { FactoryBot.create(:template_input, :template => unauthorized_job_template_1, :input_type => 'user') }
 
   let(:ansible_params) { { } }
@@ -604,8 +622,10 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
     end
   end
 
-  describe '#from_api_params' do
-    let(:composer) { JobInvocationComposer.from_api_params(params) }
+  describe '.from_api_params' do
+    let(:composer) do
+      JobInvocationComposer.from_api_params(params)
+    end
     let(:bookmark) { bookmarks(:one) }
 
     context 'with targeting from bookmark' do
@@ -659,6 +679,26 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
       end
     end
 
+    context 'with provider inputs' do
+      let(:params) do
+        { :job_category => provider_inputs_job_template.job_category,
+            :job_template_id => provider_inputs_job_template.id,
+            :targeting_type => 'static_query',
+          :search_query => 'some hosts',
+          :inputs => { input4.name => 'some_value' },
+          :ansible => { 'tags' => 'bar', 'tags_flag' => '--skip-tags' } }
+      end
+
+      it 'detects provider inputs' do
+        assert composer.save!
+        scope = composer.job_invocation.pattern_template_invocations.first.provider_input_values
+        tags = scope.find_by :name => 'tags'
+        flags = scope.find_by :name => 'tags_flag'
+        assert_equal 'bar', tags.value
+        assert_equal '--skip-tags', flags.value
+      end
+    end
+
     context 'with effective user' do
       let(:params) do
         { :job_category => trying_job_template_1.job_category,
@@ -714,12 +754,23 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
         assert composer.save!
         _(composer.job_invocation.remote_execution_feature).must_equal feature
       end
+
+      it 'sets the remote execution_feature id based on `feature` param' do
+        params[:remote_execution_feature_id] = nil
+        params[:feature] = feature.label
+        params[:job_template_id] = trying_job_template_1.id
+        refute_equal feature.job_template, trying_job_template_1
+
+        assert composer.save!
+        _(composer.job_invocation.remote_execution_feature).must_equal feature
+      end
     end
 
     context 'with invalid targeting' do
       let(:params) do
         { :job_category => trying_job_template_1.job_category,
           :job_template_id => trying_job_template_1.id,
+          :targeting_type => 'fake',
           :search_query => 'some hosts',
           :inputs => {input1.name => 'some_value'}}
       end
@@ -825,6 +876,39 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
     end
   end
 
+  describe '.for_feature' do
+    let(:feature) { FactoryBot.create(:remote_execution_feature, job_template: trying_job_template_1) }
+    let(:host) { FactoryBot.create(:host) }
+    let(:bookmark) { Bookmark.create!(:query => 'b', :name => 'bookmark', :public => true, :controller => 'hosts') }
+
+    context 'specifying hosts' do
+      it 'takes a bookmarked search' do
+        composer = JobInvocationComposer.for_feature(feature.label, bookmark, {})
+        assert_equal bookmark.id, composer.params['targeting']['bookmark_id']
+      end
+
+      it 'takes an array of host ids' do
+        composer = JobInvocationComposer.for_feature(feature.label, [host.id], {})
+        assert_match(/#{host.name}/, composer.params['targeting']['search_query'])
+      end
+
+      it 'takes a single host object' do
+        composer = JobInvocationComposer.for_feature(feature.label, host, {})
+        assert_match(/#{host.name}/, composer.params['targeting']['search_query'])
+      end
+
+      it 'takes an array of host FQDNs' do
+        composer = JobInvocationComposer.for_feature(feature.label, [host.fqdn], {})
+        assert_match(/#{host.name}/, composer.params['targeting']['search_query'])
+      end
+
+      it 'takes a search query string' do
+        composer = JobInvocationComposer.for_feature(feature.label, 'host.example.com', {})
+        assert_equal 'host.example.com', composer.search_query
+      end
+    end
+  end
+
   describe '#resolve_job_category and #resolve job_templates' do
     let(:setting_template) { as_admin { FactoryBot.create(:job_template, :name => 'trying setting', :job_category => 'fluff') } }
     let(:other_template) { as_admin { FactoryBot.create(:job_template, :name => 'trying something', :job_category => 'fluff') } }

data/test/unit/job_invocation_report_template_test.rb

@@ -0,0 +1,57 @@
+require 'test_plugin_helper'
+
+class JobReportTemplateTest < ActiveSupport::TestCase
+  class FakeTask < OpenStruct
+    class Jail < Safemode::Jail
+      allow :action_continuous_output, :result, :ended_at
+    end
+  end
+
+  context 'with valid job invocation report template' do
+    let(:job_invocation_template) do
+      file_path = File.read(File.expand_path(Rails.root + "app/views/unattended/report_templates/jobs_-_invocation_report_template.erb"))
+      template = ReportTemplate.import_without_save("Job Invocation Report Template", file_path)
+      template.save!
+      template
+    end
+
+    describe 'template setting' do
+      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
+
+        assert_include templates, 'Job Invocation Report Template'
+      end
+    end
+
+    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 },
+        ]
+      end
+      let(:fake_task) { FakeTask.new(result: 'success', action_continuous_output: fake_outputs) }
+
+      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
+        composer_params = { template_id: job_invocation_template.id, input_values: { input.id.to_s => { value: job_invocation.id.to_s } } }
+        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
+      end
+    end
+  end
+end

data/webpack/JobWizard/JobWizard.js

@@ -0,0 +1,96 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { Wizard } from '@patternfly/react-core';
+import { get } from 'foremanReact/redux/API';
+import { translate as __ } from 'foremanReact/common/I18n';
+import history from 'foremanReact/history';
+import CategoryAndTemplate from './steps/CategoryAndTemplate/';
+import { AdvancedFields } from './steps/AdvancedFields/AdvancedFields';
+import { JOB_TEMPLATE } from './JobWizardConstants';
+import { selectTemplateError } from './JobWizardSelectors';
+import './JobWizard.scss';
+
+export const JobWizard = () => {
+  const [jobTemplateID, setJobTemplateID] = useState(null);
+  const [category, setCategory] = useState('');
+  const [advancedValues, setAdvancedValues] = useState({});
+  const dispatch = useDispatch();
+
+  const setDefaults = useCallback(response => {
+    const responseJob = response.data;
+    setAdvancedValues({
+      effectiveUserValue: responseJob.effective_user?.value || '',
+      timeoutToKill: responseJob.job_template.execution_timeout_interval || '',
+    });
+  }, []);
+  useEffect(() => {
+    if (jobTemplateID) {
+      dispatch(
+        get({
+          key: JOB_TEMPLATE,
+          url: `/ui_job_wizard/template/${jobTemplateID}`,
+          handleSuccess: setDefaults,
+        })
+      );
+    }
+  }, [jobTemplateID, setDefaults, dispatch]);
+
+  const templateError = !!useSelector(selectTemplateError);
+  const isTemplate = !templateError && !!jobTemplateID;
+  const steps = [
+    {
+      name: __('Category and Template'),
+      component: (
+        <CategoryAndTemplate
+          jobTemplate={jobTemplateID}
+          setJobTemplate={setJobTemplateID}
+          category={category}
+          setCategory={setCategory}
+        />
+      ),
+    },
+    {
+      name: __('Target Hosts'),
+      component: <p>Target Hosts</p>,
+      canJumpTo: isTemplate,
+    },
+    {
+      name: __('Advanced Fields'),
+      component: (
+        <AdvancedFields
+          advancedValues={advancedValues}
+          setAdvancedValues={newValues => {
+            setAdvancedValues(currentAdvancedValues => ({
+              ...currentAdvancedValues,
+              ...newValues,
+            }));
+          }}
+          jobTemplateID={jobTemplateID}
+        />
+      ),
+      canJumpTo: isTemplate,
+    },
+    {
+      name: __('Schedule'),
+      component: <p>Schedule</p>,
+      canJumpTo: isTemplate,
+    },
+    {
+      name: __('Review Details'),
+      component: <p>Review Details</p>,
+      nextButtonText: 'Run',
+      canJumpTo: isTemplate,
+    },
+  ];
+  return (
+    <Wizard
+      onClose={() => history.goBack()}
+      navAriaLabel="Run Job steps"
+      steps={steps}
+      height="100%"
+      className="job-wizard"
+    />
+  );
+};
+
+export default JobWizard;

data/webpack/JobWizard/JobWizard.scss

@@ -0,0 +1,14 @@
+.job-wizard {
+  .pf-c-wizard__main {
+    z-index: calc(
+      var(--pf-c-wizard__footer--ZIndex) + 1
+    ); // So the select box can be shown above the wizard footer
+  }
+
+  .pf-c-wizard__main-body {
+    max-width: 500px;
+    .advanced-fields-title {
+      margin-bottom: 10px;
+    }
+  }
+}

data/webpack/JobWizard/JobWizardConstants.js

@@ -0,0 +1,6 @@
+import { foremanUrl } from 'foremanReact/common/helpers';
+
+export const JOB_TEMPLATES = 'JOB_TEMPLATES';
+export const JOB_CATEGORIES = 'JOB_CATEGORIES';
+export const JOB_TEMPLATE = 'JOB_TEMPLATE';
+export const templatesUrl = foremanUrl('/api/v2/job_templates');

data/webpack/JobWizard/JobWizardSelectors.js

@@ -0,0 +1,38 @@
+import {
+  selectAPIResponse,
+  selectAPIStatus,
+  selectAPIErrorMessage,
+} from 'foremanReact/redux/API/APISelectors';
+
+import {
+  JOB_TEMPLATES,
+  JOB_CATEGORIES,
+  JOB_TEMPLATE,
+} from './JobWizardConstants';
+
+export const selectJobTemplatesStatus = state =>
+  selectAPIStatus(state, JOB_TEMPLATES);
+
+export const filterJobTemplates = templates =>
+  templates?.filter(template => !template.snippet) || [];
+
+export const selectJobTemplates = state =>
+  filterJobTemplates(selectAPIResponse(state, JOB_TEMPLATES)?.results);
+
+export const selectJobCategories = state =>
+  selectAPIResponse(state, JOB_CATEGORIES).job_categories || [];
+
+export const selectJobCategoriesStatus = state =>
+  selectAPIStatus(state, JOB_CATEGORIES);
+
+export const selectCategoryError = state =>
+  selectAPIErrorMessage(state, JOB_CATEGORIES);
+
+export const selectAllTemplatesError = state =>
+  selectAPIErrorMessage(state, JOB_TEMPLATES);
+
+export const selectTemplateError = state =>
+  selectAPIErrorMessage(state, JOB_TEMPLATE);
+
+export const selectJobTemplate = state =>
+  selectAPIResponse(state, JOB_TEMPLATE);

data/webpack/JobWizard/__tests__/JobWizard.test.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import * as patternfly from '@patternfly/react-core';
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import JobWizardPage from '../index';
+
+jest.spyOn(patternfly, 'Wizard');
+patternfly.Wizard.mockImplementation(props => <div>{props.navAriaLabel}</div>);
+
+const fixtures = {
+  'renders ': {},
+};
+describe('JobWizardPage rendering', () =>
+  testComponentSnapshotsWithFixtures(JobWizardPage, fixtures));

data/webpack/JobWizard/__tests__/__snapshots__/JobWizard.test.js.snap

@@ -0,0 +1,32 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`JobWizardPage rendering renders  1`] = `
+<PageLayout
+  breadcrumbOptions={
+    Object {
+      "breadcrumbItems": Array [
+        Object {
+          "caption": "Jobs",
+          "url": "/jobs",
+        },
+        Object {
+          "caption": "Run job",
+        },
+      ],
+    }
+  }
+  header="Run job"
+  searchable={false}
+>
+  <Title
+    headingLevel="h2"
+    size="2xl"
+  >
+    Run job
+  </Title>
+  <Divider
+    component="div"
+  />
+  <JobWizard />
+</PageLayout>
+`;

data/webpack/JobWizard/__tests__/__snapshots__/integration.test.js.snap

@@ -0,0 +1,43 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Job wizard fill should select template: initial 1`] = `
+Array [
+  Object {
+    "key": "JOB_CATEGORIES",
+    "type": "get",
+    "url": "/ui_job_wizard/categories",
+  },
+  Object {
+    "key": "JOB_TEMPLATES",
+    "type": "get",
+    "url": URI {
+      "_deferred_build": true,
+      "_parts": Object {
+        "duplicateQueryParameters": false,
+        "escapeQuerySpace": true,
+        "fragment": null,
+        "hostname": null,
+        "password": null,
+        "path": "foreman/api/v2/job_templates",
+        "port": null,
+        "preventInvalidHostname": false,
+        "protocol": null,
+        "query": "search=job_category%3D%22Ansible+Commands%22&per_page=all",
+        "urn": null,
+        "username": null,
+      },
+      "_string": "",
+    },
+  },
+]
+`;
+
+exports[`Job wizard fill should select template: select template 1`] = `
+Array [
+  Object {
+    "key": "JOB_TEMPLATE",
+    "type": "get",
+    "url": "/ui_job_wizard/template/178",
+  },
+]
+`;