foreman_remote_execution 18.0.1 → 18.1.0

data/webpack/react_app/components/TargetingHosts/index.js

@@ -1,150 +0,0 @@
-import React, { useEffect, useState, useCallback, useRef } from 'react';
-import { useSelector, useDispatch } from 'react-redux';
-
-import { get } from 'foremanReact/redux/API';
-import { useForemanSettings } from 'foremanReact/Root/Context/ForemanContext';
-import {
-  withInterval,
-  stopInterval,
-} from 'foremanReact/redux/middlewares/IntervalMiddleware';
-import { MS_PER_SECOND } from 'foremanReact/constants';
-
-import {
-  selectItems,
-  selectApiStatus,
-  selectAutoRefresh,
-  selectTotalHosts,
-  selectIntervalExists,
-  selectStatusFilter,
-} from './TargetingHostsSelectors';
-import { getApiUrl } from './TargetingHostsHelpers';
-import { TARGETING_HOSTS } from './TargetingHostsConsts';
-import TargetingHostsPage from './TargetingHostsPage';
-import { chartFilter } from '../../redux/actions/jobInvocations';
-
-const buildSearchQuery = (query, stateFilter) => {
-  const filters = Object.entries(stateFilter).map(
-    ([key, value]) => `${key} = ${value}`
-  );
-  return [query, filters]
-    .flat()
-    .filter(x => x)
-    .map(x => `(${x})`)
-    .join(' AND ');
-};
-
-const WrappedTargetingHosts = () => {
-  const dispatch = useDispatch();
-  const { perPage, perPageOptions } = useForemanSettings();
-
-  const autoRefresh = useSelector(selectAutoRefresh);
-  const items = useSelector(selectItems);
-  const apiStatus = useSelector(selectApiStatus);
-  const totalHosts = useSelector(selectTotalHosts);
-  const statusFilter = useSelector(selectStatusFilter);
-  const [searchQuery, setSearchQuery] = useState('');
-  const [pagination, setPagination] = useState({
-    page: 1,
-    per_page: perPage,
-    perPageOptions,
-  });
-  const [apiUrl, setApiUrl] = useState(getApiUrl(searchQuery, pagination));
-  const intervalExists = useSelector(selectIntervalExists);
-
-  const stopApiInterval = useCallback(() => {
-    if (intervalExists) {
-      dispatch(stopInterval(TARGETING_HOSTS));
-    }
-  }, [dispatch, intervalExists]);
-
-  // Use refs to avoid infinite loop from handleSearch depending on pagination.per_page and searchQuery
-  const perPageRef = useRef(pagination.per_page);
-  const searchQueryRef = useRef(searchQuery);
-
-  const handleSearch = useCallback(
-    (query, status) => {
-      const defaultPagination = { page: 1, per_page: perPageRef.current };
-      stopApiInterval();
-
-      setApiUrl(getApiUrl(buildSearchQuery(query, status), defaultPagination));
-      setSearchQuery(query);
-      setPagination(defaultPagination);
-    },
-    [stopApiInterval]
-  );
-
-  // Keep refs in sync with state
-  useEffect(() => {
-    perPageRef.current = pagination.per_page;
-  }, [pagination.per_page]);
-
-  useEffect(() => {
-    searchQueryRef.current = searchQuery;
-  }, [searchQuery]);
-
-  const handlePagination = useCallback(
-    args => {
-      stopApiInterval();
-      setPagination(args);
-      setApiUrl(getApiUrl(buildSearchQuery(searchQuery, statusFilter), args));
-    },
-    [searchQuery, statusFilter, stopApiInterval]
-  );
-
-  const getData = useCallback(
-    url =>
-      withInterval(
-        get({
-          key: TARGETING_HOSTS,
-          url,
-          handleError: () => {
-            dispatch(stopInterval(TARGETING_HOSTS));
-          },
-        }),
-        MS_PER_SECOND
-      ),
-    [dispatch]
-  );
-
-  useEffect(() => {
-    dispatch(getData(apiUrl));
-
-    if (autoRefresh === 'false') {
-      dispatch(stopInterval(TARGETING_HOSTS));
-    }
-
-    return () => {
-      dispatch(stopInterval(TARGETING_HOSTS));
-    };
-  }, [dispatch, apiUrl, autoRefresh, getData]);
-
-  // Only respond to external statusFilter changes (from chart clicks)
-  // searchQuery changes are handled directly by handleSearch calls from the UI
-  useEffect(() => {
-    dispatch(stopInterval(TARGETING_HOSTS));
-    const defaultPagination = { page: 1, per_page: perPageRef.current };
-    setApiUrl(
-      getApiUrl(
-        buildSearchQuery(searchQueryRef.current, statusFilter),
-        defaultPagination
-      )
-    );
-    setPagination(defaultPagination);
-  }, [statusFilter, dispatch]);
-
-  return (
-    <TargetingHostsPage
-      handleSearch={handleSearch}
-      searchQuery={searchQuery}
-      statusFilter={statusFilter}
-      statusFilterReset={_x => chartFilter(null)(dispatch, null)}
-      apiStatus={apiStatus}
-      items={items}
-      totalHosts={totalHosts}
-      handlePagination={handlePagination}
-      page={pagination.page}
-    />
-  );
-};
-
-export default WrappedTargetingHosts;

