katello 4.3.0 → 4.4.0.rc1

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

@@ -3,9 +3,9 @@ import { isEqual } from 'lodash';
 import { renderWithRedux, patientlyWaitFor, within, fireEvent } from 'react-testing-lib-wrapper';
 import { nockInstance, assertNockRequest, mockForemanAutocomplete, mockSetting } from '../../../../../test-utils/nockWrapper';
 import { foremanApi } from '../../../../../services/api';
-import { HOST_ERRATA_KEY, ERRATA_SEARCH_QUERY } from '../../HostErrata/HostErrataConstants';
+import { HOST_ERRATA_KEY, ERRATA_SEARCH_QUERY } from '../ErrataTab/HostErrataConstants';
 import { REX_FEATURES } from '../RemoteExecutionConstants';
-import { ErrataTab } from '../ErrataTab';
+import { ErrataTab } from '../ErrataTab/ErrataTab.js';
 import mockErrataData from './errata.fixtures.json';
 import mockResolveErrataTask from './resolveErrata.fixtures.json';
 
@@ -81,11 +81,10 @@ let searchDelayScope;
 let autoSearchScope;
 
 beforeEach(() => {
-  // jest.resetModules();
   const { results } = mockErrataData;
   [firstErrata, , thirdErrata] = results;
-  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(() => {
@@ -813,7 +812,7 @@ test('apply button chooses katello agent if enabled', async (done) => {
     <ErrataTab />,
     options,
   );
-    // Assert that the errata are now showing on the screen, but wait for them to appear.
+  // Assert that the errata are now showing on the screen, but wait for them to appear.
   await patientlyWaitFor(() => expect(getAllByText('Important')[0]).toBeInTheDocument());
 
   getByLabelText('Select row 0').click();
@@ -855,7 +854,7 @@ test('Can bulk apply via katello agent', async (done) => {
     <ErrataTab />,
     options,
   );
-    // Assert that the errata are now showing on the screen, but wait for them to appear.
+  // Assert that the errata are now showing on the screen, but wait for them to appear.
   await patientlyWaitFor(() => expect(getAllByText('Important')[0]).toBeInTheDocument());
 
   getByLabelText('Select row 0').click();
@@ -874,7 +873,7 @@ test('Can bulk apply via katello agent', async (done) => {
 
 test('Can select all, exclude and bulk apply via katello agent', async (done) => {
   // This is the same test as above,
-  // but using the table action bar instead of the Restart app button
+  // but using the table action bar instead of the Apply button
   const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
   const mockErrata = makeMockErrata({});
   const { results } = mockErrata;
@@ -902,12 +901,12 @@ test('Can select all, exclude and bulk apply via katello agent', async (done) =>
     <ErrataTab />,
     options,
   );
-    // Assert that the errata are now showing on the screen, but wait for them to appear.
+  // Assert that the errata are now showing on the screen, but wait for them to appear.
   await patientlyWaitFor(() => expect(getAllByText('Important')[0]).toBeInTheDocument());
   const selectAllCheckbox = getByLabelText('Select all');
   selectAllCheckbox.click();
 
-  getByLabelText('Select row 0').click(); // de select
+  getByLabelText('Select row 0').click(); // deselect
 
   const actionMenu = getByLabelText('bulk_actions');
   actionMenu.click();
@@ -948,7 +947,7 @@ test('Apply button chooses remote execution', async (done) => {
     <ErrataTab />,
     options,
   );
-    // Assert that the errata are now showing on the screen, but wait for them to appear.
+  // Assert that the errata are now showing on the screen, but wait for them to appear.
   await patientlyWaitFor(() => expect(getAllByText('Important')[0]).toBeInTheDocument());
 
   getByLabelText('Select row 0').click();
@@ -981,9 +980,9 @@ test('Can bulk apply via remote execution', async (done) => {
   // eslint-disable-next-line camelcase
   const jobInvocationBody = ({ job_invocation: { inputs, feature, search_query } }) =>
     inputs[ERRATA_SEARCH_QUERY] === `errata_id ^ (${results[0].errata_id},${results[1].errata_id})` &&
-     feature === REX_FEATURES.KATELLO_HOST_ERRATA_INSTALL &&
-     // eslint-disable-next-line camelcase
-     search_query === `name ^ (${hostName})`;
+    feature === REX_FEATURES.KATELLO_HOST_ERRATA_INSTALL_BY_SEARCH &&
+    // eslint-disable-next-line camelcase
+    search_query === `name ^ (${hostName})`;
 
   const resolveErrataScope = nockInstance
     .post(jobInvocations, jobInvocationBody)
@@ -993,7 +992,7 @@ test('Can bulk apply via remote execution', async (done) => {
     <ErrataTab />,
     renderOptions(),
   );
-    // Assert that the errata are now showing on the screen, but wait for them to appear.
+  // Assert that the errata are now showing on the screen, but wait for them to appear.
   await patientlyWaitFor(() => expect(getAllByText('Important')[0]).toBeInTheDocument());
 
   getByLabelText('Select row 0').click();
@@ -1038,7 +1037,7 @@ test('Can select all, exclude and bulk apply via remote execution', async (done)
     <ErrataTab />,
     renderOptions(),
   );
-    // Assert that the errata are now showing on the screen, but wait for them to appear.
+  // Assert that the errata are now showing on the screen, but wait for them to appear.
   await patientlyWaitFor(() => expect(getAllByText('Important')[0]).toBeInTheDocument());
   const selectAllCheckbox = getByLabelText('Select all');
   selectAllCheckbox.click();
@@ -1076,7 +1075,7 @@ test('Can apply errata in bulk via customized remote execution', async (done) =>
   getByLabelText('Select row 0').click();
   getByLabelText('Select row 1').click();
   const errata = `${results[0].errata_id},${results[1].errata_id}`;
-  const feature = REX_FEATURES.KATELLO_HOST_ERRATA_INSTALL;
+  const feature = REX_FEATURES.KATELLO_HOST_ERRATA_INSTALL_BY_SEARCH;
   const actionMenu = getByLabelText('bulk_actions');
   actionMenu.click();
   const viaRexAction = queryByText('Apply via customized remote execution');
@@ -1176,7 +1175,7 @@ test('Can apply a single erratum to the host via customized remote execution', a
   const mockErrata = makeMockErrata({});
   const { results } = mockErrata;
   const { errata_id: errataId } = results[0];
-  const feature = REX_FEATURES.KATELLO_HOST_ERRATA_INSTALL;
+  const feature = REX_FEATURES.KATELLO_HOST_ERRATA_INSTALL_BY_SEARCH;
   const scope = nockInstance
     .get(hostErrata)
     .query(defaultQuery)

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

@@ -0,0 +1,385 @@
+import React from 'react';
+import { renderWithRedux, patientlyWaitFor, fireEvent, within } from 'react-testing-lib-wrapper';
+import { nockInstance, assertNockRequest, mockForemanAutocomplete, mockSetting } from '../../../../../test-utils/nockWrapper';
+import katelloApi, { foremanApi } from '../../../../../services/api';
+import mockPackagesData from './yumInstallablePackages.fixtures.json';
+import PackageInstallModal from '../PackageInstallModal';
+import { HOST_YUM_INSTALLABLE_PACKAGES_KEY, PACKAGE_SEARCH_QUERY } from '../../YumInstallablePackages/YumInstallablePackagesConstants';
+import { REX_FEATURES } from '../RemoteExecutionConstants';
+
+const contentFacetAttributes = {
+  id: 11,
+  uuid: 'e5761ea3-4117-4ecf-83d0-b694f99b389e',
+  content_view_default: false,
+  lifecycle_environment_library: false,
+};
+
+const renderOptions = (facetAttributes = contentFacetAttributes) => ({
+  apiNamespace: HOST_YUM_INSTALLABLE_PACKAGES_KEY,
+  initialState: {
+    API: {
+      HOST_DETAILS: {
+        response: {
+          id: 1,
+          name: 'test-host',
+          content_facet_attributes: { ...facetAttributes },
+        },
+        status: 'RESOLVED',
+      },
+    },
+  },
+});
+
+const hostYumInstallablePackages = katelloApi.getApiUrl('/packages');
+const hostPackages = foremanApi.getApiUrl('/hosts/1/packages/install');
+const jobInvocations = foremanApi.getApiUrl('/job_invocations');
+const autocompleteUrl = '/hosts/1/packages/auto_complete_search';
+const fakeTask = { id: '21c0f9e4-b27b-49aa-8774-6be66126043b' };
+
+const defaultQuery = {
+  packages_restrict_not_installed: true,
+  packages_restrict_applicable: false,
+  packages_restrict_latest: true,
+  host_id: 1,
+  per_page: 20,
+  page: 1,
+};
+
+let firstPackages;
+let secondPackages;
+let searchDelayScope;
+let autoSearchScope;
+
+beforeEach(() => {
+  const { results } = mockPackagesData;
+  [firstPackages, secondPackages] = results;
+  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 500);
+  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', true);
+});
+
+afterEach(() => {
+  assertNockRequest(searchDelayScope);
+  assertNockRequest(autoSearchScope);
+});
+
+test('Can call API for installable packages and show on screen on page load', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const { getAllByText }
+     = renderWithRedux(<PackageInstallModal
+       isOpen
+       closeModal={jest.fn()}
+       hostId={1}
+       hostName="test-host"
+       showKatelloAgent={false}
+     />, 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());
+  // 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 installable packages being present', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const noResults = {
+    total: 0,
+    subtotal: 0,
+    page: 1,
+    per_page: 20,
+    results: [],
+  };
+
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, noResults);
+
+  const { queryByText }
+    = renderWithRedux(<PackageInstallModal
+      isOpen
+      closeModal={jest.fn()}
+      hostId={1}
+      hostName="test-host"
+      showKatelloAgent={false}
+    />, renderOptions());
+
+  // Assert that there are not any packages showing on the screen.
+  await patientlyWaitFor(() => expect(queryByText('No packages available to install')).toBeInTheDocument());
+  // Assert request was made and completed, see helper function
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done); // Pass jest callback to confirm test is done
+});
+
+test('Does not show katello-agent option when disabled', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const {
+    getAllByText, getByText, getByRole, queryByText,
+  } = renderWithRedux(<PackageInstallModal
+    isOpen
+    closeModal={jest.fn()}
+    hostId={1}
+    hostName="test-host"
+    showKatelloAgent={false}
+  />, 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());
+  // Assert request was made and completed, see helper function
+  // find the first table row's checkbox
+  const checkbox = getByRole('checkbox', { name: 'Select row 0' });
+  // click the checkbox to make sure the Install dropdown will be enabled
+  fireEvent.click(checkbox);
+  const footer = getByRole('contentinfo');
+  // find the dropdown to the right of the Install button
+  // (no, the other one! The one that's in the footer.)
+  const dropdown = await patientlyWaitFor(() => within(footer).getByRole('button', { name: 'Select' }));
+  fireEvent.click(dropdown);
+  expect(getByText('Install via remote execution')).toBeInTheDocument();
+  // Assert that the katello-agent option is not present
+  expect(queryByText('katello-agent')).not.toBeInTheDocument();
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done); // Pass jest callback to confirm test is done
+});
+
+test('Shows the katello-agent option when enabled', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const {
+    getAllByText, getByText, getByRole,
+  } = renderWithRedux(<PackageInstallModal
+    isOpen
+    closeModal={jest.fn()}
+    hostId={1}
+    hostName="test-host"
+    showKatelloAgent
+  />, 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());
+  // Assert request was made and completed, see helper function
+  // find the first table row's checkbox
+  const checkbox = getByRole('checkbox', { name: 'Select row 0' });
+  // click the checkbox to make sure the Install dropdown will be enabled
+  fireEvent.click(checkbox);
+  const footer = getByRole('contentinfo');
+  const dropdown = await patientlyWaitFor(() => within(footer).getByRole('button', { name: 'Select' }));
+  fireEvent.click(dropdown);
+  expect(getByText('Install via remote execution')).toBeInTheDocument();
+  expect(getByText('Install via katello-agent')).toBeInTheDocument();
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done); // Pass jest callback to confirm test is done
+});
+
+test('Can install packages via katello-agent', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+  const installScope = nockInstance
+    .put(hostPackages, { packages: [secondPackages.name, firstPackages.name] })
+    .reply(202, fakeTask);
+  const {
+    getAllByText, getByText, getByRole,
+  } = renderWithRedux(<PackageInstallModal
+    isOpen
+    closeModal={jest.fn()}
+    hostId={1}
+    hostName="test-host"
+    showKatelloAgent
+  />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackages.name)[0]).toBeInTheDocument());
+  // find and select the first two packages
+  const checkbox1 = getByRole('checkbox', { name: 'Select row 0' });
+  const checkbox2 = getByRole('checkbox', { name: 'Select row 1' });
+  fireEvent.click(checkbox1);
+  fireEvent.click(checkbox2);
+  // click the Install dropdown
+  const footer = getByRole('contentinfo');
+  const dropdown = await patientlyWaitFor(() => within(footer).getByRole('button', { name: 'Select' }));
+  fireEvent.click(dropdown);
+  // click the katello-agent option
+  const katelloAgentOption = getByText('Install via katello-agent');
+  fireEvent.click(katelloAgentOption);
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope);
+  assertNockRequest(installScope, done);
+});
+
+test('Can install a package via remote execution', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+  const installScope = nockInstance
+    .post(jobInvocations, {
+      job_invocation: {
+        inputs: {
+          [PACKAGE_SEARCH_QUERY]: `id ^ (${firstPackages.id},${secondPackages.id})`,
+        },
+        search_query: 'name ^ (test-host)',
+        feature: REX_FEATURES.KATELLO_PACKAGE_INSTALL_BY_SEARCH,
+      },
+    })
+    .reply(201);
+
+  const {
+    getAllByText, getByText, getByRole,
+  } = renderWithRedux(<PackageInstallModal
+    isOpen
+    closeModal={jest.fn()}
+    hostId={1}
+    hostName="test-host"
+    showKatelloAgent
+  />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackages.name)[0]).toBeInTheDocument());
+  // find and select the first two packages
+  const checkbox1 = getByRole('checkbox', { name: 'Select row 0' });
+  const checkbox2 = getByRole('checkbox', { name: 'Select row 1' });
+  fireEvent.click(checkbox1);
+  fireEvent.click(checkbox2);
+  // click the Install dropdown
+  const footer = getByRole('contentinfo');
+  const dropdown = await patientlyWaitFor(() => within(footer).getByRole('button', { name: 'Select' }));
+  fireEvent.click(dropdown);
+  const rexOption = getByText('Install via remote execution');
+  fireEvent.click(rexOption);
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope);
+  assertNockRequest(installScope, done);
+});
+
+test('Can install a package via customized remote execution', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const {
+    getAllByText, queryByText, getByRole,
+  } = renderWithRedux(<PackageInstallModal
+    isOpen
+    closeModal={jest.fn()}
+    hostId={1}
+    hostName="test-host"
+  />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackages.name)[0]).toBeInTheDocument());
+  // find and select the first two packages
+  const checkbox1 = getByRole('checkbox', { name: 'Select row 0' });
+  const checkbox2 = getByRole('checkbox', { name: 'Select row 1' });
+  fireEvent.click(checkbox1);
+  fireEvent.click(checkbox2);
+  // click the Install dropdown
+  const footer = getByRole('contentinfo');
+  const dropdown = await patientlyWaitFor(() => within(footer).getByRole('button', { name: 'Select' }));
+  fireEvent.click(dropdown);
+  const customizedRexOption = queryByText('Install via customized remote execution');
+  expect(customizedRexOption).toBeInTheDocument();
+  expect(customizedRexOption).toHaveAttribute(
+    'href',
+    `/job_invocations/new?feature=${REX_FEATURES.KATELLO_PACKAGE_INSTALL}&host_ids=name%20%5E%20(test-host)&inputs%5Bpackage%5D=duck,cheetah`,
+  );
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
+});
+
+test('Uses package_install_by_search_query template when in select all mode', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const {
+    getAllByText, queryByText, getByRole,
+  } = renderWithRedux(<PackageInstallModal
+    isOpen
+    closeModal={jest.fn()}
+    hostId={1}
+    hostName="test-host"
+  />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackages.name)[0]).toBeInTheDocument());
+  // find and click the select all checkbox
+  const selectAllCheckbox = getByRole('checkbox', { name: 'Select all' });
+  fireEvent.click(selectAllCheckbox);
+  // find and deselect the first package
+  const checkbox1 = getByRole('checkbox', { name: 'Select row 0' });
+  fireEvent.click(checkbox1);
+  // click the Install dropdown
+  const footer = getByRole('contentinfo');
+  const dropdown = await patientlyWaitFor(() => within(footer).getByRole('button', { name: 'Select' }));
+  fireEvent.click(dropdown);
+  const customizedRexOption = queryByText('Install via customized remote execution');
+  expect(customizedRexOption).toBeInTheDocument();
+  expect(customizedRexOption).toHaveAttribute(
+    'href',
+    `/job_invocations/new?feature=${REX_FEATURES.KATELLO_PACKAGE_INSTALL_BY_SEARCH}&host_ids=name%20%5E%20(test-host)&inputs%5BPackage%20search%20query%5D=id%20!%5E%20(32376)`,
+  );
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
+});
+
+test('Disables the katello-agent option when in select all mode', async (done) => {
+  const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+  const scope = nockInstance
+    .get(hostYumInstallablePackages)
+    .query(defaultQuery)
+    .reply(200, mockPackagesData);
+
+  const {
+    getAllByText, getByText, getByRole,
+  } = renderWithRedux(<PackageInstallModal
+    isOpen
+    closeModal={jest.fn()}
+    hostId={1}
+    hostName="test-host"
+    showKatelloAgent
+  />, renderOptions());
+
+  await patientlyWaitFor(() => expect(getAllByText(firstPackages.name)[0]).toBeInTheDocument());
+  // find and click the select all checkbox
+  const selectAllCheckbox = getByRole('checkbox', { name: 'Select all' });
+  fireEvent.click(selectAllCheckbox);
+  // find and deselect the first package
+  const checkbox1 = getByRole('checkbox', { name: 'Select row 0' });
+  fireEvent.click(checkbox1);
+  // click the Install dropdown
+  const footer = getByRole('contentinfo');
+  const dropdown = await patientlyWaitFor(() => within(footer).getByRole('button', { name: 'Select' }));
+  fireEvent.click(dropdown);
+  const katelloAgentOption = getByText('Install via katello-agent');
+  // expect the katello-agent option to be disabled
+  expect(katelloAgentOption).toHaveAttribute('aria-disabled', 'true');
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
+});

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

