foreman_remote_execution 17.2.1 → 18.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2273dcbf9a1bd18e838f9312d802e752f181723049c543895e2ba9bbe47309b
-  data.tar.gz: 4be8496d42f9abcd54116d8e0dc09669d0e8c67674341e9672601450dc77a57a
+  metadata.gz: 4b301e962ec24666ada0b4a297277232ee94dc74a36b86875f4ce2230659c254
+  data.tar.gz: 923c5679450846add2cfba3a6741654e7bfd06f23e9e33b8ad5f19dfd2b6c217
 SHA512:
-  metadata.gz: 0656e10eb461a75898d1359ab6c03f5e10a6bbac18e03bac8ca804afd06f1050dc6bb6fb8a05ca0ced9a725dc4cd6b6202e164fca9a0ecf74179708aaa05d955
-  data.tar.gz: 76bfdccd452647bbdd56866eb6175c1efbb1efde242ef416a23902e429b1be6099e3a1f00ae9ddd1f2e956a21cb28baf099e31934ab501e112532934fdc7eadd
+  metadata.gz: 561489f3cee2bf28837084baa1fd3fb8b3a68b8acd632c0337f1b3204dc176acafefb85ecc15d058c464038ec38413a56899ce4ebd2d723596571622cb9c130f
+  data.tar.gz: '0938ab65b49a36d63fb709d905322559305ebd691f83bcf1aee8d81b9cb6cffd83db2fe50381295b7f589d37beddc457a7ee0aef3b8c02819f12008c9f461461'

data/app/controllers/api/v2/foreign_input_sets_controller.rb

@@ -76,6 +76,10 @@ module Api
       def resource_class
         ForeignInputSet
       end
+
+      def allowed_nested_id
+        %w(template_id)
+      end
     end
   end
 end

data/db/seeds.d/60-ssh_proxy_feature.rb

@@ -1,5 +1,5 @@
 f = Feature.where(:name => 'SSH').first_or_create
-raise "Unable to create proxy feature: #{format_errors f}" if f.nil? || f.errors.any?
+raise "Unable to create proxy feature: #{SeedHelper.format_errors(f)}" if f.nil? || f.errors.any?
 
 f = Feature.where(:name => 'Script').first_or_create
-raise "Unable to create proxy feature: #{format_errors f}" if f.nil? || f.errors.any?
+raise "Unable to create proxy feature: #{SeedHelper.format_errors(f)}" if f.nil? || f.errors.any?

data/db/seeds.d/90-bookmarks.rb

@@ -15,6 +15,6 @@ Bookmark.without_auditing do
     b = Bookmark.where(:name => input[:name], :controller => input[:controller]).first || Bookmark.new
     b.attributes = attributes
     b.save
-    raise "Unable to create bookmark: #{format_errors b}" if b.errors.any?
+    raise "Unable to create bookmark: #{SeedHelper.format_errors(b)}" if b.errors.any?
   end
 end

data/db/seeds.d/95-mail_notifications.rb

@@ -18,7 +18,7 @@ notifications.each do |notification|
     created_notification = RexMailNotification.create(notification)
     if created_notification.nil? || created_notification.errors.any?
       raise ::Foreman::Exception.new(N_("Unable to create mail notification: %s"),
-        format_errors(created_notification))
+        SeedHelper.format_errors(created_notification))
     end
   end
 end

data/lib/foreman_remote_execution/plugin.rb

@@ -1,5 +1,5 @@
 Foreman::Plugin.register :foreman_remote_execution do
-  requires_foreman '>= 5.0'
+  requires_foreman '>= 5.1'
   register_global_js_file 'global'
   register_gettext
 

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '17.2.1'.freeze
+  VERSION = '18.0.0'.freeze
 end

data/webpack/JobInvocationDetail/JobInvocationConstants.js

@@ -55,6 +55,16 @@ export const STATUS_TITLES = {
   NOT_STARTED: { id: 'N/A', title: __('Scheduled') },
 };
 