data/webpack/react_app/components/jobInvocations/AggregateStatus/index.js

@@ -1,60 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-
-const AggregateStatus = ({ statuses, chartFilter }) => (
-  <div id="aggregate_statuses">
-    <p className="card-pf-aggregate-status-notifications">
-      <a
-        className="card-pf-aggregate-status-notification"
-        onClick={() => chartFilter('success')}
-      >
-        <span id="success_count">
-          <span className="pficon pficon-ok" />
-          {statuses.success}
-        </span>
-      </a>
-
-      <a
-        className="card-pf-aggregate-status-notification"
-        onClick={() => chartFilter('failed')}
-      >
-        <span id="failed_count">
-          <span className="pficon pficon-error-circle-o" />
-          {statuses.failed}
-        </span>
-      </a>
-
-      <a
-        className="card-pf-aggregate-status-notification"
-        onClick={() => chartFilter('pending')}
-      >
-        <span id="pending_count">
-          <span className="pficon pficon-running" />
-          {statuses.pending}
-        </span>
-      </a>
-
-      <a
-        className="card-pf-aggregate-status-notification"
-        onClick={() => chartFilter('cancelled')}
-      >
-        <span id="cancelled_count">
-          <span className="pficon pficon-close" />
-          {statuses.cancelled}
-        </span>
-      </a>
-    </p>
-  </div>
-);
-
-AggregateStatus.propTypes = {
-  statuses: PropTypes.shape({
-    cancelled: PropTypes.number,
-    failed: PropTypes.number,
-    pending: PropTypes.number,
-    success: PropTypes.number,
-  }).isRequired,
-  chartFilter: PropTypes.func.isRequired,
-};
-
-export default AggregateStatus;

data/webpack/react_app/components/jobInvocations/AggregateStatus/index.test.js

@@ -1,76 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import '@testing-library/jest-dom';
-import AggregateStatus from './index';
-
-const defaultStatuses = {
-  success: 19,
-  failed: 20,
-  pending: 3,
-  cancelled: 31,
-};
-
-const renderAggregateStatus = ({
-  statuses = defaultStatuses,
-  chartFilter = jest.fn(),
-} = {}) => {
-  const view = render(
-    <AggregateStatus statuses={statuses} chartFilter={chartFilter} />
-  );
-
-  return { chartFilter, ...view };
-};
-
-describe('AggregateStatus', () => {
-  it('renders status notifications without counts when statuses are empty', () => {
-    const { container } = renderAggregateStatus({ statuses: {} });
-
-    expect(container.textContent.trim()).toBe('');
-  });
-
-  it('renders status counts from props', () => {
-    renderAggregateStatus();
-
-    expect(screen.getByText('19')).toBeInTheDocument();
-    expect(screen.getByText('20')).toBeInTheDocument();
-    expect(screen.getByText('3')).toBeInTheDocument();
-    expect(screen.getByText('31')).toBeInTheDocument();
-  });
-
-  it('calls chartFilter with success when the success count is clicked', async () => {
-    const { chartFilter } = renderAggregateStatus();
-
-    await userEvent.click(screen.getByText('19'));
-
-    expect(chartFilter).toHaveBeenCalledTimes(1);
-    expect(chartFilter).toHaveBeenCalledWith('success');
-  });
-
-  it('calls chartFilter with failed when the failed count is clicked', async () => {
-    const { chartFilter } = renderAggregateStatus();
-
-    await userEvent.click(screen.getByText('20'));
-
-    expect(chartFilter).toHaveBeenCalledTimes(1);
-    expect(chartFilter).toHaveBeenCalledWith('failed');
-  });
-
-  it('calls chartFilter with pending when the pending count is clicked', async () => {
-    const { chartFilter } = renderAggregateStatus();
-
-    await userEvent.click(screen.getByText('3'));
-
-    expect(chartFilter).toHaveBeenCalledTimes(1);
-    expect(chartFilter).toHaveBeenCalledWith('pending');
-  });
-
-  it('calls chartFilter with cancelled when the cancelled count is clicked', async () => {
-    const { chartFilter } = renderAggregateStatus();
-
-    await userEvent.click(screen.getByText('31'));
-
-    expect(chartFilter).toHaveBeenCalledTimes(1);
-    expect(chartFilter).toHaveBeenCalledWith('cancelled');
-  });
-});

