foreman_remote_execution 4.5.6 → 5.0.0

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
 
@@ -931,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

data/test/unit/job_template_effective_user_test.rb

@@ -4,10 +4,6 @@ class JobTemplateEffectiveUserTest < ActiveSupport::TestCase
   let(:job_template) { FactoryBot.build(:job_template, :job_category => '') }
   let(:effective_user) { job_template.effective_user }
 
-  before do
-    Setting::RemoteExecution.load_defaults
-  end
-
   describe 'by default' do
     it 'is overridable' do
       assert effective_user.overridable?

data/test/unit/remote_execution_provider_test.rb

@@ -66,10 +66,6 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     before { User.current = FactoryBot.build(:user, :admin) }
     after { User.current = nil }
 
-    before do
-      Setting::RemoteExecution.load_defaults
-    end
-
     let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
     let(:template_invocation) { job_invocation.pattern_template_invocations.first }
     let(:host) { FactoryBot.create(:host) }
@@ -212,6 +208,40 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.interfaces.each(&:save)
         host.reload
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip
+
+        # there is an execution interface with both IPv6 and IPv4: IPv4 is being preferred over IPv6 by default
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => '10.0.0.4', :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip
+      end
+
+      it 'gets ipv6 from flagged interfaces with IPv6 preference' do
+        host.host_params['remote_execution_connect_by_ip_prefer_ipv6'] = true
+        host.host_params['remote_execution_connect_by_ip'] = true
+
+        # there is an execution interface with both IPv6 and IPv4: IPv6 is being preferred over IPv4 by host parameter configuration
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => '10.0.0.4', :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip6
+      end
+
+      it 'gets ipv6 from flagged interfaces with IPv4 preference but without IPv4 address' do
+        host.host_params['remote_execution_connect_by_ip_prefer_ipv6'] = false
+        host.host_params['remote_execution_connect_by_ip'] = true
+
+        # there is an execution interface with both IPv6 and IPv4: IPv6 is being preferred over IPv4 by host parameter configuration
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => nil, :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip6
       end
     end
   end

data/test/unit/targeting_test.rb

@@ -77,24 +77,73 @@ class TargetingTest < ActiveSupport::TestCase
     it { _(targeting.reload.hosts).must_be_empty }
   end
 
