katello 4.3.0.rc4 → 4.4.0.rc2

data/webpack/components/extensions/HostDetails/Tabs/__tests__/packagesTab.test.js

@@ -1,10 +1,11 @@
 import React from 'react';
-import { renderWithRedux, patientlyWaitFor } from 'react-testing-lib-wrapper';
+import { renderWithRedux, patientlyWaitFor, fireEvent } from 'react-testing-lib-wrapper';
 import { nockInstance, assertNockRequest, mockForemanAutocomplete, mockSetting } from '../../../../../test-utils/nockWrapper';
 import { foremanApi } from '../../../../../services/api';
-import { HOST_PACKAGES_KEY } from '../../HostPackages/HostPackagesConstants';
+import { HOST_PACKAGES_KEY, PACKAGES_SEARCH_QUERY } from '../../HostPackages/HostPackagesConstants';
 import { PackagesTab } from '../PackagesTab';
 import mockPackagesData from './packages.fixtures.json';
+import { REX_FEATURES } from '../RemoteExecutionConstants';
 
 const contentFacetAttributes = {
   id: 11,
@@ -13,6 +14,7 @@ const contentFacetAttributes = {
   lifecycle_environment_library: false,
 };
 
+const hostname = 'test-host.example.com';
 const renderOptions = (facetAttributes = contentFacetAttributes) => ({
   apiNamespace: HOST_PACKAGES_KEY,
   initialState: {
@@ -20,6 +22,7 @@ const renderOptions = (facetAttributes = contentFacetAttributes) => ({
       HOST_DETAILS: {
         response: {
           id: 1,
+          name: hostname,
           content_facet_attributes: { ...facetAttributes },
         },
         status: 'RESOLVED',
@@ -28,18 +31,26 @@ const renderOptions = (facetAttributes = contentFacetAttributes) => ({
   },
 });
 
-const hostPackages = foremanApi.getApiUrl('/hosts/1/packages?include_latest_upgradable=true&per_page=20&page=1');
+const hostPackages = foremanApi.getApiUrl('/hosts/1/packages');
+const jobInvocations = foremanApi.getApiUrl('/job_invocations');
 const autocompleteUrl = '/hosts/1/packages/auto_complete_search';
+const defaultQueryWithoutSearch = {
+  include_latest_upgradable: true,
+  per_page: 20,
+  page: 1,
+};
+const defaultQuery = { ...defaultQueryWithoutSearch, search: '' };
 
-let firstPackages;
+let firstPackage;
+let secondPackage;
 let searchDelayScope;
 let autoSearchScope;
 
 beforeEach(() => {
   const { results } = mockPackagesData;
-  [firstPackages] = results;
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 500);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', true);
+  [firstPackage, secondPackage] = results;
+  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
+  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
 });
 
 afterEach(() => {
@@ -50,22 +61,21 @@ afterEach(() => {
 test('Can call API for packages and show on screen on page load', async (done) => {
   // Setup autocomplete with mockForemanAutoComplete since we aren't adding /katello
   const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
-
-  // return tracedata results when we look for packages
   const scope = nockInstance
     .get(hostPackages)
+    .query(defaultQuery)
     .reply(200, mockPackagesData);
 
   const { getAllByText } = renderWithRedux(<PackagesTab />, renderOptions());
 
   // Assert that the packages are now showing on the screen, but wait for them to appear.
-  await patientlyWaitFor(() => expect(getAllByText(firstPackages.name)[0]).toBeInTheDocument());
+  await patientlyWaitFor(() => expect(getAllByText(firstPackage.name)[0]).toBeInTheDocument());
   // Assert request was made and completed, see helper function
   assertNockRequest(autocompleteScope);
   assertNockRequest(scope, done); // Pass jest callback to confirm test is done
 });
 
-test('Can handle no packags being present', async (done) => {
+test('Can handle no packages being present', async (done) => {
   // Setup autocomplete with mockForemanAutoComplete since we aren't adding /katello
   const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
 
@@ -79,6 +89,7 @@ test('Can handle no packags being present', async (done) => {
 
   const scope = nockInstance
     .get(hostPackages)
+    .query(defaultQuery)
     .reply(200, noResults);
 
   const { queryByText } = renderWithRedux(<PackagesTab />, renderOptions());
@@ -89,3 +100,293 @@ test('Can handle no packags being present', async (done) => {
   assertNockRequest(autocompleteScope);
   assertNockRequest(scope, done); // Pass jest callback to confirm test is done
 });
+
+test('Can filter by package status', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+  const scope = nockInstance
+    .get(hostPackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const scope2 = nockInstance
+    .get(hostPackages)
+    .query({ ...defaultQuery, status: 'upgradable' })
+    .reply(200, { ...mockPackagesData, results: [firstPackage] });
+
+  const {
+    queryByText,
+    getByRole,
+    getAllByText,
+    getByText,
+  } = renderWithRedux(<PackagesTab />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackage.name)[0]).toBeInTheDocument());
+  // the Upgradable text in the table is just a text node, while the dropdown is a button
+  expect(getByText('Up-to date', { ignore: ['button', 'title'] })).toBeInTheDocument();
+  expect(getByText('coreutils', { ignore: ['button', 'title'] })).toBeInTheDocument();
+  expect(getByText('acl', { ignore: ['button', 'title'] })).toBeInTheDocument();
+
+  const statusDropdown = queryByText('Status', { ignore: 'th' });
+  expect(statusDropdown).toBeInTheDocument();
+  fireEvent.click(statusDropdown);
+  const upgradable = getByRole('option', { name: 'select Upgradable' });
+  fireEvent.click(upgradable);
+  await patientlyWaitFor(() => {
+    expect(queryByText('coreutils')).toBeInTheDocument();
+    expect(queryByText('acl')).not.toBeInTheDocument();
+  });
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope);
+  assertNockRequest(searchDelayScope);
+  assertNockRequest(autoSearchScope);
+  assertNockRequest(scope2, done); // Pass jest callback to confirm test is done
+});
+
+test('Can upgrade a package via remote execution', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostPackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const statusScope = nockInstance
+    .get(hostPackages)
+    .query({ ...defaultQuery, status: 'upgradable' })
+    .reply(200, { ...mockPackagesData, results: [firstPackage] });
+
+  const upgradeScope = nockInstance
+    .post(jobInvocations, {
+      job_invocation: {
+        inputs: {
+          package: firstPackage.upgradable_version,
+        },
+        search_query: `name ^ (${hostname})`,
+        feature: REX_FEATURES.KATELLO_PACKAGE_UPDATE,
+      },
+    })
+    .reply(201);
+
+  const {
+    getByRole,
+    getAllByText,
+    getByLabelText,
+    getByText,
+  } = renderWithRedux(<PackagesTab />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackage.name)[0]).toBeInTheDocument());
+
+  const statusDropdown = getByText('Status', { ignore: 'th' });
+  expect(statusDropdown).toBeInTheDocument();
+  fireEvent.click(statusDropdown);
+  const upgradable = getByRole('option', { name: 'select Upgradable' });
+  fireEvent.click(upgradable);
+  await patientlyWaitFor(() => {
+    expect(getByText('coreutils')).toBeInTheDocument();
+  });
+
+  const kebabDropdown = getByLabelText('Actions');
+  kebabDropdown.click();
+
+  const rexAction = getByText('Upgrade via remote execution');
+  await patientlyWaitFor(() => expect(rexAction).toBeInTheDocument());
+  fireEvent.click(rexAction);
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope);
+  assertNockRequest(statusScope);
+  assertNockRequest(upgradeScope, done);
+});
+
+test('Can upgrade a package via customized remote execution', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostPackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const statusScope = nockInstance
+    .get(hostPackages)
+    .query({ ...defaultQuery, status: 'upgradable' })
+    .reply(200, { ...mockPackagesData, results: [firstPackage] });
+
+  const {
+    getByRole,
+    getAllByText,
+    getByLabelText,
+    getByText,
+  } = renderWithRedux(<PackagesTab />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackage.name)[0]).toBeInTheDocument());
+
+  const statusDropdown = getByText('Status', { ignore: 'th' });
+  expect(statusDropdown).toBeInTheDocument();
+  fireEvent.click(statusDropdown);
+  const upgradable = getByRole('option', { name: 'select Upgradable' });
+  fireEvent.click(upgradable);
+  await patientlyWaitFor(() => {
+    expect(getByText('coreutils')).toBeInTheDocument();
+  });
+
+  const kebabDropdown = getByLabelText('Actions');
+  kebabDropdown.click();
+
+  const rexAction = getByText('Upgrade via customized remote execution');
+  const feature = REX_FEATURES.KATELLO_PACKAGE_UPDATE;
+  const packageName = firstPackage.upgradable_version;
+
+  expect(rexAction).toBeInTheDocument();
+  expect(rexAction).toHaveAttribute(
+    'href',
+    `/job_invocations/new?feature=${feature}&host_ids=name%20%5E%20(${hostname})&inputs%5Bpackage%5D=${packageName}`,
+  );
+
+  fireEvent.click(rexAction);
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope);
+  assertNockRequest(statusScope, done);
+});
+
+test('Can bulk upgrade via remote execution', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostPackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const upgradeScope = nockInstance
+    .post(jobInvocations, {
+      job_invocation: {
+        inputs: {
+          [PACKAGES_SEARCH_QUERY]: `id ^ (${firstPackage.id},${secondPackage.id})`,
+        },
+        search_query: `name ^ (${hostname})`,
+        feature: REX_FEATURES.KATELLO_PACKAGES_UPDATE_BY_SEARCH,
+      },
+    })
+    .reply(201);
+
+  const {
+    getAllByRole,
+    getAllByText,
+    getByRole,
+    getByLabelText,
+  } = renderWithRedux(<PackagesTab />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackage.name)[0]).toBeInTheDocument());
+
+  getByRole('checkbox', { name: 'Select row 0' }).click();
+  expect(getByLabelText('Select row 0').checked).toEqual(true);
+  getByRole('checkbox', { name: 'Select row 1' }).click();
+  expect(getByLabelText('Select row 1').checked).toEqual(true);
+
+  const upgradeDropdown = getAllByRole('button', { name: 'Select' })[1];
+  fireEvent.click(upgradeDropdown);
+
+  const rexAction = getByLabelText('bulk_upgrade_rex');
+  expect(rexAction).toBeInTheDocument();
+  fireEvent.click(rexAction);
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope);
+  assertNockRequest(upgradeScope, done);
+});
+
+test('Can bulk upgrade via customized remote execution', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostPackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const {
+    getAllByRole,
+    getAllByText,
+    getByRole,
+    getByLabelText,
+  } = renderWithRedux(<PackagesTab />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackage.name)[0]).toBeInTheDocument());
+
+  const feature = REX_FEATURES.KATELLO_PACKAGES_UPDATE_BY_SEARCH;
+  const packages = `${firstPackage.id},${secondPackage.id}`;
+  const job =
+    `/job_invocations/new?feature=${feature}&host_ids=name%20%5E%20(${hostname})&inputs%5BPackages%20search%20query%5D=id%20%5E%20(${packages})`;
+
+  getByRole('checkbox', { name: 'Select row 0' }).click();
+  expect(getByLabelText('Select row 0').checked).toEqual(true);
+  getByRole('checkbox', { name: 'Select row 1' }).click();
+  expect(getByLabelText('Select row 1').checked).toEqual(true);
+
+  const upgradeDropdown = getAllByRole('button', { name: 'Select' })[1];
+  fireEvent.click(upgradeDropdown);
+  expect(upgradeDropdown).not.toHaveAttribute('disabled');
+
+  const rexAction = getByLabelText('bulk_upgrade_customized_rex');
+  expect(rexAction).toBeInTheDocument();
+  expect(rexAction).toHaveAttribute('href', job);
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
+});
+
+test('Upgrade is disabled when there are non-upgradable packages selected', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostPackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const {
+    getAllByRole,
+    getAllByText,
+    getByLabelText,
+    getByRole,
+  } = renderWithRedux(<PackagesTab />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackage.name)[0]).toBeInTheDocument());
+
+  // select an upgradable package
+  getByRole('checkbox', { name: 'Select row 0' }).click();
+  // select an up-to-date package
+  getByRole('checkbox', { name: 'Select row 2' }).click();
+  expect(getByLabelText('Select row 2').checked).toEqual(true);
+
+  const upgradeDropdown = getAllByRole('button', { name: 'Select' })[1];
+  expect(upgradeDropdown).toHaveAttribute('disabled');
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
+});
+
+test('Remove is disabled when in select all mode', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+  const scope = nockInstance
+    .get(hostPackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const {
+    getAllByText, getByRole,
+  } = renderWithRedux(<PackagesTab />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackage.name)[0]).toBeInTheDocument());
+
+  // find and click the select all checkbox
+  const selectAllCheckbox = getByRole('checkbox', { name: 'Select all' });
+  fireEvent.click(selectAllCheckbox);
+  getByRole('button', { name: 'bulk_actions' }).click();
+
+  const removeButton = getByRole('button', { name: 'bulk_remove' });
+  await patientlyWaitFor(() => expect(removeButton).toBeInTheDocument());
+  expect(removeButton).toHaveAttribute('aria-disabled', 'true');
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
+});