data/webpack/react_app/components/jobInvocations/index.js

@@ -1,94 +0,0 @@
-import { connect } from 'react-redux';
-import React from 'react';
-import Immutable from 'seamless-immutable';
-import PropTypes from 'prop-types';
-// eslint-disable-next-line import/no-extraneous-dependencies
-import DonutChart from 'foremanReact/components/common/charts/DonutChart';
-import AggregateStatus from './AggregateStatus';
-import * as JobInvocationActions from '../../redux/actions/jobInvocations';
-
-const colIndexOfMaxValue = columns =>
-  columns.reduce((iMax, x, i, arr) => (x[1] > arr[iMax][1] ? i : iMax), 0);
-
-const colorMap = {
-  '#5CB85C': 'success',
-  '#D9534F': 'failed',
-  '#DEDEDE': 'pending',
-  '#B7312D': 'cancelled',
-};
-
-class JobInvocationContainer extends React.Component {
-  componentDidMount() {
-    const {
-      startJobInvocationsPolling,
-      data: { url },
-    } = this.props;
-
-    startJobInvocationsPolling(url);
-  }
-
-  render() {
-    const { jobInvocations, statuses, chartFilter } = this.props;
-    const iMax = colIndexOfMaxValue(jobInvocations);
-
-    const map = jobInvocations.reduce(
-      (acc, [label, _count, color]) => ({ [label]: colorMap[color], ...acc }),
-      {}
-    );
-
-    return (
-      <div id="job_invocations_chart_container">
-        <DonutChart
-          data={Immutable.asMutable(jobInvocations)}
-          title={{
-            type: 'percent',
-            secondary: (jobInvocations[iMax] || [])[0],
-          }}
-          onclick={(d, element) => {
-            chartFilter(map[d.name]);
-          }}
-        />
-        <AggregateStatus statuses={statuses} chartFilter={chartFilter} />
-      </div>
-    );
-  }
-}
-
-const mapStateToProps = state => {
-  const {
-    jobInvocations,
-    statuses,
-  } = state.foremanRemoteExecutionReducers.jobInvocations;
-
-  return {
-    jobInvocations,
-    statuses,
-  };
-};
-
-JobInvocationContainer.propTypes = {
-  startJobInvocationsPolling: PropTypes.func,
-  data: PropTypes.shape({
-    url: PropTypes.string,
-  }),
-  jobInvocations: PropTypes.arrayOf(PropTypes.array),
-  statuses: PropTypes.shape({
-    cancelled: PropTypes.number,
-    failed: PropTypes.number,
-    pending: PropTypes.number,
-    success: PropTypes.number,
-  }),
-  chartFilter: PropTypes.func,
-};
-
-JobInvocationContainer.defaultProps = {
-  startJobInvocationsPolling: JobInvocationActions.startJobInvocationsPolling,
-  chartFilter: JobInvocationActions.chartFilter,
-  data: {},
-  jobInvocations: [['property', 3, 'color']],
-  statuses: {},
-};
-export default connect(
-  mapStateToProps,
-  JobInvocationActions
-)(JobInvocationContainer);

