katello 4.8.0.rc2 → 4.8.0

data/webpack/components/Content/__tests__/__snapshots__/ContentPage.test.js.snap

@@ -1,89 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Content page should render and contain appropriate components 1`] = `
-<Grid
-  bsClass="container-fluid"
-  componentClass="div"
-  fluid={false}
->
-  <Row
-    bsClass="row"
-    componentClass="div"
-  >
-    <Col
-      bsClass="col"
-      componentClass="div"
-      sm={12}
-    >
-      <h1>
-        Content Header
-      </h1>
-    </Col>
-  </Row>
-  <Row
-    bsClass="row"
-    componentClass="div"
-  >
-    <Col
-      bsClass="col"
-      componentClass="div"
-      sm={6}
-    >
-      <Form
-        bsClass="form"
-        className="toolbar-pf-actions"
-        componentClass="form"
-        horizontal={false}
-        inline={false}
-      >
-        <FormGroup
-          bsClass="form-group"
-          className="toolbar-pf toolbar-pf-filter"
-        >
-          <SearchBar
-            data={
-              Object {
-                "autocomplete": Object {
-                  "apiParams": Object {},
-                  "id": "searchBar-content-page-Content Header",
-                  "searchQuery": "",
-                  "url": "undefined/auto_complete_search",
-                  "useKeyShortcuts": true,
-                },
-                "bookmarks": Object {
-                  "canCreate": true,
-                  "documentationUrl": "/links/manual/4.1.5Searching",
-                  "id": "searchBar-content-page-Content Header",
-                  "url": "/api/bookmarks",
-                },
-                "controller": undefined,
-              }
-            }
-            initialInputValue=""
-            initialQuery=""
-            name={null}
-            onSearch={[Function]}
-            onSearchChange={[Function]}
-          />
-        </FormGroup>
-      </Form>
-    </Col>
-  </Row>
-  <Row
-    bsClass="row"
-    componentClass="div"
-  >
-    <Col
-      bsClass="col"
-      componentClass="div"
-      sm={12}
-    >
-      <ContentTable
-        content={Object {}}
-        onPaginationChange={[Function]}
-        tableSchema={Array []}
-      />
-    </Col>
-  </Row>
-</Grid>
-`;

data/webpack/components/Search/Search.js

@@ -1,156 +0,0 @@
-import React, { useState, useEffect, useRef } from 'react';
-import { useDispatch } from 'react-redux';
-import { ControlLabel } from 'react-bootstrap';
-import { loadSetting } from 'foremanReact/components/Settings/SettingsActions';
-import { translate as __ } from 'foremanReact/common/I18n';
-import PropTypes from 'prop-types';
-import TypeAhead from '../TypeAhead';
-import api, { foremanApi } from '../../services/api';
-import { stringIncludes } from './helpers';
-import {
-  AUTOSEARCH_DELAY,
-  AUTOSEARCH_WHILE_TYPING,
-} from '../../scenes/Settings/SettingsConstants';
-
-// Don't trigger auto-search until you've typed an operator and begun to type a value
-const searchContainsOperator = (search = '') => {
-  const operators = ['>=', '<=', '>', '<', '~', '^', '!^', '=', '!=', '~', '!~'];
-  return operators.some(operator => search.includes(operator) && !search.trim().endsWith(operator));
-};
-// Apply the above function only to the last 'key = value' pair, if there are multiple
-const allowSearch = (originalSearch = '') => {
-  const search = originalSearch.toLowerCase().trim();
-  // find the last occurrence of 'or' or 'and'
-  const lastOr = originalSearch.lastIndexOf(' or ');
-  const lastAnd = originalSearch.lastIndexOf(' and ');
-  if (lastOr === -1 && lastAnd === -1) {
-    return searchContainsOperator(search);
-  }
-  const winningOperator = lastOr > lastAnd ? ' or ' : ' and ';
-  const lastSearch = search.split(winningOperator);
-  return searchContainsOperator(lastSearch[lastSearch.length - 1]);
-};
-
-const Search = ({
-  onSearch,
-  updateSearchQuery,
-  isDisabled,
-  settings: { autoSearchDelay, autoSearchEnabled = true },
-  initialInputValue,
-  patternfly4,
-  getAutoCompleteParams,
-  foremanApiAutoComplete,
-  bookmarkController,
-  readOnlyBookmarks,
-  placeholder,
-  isTextInput,
-  setTextInputValue,
-}) => {
-  const [items, setItems] = useState([]);
-  const dispatch = useDispatch();
-  const mountedRef = useRef(true);
-  const onInputUpdate = async (searchTerm = '') => {
-    const newItems = items.filter(({ text }) => stringIncludes(text, searchTerm));
-
-    if (newItems.length !== items.length) {
-      // Checking whether the current component is mounted before state change events
-      if (!mountedRef.current) return;
-      setItems(newItems);
-    }
-
-    const { params, endpoint } = getAutoCompleteParams(searchTerm);
-
-    if (endpoint) {
-      let data;
-      if (foremanApiAutoComplete) {
-        data = await foremanApi.get(endpoint, undefined, params);
-      } else {
-        data = await api.get(endpoint, undefined, params);
-      }
-      // Checking whether the current component is mounted before state change events
-      if (!mountedRef.current) return;
-      switch (true) {
-      case endpoint.includes('auto_complete_arch'):
-      case endpoint.includes('auto_complete_name'):
-        setItems(data?.data?.map(label => ({ text: label.trim() })));
-        break;
-      default:
-        setItems(data?.data?.filter(({ error }) => !error).map(({ label }) => ({
-          text: label.trim(),
-        })));
-      }
-    }
-    if (autoSearchEnabled && patternfly4 && allowSearch(searchTerm)) {
-      onSearch(searchTerm || '');
-    }
-  };
-
-  useEffect(() => {
-    dispatch(loadSetting(AUTOSEARCH_DELAY));
-    dispatch(loadSetting(AUTOSEARCH_WHILE_TYPING));
-    return () => { mountedRef.current = false; };
-  }, [dispatch]);
-
-  const onNewSearch = (search) => {
-    if (updateSearchQuery) updateSearchQuery(search);
-    onSearch(search);
-  };
-
-  return (
-    <div>
-      <ControlLabel srOnly>{__('Search')}</ControlLabel>
-      <TypeAhead
-        autoSearchDelay={autoSearchDelay}
-        bookmarkController={bookmarkController}
-        readOnlyBookmarks={readOnlyBookmarks}
-        isDisabled={isDisabled}
-        items={items}
-        onInputUpdate={onInputUpdate}
-        onSearch={onNewSearch}
-        initialInputValue={initialInputValue}
-        patternfly4={patternfly4}
-        autoSearchEnabled={autoSearchEnabled}
-        placeholder={placeholder}
-        isTextInput={isTextInput}
-        setTextInputValue={setTextInputValue}
-      />
-    </div>
-  );
-};
-
-Search.propTypes = {
-  onSearch: PropTypes.func.isRequired,
-  getAutoCompleteParams: PropTypes.func.isRequired,
-  foremanApiAutoComplete: PropTypes.bool,
-  updateSearchQuery: PropTypes.func,
-  initialInputValue: PropTypes.string,
-  patternfly4: PropTypes.bool,
-  isDisabled: PropTypes.bool,
-  settings: PropTypes.shape({
-    autoSearchEnabled: PropTypes.bool,
-    autoSearchDelay: PropTypes.number,
-  }),
-  bookmarkController: PropTypes.string,
-  readOnlyBookmarks: PropTypes.bool,
-  placeholder: PropTypes.string,
-  isTextInput: PropTypes.bool,
-  setTextInputValue: PropTypes.func,
-};
-
-Search.defaultProps = {
-  updateSearchQuery: undefined,
-  foremanApiAutoComplete: false,
-  initialInputValue: '',
-  patternfly4: false,
-  settings: {
-    autoSearchEnabled: true,
-  },
-  isDisabled: undefined,
-  bookmarkController: undefined,
-  readOnlyBookmarks: false,
-  placeholder: undefined,
-  isTextInput: false,
-  setTextInputValue: undefined,
-};
-
-export default Search;

data/webpack/components/Search/__tests__/search.test.js

@@ -1,104 +0,0 @@
-import React from 'react';
-import { renderWithRedux, patientlyWaitFor, fireEvent } from 'react-testing-lib-wrapper';
-import {
-  nockInstance, assertNockRequest, mockAutocomplete, mockSetting,
-} from '../../../test-utils/nockWrapper';
-import { AUTOSEARCH_WHILE_TYPING, AUTOSEARCH_DELAY } from '../../../scenes/Settings/SettingsConstants.js';
-import Search from '../../Search';
-
-const endpoint = '/fake_endpoint';
-const searchButtonLabel = 'search button';
-const props = {
-  onSearch: jest.fn(),
-  getAutoCompleteParams: search => ({
-    params: { organization_id: 1, search },
-    endpoint,
-  }),
-  patternfly4: true,
-};
-
-let searchDelayScope;
-beforeEach(() => {
-  searchDelayScope = mockSetting(nockInstance, AUTOSEARCH_DELAY, 0);
-});
-
-afterEach(() => {
-  assertNockRequest(searchDelayScope);
-});
-
-jest.mock('../../../utils/useDebounce', () => ({
-  __esModule: true,
-  default: value => value,
-}));
-
-
-test('Autocomplete shows on input', async (done) => {
-  const suggestion = 'suggestedQuery';
-  const response = [
-    {
-      completed: '', part: ` ${suggestion} `, label: ` ${suggestion} `, category: '',
-    },
-  ];
-  const query = { organization_id: 1, search: 'foo' };
-  const autoSearchScope = mockSetting(nockInstance, AUTOSEARCH_WHILE_TYPING, true);
-  const initialScope = mockAutocomplete(nockInstance, endpoint, { ...query, search: '' }, []);
-  const autocompleteScope = mockAutocomplete(nockInstance, endpoint, query, response);
-
-  const { getByLabelText, getByText, queryByText } = renderWithRedux(<Search {...props} />);
-
-  expect(queryByText(`${suggestion}`)).not.toBeInTheDocument();
-
-  fireEvent.change(getByLabelText(/text input for search/i), { target: { value: 'foo' } });
-
-  await patientlyWaitFor(() => expect(getByText(`${suggestion}`)).toBeInTheDocument());
-
-  assertNockRequest(initialScope);
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(autocompleteScope, done);
-});
-
-test('autosearch turned off does show patternfly 4 search button', async (done) => {
-  const autoSearchScope = mockSetting(nockInstance, AUTOSEARCH_WHILE_TYPING, false);
-  const autocompleteScope = mockAutocomplete(nockInstance, endpoint);
-
-  const { getByLabelText } = renderWithRedux(<Search {...props} />);
-
-  // Using patientlyWaitFor as the autoSearch setting defaults to true,
-  // it won't be changed until http call
-  await patientlyWaitFor(() => expect(getByLabelText(searchButtonLabel)).toBeInTheDocument());
-
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(autocompleteScope, done);
-});
-
-test('search function is called when search is typed into with autosearch', async (done) => {
-  const autoSearchScope = mockSetting(nockInstance, AUTOSEARCH_WHILE_TYPING);
-  const autocompleteScope = mockAutocomplete(nockInstance, endpoint, true, [], 2);
-  const mockSearch = jest.fn();
-
-  const { getByLabelText } = renderWithRedux(<Search {...{ ...props, onSearch: mockSearch }} />);
-  fireEvent.change(getByLabelText(/text input for search/i), { target: { value: 'name = foo' } });
-  await patientlyWaitFor(() => expect(mockSearch.mock.calls).toHaveLength(1));
-
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(autocompleteScope, done);
-});
-
-test('search function is called by clicking search button without autosearch', async (done) => {
-  const autoSearchScope = mockSetting(nockInstance, AUTOSEARCH_WHILE_TYPING, false);
-  const autocompleteScope = mockAutocomplete(nockInstance, endpoint, true, [], 2);
-  const mockSearch = jest.fn();
-
-  const { getByLabelText } = renderWithRedux(<Search {...{ ...props, onSearch: mockSearch }} />);
-
-  fireEvent.change(getByLabelText(/text input for search/i), { target: { value: 'foo' } });
-  let searchButton;
-  await patientlyWaitFor(() => {
-    searchButton = getByLabelText(searchButtonLabel);
-    expect(searchButton).toBeInTheDocument();
-  });
-  searchButton.click();
-  expect(mockSearch.mock.calls).toHaveLength(1);
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(autocompleteScope, done);
-});

data/webpack/components/Search/helpers.js

@@ -1,6 +0,0 @@
-// eslint-disable-next-line import/prefer-default-export
-export const stringIncludes = (string, includes) => {
-  const a = string.replace(/\s/g, '').toLowerCase();
-  const b = includes.replace(/\s/g, '').toLowerCase();
-  return a.includes(b);
-};

data/webpack/components/Search/index.js

@@ -1,15 +0,0 @@
-import { bindActionCreators } from 'redux';
-import { connect } from 'react-redux';
-import * as settingActions from 'foremanReact/components/Settings/SettingsActions';
-import { selectSettings } from '../../scenes/Settings/SettingsSelectors';
-import Search from './Search';
-
-const mapStateToProps = state => ({
-  settings: selectSettings(state),
-});
-
-const actions = { ...settingActions };
-
-const mapDispatchToProps = dispatch => bindActionCreators(actions, dispatch);
-
-export default connect(mapStateToProps, mapDispatchToProps)(Search);

data/webpack/components/TypeAhead/TypeAhead.js

@@ -1,157 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import Downshift from 'downshift';
-import PropTypes from 'prop-types';
-import { translate as __ } from 'foremanReact/common/I18n';
-import { useDispatch, useSelector } from 'react-redux';
-import TypeAheadSearch from './pf3Search/TypeAheadSearch';
-// eslint-disable-next-line import/no-named-default
-import { default as TypeAheadSearchPf4 } from './pf4Search/TypeAheadSearch';
-import { getActiveItems } from './helpers/helpers';
-import './TypeAhead.scss';
-import useDebounce from '../../utils/useDebounce';
-import { selectHostDetailsClearSearch } from '../extensions/HostDetails/HostDetailsSelectors';
-
-
-const TypeAhead = ({
-  items,
-  isDisabled,
-  onInputUpdate,
-  onSearch,
-  actionText,
-  patternfly4,
-  autoSearchEnabled,
-  autoSearchDelay,
-  bookmarkController,
-  readOnlyBookmarks,
-  placeholder,
-  isTextInput,
-  setTextInputValue,
-  initialInputValue,
-}) => {
-  const [inputValue, setInputValue] = useState(initialInputValue);
-  const debouncedValue = useDebounce(inputValue, autoSearchDelay);
-  const dispatch = useDispatch();
-  const existingClearSearch = useSelector(selectHostDetailsClearSearch);
-  useEffect(
-    () => {
-      onInputUpdate(debouncedValue);
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [debouncedValue],
-  );
-  // eslint-disable-next-line arrow-body-style
-  useEffect(() => {
-    return function cleanupClearSearch() {
-      dispatch({
-        type: 'SET_CLEAR_SEARCH',
-        payload: {},
-      });
-    };
-  }, [dispatch]);
-
-  const clearSearch = () => {
-    setInputValue('');
-    onSearch('');
-  };
-
-  const handleStateChange = ({ inputValue: value }) => {
-    if (typeof value === 'string') {
-      setInputValue(value);
-      if (setTextInputValue) setTextInputValue(value);
-    }
-    if (typeof existingClearSearch !== 'function') {
-      dispatch({
-        type: 'SET_CLEAR_SEARCH',
-        payload: clearSearch,
-      });
-    }
-  };
-  const activeItems = getActiveItems(items);
-  return (
-    <Downshift
-      onStateChange={handleStateChange}
-      defaultHighlightedIndex={0}
-      selectedItem={inputValue}
-    >
-      {({
-        getInputProps,
-        getItemProps,
-        isOpen,
-        inputValue: internalInputValue,
-        highlightedIndex,
-        selectedItem,
-        selectItem,
-        openMenu,
-      }) => {
-        const typeAheadProps = {
-          bookmarkController,
-          readOnlyBookmarks,
-          isDisabled,
-          userInputValue: inputValue,
-          clearSearch,
-          getInputProps,
-          getItemProps,
-          isOpen,
-          inputValue: internalInputValue,
-          highlightedIndex,
-          selectedItem,
-          selectItem,
-          openMenu,
-          onSearch,
-          items,
-          activeItems,
-          placeholder,
-          shouldShowItems: isOpen && items.length > 0,
-          isTextInput,
-        };
-
-        return (
-          <div>
-            {patternfly4 ?
-              <TypeAheadSearchPf4 autoSearchEnabled={autoSearchEnabled} {...typeAheadProps} /> :
-              <TypeAheadSearch actionText={actionText} {...typeAheadProps} placeholder={null} />}
-          </div>
-        );
-      }}
-    </Downshift>
-  );
-};
-
-TypeAhead.propTypes = {
-  items: PropTypes.arrayOf(PropTypes.shape({
-    /* text to display in MenuItem  */
-    text: PropTypes.string,
-    /* item can be a header or divider or undefined for regular item */
-    type: PropTypes.oneOf(['header', 'divider']),
-    /* optionally disable a regular item */
-    disabled: PropTypes.bool,
-  })).isRequired,
-  isDisabled: PropTypes.bool,
-  onInputUpdate: PropTypes.func.isRequired,
-  onSearch: PropTypes.func.isRequired,
-  actionText: PropTypes.string,
-  initialInputValue: PropTypes.string,
-  patternfly4: PropTypes.bool,
-  autoSearchEnabled: PropTypes.bool.isRequired,
-  autoSearchDelay: PropTypes.number,
-  bookmarkController: PropTypes.string,
-  readOnlyBookmarks: PropTypes.bool,
-  placeholder: PropTypes.string,
-  isTextInput: PropTypes.bool,
-  setTextInputValue: PropTypes.func,
-};
-
-TypeAhead.defaultProps = {
-  actionText: __('Search'),
-  initialInputValue: '',
-  patternfly4: false,
-  isDisabled: undefined,
-  autoSearchDelay: 500,
-  bookmarkController: undefined,
-  readOnlyBookmarks: false,
-  placeholder: undefined,
-  isTextInput: false,
-  setTextInputValue: undefined,
-};
-
-export default TypeAhead;

data/webpack/components/TypeAhead/TypeAhead.scss

@@ -1,7 +0,0 @@
-.typeahead-dropdown {
-  display: block;
-  position: absolute;
-  left: inherit;
-  margin-top: 0;
-  top: auto;
-}

data/webpack/components/TypeAhead/helpers/commonPropTypes.js

@@ -1,35 +0,0 @@
-import PropTypes from 'prop-types';
-
-const commonSearchPropTypes = {
-  userInputValue: PropTypes.string.isRequired,
-  clearSearch: PropTypes.func.isRequired,
-  getInputProps: PropTypes.func.isRequired,
-  getItemProps: PropTypes.func.isRequired,
-  isOpen: PropTypes.bool.isRequired,
-  inputValue: PropTypes.string.isRequired,
-  highlightedIndex: PropTypes.number.isRequired,
-  selectedItem: PropTypes.string.isRequired,
-  selectItem: PropTypes.func.isRequired,
-  openMenu: PropTypes.func.isRequired,
-  onSearch: PropTypes.func.isRequired,
-  items: PropTypes.arrayOf(PropTypes.shape({
-    text: PropTypes.string,
-  })).isRequired,
-  activeItems: PropTypes.arrayOf(PropTypes.string).isRequired,
-  shouldShowItems: PropTypes.bool.isRequired,
-};
-
-export const commonInputPropTypes = {
-  passedProps: PropTypes.shape({}).isRequired,
-  onKeyPress: PropTypes.func.isRequired,
-  onInputFocus: PropTypes.func.isRequired,
-};
-
-export const commonItemPropTypes = {
-  items: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
-  activeItems: PropTypes.arrayOf(PropTypes.string).isRequired,
-  highlightedIndex: PropTypes.number.isRequired,
-  getItemProps: PropTypes.func.isRequired,
-};
-
-export default commonSearchPropTypes;

data/webpack/components/TypeAhead/helpers/helpers.js

@@ -1,32 +0,0 @@
-import { KEYCODES } from 'foremanReact/common/keyCodes';
-
-const keyPressHandler = (
-  e, isOpen, activeItems, highlightedIndex,
-  selectItem, userInputValue, onSearch,
-) => {
-  switch (e.keyCode) {
-  case KEYCODES.TAB_KEY:
-    if (isOpen && activeItems[highlightedIndex]) {
-      selectItem(activeItems[highlightedIndex]);
-      e.preventDefault();
-    }
-    break;
-
-  case KEYCODES.ENTER:
-    if (!isOpen || !activeItems[highlightedIndex]) {
-      onSearch(userInputValue);
-      e.preventDefault();
-    }
-    break;
-
-  default:
-    break;
-  }
-};
-
-export const getActiveItems = items =>
-  items
-    .filter(({ disabled, type }) => !disabled && !['header', 'divider'].includes(type))
-    .map(({ text }) => text);
-
-export default keyPressHandler;

data/webpack/components/TypeAhead/index.js

@@ -1,3 +0,0 @@
-import TypeAhead from './TypeAhead';
-
-export default TypeAhead;

data/webpack/components/TypeAhead/pf3Search/TypeAheadInput.js

@@ -1,44 +0,0 @@
-import React, { Component } from 'react';
-import { FormControl } from 'patternfly-react';
-
-import { commonInputPropTypes } from '../helpers/commonPropTypes';
-
-class TypeAheadInput extends Component {
-  constructor(props) {
-    super(props);
-    this.handleKeyPress = this.handleKeyPress.bind(this);
-  }
-
-  componentDidMount() {
-    if (this.ref) {
-      this.ref.addEventListener('keydown', this.handleKeyPress);
-    }
-  }
-
-  componentWillUnmount() {
-    if (this.ref) {
-      this.ref.removeEventListener('keydown', this.handleKeyPress);
-    }
-  }
-
-  handleKeyPress(e) {
-    this.props.onKeyPress(e);
-  }
-
-  render() {
-    return (
-      <FormControl
-        inputRef={(ref) => {
-          this.ref = ref;
-        }}
-        onFocus={this.props.onInputFocus}
-        type="text"
-        {...this.props.passedProps}
-      />
-    );
-  }
-}
-
-TypeAheadInput.propTypes = commonInputPropTypes;
-
-export default TypeAheadInput;