data/webpack/components/extensions/HostDetails/Tabs/__tests__/repositorySetsTab.test.js

@@ -59,8 +59,8 @@ beforeEach(() => {
   const { results } = mockRepoSetData;
   [firstRepoSet] = results;
   bookmarkScope = nockInstance.get(repositorySetBookmarks).reply(200, mockBookmarkData);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 500);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', true);
+  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
+  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
 });
 
 afterEach(() => {

data/webpack/components/extensions/HostDetails/Tabs/__tests__/tracesTab.test.js

@@ -3,8 +3,8 @@ import { renderWithRedux, waitFor, patientlyWaitFor, fireEvent, act } from 'reac
 import nock, { nockInstance, assertNockRequest, mockForemanAutocomplete, mockSetting } from '../../../../../test-utils/nockWrapper';
 import { foremanApi } from '../../../../../services/api';
 import { REX_FEATURES } from '../RemoteExecutionConstants';
-import { HOST_TRACES_KEY, TRACES_SEARCH_QUERY } from '../HostTracesConstants';
-import TracesTab from '../TracesTab';
+import { HOST_TRACES_KEY, TRACES_SEARCH_QUERY } from '../TracesTab/HostTracesConstants';
+import TracesTab from '../TracesTab/TracesTab.js';
 import mockTraceData from './traces.fixtures.json';
 import mockResolveTraceTask from './resolveTraces.fixtures.json';
 import emptyTraceResults from './tracerEmptyTraceResults.fixtures.json';
@@ -40,10 +40,6 @@ const renderOptions = isTracerInstalled => ({ // sets initial Redux state
   },
 });
 
-// Find the checkbox to the left of the trace.
-// (We could also have just found the checkbox by its aria-label "Select row 0",
-// but this is closer to how the user would do it)
-const checkboxToTheLeftOf = node => node.previousElementSibling.firstElementChild;
 const actionMenuToTheRightOf = node => node.nextElementSibling.firstElementChild.firstElementChild;
 
 const hostTraces = foremanApi.getApiUrl('/hosts/1/traces?per_page=20&page=1');
@@ -51,16 +47,15 @@ const autocompleteUrl = '/hosts/1/traces/auto_complete_search';
 const jobInvocations = foremanApi.getApiUrl('/job_invocations');
 
 let firstTrace;
-let secondTrace;
 let searchDelayScope;
 let autoSearchScope;
 
 describe('With tracer installed', () => {
   beforeEach(() => {
     const { results } = mockTraceData;
-    [firstTrace, secondTrace] = results;
-    searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 500);
-    autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', true);
+    [firstTrace] = results;
+    searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
+    autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
   });
 
   afterEach(() => {
@@ -119,17 +114,17 @@ describe('With tracer installed', () => {
       .reply(201, mockResolveTraceTask);
 
 
-    const { getByText } = renderWithRedux(
+    const { getByText, getByLabelText } = renderWithRedux(
       <TracesTab />,
       renderOptions(true),
     );
+
     let traceCheckbox;
-    // Find the trace.
+    // Find the trace checkbox.
     await patientlyWaitFor(() => {
-      const traceNameNode = getByText(firstTrace.application);
-      traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+      traceCheckbox = getByLabelText('Select row 0');
     });
-    traceCheckbox.click();
+    fireEvent.click(traceCheckbox);
     expect(traceCheckbox.checked).toEqual(true);
 
     const restartAppButton = getByText('Restart app');
@@ -158,16 +153,17 @@ describe('With tracer installed', () => {
       .reply(201, mockResolveTraceTask);
 
 
-    const { getByText, getByLabelText, queryByText } = renderWithRedux(
+    const { getByLabelText, queryByText } = renderWithRedux(
       <TracesTab />,
       renderOptions(true),
     );
     let traceCheckbox;
+
+    // Find the trace.
     await patientlyWaitFor(() => {
-      const traceNameNode = getByText(firstTrace.application);
-      traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+      traceCheckbox = getByLabelText('Select row 0');
     });
-    traceCheckbox.click();
+    fireEvent.click(traceCheckbox);
     expect(traceCheckbox.checked).toEqual(true);
     const actionMenu = getByLabelText('bulk_actions');
     actionMenu.click();
@@ -204,14 +200,16 @@ describe('With tracer installed', () => {
     );
 
     let traceCheckbox;
-    // Assert that the traces are now showing on the screen, but wait for them to appear.
+    // Find the trace.
     await patientlyWaitFor(() => {
-      const traceNameNode = getByText(firstTrace.application);
-      traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+      traceCheckbox = getByLabelText('Select row 0');
     });
+
+
     const selectAllCheckbox = getByLabelText('Select all');
     fireEvent.click(selectAllCheckbox);
     expect(traceCheckbox.checked).toEqual(true);
+
     fireEvent.click(getByLabelText('Select row 0')); // de select
     fireEvent.click(getByLabelText('Select row 2')); // de select
 
@@ -298,16 +296,15 @@ describe('With tracer installed', () => {
       .get(hostTraces)
       .reply(200, mockTraceData);
 
-    const { getByText, getByLabelText, queryByText } = renderWithRedux(
+    const { getByLabelText, queryByText } = renderWithRedux(
       <TracesTab />,
       renderOptions(true),
     );
     let traceCheckbox;
     await patientlyWaitFor(() => {
-      const traceNameNode = getByText(firstTrace.application);
-      traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+      traceCheckbox = getByLabelText('Select row 0');
     });
-    traceCheckbox.click();
+    fireEvent.click(traceCheckbox);
     expect(traceCheckbox.checked).toEqual(true);
 
     const actionMenu = getByLabelText('bulk_actions');
@@ -327,7 +324,7 @@ describe('With tracer installed', () => {
   describe('Remote execution URL helper logic', () => {
     beforeEach(() => {
       const { results } = mockTraceData;
-      [firstTrace, secondTrace] = results;
+      [firstTrace] = results;
     });
 
     afterEach(() => {
@@ -341,14 +338,13 @@ describe('With tracer installed', () => {
         .get(hostTraces)
         .reply(200, mockTraceData);
 
-      const { getByText } = renderWithRedux(
+      const { getByLabelText } = renderWithRedux(
         <TracesTab />,
         renderOptions(true),
       );
       let traceCheckbox;
       await patientlyWaitFor(() => {
-        const traceNameNode = getByText(secondTrace.application);
-        traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+        traceCheckbox = getByLabelText('Select row 1');
       });
       expect(traceCheckbox.disabled).toEqual(true);
 

data/webpack/components/extensions/HostDetails/Tabs/__tests__/yumInstallablePackages.fixtures.json

@@ -0,0 +1,72 @@
+{
+    "total": 18,
+    "subtotal": 3,
+    "selectable": 3,
+    "page": "1",
+    "per_page": "20",
+    "error": null,
+    "search": null,
+    "sort": {
+        "by": null,
+        "order": null
+    },
+    "results": [
+        {
+            "id": 32376,
+            "pulp_id": "/pulp/api/v3/content/rpm/packages/4b817f2d-d428-4eb4-aa4c-6cd9dc2a0300/",
+            "name": "cheetah",
+            "version": "0.3",
+            "release": "0.8",
+            "arch": "noarch",
+            "epoch": "0",
+            "summary": "A dummy package of cheetah",
+            "modular": false,
+            "filename": "cheetah-0.3-0.8.noarch.rpm",
+            "sourcerpm": "cheetah-0.3-0.8.src.rpm",
+            "checksum": "422d0baa0cd9d7713ae796e886a23e17f578f924f74880debdbb7d65fb368dae",
+            "nvrea": "cheetah-0.3-0.8.noarch",
+            "nvra": "cheetah-0.3-0.8.noarch",
+            "uuid": "/pulp/api/v3/content/rpm/packages/4b817f2d-d428-4eb4-aa4c-6cd9dc2a0300/",
+            "hosts_available_count": 0,
+            "hosts_applicable_count": 0
+        },
+        {
+            "id": 32372,
+            "pulp_id": "/pulp/api/v3/content/rpm/packages/c7aee0d3-32d9-49dd-99f9-9269fae7cb6f/",
+            "name": "duck",
+            "version": "0.7",
+            "release": "1",
+            "arch": "noarch",
+            "epoch": "0",
+            "summary": "Quack like a duck at the park.",
+            "modular": true,
+            "filename": "duck-0.7-1.noarch.rpm",
+            "sourcerpm": "duck-0.7-1.src.rpm",
+            "checksum": "5bd363b860ad6783217cbca3bbc3ef260f98d140ffb121bf4c208e3f66c24712",
+            "nvrea": "duck-0.7-1.noarch",
+            "nvra": "duck-0.7-1.noarch",
+            "uuid": "/pulp/api/v3/content/rpm/packages/c7aee0d3-32d9-49dd-99f9-9269fae7cb6f/",
+            "hosts_available_count": 0,
+            "hosts_applicable_count": 0
+        },
+        {
+            "id": 32370,
+            "pulp_id": "/pulp/api/v3/content/rpm/packages/0e9309fd-1a4a-4799-bb49-f3919531b575/",
+            "name": "elephant",
+            "version": "0.3",
+            "release": "0.8",
+            "arch": "noarch",
+            "epoch": "0",
+            "summary": "A dummy package of elephant",
+            "modular": false,
+            "filename": "elephant-0.3-0.8.noarch.rpm",
+            "sourcerpm": "elephant-0.3-0.8.src.rpm",
+            "checksum": "3e1c70cd1b421328acaf6397cb3d16145306bb95f65d1b095fc31372a0a701f3",
+            "nvrea": "elephant-0.3-0.8.noarch",
+            "nvra": "elephant-0.3-0.8.noarch",
+            "uuid": "/pulp/api/v3/content/rpm/packages/0e9309fd-1a4a-4799-bb49-f3919531b575/",
+            "hosts_available_count": 0,
+            "hosts_applicable_count": 0
+        }
+    ]
+}

data/webpack/components/extensions/HostDetails/Tabs/customizedRexUrlHelpers.js

@@ -1,6 +1,8 @@
 import { REX_FEATURES } from './RemoteExecutionConstants';
-import { KATELLO_TRACER_PACKAGE, TRACES_SEARCH_QUERY } from './HostTracesConstants';
-import { ERRATA_SEARCH_QUERY } from '../HostErrata/HostErrataConstants';
+import { TRACES_SEARCH_QUERY } from './TracesTab/HostTracesConstants';
+import { ERRATA_SEARCH_QUERY } from './ErrataTab/HostErrataConstants';
+import { PACKAGE_SEARCH_QUERY } from '../YumInstallablePackages/YumInstallablePackagesConstants';
+import { PACKAGES_SEARCH_QUERY } from '../HostPackages/HostPackagesConstants';
 
 export const createJob = ({
   hostname, feature, inputs,
@@ -15,10 +17,28 @@ export const createJob = ({
   return `/job_invocations/new?${urlQuery}`;
 };
 
-export const katelloPackageInstallUrl = ({ hostname }) => createJob({
+export const katelloPackageInstallUrl = ({ hostname, packages }) => createJob({
   hostname,
   feature: REX_FEATURES.KATELLO_PACKAGE_INSTALL,
-  inputs: { package: KATELLO_TRACER_PACKAGE },
+  inputs: { package: packages },
+});
+
+export const katelloPackageInstallBySearchUrl = ({ hostname, search }) => createJob({
+  hostname,
+  feature: REX_FEATURES.KATELLO_PACKAGE_INSTALL_BY_SEARCH,
+  inputs: { [PACKAGE_SEARCH_QUERY]: search },
+});
+
+export const katelloPackageUpdateUrl = ({ hostname, packageName }) => createJob({
+  hostname,
+  feature: REX_FEATURES.KATELLO_PACKAGE_UPDATE,
+  inputs: { package: packageName },
+});
+
+export const packagesUpdateUrl = ({ hostname, search }) => createJob({
+  hostname,
+  feature: REX_FEATURES.KATELLO_PACKAGES_UPDATE_BY_SEARCH,
+  inputs: { [PACKAGES_SEARCH_QUERY]: search },
 });
 
 export const resolveTraceUrl = ({ hostname, search }) => createJob({
@@ -29,6 +49,6 @@ export const resolveTraceUrl = ({ hostname, search }) => createJob({
 
 export const errataInstallUrl = ({ hostname, search }) => createJob({
   hostname,
-  feature: REX_FEATURES.KATELLO_HOST_ERRATA_INSTALL,
+  feature: REX_FEATURES.KATELLO_HOST_ERRATA_INSTALL_BY_SEARCH,
   inputs: { [ERRATA_SEARCH_QUERY]: search },
 });