foreman_remote_execution 4.4.0 → 4.5.3

data/test/unit/job_invocation_composer_test.rb

@@ -622,7 +622,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
     end
   end
 
-  describe '#from_api_params' do
+  describe '.from_api_params' do
     let(:composer) do
       JobInvocationComposer.from_api_params(params)
     end
@@ -754,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
@@ -853,7 +864,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
@@ -863,6 +876,50 @@ 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
+    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

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,55 +1,116 @@
-import React, { useState } 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 [jobTemplate, setJobTemplate] = useState(null);
+  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'),
+      name: __('Category and Template'),
       component: (
         <CategoryAndTemplate
-          jobTemplate={jobTemplate}
-          setJobTemplate={setJobTemplate}
+          jobTemplate={jobTemplateID}
+          setJobTemplate={setJobTemplateID}
           category={category}
           setCategory={setCategory}
         />
       ),
     },
     {
-      name: __('Target hosts'),
-      component: <p>TargetHosts </p>,
-      canJumpTo: !!jobTemplate,
+      name: __('Target Hosts'),
+      component: <p>Target Hosts</p>,
+      canJumpTo: isTemplate,
     },
     {
-      name: __('Advanced fields'),
-      component: <p> AdvancedFields </p>,
-      canJumpTo: !!jobTemplate,
+      name: __('Advanced Fields'),
+      component: (
+        <AdvancedFields
+          advancedValues={advancedValues}
+          setAdvancedValues={newValues => {
+            setAdvancedValues(currentAdvancedValues => ({
+              ...currentAdvancedValues,
+              ...newValues,
+            }));
+          }}
+          jobTemplateID={jobTemplateID}
+        />
+      ),
+      canJumpTo: isTemplate,
     },
     {
       name: __('Schedule'),
-      component: <p>Schedule</p>,
-      canJumpTo: !!jobTemplate,
+      component: <Schedule />,
+      canJumpTo: isTemplate,
     },
     {
-      name: __('Review details'),
-      component: <p>ReviewDetails</p>,
+      name: __('Review Details'),
+      component: <p>Review Details</p>,
       nextButtonText: 'Run',
-      canJumpTo: !!jobTemplate,
+      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"
     />
   );
 };
+
+export default JobWizard;

data/webpack/JobWizard/JobWizard.scss

@@ -1,6 +1,5 @@
 .job-wizard {
   .pf-c-wizard__main {
-    overflow: visible;
     z-index: calc(
       var(--pf-c-wizard__footer--ZIndex) + 1
     ); // So the select box can be shown above the wizard footer
@@ -8,5 +7,47 @@
 
   .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

@@ -1,5 +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

@@ -1,9 +1,14 @@
 import {
   selectAPIResponse,
   selectAPIStatus,
+  selectAPIErrorMessage,
 } from 'foremanReact/redux/API/APISelectors';
 
-import { JOB_TEMPLATES, JOB_CATEGORIES } from './JobWizardConstants';
+import {
+  JOB_TEMPLATES,
+  JOB_CATEGORIES,
+  JOB_TEMPLATE,
+} from './JobWizardConstants';
 
 export const selectJobTemplatesStatus = state =>
   selectAPIStatus(state, JOB_TEMPLATES);
@@ -19,3 +24,24 @@ export const selectJobCategories = state =>
 
 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 };
+  });
+};