+  describe '#resolve_hosts!' do
+    let(:second_host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
+    let(:targeting) { FactoryBot.build(:targeting) }
+
+    before do
+      host
+      second_host
+      infra_host
+    end
+
+    context 'with infrastructure host permission' do
+      before do
+        setup_user('view', 'hosts')
+        setup_user('execute_jobs_on', 'infrastructure_hosts')
+      end
+
+      it 'resolves all hosts' do
+        hosts = [host, second_host, infra_host]
+        targeting.search_query = "name ^ (#{hosts.map(&:name).join(',')})"
+        targeting.user = User.current
+        targeting.resolve_hosts!
+
+        targeting.hosts.must_include host
+        targeting.hosts.must_include second_host
+        targeting.hosts.must_include infra_host
+      end
+    end
+
+    context 'without infrastructure host permission' do
+      before { setup_user('view', 'hosts') }
+
+      it 'ignores infrastructure hosts' do
+        hosts = [host, second_host, infra_host]
+        targeting.search_query = "name ^ (#{hosts.map(&:name).join(',')})"
+        targeting.user = User.current
+        targeting.resolve_hosts!
+
+        targeting.hosts.must_include host
+        targeting.hosts.must_include second_host
+        targeting.hosts.wont_include infra_host
+      end
+    end
+  end
+
   describe '#build_query_from_hosts(ids)' do
     let(:second_host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
 
     before do
       host
       second_host
+      infra_host
     end
 
     context 'for two hosts' do
-      let(:query) { Targeting.build_query_from_hosts([ host.id, second_host.id ]) }
+      let(:query) { Targeting.build_query_from_hosts([ host.id, second_host.id, infra_host.id ]) }
 
       it 'builds query using host names joining inside ^' do
         _(query).must_include host.name
         _(query).must_include second_host.name
+        _(query).must_include infra_host.name
         _(query).must_include 'name ^'
 
         Host.search_for(query).must_include host
         Host.search_for(query).must_include second_host
+        Host.search_for(query).must_include infra_host
       end
     end
 
@@ -105,6 +154,7 @@ class TargetingTest < ActiveSupport::TestCase
         _(query).must_equal "name ^ (#{host.name})"
         Host.search_for(query).must_include host
         Host.search_for(query).wont_include second_host
+        Host.search_for(query).wont_include infra_host
       end
     end
 
@@ -114,6 +164,23 @@ class TargetingTest < ActiveSupport::TestCase
       it 'builds query to find all hosts' do
         Host.search_for(query).must_include host
         Host.search_for(query).must_include second_host
+        Host.search_for(query).must_include infra_host
+      end
+    end
+
+    context 'without infrastructure host permission' do
+      before { User.current = nil }
+
+      it 'ignores the infrastructure host' do
+        query = Targeting.build_query_from_hosts([host.id, second_host.id, infra_host.id])
+        _(query).must_include host.name
+        _(query).must_include second_host.name
+        _(query).wont_include infra_host.name
+        _(query).must_include 'name ^'
+
+        Host.search_for(query).must_include host
+        Host.search_for(query).must_include second_host
+        Host.search_for(query).wont_include infra_host
       end
     end
   end

data/webpack/JobWizard/JobWizard.js

@@ -4,20 +4,43 @@ import { useDispatch, useSelector } from 'react-redux';
 import { Wizard } from '@patternfly/react-core';
 import { get } from 'foremanReact/redux/API';
 import history from 'foremanReact/history';
+
+import {
+  useForemanOrganization,
+  useForemanLocation,
+} from 'foremanReact/Root/Context/ForemanContext';
 import CategoryAndTemplate from './steps/CategoryAndTemplate/';
 import { AdvancedFields } from './steps/AdvancedFields/AdvancedFields';
-import { JOB_TEMPLATE, WIZARD_TITLES } from './JobWizardConstants';
-import { selectTemplateError } from './JobWizardSelectors';
+import {
+  JOB_TEMPLATE,
+  WIZARD_TITLES,
+  initialScheduleState,
+} from './JobWizardConstants';
+import {
+  selectTemplateError,
+  selectJobTemplate,
+  selectIsSubmitting,
+} from './JobWizardSelectors';
 import Schedule from './steps/Schedule/';
 import HostsAndInputs from './steps/HostsAndInputs/';
+import ReviewDetails from './steps/ReviewDetails/';
+import { useValidation } from './validation';
+import { useAutoFill } from './autofill';
+import { submit } from './submit';
 import './JobWizard.scss';
 
 export const JobWizard = () => {
   const [jobTemplateID, setJobTemplateID] = useState(null);
   const [category, setCategory] = useState('');
-  const [advancedValues, setAdvancedValues] = useState({});
+  const [advancedValues, setAdvancedValues] = useState({ templateValues: {} });
   const [templateValues, setTemplateValues] = useState({}); // TODO use templateValues in advanced fields - description https://github.com/theforeman/foreman_remote_execution/pull/605
-  const [selectedHosts, setSelectedHosts] = useState(['host1', 'host2']);
+  const [scheduleValue, setScheduleValue] = useState(initialScheduleState);
+  const [selectedTargets, setSelectedTargets] = useState({
+    hosts: [],
+    hostCollections: [],
+    hostGroups: [],
+  });
+  const [hostsSearchQuery, setHostsSearchQuery] = useState('');
   const dispatch = useDispatch();
 
   const setDefaults = useCallback(
@@ -26,7 +49,7 @@ export const JobWizard = () => {
         template_inputs,
         advanced_template_inputs,
         effective_user,
-        job_template: { execution_timeout_interval, description_format },
+        job_template: { name, execution_timeout_interval, description_format },
       },
     }) => {
       const advancedTemplateValues = {};
@@ -47,12 +70,21 @@ export const JobWizard = () => {
             advancedTemplateValues[input.name] = input?.default || '';
           });
         }
+        const generateDefaultDescription = () => {
+          if (description_format) return description_format;
+          const allInputs = [...advancedInputs, ...inputs];
+          if (!allInputs.length) return name;
+          const inputsString = allInputs
+            .map(({ name: inputname }) => `${inputname}="%{${inputname}}"`)
+            .join(' ');
+          return `${name} with inputs ${inputsString}`;
+        };
         return {
           ...currentAdvancedValues,
           effectiveUserValue: effective_user?.value || '',
           timeoutToKill: execution_timeout_interval || '',
           templateValues: advancedTemplateValues,
-          description: description_format || '',
+          description: generateDefaultDescription() || '',
           isRandomizedOrdering: false,
         };
       });