@@ -22,7 +22,7 @@
         "id": 676,
 	"name": "acl",
 	"nvra": "acl-2.2.53-1.el8.x86_64",
-	"upgradable_version": "acl-2.5.3-1.el8.x86_64"
+	"upgradable_version": null
      }
   ]
 }

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

@@ -1,5 +1,5 @@
 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';
@@ -20,6 +20,7 @@ const renderOptions = (facetAttributes = contentFacetAttributes) => ({
       HOST_DETAILS: {
         response: {
           id: 1,
+          name: 'test-host',
           content_facet_attributes: { ...facetAttributes },
         },
         status: 'RESOLVED',
@@ -28,8 +29,14 @@ 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 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 searchDelayScope;
@@ -38,8 +45,8 @@ let autoSearchScope;
 beforeEach(() => {
   const { results } = mockPackagesData;
   [firstPackages] = results;
-  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(() => {
@@ -50,10 +57,9 @@ 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());
@@ -65,7 +71,7 @@ test('Can call API for packages and show on screen on page load', async (done) =
   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 +85,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 +96,47 @@ 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: [firstPackages] });
+
+  const {
+    queryByText,
+    getByRole,
+    getAllByText,
+    getByText,
+  } = renderWithRedux(<PackagesTab />, renderOptions());
+
+  // Assert that the errata are now showing on the screen, but wait for them to appear.
+  await patientlyWaitFor(() => expect(getAllByText(firstPackages.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
+});

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';
@@ -59,8 +59,8 @@ describe('With tracer installed', () => {
   beforeEach(() => {
     const { results } = mockTraceData;
     [firstTrace, secondTrace] = results;
-    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(() => {