katello 4.7.2 → 4.8.0.rc1

data/webpack/scenes/ContentViews/Details/Versions/VersionDetails/ContentViewVersionDetailConfig.js

@@ -55,6 +55,8 @@ export const TableType = PropTypes.shape({
   responseSelector: PropTypes.func,
   statusSelector: PropTypes.func,
   autocompleteEndpoint: PropTypes.string,
+  autocompleteQueryParams: PropTypes.shape({}),
+  bookmarkController: PropTypes.string,
   fetchItems: PropTypes.func,
   columnHeaders:
     PropTypes.arrayOf(PropTypes.shape({
@@ -72,6 +74,8 @@ export default ({ cvId, versionId }) => [
     responseSelector: state => selectCVVersions(state, cvId),
     statusSelector: state => selectCVVersionsStatus(state, cvId),
     autocompleteEndpoint: '',
+    autocompleteQueryParams: undefined,
+    bookmarkController: '',
     fetchItems: params => getContentViewVersions(
       cvId,
       { composite_version_id: versionId, ...params, content_view_id: undefined },
@@ -99,7 +103,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item?.repositories?.length,
     responseSelector: state => selectRepositories(state),
     statusSelector: state => selectRepositoriesStatus(state),
-    autocompleteEndpoint: `/repositories/auto_complete_search?archived=true&content_view_version_id=${versionId}`,
+    autocompleteEndpoint: '/katello/api/v2/repositories',
+    autocompleteQueryParams: { archived: true, content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_repositories',
     fetchItems: params => getRepositories({
       content_view_version_id: versionId,
       archived: true,
@@ -137,7 +143,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item?.rpm_count,
     responseSelector: state => selectRPMPackages(state),
     statusSelector: state => selectRPMPackagesStatus(state),
-    autocompleteEndpoint: `/packages/auto_complete_search?content_view_version_id=${versionId}`,
+    autocompleteEndpoint: '/katello/api/v2/packages',
+    autocompleteQueryParams: { content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_components',
     fetchItems: params => getRPMPackages({ content_view_version_id: versionId, ...params }),
     columnHeaders: [
       {
@@ -160,7 +168,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item?.package_group_count,
     responseSelector: state => selectRPMPackageGroups(state),
     statusSelector: state => selectRPMPackageGroupsStatus(state),
-    autocompleteEndpoint: `/package_groups/auto_complete_search?content_view_version_id=${versionId}`,
+    autocompleteEndpoint: '/katello/api/v2/package_groups',
+    autocompleteQueryParams: { content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_components',
     fetchItems: params => getPackageGroups({ content_view_version_id: versionId, ...params }),
     columnHeaders: [
       { title: __('Name'), getProperty: item => item?.name },
@@ -174,7 +184,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item?.file_count,
     responseSelector: state => selectFiles(state),
     statusSelector: state => selectFilesStatus(state),
-    autocompleteEndpoint: `/files/auto_complete_search?content_view_version_id=${versionId}`,
+    autocompleteEndpoint: '/katello/api/v2/files',
+    autocompleteQueryParams: { content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_components',
     fetchItems: params => getFiles({ content_view_version_id: versionId, ...params }),
     columnHeaders: [
       {
@@ -194,7 +206,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item?.erratum_count,
     responseSelector: state => selectErrata(state),
     statusSelector: state => selectErrataStatus(state),
-    autocompleteEndpoint: `/errata/auto_complete_search?content_view_version_id=${versionId}`,
+    autocompleteEndpoint: '/katello/api/v2/errata',
+    autocompleteQueryParams: { content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_components',
     fetchItems: params => getErrata({ content_view_version_id: versionId, ...params }),
     columnHeaders: [
       {
@@ -249,7 +263,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item?.module_stream_count,
     responseSelector: state => selectModuleStreams(state),
     statusSelector: state => selectModuleStreamsStatus(state),
-    autocompleteEndpoint: `/module_streams/auto_complete_search?content_view_version_id=${versionId}`,
+    autocompleteEndpoint: '/katello/api/v2/module_streams',
+    autocompleteQueryParams: { content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_components',
     fetchItems: params => getModuleStreams({ content_view_version_id: versionId, ...params }),
     columnHeaders: [
       {
@@ -272,7 +288,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item?.deb_count,
     responseSelector: state => selectDebPackages(state),
     statusSelector: state => selectDebPackagesStatus(state),
-    autocompleteEndpoint: `/debs/auto_complete_search?content_view_version_id=${versionId}`,
+    autocompleteEndpoint: '/katello/api/v2/debs',
+    autocompleteQueryParams: { content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_components',
     fetchItems: params => getDebPackages({ content_view_version_id: versionId, ...params }),
     columnHeaders: [
       {
@@ -293,7 +311,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item?.docker_tag_count,
     responseSelector: state => selectDockerTags(state),
     statusSelector: state => selectDockerTagsStatus(state),
-    autocompleteEndpoint: `/docker_tags/auto_complete_search?content_view_version_id=${versionId}`,
+    autocompleteEndpoint: '/katello/api/v2/docker_tags',
+    autocompleteQueryParams: { content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_components',
     fetchItems: params => getDockerTags({ content_view_version_id: versionId, ...params }),
     columnHeaders: [
       {
@@ -323,7 +343,9 @@ export default ({ cvId, versionId }) => [
     getCountKey: item => item[`${singularLabel}_count`],
     responseSelector: state => selectContent(pluralLabel, state),
     statusSelector: state => selectContentStatus(pluralLabel, state),
-    autocompleteEndpoint: `/${pluralLabel}/auto_complete_search?content_view_version_id=${versionId}`,
+    autocompleteEndpoint: `/katello/api/v2/${pluralLabel}`,
+    autocompleteQueryParams: { content_view_version_id: versionId },
+    bookmarkController: 'katello_content_view_components',
     fetchItems: params =>
       getContent(pluralLabel, { content_view_version_id: versionId, ...params }),
     columnHeaders,

data/webpack/scenes/ContentViews/Details/Versions/VersionDetails/ContentViewVersionDetailsTable.js

@@ -32,6 +32,8 @@ const ContentViewVersionDetailsTable = ({
     responseSelector,
     statusSelector,
     autocompleteEndpoint,
+    autocompleteQueryParams,
+    bookmarkController,
     fetchItems,
     columnHeaders,
     hideSearch,
@@ -77,6 +79,8 @@ const ContentViewVersionDetailsTable = ({
           updateSearchQuery,
           status,
           autocompleteEndpoint,
+          autocompleteQueryParams,
+          bookmarkController,
           hideSearch,
         }}
         ouiaId={`content-view-version-details-${kebabCase(route)}-table`}

data/webpack/scenes/ContentViews/Details/Versions/VersionDetails/__tests__/ContentViewVersionDetails.test.js

@@ -2,11 +2,10 @@ import React from 'react';
 import { renderWithRedux, patientlyWaitFor } from 'react-testing-lib-wrapper';
 import { Route } from 'react-router-dom';
 import { head, last } from 'lodash';
-import { nockInstance, assertNockRequest, mockSetting, mockAutocomplete } from '../../../../../../test-utils/nockWrapper';
+import { nockInstance, assertNockRequest, mockAutocomplete } from '../../../../../../test-utils/nockWrapper';
 import api from '../../../../../../services/api';
 import { cvVersionDetailsKey } from '../../../../ContentViewsConstants';
 import ContentViewVersionDetails from '../ContentViewVersionDetails';
-import { AUTOSEARCH_DELAY, AUTOSEARCH_WHILE_TYPING } from '../../../../../Settings/SettingsConstants';
 import ContentViewVersionDetailsData from './ContentViewVersionDetails.fixtures.json';
 import ContentViewVersionDetailsCounts from './ContentViewVersionDetailsCounts.fixtures.json';
 import cvDetailData from '../../../../__tests__/mockDetails.fixtures.json';
@@ -42,6 +41,28 @@ const renderOptions = {
   },
 };
 
+const autocompleteQuery = name => ((name === 'Repositories') ? {
+  archived: true,
+  organization_id: 1,
+  content_view_version_id: 73,
+  search: '',
+} : {
+  organization_id: 1,
+  content_view_version_id: 73,
+  search: '',
+});
+
+const queryParams = name => ((name === 'Repositories') ? {
+  archived: true,
+  content_view_version_id: 73,
+  per_page: 20,
+  page: 1,
+} : {
+  content_view_version_id: 73,
+  per_page: 20,
+  page: 1,
+});
+
 beforeEach(() => {
   envScope = nockInstance
     .get(environmentPathsPath)
@@ -90,7 +111,6 @@ test('Can show versions details - Components Tab', async (done) => {
   assertNockRequest(componentScope, done);
 });
 
-
 const testConfig = [
   {
     name: 'Repositories',
@@ -196,9 +216,11 @@ testConfig.forEach(({
   test(`Can show versions details - ${name} Tab`, async (done) => {
     const { version } = ContentViewVersionDetailsData;
 
-    const autocompleteScope = mockAutocomplete(nockInstance, autoCompleteUrl);
-    const searchDelayScope = mockSetting(nockInstance, AUTOSEARCH_DELAY);
-    const autoSearchScope = mockSetting(nockInstance, AUTOSEARCH_WHILE_TYPING);
+    const autocompleteScope = mockAutocomplete(
+      nockInstance,
+      autoCompleteUrl,
+      autocompleteQuery(name),
+    );
 
     const scope = nockInstance
       .get(cvVersions)
@@ -207,7 +229,7 @@ testConfig.forEach(({
 
     const tabScope = nockInstance
       .get(dataUrl)
-      .query(true)
+      .query(queryParams(name))
       .reply(200, data);
 
     const { getByText, queryByText } = renderWithRedux(
@@ -231,8 +253,6 @@ testConfig.forEach(({
     });
 
     assertNockRequest(autocompleteScope);
-    assertNockRequest(searchDelayScope);
-    assertNockRequest(autoSearchScope);
     assertNockRequest(scope);
     assertNockRequest(tabScope);
     assertNockRequest(scope, done);
@@ -247,9 +267,7 @@ test('Can change repository selector', async (done) => {
   } = testConfig[1]; // RPM Packages
 
   const { version } = ContentViewVersionDetailsData;
-  const autocompleteScope = mockAutocomplete(nockInstance, autoCompleteUrl);
-  const searchDelayScope = mockSetting(nockInstance, AUTOSEARCH_DELAY, 0);
-  const autoSearchScope = mockSetting(nockInstance, AUTOSEARCH_WHILE_TYPING);
+  const autocompleteScope = mockAutocomplete(nockInstance, autoCompleteUrl, autocompleteQuery);
 
   const scope = nockInstance
     .get(cvVersions)
@@ -297,8 +315,6 @@ test('Can change repository selector', async (done) => {
   });
 
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
   assertNockRequest(scope);
   assertNockRequest(tabScope);
   assertNockRequest(scope, done);

data/webpack/scenes/ContentViews/Table/ContentViewsTable.js

@@ -162,7 +162,7 @@ const ContentViewTable = () => {
       bookmarkController="katello_content_views"
       variant={TableVariant.compact}
       status={status}
-      autocompleteEndpoint="/content_views/auto_complete_search"
+      autocompleteEndpoint="/katello/api/v2/content_views"
       primaryActionButton={canCreate ? (
         <Button
           ouiaId="create-content-view"

data/webpack/scenes/ContentViews/__tests__/contentViewPage.test.js

@@ -6,7 +6,7 @@ import CONTENT_VIEWS_KEY from '../ContentViewsConstants';
 import ContentViewsPage from '../../ContentViews';
 import api from '../../../services/api';
 import {
-  nockInstance, assertNockRequest, mockAutocomplete, mockSetting,
+  nockInstance, assertNockRequest, mockAutocomplete,
 } from '../../../test-utils/nockWrapper';
 import createBasicCVs from './basicContentViews.fixtures';
 import cvIndexData from './contentViewList.fixtures.json';
@@ -14,28 +14,23 @@ import cvIndexData from './contentViewList.fixtures.json';
 const cvIndexPath = api.getApiUrl('/content_views');
 const autocompleteUrl = '/content_views/auto_complete_search';
 const renderOptions = { apiNamespace: CONTENT_VIEWS_KEY };
+const autocompleteQuery = {
+  organization_id: 1,
+  search: '',
+};
 
 let firstCV;
-let searchDelayScope;
-let autoSearchScope;
-let scopeBookmark;
 beforeEach(() => {
   const { results } = cvIndexData;
   [firstCV] = results;
 });
 
 test('Can call API for CVs and show on screen on page load', async (done) => {
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
   const scope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(200, cvIndexData);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-  scopeBookmark = nockInstance
-    .get('/api/v2/bookmarks')
-    .query(true)
-    .reply(200, {});
 
   const { queryByText, queryAllByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
 
@@ -49,25 +44,16 @@ test('Can call API for CVs and show on screen on page load', async (done) => {
   });
 
 
-  assertNockRequest(scopeBookmark);
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
   assertNockRequest(scope, done);
 });
 
 test('Can show last task and link to it', async (done) => {
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
   const scope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(200, cvIndexData);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-  scopeBookmark = nockInstance
-    .get('/api/v2/bookmarks')
-    .query(true)
-    .reply(200, {});
 
   const { getByText, queryByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
 
@@ -82,25 +68,16 @@ test('Can show last task and link to it', async (done) => {
     expect(queryByText('N/A')).toBeTruthy();
   });
 
-  assertNockRequest(scopeBookmark);
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
   assertNockRequest(scope, done); // Pass jest callback to confirm test is done
 });
 
 test('Can show latest version and link to it', async (done) => {
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
   const scope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(200, cvIndexData);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-  scopeBookmark = nockInstance
-    .get('/api/v2/bookmarks')
-    .query(true)
-    .reply(200, {});
 
   const {
     getByText,
@@ -123,25 +100,16 @@ test('Can show latest version and link to it', async (done) => {
     expect(getByText('dev').closest('a'))
       .toHaveAttribute('href', '/lifecycle_environments/2');
   });
-  assertNockRequest(scopeBookmark);
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
   assertNockRequest(scope, done); // Pass jest callback to confirm test is done
 });
 
 test('Can expand cv and show activation keys and hosts', async (done) => {
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
   const scope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(200, cvIndexData);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-  scopeBookmark = nockInstance
-    .get('/api/v2/bookmarks')
-    .query(true)
-    .reply(200, {});
 
   const {
     queryByLabelText,
@@ -171,9 +139,6 @@ test('Can expand cv and show activation keys and hosts', async (done) => {
   });
 
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(scopeBookmark);
   assertNockRequest(scope, done); // Pass jest callback to confirm test is done
 });
 
@@ -215,25 +180,16 @@ test('Can handle unpublished Content Views', async (done) => {
   const { results } = cvIndexData;
   const unpublishedCVs = results.map(cv => ({ ...cv, last_published: null }));
   const unpublishedCVData = { ...cvIndexData, results: unpublishedCVs };
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
   const scope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(200, unpublishedCVData);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-  scopeBookmark = nockInstance
-    .get('/api/v2/bookmarks')
-    .query(true)
-    .reply(200, {});
 
   const { getAllByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
 
   await patientlyWaitFor(() => expect(getAllByText(/not yet published/i).length).toBeGreaterThan(0));
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(scopeBookmark);
   assertNockRequest(scope, done);
 });
 
@@ -242,13 +198,7 @@ test('Can handle pagination', async (done) => {
   const { results } = cvIndexLarge;
   const cvIndexFirstPage = { ...cvIndexLarge, ...{ results: results.slice(0, 20) } };
   const cvIndexSecondPage = { ...cvIndexLarge, page: 2, results: results.slice(20, 40) };
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-  scopeBookmark = nockInstance
-    .get('/api/v2/bookmarks')
-    .query(true)
-    .reply(200, {});
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
 
   // Match first page API request
   const firstPageScope = nockInstance
@@ -283,39 +233,43 @@ test('Can handle pagination', async (done) => {
     expect(queryByText(results[41].name)).not.toBeInTheDocument();
   });
   assertNockRequest(autocompleteScope);
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(scopeBookmark);
   assertNockRequest(firstPageScope);
   assertNockRequest(secondPageScope, done); // Only pass jest callback to the last API request
 });
 
 test('Can search for specific Content View', async (done) => {
   const cvname = 'composite one';
-  const { results } = cvIndexData;
-  const matchQuery = actualParams => actualParams?.search?.includes(cvname);
-  const searchResults = {
-    ...cvIndexData,
-    ...{ total: 1, subtotal: 1, results: results.slice(-1) },
+  const matchQuery = {
+    organization_id: 1,
+    search: `name = ${firstCV.name}`,
   };
-
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
-  const withSearchScope = mockAutocomplete(nockInstance, autocompleteUrl, matchQuery);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-  scopeBookmark = nockInstance
-    .get('/api/v2/bookmarks')
-    .query(true)
-    .reply(200, {});
+  const searchResults = [
+    {
+      completed: 'name = cv1',
+      part: 'and',
+      label: 'name = cv1 and',
+      category: 'Operators',
+    },
+    {
+      completed: 'name = cv1',
+      part: 'or',
+      label: 'name = cv1 or',
+      category: 'Operators',
+    },
+  ];
+
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
+  const withSearchScope = mockAutocomplete(
+    nockInstance,
+    autocompleteUrl,
+    matchQuery,
+    searchResults,
+  );
 
   const initialScope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(200, cvIndexData);
-  const searchResultScope = nockInstance
-    .get(cvIndexPath)
-    .query(matchQuery)
-    .reply(200, searchResults);
 
   const {
     getByLabelText,
@@ -325,71 +279,52 @@ test('Can search for specific Content View', async (done) => {
 
   await patientlyWaitFor(() => expect(getByText(firstCV.name)).toBeInTheDocument());
 
-  const searchInput = getByLabelText(/text input for search/i);
+  const searchInput = getByLabelText('Search input');
   expect(searchInput).toBeInTheDocument();
-  fireEvent.change(searchInput, { target: { value: `name = \"${cvname}\"` } });
+  searchInput.focus();
+  fireEvent.change(searchInput, { target: { value: `name = ${firstCV.name}` } });
 
   await patientlyWaitFor(() => {
-    expect(getByText(cvname)).toBeInTheDocument();
-    expect(queryByText(firstCV.name)).not.toBeInTheDocument();
+    expect(getByText(`name = ${firstCV.name} and`)).toBeInTheDocument();
+    expect(queryByText(`name = ${cvname} and`)).not.toBeInTheDocument();
   });
 
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(scopeBookmark);
   assertNockRequest(initialScope);
-  assertNockRequest(withSearchScope);
-  assertNockRequest(searchResultScope, done);
+  assertNockRequest(withSearchScope, done);
 });
 
-test('No results message is shown for empty search', async (done) => {
+test('Nothing is shown for empty search', async (done) => {
   const cvname = 'notanactualname';
   const query = `name = \"${cvname}\"`;
-  const matchQuery = actualParams => actualParams?.search?.includes(cvname);
-  const emptyResults = {
-    total: 0,
-    subtotal: 0,
-    page: 1,
-    per_page: 20,
+  const matchQuery = {
+    organization_id: 1,
     search: query,
-    results: [],
-    can_view: true,
-    can_create: true,
   };
 
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-  scopeBookmark = nockInstance
-    .get('/api/v2/bookmarks')
-    .query(true)
-    .reply(200, {});
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
   const withSearchScope = mockAutocomplete(nockInstance, autocompleteUrl, matchQuery);
   const initialScope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(200, cvIndexData);
-  const searchResultScope = nockInstance
-    .get(cvIndexPath)
-    .query(matchQuery)
-    .reply(200, emptyResults);
 
-  const { getByLabelText, getByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
+  const {
+    getByLabelText,
+    getByText,
+    queryByText,
+  } = renderWithRedux(<ContentViewsPage />, renderOptions);
 
   await patientlyWaitFor(() => expect(getByText(firstCV.name)).toBeInTheDocument());
 
-  fireEvent.change(getByLabelText(/text input for search/i), { target: { value: query } });
+  getByLabelText('Search input').focus();
+  fireEvent.change(getByLabelText('Search input'), { target: { value: query } });
 
-  await patientlyWaitFor(() => expect(getByText(/No matching content views found/i)).toBeInTheDocument());
+  await patientlyWaitFor(() => expect(queryByText(`${query} and`)).not.toBeInTheDocument());
 
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
-  assertNockRequest(scopeBookmark);
   assertNockRequest(initialScope);
-  assertNockRequest(withSearchScope);
-  assertNockRequest(searchResultScope, done);
+  assertNockRequest(withSearchScope, done);
 });
 
 test('Displays Create Content View and opens modal with Form', async () => {

data/webpack/scenes/ContentViews/components/WizardHeader.js

@@ -9,7 +9,7 @@ const WizardHeader = ({
   <Grid style={{ gridGap: '24px' }}>
     {title &&
       <TextContent>
-        <Text component={TextVariants.h2}>{title}</Text>
+        <Text ouiaId="wizard-header-text" component={TextVariants.h2}>{title}</Text>
       </TextContent>}
     {description &&
       <TextContent>

data/webpack/scenes/ContentViews/expansions/RelatedContentViewComponentsModal.js

@@ -70,7 +70,7 @@ const RelatedContentViewsModal = ({ cvName, cvId, relatedCVCount }) => {
               ouiaId="related-content-view-components-table"
               fetchItems={useCallback(params => getContentViewComponents(cvId, params, 'Added'), [cvId])}
               variant={TableVariant.compact}
-              autocompleteEndpoint="/content_views/auto_complete_search"
+              autocompleteEndpoint="/katello/api/v2/content_views"
               emptyContentTitle={__('You currently don\'t have any related content views.')}
               emptySearchTitle={__('No matching content views found')}
               emptyContentBody={__('Related content views will appear here when created.')}

data/webpack/scenes/ContentViews/expansions/__tests__/contentViewComponentsModal.test.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import { renderWithRedux, patientlyWaitFor, fireEvent } from 'react-testing-lib-wrapper';
 
-import { nockInstance, assertNockRequest } from '../../../../test-utils/nockWrapper';
+import { nockInstance, assertNockRequest, mockAutocomplete } from '../../../../test-utils/nockWrapper';
 import api from '../../../../services/api';
 
 import RelatedContentViewComponentsModal from '../RelatedContentViewComponentsModal';
@@ -16,6 +16,12 @@ test('Can call API and show Related Content Views Components Modal', async (done
   const relatedCvCount = 2;
   const cvName = 'italiano';
   const contentViewComponentsPath = api.getApiUrl(`/content_views/${cvId}/content_view_components/show_all`);
+  const autocompleteUrl = '/content_views/auto_complete_search';
+  const autocompleteQuery = {
+    organization_id: 1,
+    search: '',
+  };
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
 
   const scope = nockInstance
     .get(contentViewComponentsPath)
@@ -32,6 +38,7 @@ test('Can call API and show Related Content Views Components Modal', async (done
   fireEvent.click(getByLabelText(`button_${cvId}`));
   await patientlyWaitFor(() => expect(getByText('Related content views')).toBeInTheDocument());
 
+  assertNockRequest(autocompleteScope);
   assertNockRequest(scope, done);
 });
 

data/webpack/scenes/ModuleStreams/ModuleStreamsPage.js

@@ -32,14 +32,6 @@ class ModuleStreamsPage extends Component {
     this.props.getModuleStreams({ search });
   };
 
-  getAutoCompleteParams = search => ({
-    endpoint: '/module_streams/auto_complete_search',
-    params: {
-      organization_id: orgId(),
-      search,
-    },
-  });
-
   updateSearchQuery = (searchQuery) => {
     this.setState({ searchQuery });
   };
@@ -52,7 +44,9 @@ class ModuleStreamsPage extends Component {
         content={moduleStreams}
         tableSchema={TableSchema}
         onSearch={this.onSearch}
-        getAutoCompleteParams={this.getAutoCompleteParams}
+        autocompleteEndpoint="/katello/api/v2/module_streams"
+        autocompleteQueryParams={{ organization_id: orgId() }}
+        bookmarkController="katello_module_streams"
         updateSearchQuery={this.updateSearchQuery}
         initialInputValue={this.state.searchQuery}
         onPaginationChange={this.onPaginationChange}

data/webpack/scenes/ModuleStreams/__tests__/__snapshots__/ModuleStreamPage.test.js.snap

@@ -2,8 +2,14 @@
 
 exports[`Module streams page should render and contain appropiate components 1`] = `
 <ContentPage
+  autocompleteEndpoint="/katello/api/v2/module_streams"
+  autocompleteQueryParams={
+    Object {
+      "organization_id": 1,
+    }
+  }
+  bookmarkController="katello_module_streams"
   content={Object {}}
-  getAutoCompleteParams={[Function]}
   header="Module Streams"
   initialInputValue=""
   onPaginationChange={[Function]}