foreman_remote_execution 4.3.1 → 4.5.2

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/test/unit/job_invocation_test.rb

@@ -10,7 +10,7 @@ class JobInvocationTest < ActiveSupport::TestCase
     end
 
     it 'is able to perform search through job invocations' do
-      found_jobs = JobInvocation.search_for(%{job_category = "#{job_invocation.job_category}"}).paginate(:page => 1).with_task.order('job_invocations.id DESC')
+      found_jobs = JobInvocation.search_for(%{job_category = "#{job_invocation.job_category}"}).paginate(:page => 1).order('job_invocations.id DESC')
       _(found_jobs).must_equal [job_invocation]
     end
 

data/webpack/JobWizard/JobWizard.js

@@ -1,30 +1,114 @@
-import React from 'react';
+/* eslint-disable camelcase */
+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 Schedule from './steps/Schedule/';
+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(
+    ({
+      data: {
+        advanced_template_inputs,
+        effective_user,
+        job_template: { executionTimeoutInterval, description_format },
+      },
+    }) => {
+      const advancedTemplateValues = {};
+      const advancedInputs = advanced_template_inputs;
+      if (advancedInputs) {
+        advancedInputs.forEach(input => {
+          advancedTemplateValues[input.name] = input?.default || '';
+        });
+      }
+      setAdvancedValues(currentAdvancedValues => ({
+        ...currentAdvancedValues,
+        effectiveUserValue: effective_user?.value || '',
+        timeoutToKill: executionTimeoutInterval || '',
+        templateValues: advancedTemplateValues,
+        description: description_format || '',
+      }));
+    },
+    []
+  );
+  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: <p>Category and template</p>,
+      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: <Schedule />,
+      canJumpTo: isTemplate,
     },
-    { name: __('Target hosts'), component: <p>TargetHosts </p> },
-    { name: __('Advanced fields'), component: <p> AdvancedFields </p> },
-    { name: __('Schedule'), component: <p>Schedule</p> },
     {
-      name: __('Review details'),
-      component: <p>ReviewDetails</p>,
+      name: __('Review Details'),
+      component: <p>Review Details</p>,
       nextButtonText: 'Run',
+      canJumpTo: isTemplate,
     },
   ];
-  const title = __('Run Job');
   return (
     <Wizard
       onClose={() => history.goBack()}
-      navAriaLabel={`${title} steps`}
+      navAriaLabel="Run Job steps"
       steps={steps}
-      height="70vh"
+      height="100%"
+      className="job-wizard"
     />
   );
 };

data/webpack/JobWizard/JobWizard.scss

@@ -0,0 +1,53 @@
+.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;
+    }
+    #advanced-fields-job-template {
+      .foreman-search-field {
+        // Giving pf3 search bar a pf4 look
+        .search-bar {
+          display: block;
+        }
+        .input-group-btn {
+          display: none;
+        }
+        li {
+          font-size: 16px;
+        }
+        input {
+          font-size: 16px;
+          height: 36px;
+        }
+        .foreman-autocomplete .autocomplete-focus-shortcut {
+          top: 8px;
+          font-size: 16px;
+        }
+        .foreman-autocomplete .autocomplete-aux {
+          top: 8px;
+          font-size: 16px;
+          .autocomplete-clear-button {
+            font-size: 16px;
+          }
+        }
+      }
+    }
+  }
+
+  .schedule-tab {
+    input[type='radio'],
+    input[type='checkbox'] {
+      margin: 0;
+    }
+    .advanced-scheduling-button {
+      text-align: start;
+    }
+  }
+}

data/webpack/JobWizard/JobWizardConstants.js

@@ -0,0 +1,16 @@
+import { translate as __ } from 'foremanReact/common/I18n';
+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');
+
+export const repeatTypes = {
+  noRepeat: __('Does not repeat'),
+  cronline: __('Cronline'),
+  monthly: __('Monthly'),
+  weekly: __('Weekly'),
+  daily: __('Daily'),
+  hourly: __('Hourly'),
+};

data/webpack/JobWizard/JobWizardSelectors.js