+export const TERMINAL_HOST_STATUSES = new Set([
+  'success',
+  'error',
+  'cancelled',
+]);
+
+export const areAllHostsTerminal = results =>
+  results?.length > 0 &&
+  results.every(host => TERMINAL_HOST_STATUSES.has(host.job_status));
+
 export const DATE_OPTIONS = {
   day: 'numeric',
   month: 'short',

data/webpack/JobInvocationDetail/JobInvocationHostTable.js

@@ -42,6 +42,7 @@ import Columns, {
   STATUS_UPPERCASE,
   AWAITING_STATUS_FILTER,
   AUTO_REFRESH_INTERVAL_MS,
+  areAllHostsTerminal,
 } from './JobInvocationConstants';
 import { TemplateInvocation } from './TemplateInvocation';
 import { RowActions } from './TemplateInvocationComponents/TemplateActionButtons';
@@ -196,7 +197,13 @@ const JobInvocationHostTable = ({
             if (thisRequest !== requestIdRef.current) return;
             if (!mountedRef.current) return;
             updateHostsState(data);
-            if (!jobFinishedRef.current) {
+            const hasActiveFilter = !!(
+              currentPollParams.current.search ||
+              currentPollParams.current.awaiting
+            );
+            const pageAllTerminal =
+              !hasActiveFilter && areAllHostsTerminal(data.data?.results);
+            if (!jobFinishedRef.current && !pageAllTerminal) {
               pollTimeoutId.current = setTimeout(
                 () => makeApiCall(currentPollParams.current),
                 AUTO_REFRESH_INTERVAL_MS

data/webpack/JobInvocationDetail/__tests__/JobInvocationHostTablePolling.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import React from 'react';
 import { render, act } from '@testing-library/react';
 import '@testing-library/jest-dom';
@@ -44,13 +45,28 @@ const hostsResponse = {
       operatingsystem_name: 'RHEL 9',
       hostgroup_id: 1,
       hostgroup_name: 'default',
-      job_status: 'success',
+      job_status: 'running',
       smart_proxy_id: 1,
       smart_proxy_name: 'proxy1',
     },
   ],
 };
 
+const terminalHostsResponse = {
+  ...hostsResponse,
+  results: [{ ...hostsResponse.results[0], job_status: 'success' }],
+};
+
+const mixedHostsResponse = {
+  ...hostsResponse,
+  total: 2,
+  subtotal: 2,
+  results: [
+    { ...hostsResponse.results[0], id: 1, job_status: 'success' },
+    { ...hostsResponse.results[0], id: 2, job_status: 'running' },
+  ],
+};
+
 let apiGetSpy;
 let hostsCalls;
 let pendingCallbacks;
@@ -66,9 +82,9 @@ const flushPendingCallbacks = () => {
   batch.forEach(cb => cb());
 };
 
-const renderTable = (props = {}) => {
+const renderTable = (props = {}, historyEntries = ['/']) => {
   const store = createStore();
-  const history = createMemoryHistory();
+  const history = createMemoryHistory({ initialEntries: historyEntries });
   const Wrapper = createForemanContextWrapper();
 
   const defaultProps = {
@@ -93,16 +109,14 @@ const renderTable = (props = {}) => {
   return { ...result, store, history };
 };
 
-const setupSuccessMock = () => {
+const setupSuccessMock = (response = hostsResponse) => {
   apiGetSpy = jest
     .spyOn(APIActions, 'get')
     .mockImplementation(opts => dispatch => {
       if (opts.key === JOB_INVOCATION_HOSTS) {
         hostsCalls.push(opts);
         if (opts.handleSuccess) {
-          pendingCallbacks.push(() =>
-            opts.handleSuccess({ data: hostsResponse })
-          );
+          pendingCallbacks.push(() => opts.handleSuccess({ data: response }));
         }
       }
     });
@@ -311,6 +325,98 @@ describe('JobInvocationHostTable polling', () => {
     expect(hostsCalls.length).toBeGreaterThan(callsAfterFilterChange);
   });
 
+  it('stops polling when all hosts on the page are terminal', () => {
+    apiGetSpy.mockRestore();
+    setupSuccessMock(terminalHostsResponse);
+
+    renderTable();
+
+    expect(hostsCalls).toHaveLength(1);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(10000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(1);
+  });
+
+  it('continues polling when at least one host on the page is non-terminal', () => {
+    apiGetSpy.mockRestore();
+    setupSuccessMock(mixedHostsResponse);
+
+    renderTable();
+
+    expect(hostsCalls).toHaveLength(1);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(2);
+  });
+
+  it('continues polling when all hosts on the page are terminal but a status filter is active', () => {
+    apiGetSpy.mockRestore();
+    setupSuccessMock(terminalHostsResponse);
+
+    renderTable({ initialFilter: 'success' });
+
+    expect(hostsCalls).toHaveLength(1);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(2);
+  });
+
+  it('continues polling when all hosts on the page are terminal but a search query is active', () => {
+    apiGetSpy.mockRestore();
+    setupSuccessMock(terminalHostsResponse);
+
+    renderTable({}, ['/?search=host1']);
+
+    expect(hostsCalls).toHaveLength(1);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(2);
+  });
+
   it('sends include_permissions only on the first request', () => {
     renderTable();
 

data/webpack/JobInvocationDetail/__tests__/areAllHostsTerminal.test.js

@@ -0,0 +1,40 @@
+import { areAllHostsTerminal } from '../JobInvocationConstants';
+
+describe('areAllHostsTerminal', () => {
+  it('returns false for an empty results array', () => {
+    expect(areAllHostsTerminal([])).toBe(false);
+  });
+
+  it('returns false for undefined results', () => {
+    expect(areAllHostsTerminal(undefined)).toBe(false);
+  });
+
+  it('returns true when every host is in a terminal state', () => {
+    expect(
+      areAllHostsTerminal([
+        { id: 1, job_status: 'success' },
+        { id: 2, job_status: 'error' },
+        { id: 3, job_status: 'cancelled' },
+      ])
+    ).toBe(true);
+  });
+
+  it('returns false when at least one host is non-terminal', () => {
+    expect(
+      areAllHostsTerminal([
+        { id: 1, job_status: 'success' },
+        { id: 2, job_status: 'running' },
+      ])
+    ).toBe(false);
+  });
+
+  it('returns false when every host is non-terminal', () => {
+    expect(
+      areAllHostsTerminal([
+        { id: 1, job_status: 'running' },
+        { id: 2, job_status: 'planned' },
+        { id: 3, job_status: 'N/A' },
+      ])
+    ).toBe(false);
+  });
+});

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

@@ -1,8 +1,9 @@
 /* eslint-disable max-lines */
 import React from 'react';
 import { Provider } from 'react-redux';
-import { mount } from '@theforeman/test';
-import { fireEvent, screen, render, act } from '@testing-library/react';
+import { screen, render, act, fireEvent } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import '@testing-library/jest-dom';
 import { MockedProvider } from '@apollo/client/testing';
 import * as api from 'foremanReact/redux/API';
 import { JobWizard } from '../../../JobWizard';
@@ -20,11 +21,55 @@ import { WIZARD_TITLES } from '../../../JobWizardConstants';
 const lodash = require('lodash');
 
 lodash.debounce = fn => fn;
+
 const store = testSetup(selectors, api);
 mockApi(api);
 
 jest.useFakeTimers();
 
+const clickOptions = { skipHover: true };
+
+const wizardStepButton = title =>
+  screen.getByText(title, { selector: 'button' });
+
+const clickWizardStep = async title => {
+  await act(async () => {
+    fireEvent.click(wizardStepButton(title));
+    jest.advanceTimersByTime(1000);
+  });
+};
+
+const typeIntoField = async (field, value) => {
+  await act(async () => {
+    await userEvent.click(field, {}, clickOptions);
+    await userEvent.clear(field);
+    userEvent.paste(field, value);
+    jest.advanceTimersByTime(1000);
+  });
+};
+
+const renderJobWizard = ({ customStore = store, withGql = true } = {}) => {
+  const wizard = (
+    <Provider store={customStore}>
+      <JobWizard />
+    </Provider>
+  );
+
+  if (withGql) {
+    return render(
+      <MockedProvider mocks={gqlMock} addTypename={false}>
+        {wizard}
+      </MockedProvider>
+    );
+  }
+
+  return render(wizard);
+};
+
+const goToAdvancedStep = async () => {
+  await clickWizardStep(WIZARD_TITLES.advanced);
+};
+
 describe('AdvancedFields', () => {
   beforeEach(() => {
     jest.spyOn(selectors, 'selectRouterSearch');
@@ -32,87 +77,45 @@ describe('AdvancedFields', () => {
       'host_ids[]': ['105', '37'],
     }));
   });
+
   afterEach(() => {
     selectors.selectRouterSearch.mockRestore();
   });
-  it('should save data between steps for advanced fields', async () => {
-    const wrapper = mount(
-      <MockedProvider mocks={gqlMock} addTypename={false}>
-        <Provider store={store}>
-          <JobWizard />
-        </Provider>
-      </MockedProvider>
-    );
-    // setup
-    wrapper
-      .find('.pf-v5-c-button.pf-v5-c-select__toggle-button')
-      .simulate('click');
-    wrapper
-      .find('.pf-v5-c-select__menu-item')
-      .first()
-      .simulate('click');
-
-    // test
-    expect(
-      wrapper.find('.pf-v5-c-wizard__nav-link.pf-m-disabled')
-    ).toHaveLength(0);
-    wrapper
-      .find('.pf-v5-c-wizard__nav-link')
-      .at(2)
-      .simulate('click'); // Advanced step
 
-    await act(async () => {
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
+  it('preserves advanced field values when navigating between wizard steps', async () => {
+    renderJobWizard();
+    await goToAdvancedStep();
+
+    const effectiveUserInput = screen.getByLabelText('effective user', {
+      selector: 'input',
+    });
+    const advancedTemplateInput = screen.getByLabelText('adv plain hidden', {
+      selector: 'textarea',
     });
-    const effectiveUserInput = () => wrapper.find('input#effective-user');
-    const advancedTemplateInput = () =>
-      wrapper.find('.pf-v5-c-form__group-control textarea');
-    const effectiveUesrValue = 'effective user new value';
+    const effectiveUserValue = 'effective user new value';
     const advancedTemplateInputValue = 'advanced input new value';
-    effectiveUserInput().getDOMNode().value = effectiveUesrValue;
-
-    effectiveUserInput().simulate('change');
-    wrapper.update();
-    advancedTemplateInput().getDOMNode().value = advancedTemplateInputValue;
-    advancedTemplateInput().simulate('change');
-    expect(effectiveUserInput().prop('value')).toEqual(effectiveUesrValue);
-    expect(advancedTemplateInput().prop('value')).toEqual(
-      advancedTemplateInputValue
-    );
 
-    wrapper
-      .find('.pf-v5-c-wizard__nav-link')
-      .at(1)
-      .simulate('click');
+    await typeIntoField(effectiveUserInput, effectiveUserValue);
+    await typeIntoField(advancedTemplateInput, advancedTemplateInputValue);
 
-    expect(
-      wrapper.find('.pf-v5-c-wizard__nav-link.pf-m-current').text()
-    ).toEqual('Target hosts and inputs');
-    wrapper
-      .find('.pf-v5-c-wizard__nav-link')
-      .at(2)
-      .simulate('click'); // Advanced step
+    expect(effectiveUserInput).toHaveValue(effectiveUserValue);
+    expect(advancedTemplateInput).toHaveValue(advancedTemplateInputValue);
 
-    await act(async () => {
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
-    });
-    expect(effectiveUserInput().prop('value')).toEqual(effectiveUesrValue);
-    expect(advancedTemplateInput().prop('value')).toEqual(
-      advancedTemplateInputValue
+    await clickWizardStep(WIZARD_TITLES.hostsAndInputs);
+    expect(wizardStepButton(WIZARD_TITLES.hostsAndInputs)).toHaveAttribute(
+      'aria-current',
+      'step'
     );
+
+    await goToAdvancedStep();
+
+    expect(effectiveUserInput).toHaveValue(effectiveUserValue);
+    expect(advancedTemplateInput).toHaveValue(advancedTemplateInputValue);
   });
-  it('fill template fields', async () => {
-    render(
-      <MockedProvider mocks={gqlMock} addTypename={false}>
-        <Provider store={store}>
-          <JobWizard />
-        </Provider>
-      </MockedProvider>
-    );
-    await act(async () => {
-      fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
-    });
+
+  it('preserves template field values when navigating between wizard steps', async () => {
+    renderJobWizard();
+    await goToAdvancedStep();
 
     const searchValue = 'search test';
     const textValue = 'I am a text';
@@ -131,134 +134,126 @@ describe('AdvancedFields', () => {
 
     fireEvent.click(selectField);
     await act(async () => {
-      await fireEvent.click(screen.getByText('option 2'));
-      fireEvent.click(screen.getAllByText(WIZARD_TITLES.advanced)[0]); // to remove focus
-
-      fireEvent.click(resourceSelectField);
-      fireEvent.click(screen.getByText('resource2'));
-      fireEvent.change(textField, {
-        target: { value: textValue },
-      });
-      fireEvent.change(searchField, {
-        target: { value: searchValue },
-      });
-      await fireEvent.change(dateField, {
-        target: { value: dateValue },
-      });
-      fireEvent.change(timeField, {
-        target: { value: timeValue },
-      });
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
-    });
-    expect(
-      screen.getByLabelText('adv plain hidden', {
-        selector: 'textarea',
-      }).value
-    ).toBe(textValue);
-    expect(searchField.value).toBe(searchValue);
-    expect(screen.getByLabelText('adv date datepicker').value).toBe(dateValue);
-    expect(timeField.value).toBe(timeValue);
-    await act(async () => {
-      fireEvent.click(screen.getByText(WIZARD_TITLES.categoryAndTemplate));
+      await userEvent.click(screen.getByText('option 2'), {}, clickOptions);
+      await userEvent.click(
+        screen.getAllByText(WIZARD_TITLES.advanced)[0],
+        {},
+        clickOptions
+      );
+
+      await userEvent.click(resourceSelectField, {}, clickOptions);
+      await userEvent.click(screen.getByText('resource2'), {}, clickOptions);
+      await typeIntoField(textField, textValue);
+      await typeIntoField(searchField, searchValue);
+      fireEvent.change(dateField, { target: { value: dateValue } });
+      fireEvent.change(timeField, { target: { value: timeValue } });
+      jest.advanceTimersByTime(1000);
     });
+
+    expect(textField).toHaveValue(textValue);
+    expect(searchField).toHaveValue(searchValue);
+    expect(dateField).toHaveValue(dateValue);
+    expect(timeField).toHaveValue(timeValue);
+
+    await clickWizardStep(WIZARD_TITLES.categoryAndTemplate);
     expect(screen.getAllByText(WIZARD_TITLES.categoryAndTemplate)).toHaveLength(
       3
     );
 
-    await act(async () => {
-      await fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
-      jest.advanceTimersByTime(1000);
-    });
-    expect(textField.value).toBe(textValue);
-    expect(searchField.value).toBe(searchValue);
-    expect(dateField.value).toBe(dateValue);
-    expect(timeField.value).toBe(timeValue);
-    expect(screen.queryAllByText('option 1')).toHaveLength(0);
-    expect(screen.queryAllByText('option 2')).toHaveLength(1);
-    expect(screen.queryAllByDisplayValue('resource1')).toHaveLength(0);
-    expect(screen.queryAllByDisplayValue('resource2')).toHaveLength(1);
+    await goToAdvancedStep();
+
+    expect(textField).toHaveValue(textValue);
+    expect(searchField).toHaveValue(searchValue);
+    expect(dateField).toHaveValue(dateValue);
+    expect(timeField).toHaveValue(timeValue);
+    expect(screen.queryByText('option 1')).not.toBeInTheDocument();
+    expect(screen.getByText('option 2')).toBeInTheDocument();
+    expect(screen.queryByDisplayValue('resource1')).not.toBeInTheDocument();
+    expect(screen.getByDisplayValue('resource2')).toBeInTheDocument();
   });
-  it('fill defaults into fields', async () => {
-    render(
-      <MockedProvider mocks={gqlMock} addTypename={false}>
-        <Provider store={store}>
-          <JobWizard />
-        </Provider>
-      </MockedProvider>
-    );
-    await act(async () => {
-      fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
-    });
+
+  it('fills default values into advanced fields', async () => {
+    renderJobWizard();
+    await goToAdvancedStep();
 
     expect(
-      screen.getByLabelText('ssh user', {
-        selector: 'input',
-      }).value
-    ).toBe('');
+      screen.getByLabelText('ssh user', { selector: 'input' })
+    ).toHaveValue('');
     expect(
-      screen.getByLabelText('effective user', {
-        selector: 'input',
-      }).value
-    ).toBe('default effective user');
+      screen.getByLabelText('effective user', { selector: 'input' })
+    ).toHaveValue('default effective user');
     expect(
-      screen.getByLabelText('timeout to kill', {
-        selector: 'input',
-      }).value
-    ).toBe('2');
-
+      screen.getByLabelText('timeout to kill', { selector: 'input' })
+    ).toHaveValue('2');
     expect(
-      screen.getByLabelText('description preview', {
-        selector: 'input',
-      }).value
-    ).toBe(
+      screen.getByLabelText('description preview', { selector: 'input' })
+    ).toHaveValue(
       'template1 with inputs adv plain hidden="Default val" adv plain select="" adv resource select="" adv search="" adv date="" plain hidden="Default val"'
     );
   });
-  it('DescriptionField', async () => {
-    render(
-      <Provider store={store}>
-        <JobWizard />
-      </Provider>
-    );
-    await act(async () => {
-      fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
-    });
+
+  it('renders advanced fields step with expected form fields', async () => {
+    renderJobWizard();
+    await goToAdvancedStep();
+
+    expect(
+      screen.getByLabelText('adv plain hidden', { selector: 'textarea' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByLabelText('adv plain select toggle')
+    ).toBeInTheDocument();
+    expect(
+      screen.getByLabelText('adv resource select toggle')
+    ).toBeInTheDocument();
+    expect(
+      screen.getByLabelText('ssh user', { selector: 'input' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByLabelText('effective user', { selector: 'input' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByLabelText('description preview', { selector: 'input' })
+    ).toBeInTheDocument();
+  });
+
+  it('updates description preview when editing the description template', async () => {
+    renderJobWizard({ withGql: false });
+    await goToAdvancedStep();
 
     const textField = screen.getByLabelText('adv plain hidden', {
       selector: 'textarea',
     });
-    await act(async () => {
-      await fireEvent.change(textField, {
-        target: { value: 'test command' },
-      });
-    });
+    await typeIntoField(textField, 'test command');
+
     const descriptionValue = 'Run %{adv plain hidden} %{wrong command name}';
 
     await act(async () => {
-      fireEvent.click(screen.getByText('Edit job description template'));
+      await userEvent.click(
+        screen.getByText('Edit job description template'),
+        {},
+        clickOptions
+      );
     });
 
     const editText = screen.getByLabelText('description edit', {
       selector: 'input',
     });
-    await fireEvent.change(editText, {
-      target: { value: descriptionValue },
-    });
+    await typeIntoField(editText, descriptionValue);
     await act(async () => {
-      fireEvent.click(screen.getByText('Preview job description'));
+      await userEvent.click(
+        screen.getByText('Preview job description'),
+        {},
+        clickOptions
+      );
     });
+
     expect(
-      screen.getByLabelText('description preview', {
-        selector: 'input',
-      }).value
-    ).toBe('Run test command %{wrong command name}');
+      screen.getByLabelText('description preview', { selector: 'input' })
+    ).toHaveValue('Run test command %{wrong command name}');
   });
 
-  it('DescriptionField with no inputs', async () => {
+  it('shows template name in description preview when template has no inputs', async () => {
     jest.spyOn(api, 'get');
-
     jest.spyOn(selectors, 'selectTemplateInputs');
     jest.spyOn(selectors, 'selectAdvancedTemplateInputs');
     selectors.selectTemplateInputs.mockImplementation(() => []);
@@ -289,23 +284,20 @@ describe('AdvancedFields', () => {
       }
       return { type: 'get', ...action };
     });
-    render(
-      <Provider store={store}>
-        <JobWizard />
-      </Provider>
-    );
-    await act(async () => {
-      fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
-    });
+
+    renderJobWizard({ withGql: false });
+    await goToAdvancedStep();
+
     expect(
-      screen.getByLabelText('description preview', {
-        selector: 'input',
-      }).value
-    ).toBe('template1');
+      screen.getByLabelText('description preview', { selector: 'input' })
+    ).toHaveValue('template1');
+
+    selectors.selectTemplateInputs.mockRestore();
+    selectors.selectAdvancedTemplateInputs.mockRestore();
+    api.get.mockRestore();
   });
 
-  it('DescriptionField with description_format', async () => {
+  it('uses description_format for description preview', async () => {
     jest.spyOn(api, 'get');
     jest.spyOn(selectors, 'selectTemplateInputs');
     selectors.selectTemplateInputs.mockImplementation(() => [
@@ -334,7 +326,6 @@ describe('AdvancedFields', () => {
                 ...jobTemplateResponse.job_template,
                 description_format: 'Run %{command}',
               },
-
               template_inputs: [
                 {
                   name: 'command',
@@ -363,46 +354,34 @@ describe('AdvancedFields', () => {
       }
       return { type: 'get', ...action };
     });
-    render(
-      <Provider store={store}>
-        <JobWizard />
-      </Provider>
-    );
-    await act(async () => {
-      fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
-    });
+
+    renderJobWizard({ withGql: false });
+    await goToAdvancedStep();
+
     expect(
-      screen.getByLabelText('description preview', {
-        selector: 'input',
-      }).value
-    ).toBe('Run Default val');
+      screen.getByLabelText('description preview', { selector: 'input' })
+    ).toHaveValue('Run Default val');
+
+    selectors.selectTemplateInputs.mockRestore();
+    api.get.mockRestore();
   });
 
-  it('search resources action', async () => {
-    jest.useFakeTimers();
-    mockApi(api);
+  it('dispatches resource search when typing in resource select', async () => {
     const newStore = testSetup(selectors, api);
-    render(
-      <Provider store={newStore}>
-        <JobWizard />
-      </Provider>
-    );
-    await act(async () => {
-      fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
-      jest.advanceTimersByTime(1000); // to handle pf4 date picker popover
-    });
+    mockApi(api);
+
+    renderJobWizard({ customStore: newStore, withGql: false });
+    await goToAdvancedStep();
+
     const resourceSelectField = screen.getByLabelText(
       'adv resource select typeahead input'
     );
 
+    await typeIntoField(resourceSelectField, 'some search');
     await act(async () => {
-      await fireEvent.change(resourceSelectField, {
-        target: { value: 'some search' },
-      });
-
       jest.advanceTimersByTime(10000);
     });
+
     const actions = newStore.getActions();
     const resourceSearchAction = actions.filter(
       action => action.key === 'ForemanTasksTask'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foreman_remote_execution
 version: !ruby/object:Gem::Version
-  version: 17.2.1
+  version: 18.0.0
 platform: ruby
 authors:
 - Foreman Remote Execution team
 bindir: bin
 cert_chain: []
-date: 2026-09-03 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deface
@@ -405,6 +405,7 @@ files:
 - webpack/JobInvocationDetail/__tests__/TableToolbarActions.test.js
 - webpack/JobInvocationDetail/__tests__/TemplateInvocation.test.js
 - webpack/JobInvocationDetail/__tests__/TemplateInvocationPolling.test.js
+- webpack/JobInvocationDetail/__tests__/areAllHostsTerminal.test.js
 - webpack/JobInvocationDetail/__tests__/fixtures.js
 - webpack/JobInvocationDetail/__tests__/foremanTestHelpers.js
 - webpack/JobInvocationDetail/index.js
@@ -566,7 +567,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A plugin bringing remote execution to the Foreman, completing the config
   management functionality with remote management functionality.