@@ -71,8 +103,20 @@ export const JobWizard = () => {
     }
   }, [jobTemplateID, setDefaults, dispatch]);
 
+  const [valid, setValid] = useValidation({
+    advancedValues,
+    templateValues,
+  });
+  useAutoFill({
+    setSelectedTargets,
+    setHostsSearchQuery,
+  });
   const templateError = !!useSelector(selectTemplateError);
-  const isTemplate = !templateError && !!jobTemplateID;
+  const templateResponse = useSelector(selectJobTemplate);
+  const isSubmitting = useSelector(selectIsSubmitting);
+  const isTemplate =
+    !templateError && !!jobTemplateID && templateResponse.job_template;
+
   const steps = [
     {
       name: WIZARD_TITLES.categoryAndTemplate,
@@ -84,6 +128,7 @@ export const JobWizard = () => {
           setCategory={setCategory}
         />
       ),
+      enableNext: isTemplate,
     },
     {
       name: WIZARD_TITLES.hostsAndInputs,
@@ -91,11 +136,14 @@ export const JobWizard = () => {
         <HostsAndInputs
           templateValues={templateValues}
           setTemplateValues={setTemplateValues}
-          selectedHosts={selectedHosts}
-          setSelectedHosts={setSelectedHosts}
+          selected={selectedTargets}
+          setSelected={setSelectedTargets}
+          hostsSearchQuery={hostsSearchQuery}
+          setHostsSearchQuery={setHostsSearchQuery}
         />
       ),
       canJumpTo: isTemplate,
+      enableNext: isTemplate && valid.hostsAndInputs,
     },
     {
       name: WIZARD_TITLES.advanced,
@@ -108,23 +156,53 @@ export const JobWizard = () => {
               ...newValues,
             }));
           }}
-          jobTemplateID={jobTemplateID}
+          templateValues={templateValues}
         />
       ),
-      canJumpTo: isTemplate,
+      canJumpTo: isTemplate && valid.hostsAndInputs,
+      enableNext: isTemplate && valid.hostsAndInputs && valid.advanced,
     },
     {
       name: WIZARD_TITLES.schedule,
-      component: <Schedule />,
-      canJumpTo: isTemplate,
+      component: (
+        <Schedule
+          scheduleValue={scheduleValue}
+          setScheduleValue={setScheduleValue}
+          setValid={newValue => {
+            setValid(currentValid => ({ ...currentValid, schedule: newValue }));
+          }}
+        />
+      ),
+      canJumpTo: isTemplate && valid.hostsAndInputs && valid.advanced,
+      enableNext:
+        isTemplate && valid.hostsAndInputs && valid.advanced && valid.schedule,
     },
     {
       name: WIZARD_TITLES.review,
-      component: <p>Review Details</p>,
+      component: (
+        <ReviewDetails
+          jobCategory={category}
+          jobTemplateID={jobTemplateID}
+          advancedValues={advancedValues}
+          scheduleValue={scheduleValue}
+          templateValues={templateValues}
+          selectedTargets={selectedTargets}
+          hostsSearchQuery={hostsSearchQuery}
+        />
+      ),
       nextButtonText: 'Run',
-      canJumpTo: isTemplate,
+      canJumpTo:
+        isTemplate && valid.hostsAndInputs && valid.advanced && valid.schedule,
+      enableNext:
+        isTemplate &&
+        valid.hostsAndInputs &&
+        valid.advanced &&
+        valid.schedule &&
+        !isSubmitting,
     },
   ];
+  const location = useForemanLocation();
+  const organization = useForemanOrganization();
   return (
     <Wizard
       onClose={() => history.goBack()}
@@ -132,6 +210,19 @@ export const JobWizard = () => {
       steps={steps}
       height="100%"
       className="job-wizard"
+      onSave={() => {
+        submit({
+          jobTemplateID,
+          templateValues,
+          advancedValues,
+          scheduleValue,
+          dispatch,
+          selectedTargets,
+          hostsSearchQuery,
+          location,
+          organization,
+        });
+      }}
     />
   );
 };