data/webpack/react_app/extend/reducers.js

@@ -1,5 +0,0 @@
-import { registerReducer } from 'foremanReact/common/MountingService';
-import rootReducer from '../redux/reducers';
-
-export default () =>
-  registerReducer('foremanRemoteExecutionReducers', rootReducer);

data/webpack/react_app/redux/actions/jobInvocations/index.js

@@ -1,87 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import API from 'foremanReact/API';
-import { HTTP_STATUS_CODES, MS_PER_SECOND } from 'foremanReact/constants';
-
-import {
-  JOB_INVOCATIONS_GET_JOB_INVOCATIONS,
-  JOB_INVOCATIONS_POLLING_STARTED,
-  JOB_INVOCATIONS_JOB_FINISHED,
-} from '../../consts';
-
-const defaultJobInvocationsPollingInterval = MS_PER_SECOND;
-const jobInvocationsInterval =
-  process.env.JOB_INVOCATIONS_POLLING || defaultJobInvocationsPollingInterval;
-
-const getJobInvocations = url => async (dispatch, getState) => {
-  function onGetJobInvocationsSuccess({ data }) {
-    // If the job has finished, stop polling
-    if (data.finished) {
-      dispatch({
-        type: JOB_INVOCATIONS_JOB_FINISHED,
-        payload: {
-          jobInvocations: data,
-        },
-      });
-    } else {
-      dispatch({
-        type: JOB_INVOCATIONS_GET_JOB_INVOCATIONS,
-        payload: {
-          jobInvocations: data,
-        },
-      });
-    }
-  }
-
-  function onGetJobInvocationsFailed(error) {
-    if (error.response.status === HTTP_STATUS_CODES.UNAUTHORIZED) {
-      window.location.replace('/users/login');
-    }
-  }
-
-  function triggerPolling() {
-    if (jobInvocationsInterval) {
-      setTimeout(
-        () => dispatch(getJobInvocations(url)),
-        jobInvocationsInterval
-      );
-    }
-  }
-
-  const isDocumentVisible =
-    document.visibilityState === 'visible' ||
-    document.visibilityState === 'prerender';
-
-  if (getState().foremanRemoteExecutionReducers.jobInvocations.isPolling) {
-    if (isDocumentVisible) {
-      try {
-        const data = await API.get(url);
-        onGetJobInvocationsSuccess(data);
-      } catch (error) {
-        onGetJobInvocationsFailed(error);
-      } finally {
-        triggerPolling();
-      }
-    } else {
-      // document is not visible, keep polling without api call
-      triggerPolling();
-    }
-  }
-};
-
-export const startJobInvocationsPolling = url => (dispatch, getState) => {
-  if (getState().foremanRemoteExecutionReducers.jobInvocations.isPolling) {
-    return;
-  }
-  dispatch({
-    type: JOB_INVOCATIONS_POLLING_STARTED,
-  });
-  dispatch(getJobInvocations(url));
-};
-
-export const chartFilter = state => (dispatch, getState) => {
-  const filter = state ? { 'job_invocation.result': state.toLowerCase() } : {};
-  dispatch({
-    type: 'JOB_INVOCATION_CHART_FILTER',
-    payload: { filter },
-  });
-};

data/webpack/react_app/redux/consts.js

@@ -1,5 +0,0 @@
-export const JOB_INVOCATIONS_POLLING_STARTED =
-  'JOB_INVOCATIONS_POLLING_STARTED';
-export const JOB_INVOCATIONS_GET_JOB_INVOCATIONS =
-  'JOB_INVOCATIONS_GET_JOB_INVOCATIONS';
-export const JOB_INVOCATIONS_JOB_FINISHED = 'JOB_INVOCATIONS_JOB_FINISHED';

data/webpack/react_app/redux/reducers/index.js

@@ -1,6 +0,0 @@
-import { combineReducers } from 'redux';
-import jobInvocations from './jobInvocations/';
-
-export default combineReducers({
-  jobInvocations,
-});

data/webpack/react_app/redux/reducers/jobInvocations/index.fixtures.js

