foreman_remote_execution 4.6.0 → 4.7.0

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/unit/concerns/host_extensions_test.rb

@@ -131,23 +131,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

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

@@ -350,12 +350,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') }
@@ -864,7 +858,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 +870,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 +925,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_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,3 +1,4 @@
+/* eslint-disable camelcase */
 import React, { useState, useEffect, useCallback } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { Wizard } from '@patternfly/react-core';
@@ -8,6 +9,7 @@ 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 = () => {
@@ -16,13 +18,31 @@ export const JobWizard = () => {
   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 || '',
-    });
-  }, []);
+  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(
@@ -72,7 +92,7 @@ export const JobWizard = () => {
     },
     {
       name: __('Schedule'),
-      component: <p>Schedule</p>,
+      component: <Schedule />,
       canJumpTo: isTemplate,
     },
     {

data/webpack/JobWizard/JobWizard.scss

@@ -10,5 +10,44 @@
     .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,6 +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

@@ -36,3 +36,12 @@ export const selectTemplateError = state =>
 
 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__/fixtures.js

@@ -1,6 +1,8 @@
-const jobTemplate = {
+import configureMockStore from 'redux-mock-store';
+
+export const jobTemplate = {
   id: 178,
-  name: 'Run Command - Ansible Default',
+  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,
@@ -23,4 +25,104 @@ export const jobTemplateResponse = {
     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 };
+  });
 };