katello 4.2.1 → 4.3.0.rc1

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

@@ -0,0 +1,35 @@
+{
+  "id": 66,
+  "description": "Restart Services",
+  "job_category": "Katello",
+  "targeting_id": 66,
+  "status": 3,
+  "start_at": "2021-10-12 14:58:05 -0400",
+  "status_label": "running",
+  "dynflow_task": {
+    "id": "947e862c-773b-46ec-9735-78428e742356",
+    "state": "planned"
+  },
+  "succeeded": "N/A",
+  "failed": "N/A",
+  "pending": "N/A",
+  "total": 1,
+  "missing": 0,
+  "targeting": {
+    "bookmark_id": null,
+    "search_query": "name ^ (centos7-katello-client.fedora.example.com)",
+    "targeting_type": "static_query",
+    "user_id": 4,
+    "randomized_ordering": null,
+    "hosts": [
+      {
+        "name": "centos7-katello-client.fedora.example.com",
+        "id": 13
+      }
+    ]
+  },
+  "task": {
+    "id": "947e862c-773b-46ec-9735-78428e742356",
+    "state": "planned"
+  }
+}

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

@@ -0,0 +1,7 @@
+{
+    "total": 0,
+    "subtotal": 0,
+    "page": 1,
+    "per_page": 20,
+    "results": []
+}

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

@@ -0,0 +1,35 @@
+{
+  "id": 26,
+  "description": "Install package(s) katello-host-tools-tracer",
+  "job_category": "Katello",
+  "targeting_id": 26,
+  "status": 3,
+  "start_at": "2021-09-27 16:04:10 -0400",
+  "status_label": "running",
+  "dynflow_task": {
+    "id": "dc996e54-5c7a-4d9e-96bf-a6f2af9da6f2",
+    "state": "planned"
+  },
+  "succeeded": "N/A",
+  "failed": "N/A",
+  "pending": "N/A",
+  "total": 1,
+  "missing": 0,
+  "targeting": {
+    "bookmark_id": null,
+    "search_query": "name ^ (centos7-katello-client.fedora.example.com)",
+    "targeting_type": "static_query",
+    "user_id": 4,
+    "randomized_ordering": null,
+    "hosts": [
+      {
+        "name": "centos7-katello-client.fedora.example.com",
+        "id": 13
+      }
+    ]
+  },
+  "task": {
+    "id": "dc996e54-5c7a-4d9e-96bf-a6f2af9da6f2",
+    "state": "planned"
+  }
+}

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

@@ -0,0 +1,44 @@
+{
+  "total": 20,
+  "subtotal": 20,
+  "page": 1,
+  "per_page": 20,
+  "error": null,
+  "search": null,
+  "sort": {
+      "by": "application",
+      "order": "asc"
+  },
+  "results": [
+    {
+        "id": 10,
+        "application": "chronyd",
+        "helper": "systemctl restart chronyd",
+        "restart_command": "systemctl restart chronyd",
+        "app_type": "daemon",
+        "host_id": 1,
+        "host": "centos7.katello.lan",
+        "reboot_required": false
+    },
+    {
+        "id": 13,
+        "application": "bash",
+        "helper": "You will have to log out & log in again",
+        "restart_command": null,
+        "app_type": "session",
+        "host_id": 1,
+        "host": "centos7.katello.lan",
+        "reboot_required": false
+    },
+    {
+        "id": 18,
+        "application": "firewalld",
+        "helper": "systemctl restart firewalld",
+        "restart_command": "systemctl restart firewalld",
+        "app_type": "daemon",
+        "host_id": 1,
+        "host": "centos7.katello.lan",
+        "reboot_required": false
+     }
+  ]
+}

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