@@ -1,46 +0,0 @@
-import Immutable from 'seamless-immutable';
-
-export const initialState = Immutable({
-  isPolling: false,
-  jobInvocations: [],
-  statuses: {},
-});
-
-export const pollingStarted = Immutable({
-  isPolling: true,
-  jobInvocations: [],
-  statuses: {},
-});
-
-export const jobInvocationsPayload = Immutable({
-  jobInvocations: {
-    job_invocations: [
-      ['Success', 100, '#B7312D'],
-      ['Failed', 20, '#B7312D'],
-      ['Pending', 40, '#B7312D'],
-      ['Cancelled', 0, '#B7312D'],
-    ],
-    statuses: {
-      cancelled: 0,
-      failed: 0,
-      pending: 0,
-      success: 1,
-    },
-  },
-});
-
-export const jobInvocationsReceived = Immutable({
-  isPolling: true,
-  jobInvocations: [
-    ['Success', 100, '#B7312D'],
-    ['Failed', 20, '#B7312D'],
-    ['Pending', 40, '#B7312D'],
-    ['Cancelled', 0, '#B7312D'],
-  ],
-  statuses: {
-    cancelled: 0,
-    failed: 0,
-    pending: 0,
-    success: 1,
-  },
-});

data/webpack/react_app/redux/reducers/jobInvocations/index.js

@@ -1,34 +0,0 @@
-import Immutable from 'seamless-immutable';
-
-import {
-  JOB_INVOCATIONS_GET_JOB_INVOCATIONS,
-  JOB_INVOCATIONS_POLLING_STARTED,
-  JOB_INVOCATIONS_JOB_FINISHED,
-} from '../../consts';
-
-const initialState = Immutable({
-  isPolling: false,
-  jobInvocations: [],
-  statuses: {},
-});
-
-export default (state = initialState, action) => {
-  const { payload } = action;
-  switch (action.type) {
-    case JOB_INVOCATIONS_POLLING_STARTED:
-      return state.set('isPolling', true);
-    case JOB_INVOCATIONS_JOB_FINISHED:
-      return state
-        .set('isPolling', false)
-        .set('jobInvocations', payload.jobInvocations.job_invocations)
-        .set('statuses', payload.jobInvocations.statuses);
-    case JOB_INVOCATIONS_GET_JOB_INVOCATIONS:
-      return state
-        .set('jobInvocations', payload.jobInvocations.job_invocations)
-        .set('statuses', payload.jobInvocations.statuses);
-    case 'JOB_INVOCATION_CHART_FILTER':
-      return state.set('jobInvocationStateFilter', payload.filter);
-    default:
-      return state;
-  }
-};

data/webpack/react_app/redux/reducers/jobInvocations/index.test.js

@@ -1,43 +0,0 @@
-import {
-  JOB_INVOCATIONS_GET_JOB_INVOCATIONS,
-  JOB_INVOCATIONS_POLLING_STARTED,
-  JOB_INVOCATIONS_JOB_FINISHED,
-} from '../../consts';
-
-import {
-  initialState,
-  pollingStarted,
-  jobInvocationsPayload,
-  jobInvocationsReceived,
-} from './index.fixtures';
-
-import reducer from './index';
-
-describe('job invocations chart reducer', () => {
-  it('should return the initial state', () => {
-    expect(reducer(undefined, {})).toEqual(initialState);
-  });
-  it('should start polling given POLLING_STARTED', () => {
-    expect(
-      reducer(initialState, {
-        type: JOB_INVOCATIONS_POLLING_STARTED,
-      })
-    ).toEqual(pollingStarted);
-  });
-  it('should stop polling given JOB_FINISHED', () => {
-    expect(
-      reducer(pollingStarted, {
-        type: JOB_INVOCATIONS_JOB_FINISHED,
-        payload: { jobInvocations: { job_invocations: [], statuses: {} } },
-      })
-    ).toEqual(initialState);
-  });
-  it('should receive job invocations given GET_JOB_INVOCATIONS', () => {
-    expect(
-      reducer(pollingStarted, {
-        type: JOB_INVOCATIONS_GET_JOB_INVOCATIONS,
-        payload: jobInvocationsPayload,
-      })
-    ).toEqual(jobInvocationsReceived);
-  });
-});