@@ -0,0 +1,47 @@
+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);
+
+export const selectEffectiveUser = state =>
+  selectAPIResponse(state, JOB_TEMPLATE).effective_user;
+
+export const selectAdvancedTemplateInputs = state =>
+  selectAPIResponse(state, JOB_TEMPLATE).advanced_template_inputs || [];
+
+export const selectTemplateInputs = state =>
+  selectAPIResponse(state, JOB_TEMPLATE).template_inputs || [];

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",
+  },
+]
+`;

data/webpack/JobWizard/__tests__/fixtures.js

@@ -0,0 +1,128 @@
+import configureMockStore from 'redux-mock-store';
+
+export const jobTemplate = {
+  id: 178,
+  name: 'template1',
+  template:
+    "---\n- hosts: all\n  tasks:\n    - shell:\n        cmd: |\n<%=       indent(10) { input('command') } %>\n      register: out\n    - debug: var=out",
+  snippet: false,
+  default: true,
+  job_category: 'Ansible Commands',
+  provider_type: 'Ansible',
+  description_format: 'Run %{command}',
+  execution_timeout_interval: 2,
+  description: null,
+};
+
+export const jobTemplates = [jobTemplate];
+
+export const jobTemplateResponse = {
+  job_template: jobTemplate,
+  effective_user: {
+    id: null,
+    job_template_id: 178,
+    value: 'default effective user',
+    overridable: true,
+    current_user: false,
+  },
+  advanced_template_inputs: [
+    {
+      name: 'adv plain hidden',
+      required: true,
+      input_type: 'user',
+      description: 'some Description',
+      advanced: true,
+      value_type: 'plain',
+      resource_type: 'ansible_roles',
+      default: 'Default val',
+      hidden_value: true,
+    },
+    {
+      name: 'adv plain select',
+      required: false,
+      input_type: 'user',
+      options: 'option 1\r\noption 2\r\noption 3\r\noption 4',
+      advanced: true,
+      value_type: 'plain',
+      resource_type: 'ansible_roles',
+      default: '',
+      hidden_value: false,
+    },
+    {
+      name: 'adv search',
+      required: false,
+      options: '',
+      advanced: true,
+      value_type: 'search',
+      resource_type: 'foreman_tasks/tasks',
+      default: '',
+      hidden_value: false,
+    },
+    {
+      name: 'adv date',
+      required: false,
+      options: '',
+      advanced: true,
+      value_type: 'date',
+      resource_type: 'ansible_roles',
+      default: '',
+      hidden_value: false,
+    },
+  ],
+  template_inputs: [
+    {
+      name: 'plain hidden',
+      required: true,
+      input_type: 'user',
+      description: 'some Description',
+      advanced: false,
+      value_type: 'plain',
+      resource_type: 'ansible_roles',
+      default: 'Default val',
+      hidden_value: true,
+    },
+  ],
+};
+
+export const jobCategories = ['Ansible Commands', 'Puppet', 'Services'];
+
+export const testSetup = (selectors, api) => {
+  jest.spyOn(api, 'get');
+  jest.spyOn(selectors, 'selectJobTemplate');
+  jest.spyOn(selectors, 'selectJobTemplates');
+  jest.spyOn(selectors, 'selectJobCategories');
+  jest.spyOn(selectors, 'selectJobCategoriesStatus');
+
+  selectors.selectJobCategories.mockImplementation(() => jobCategories);
+  selectors.selectJobTemplates.mockImplementation(() => [
+    jobTemplate,
+    { ...jobTemplate, id: 2, name: 'template2' },
+  ]);
+  const mockStore = configureMockStore([]);
+  const store = mockStore({});
+  return store;
+};
+
+export const mockTemplate = selectors => {
+  selectors.selectJobTemplate.mockImplementation(() => jobTemplate);
+  selectors.selectJobCategoriesStatus.mockImplementation(() => 'RESOLVED');
+};
+export const mockApi = api => {
+  api.get.mockImplementation(({ handleSuccess, ...action }) => {
+    if (action.key === 'JOB_CATEGORIES') {
+      handleSuccess &&
+        handleSuccess({ data: { job_categories: jobCategories } });
+    } else if (action.key === 'JOB_TEMPLATE') {
+      handleSuccess &&
+        handleSuccess({
+          data: jobTemplateResponse,
+        });
+    } else if (action.key === 'JOB_TEMPLATES') {
+      handleSuccess &&
+        handleSuccess({
+          data: { results: [jobTemplate] },
+        });
+    }
+    return { type: 'get', ...action };
+  });
+};