@@ -0,0 +1,386 @@
+import React from 'react';
+import { renderWithRedux, waitFor, patientlyWaitFor, fireEvent, act } from 'react-testing-lib-wrapper';
+import nock, { nockInstance, assertNockRequest, mockForemanAutocomplete, mockSetting } from '../../../../../test-utils/nockWrapper';
+import { foremanApi } from '../../../../../services/api';
+import { HOST_TRACES_KEY } from '../HostTracesConstants';
+import TracesTab from '../TracesTab';
+import mockTraceData from './traces.fixtures.json';
+import mockResolveTraceTask from './resolveTraces.fixtures.json';
+import emptyTraceResults from './tracerEmptyTraceResults.fixtures.json';
+import mockJobInvocationStatus from './tracerEnableJobInvocation.fixtures.json';
+
+const tracerInstalledResponse = {
+  id: 1,
+  name: 'client.example.com',
+  content_facet_attributes: {
+    katello_tracer_installed: true,
+  },
+};
+
+const tracerNotInstalledResponse = {
+  ...tracerInstalledResponse,
+  content_facet_attributes: {
+    katello_tracer_installed: false,
+  },
+};
+
+const renderOptions = isTracerInstalled => ({ // sets initial Redux state
+  apiNamespace: HOST_TRACES_KEY,
+  initialState: {
+    API: {
+      HOST_DETAILS: {
+        response: isTracerInstalled ? tracerInstalledResponse : tracerNotInstalledResponse,
+        status: 'RESOLVED',
+      },
+    },
+  },
+});
+
+// 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');
+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);
+  });
+
+  afterEach(() => {
+    assertNockRequest(searchDelayScope);
+    assertNockRequest(autoSearchScope);
+    nock.cleanAll();
+  });
+
+  test('Can call API for traces 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 traces
+    const scope = nockInstance
+      .get(hostTraces)
+      .reply(200, mockTraceData);
+
+
+    const { queryByText } = renderWithRedux(<TracesTab />, renderOptions(true));
+
+    // Assert that the traces are now showing on the screen, but wait for them to appear.
+    await patientlyWaitFor(() => expect(queryByText(firstTrace.application)).toBeInTheDocument());
+    // Assert request was made and completed, see helper function
+    assertNockRequest(autocompleteScope);
+    assertNockRequest(scope, done);
+  });
+
+  test('Can handle no traces being present', async (done) => {
+    // Setup autocomplete with mockForemanAutoComplete since we aren't adding /katello
+    const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+    const scope = nockInstance
+      .get(hostTraces)
+      .reply(200, emptyTraceResults);
+
+
+    const { queryByText } = renderWithRedux(<TracesTab />, renderOptions(true));
+
+    // Assert that there are not any traces showing on the screen.
+    await patientlyWaitFor(() => expect(queryByText('This host currently does not have traces.')).toBeInTheDocument());
+    // Assert request was made and completed, see helper function
+    assertNockRequest(autocompleteScope);
+    assertNockRequest(scope, done);
+  });
+
+  test('Can bulk restart traces via Restart App button', async (done) => {
+    // Setup autocomplete with mockForemanAutoComplete since we aren't adding /katello
+    const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+    const scope = nockInstance
+      .get(hostTraces)
+      .times(2)
+      .reply(200, mockTraceData);
+    const resolveTracesScope = nockInstance
+      .post(jobInvocations)
+      .reply(201, mockResolveTraceTask);
+
+
+    const { getByText } = renderWithRedux(
+      <TracesTab />,
+      renderOptions(true),
+    );
+    let traceCheckbox;
+    // Find the trace.
+    await patientlyWaitFor(() => {
+      const traceNameNode = getByText(firstTrace.application);
+      traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+    });
+    traceCheckbox.click();
+    expect(traceCheckbox.checked).toEqual(true);
+
+    const restartAppButton = getByText('Restart app');
+    // wait 50ms so that the button is enabled
+    await waitFor(() => {
+      expect(getByText('Restart app')).not.toBeDisabled();
+      restartAppButton.click();
+    });
+
+    assertNockRequest(autocompleteScope);
+    assertNockRequest(resolveTracesScope);
+    assertNockRequest(scope, done);
+  });
+
+  test('Can bulk restart traces via remote execution', async (done) => {
+    // This is the same test as above,
+    // but using the table action bar instead of the Restart app button
+    const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+    const scope = nockInstance
+      .get(hostTraces)
+      .times(2)
+      .reply(200, mockTraceData);
+    const resolveTracesScope = nockInstance
+      .post(jobInvocations)
+      .reply(201, mockResolveTraceTask);
+
+
+    const { getByText, getByLabelText, queryByText } = renderWithRedux(
+      <TracesTab />,
+      renderOptions(true),
+    );
+    let traceCheckbox;
+    await patientlyWaitFor(() => {
+      const traceNameNode = getByText(firstTrace.application);
+      traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+    });
+    traceCheckbox.click();
+    expect(traceCheckbox.checked).toEqual(true);
+
+    const actionMenu = getByLabelText('bulk_actions');
+    actionMenu.click();
+    const viaRexAction = queryByText('Restart via remote execution');
+    expect(viaRexAction).toBeInTheDocument();
+    viaRexAction.click();
+
+    assertNockRequest(autocompleteScope);
+    assertNockRequest(resolveTracesScope);
+    assertNockRequest(scope, done);
+  });
+
+  test('Can restart a single trace via remote execution', async (done) => {
+    const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+    const scope = nockInstance
+      .get(hostTraces)
+      .times(2)
+      .reply(200, mockTraceData);
+    const resolveTracesScope = nockInstance
+      .post(jobInvocations)
+      .reply(201, mockResolveTraceTask);
+
+
+    const { getByText } = renderWithRedux(
+      <TracesTab />,
+      renderOptions(true),
+    );
+    let traceActionMenu;
+    await patientlyWaitFor(() => {
+      const traceNameNode = getByText(firstTrace.helper);
+      traceActionMenu = actionMenuToTheRightOf(traceNameNode);
+      expect(traceActionMenu).toHaveAttribute('aria-label', 'Actions');
+    });
+    traceActionMenu.click();
+
+    let viaRexAction;
+    await patientlyWaitFor(() => {
+      viaRexAction = getByText('Restart via remote execution');
+      expect(viaRexAction).toBeInTheDocument();
+    });
+    viaRexAction.click();
+
+    assertNockRequest(autocompleteScope);
+    assertNockRequest(resolveTracesScope);
+    assertNockRequest(scope, done);
+  });
+
+  test('Can restart a single trace via customized remote execution', async (done) => {
+    const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+    const scope = nockInstance
+      .get(hostTraces)
+      .reply(200, mockTraceData);
+
+    const { getByText } = renderWithRedux(
+      <TracesTab />,
+      renderOptions(true),
+    );
+
+    let traceActionMenu;
+    await patientlyWaitFor(() => {
+      const traceNameNode = getByText(firstTrace.helper);
+      traceActionMenu = actionMenuToTheRightOf(traceNameNode);
+      expect(traceActionMenu).toHaveAttribute('aria-label', 'Actions');
+    });
+    traceActionMenu.click();
+
+    let viaCustomizedRexAction;
+    await patientlyWaitFor(() => {
+      viaCustomizedRexAction = getByText('Restart via customized remote execution');
+      expect(viaCustomizedRexAction).toBeInTheDocument();
+    });
+    expect(viaCustomizedRexAction).toHaveAttribute(
+      'href',
+      '/job_invocations/new?feature=katello_host_tracer_resolve&inputs%5Bids%5D=10&host_ids=name%20%5E%20(client.example.com)',
+    );
+
+    assertNockRequest(autocompleteScope);
+    assertNockRequest(scope, done);
+  });
+
+  test('Can bulk restart traces via customized remote execution', async (done) => {
+    const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+    const scope = nockInstance
+      .get(hostTraces)
+      .reply(200, mockTraceData);
+
+    const { getByText, getByLabelText, queryByText } = renderWithRedux(
+      <TracesTab />,
+      renderOptions(true),
+    );
+    let traceCheckbox;
+    await patientlyWaitFor(() => {
+      const traceNameNode = getByText(firstTrace.application);
+      traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+    });
+    traceCheckbox.click();
+    expect(traceCheckbox.checked).toEqual(true);
+
+    const actionMenu = getByLabelText('bulk_actions');
+    actionMenu.click();
+    const viaCustomizedRexAction = queryByText('Restart via customized remote execution');
+
+    expect(viaCustomizedRexAction).toBeInTheDocument();
+    expect(viaCustomizedRexAction).toHaveAttribute(
+      'href',
+      '/job_invocations/new?feature=katello_host_tracer_resolve&inputs%5Bids%5D=10&host_ids=name%20%5E%20(client.example.com)',
+    );
+
+    assertNockRequest(autocompleteScope);
+    assertNockRequest(scope, done);
+  });
+
+  describe('Remote execution URL helper logic', () => {
+    beforeEach(() => {
+      const { results } = mockTraceData;
+      [firstTrace, secondTrace] = results;
+    });
+
+    afterEach(() => {
+      nock.cleanAll();
+    });
+
+    test('Does not allow selection of session type traces', async (done) => {
+      const autocompleteScope = mockForemanAutocomplete(nockInstance, autocompleteUrl);
+
+      const scope = nockInstance
+        .get(hostTraces)
+        .reply(200, mockTraceData);
+
+      const { getByText } = renderWithRedux(
+        <TracesTab />,
+        renderOptions(true),
+      );
+      let traceCheckbox;
+      await patientlyWaitFor(() => {
+        const traceNameNode = getByText(secondTrace.application);
+        traceCheckbox = checkboxToTheLeftOf(traceNameNode);
+      });
+      expect(traceCheckbox.disabled).toEqual(true);
+
+      assertNockRequest(autocompleteScope);
+      assertNockRequest(scope, done);
+    });
+  });
+});
+
+describe('Without tracer installed', () => {
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  test('Shows Enable Tracer empty state', async () => {
+    const { queryByText } = renderWithRedux(<TracesTab />, renderOptions(false));
+
+    await patientlyWaitFor(() => expect(queryByText('Traces are not enabled')).toBeInTheDocument());
+    // Assert request was made and completed, see helper function
+  });
+
+  test('Shows Enable Tracer modal', async () => {
+    const { getByText, queryByText } = renderWithRedux(<TracesTab />, renderOptions(false));
+
+    await patientlyWaitFor(() => expect(queryByText('Traces are not enabled')).toBeInTheDocument());
+    const enableTracesButton = getByText('Enable Traces');
+    enableTracesButton.click();
+    expect(queryByText('via remote execution')).toBeInTheDocument();
+
+    const cancelLink = queryByText('Cancel');
+    cancelLink.click();
+    expect(queryByText('via remote execution')).not.toBeInTheDocument();
+  });
+
+  test('Can enable tracer via remote execution', async (done) => {
+    const jobInvocationScope = nockInstance
+      .post(jobInvocations)
+      .reply(201, mockJobInvocationStatus);
+
+    const { getByText, getByRole, queryByText }
+      = renderWithRedux(<TracesTab />, renderOptions(false));
+
+    await patientlyWaitFor(() => expect(queryByText('Traces are not enabled')).toBeInTheDocument());
+    const enableTracesButton = getByText('Enable Traces');
+    enableTracesButton.click();
+    expect(queryByText('via remote execution')).toBeVisible();
+
+    const enableTracesModalButton = getByRole('button', { name: 'Enable Tracer' });
+    fireEvent.click(enableTracesModalButton);
+    expect(queryByText('via remote execution')).not.toBeInTheDocument();
+
+    assertNockRequest(jobInvocationScope, done);
+  });
+
+  test('Can enable tracer via customized remote execution', async () => {
+    const { getByText, getByRole, queryByText }
+      = renderWithRedux(<TracesTab />, renderOptions(false));
+
+    await patientlyWaitFor(() => expect(queryByText('Traces are not enabled')).toBeInTheDocument());
+    const enableTracesButton = getByText('Enable Traces');
+    enableTracesButton.click();
+
+    const dropdown = queryByText('via remote execution');
+    await act(async () => fireEvent.click(dropdown));
+
+    const viaCustomizedRex = queryByText('via customized remote execution');
+    expect(viaCustomizedRex).toBeVisible();
+    viaCustomizedRex.click();
+    expect(queryByText('via remote execution')).not.toBeInTheDocument();
+
+    const enableTracesModalLink = getByRole('link', { name: 'Enable Tracer' });
+    expect(enableTracesModalLink)
+      .toHaveAttribute(
+        'href',
+        '/job_invocations/new?feature=katello_package_install&inputs%5Bpackage%5D=katello-host-tools-tracer&host_ids=name%20%5E%20(client.example.com)',
+      );
+    enableTracesModalLink.click();
+    expect(enableTracesModalLink).toHaveClass('pf-m-in-progress');
+  });
+});

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

@@ -0,0 +1,20 @@
+import { REX_FEATURES } from './RemoteExecutionConstants';
+import { KATELLO_TRACER_PACKAGE } from './HostTracesConstants';
+
+export const katelloPackageInstallUrl = ({ hostname }) => {
+  const urlQuery = encodeURI([
+    `feature=${REX_FEATURES.KATELLO_PACKAGE_INSTALL}`,
+    `inputs[package]=${KATELLO_TRACER_PACKAGE}`,
+    `host_ids=name ^ (${hostname})`,
+  ].join('&'));
+  return `/job_invocations/new?${urlQuery}`;
+};
+
+export const resolveTraceUrl = ({ hostname, ids }) => {
+  const urlQuery = encodeURI([
+    `feature=${REX_FEATURES.KATELLO_HOST_TRACER_RESOLVE}`,
+    `inputs[ids]=${ids.join(',')}`,
+    `host_ids=name ^ (${hostname})`,
+  ].join('&'));
+  return `/job_invocations/new?${urlQuery}`;
+};

data/webpack/components/extensions/RegistrationCommands/fields/ActivationKeys.js

@@ -40,7 +40,7 @@ const ActivationKeys = ({
   // Validate field when hostgroup is changed (host group may have some keys)
   useEffect(() => {
     handleInvalidField('Activation Keys', akHasValidValue(hostGroupId, pluginValues?.activationKeys, hostGroupActivationKeys));
-  }, [hostGroupId, hostGroupActivationKeys, pluginValues]); // eslint-disable-line react-hooks/exhaustive-deps
+  }, [handleInvalidField, hostGroupId, hostGroupActivationKeys, pluginValues]);
 
   return (
     <FormGroup

data/webpack/components/extensions/RegistrationCommands/index.js

@@ -18,7 +18,7 @@ const RegistrationCommands = ({
 }) => {
   useEffect(() => {
     onChange({ activationKeys: [], lifecycleEnvironmentId: '' });
-  }, [organizationId, hostGroupId]); // eslint-disable-line react-hooks/exhaustive-deps
+  }, [onChange, organizationId, hostGroupId]);
 
   return (
     <>

data/webpack/components/pf3Table/components/Table.js

@@ -33,7 +33,7 @@ const Table = ({
     <div>
       <PfTable.PfProvider
         columns={columns}
-        className="table-fixed"
+        className="table-fixed neat-table-cells"
         striped
         bordered
         hover

data/webpack/components/pf3Table/components/__snapshots__/Table.test.js.snap

@@ -4,7 +4,7 @@ exports[`Table renders Table with body 1`] = `
 <div>
   <TablePfProvider
     bordered={true}
-    className="table-fixed"
+    className="table-fixed neat-table-cells"
     columns={
       Array [
         Object {
@@ -72,7 +72,7 @@ exports[`Table renders Table with children 1`] = `
 <div>
   <TablePfProvider
     bordered={true}
-    className="table-fixed"
+    className="table-fixed neat-table-cells"
     columns={
       Array [
         Object {
@@ -111,7 +111,7 @@ exports[`Table renders Table with pagination 1`] = `
 <div>
   <TablePfProvider
     bordered={true}
-    className="table-fixed"
+    className="table-fixed neat-table-cells"
     columns={
       Array [
         Object {

data/webpack/containers/Application/Routes.js

@@ -4,8 +4,8 @@ import { links } from './config';
 
 export default () => (
   <div>
-    {links.map(({ path, component }) => (
-      <Route exact key={path} path={`/${path}`} component={component} />
-      ))}
+    {links.map(({ path, component, exact = true }) => (
+      <Route exact={exact} key={path} path={`/${path}`} component={component} />
+    ))}
   </div>
 );

data/webpack/containers/Application/config.js

@@ -11,6 +11,8 @@ import AnsibleCollections from '../../scenes/AnsibleCollections';
 import AnsibleCollectionDetails from '../../scenes/AnsibleCollections/Details';
 import ContentViews from '../../scenes/ContentViews';
 import ContentViewDetails from '../../scenes/ContentViews/Details';
+import Content from '../../scenes/Content';
+import ContentDetails from '../../scenes/Content/Details';
 import withHeader from './withHeaders';
 
 // eslint-disable-next-line import/prefer-default-export
@@ -45,19 +47,32 @@ export const links = [
     component: WithOrganization(withHeader(ModuleStreamDetails, { title: __('Module Stream Details') })),
   },
   {
-    path: 'ansible_collections',
+    path: 'legacy_ansible_collections',
     component: WithOrganization(withHeader(AnsibleCollections, { title: __('Ansible Collections') })),
   },
   {
-    path: 'ansible_collections/:id([0-9]+)',
+    path: 'legacy_ansible_collections/:id([0-9]+)',
     component: WithOrganization(withHeader(AnsibleCollectionDetails, { title: __('Ansible Collection Details') })),
   },
   {
-    path: 'labs/content_views',
-    component: withHeader(ContentViews, { title: __('Content Views') }),
+    path: 'content_views',
+    component: WithOrganization(withHeader(ContentViews, { title: __('Content Views') })),
   },
   {
-    path: 'labs/content_views/:id([0-9]+)',
-    component: withHeader(ContentViewDetails, { title: __('Content View Details') }),
+    path: 'content_views/:id([0-9]+)',
+    component: WithOrganization(withHeader(ContentViewDetails, { title: __('Content View Details') })),
+    exact: false,
+  },
+  {
+    path: 'content',
+    component: WithOrganization(withHeader(Content, { title: __('Content') })),
+  },
+  {
+    path: 'content/:content_type([a-z_]+)',
+    component: WithOrganization(withHeader(Content, { title: __('Content') })),
+  },
+  {
+    path: 'content/:content_type([a-z_]+)/:id([0-9]+)',
+    component: WithOrganization(withHeader(ContentDetails, { title: __('Content Details') })),
   },
 ];