katello 4.5.1 → 4.8.0.rc2

data/webpack/scenes/ContentViews/Details/Filters/__tests__/CVContainerImageFilterContent.test.js

@@ -3,7 +3,7 @@ import { renderWithRedux, patientlyWaitFor, fireEvent, act } from 'react-testing
 import { Route } from 'react-router-dom';
 
 import { cvFilterDetailsKey } from '../../../ContentViewsConstants';
-import nock, {
+import {
   nockInstance,
   assertNockRequest,
   mockAutocomplete,
@@ -13,6 +13,7 @@ import api from '../../../../../services/api';
 import CVContainerImageFilterContent from '../CVContainerImageFilterContent';
 import cvFilterFixtures from './CVContainerImageFilterContent.fixtures.json';
 import details from '../../../../ContentViews/__tests__/mockDetails.fixtures.json';
+import emptyCVContainerImageData from './emptyCVContainerImageFilterContent.fixtures.json';
 
 const afterDeleteFilterResultsArray = [...cvFilterFixtures.results];
 afterDeleteFilterResultsArray.shift();
@@ -31,6 +32,10 @@ const addedRule = {
 };
 
 const autocompleteUrl = '/content_view_filters/195/rules/auto_complete_search';
+const autocompleteQuery = {
+  organization_id: 1,
+  search: '',
+};
 const renderOptions = {
   apiNamespace: cvFilterDetailsKey(13, 195),
   routerParams: {
@@ -41,21 +46,8 @@ const renderOptions = {
 
 const withCVRoute = component => <Route path="/content_views/:id([0-9]+)#/filters/:filterId([0-9]+)">{component}</Route>;
 
-let searchDelayScope;
-let autoSearchScope;
-beforeEach(() => {
-  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
-});
-
-afterEach(() => {
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
-  nock.cleanAll();
-});
-
 test('Can view container image filter rules', async (done) => {
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
   const cvFiltersScope = nockInstance
     .get(cvFilterRulesPath)
     .query(true)
@@ -89,7 +81,7 @@ test('Can view container image filter rules', async (done) => {
 
 // Remove
 test('Can remove filter rules', async (done) => {
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
 
   const cvFiltersScope = nockInstance
     .get(cvFilterRulesPath)
@@ -138,13 +130,18 @@ test('Can remove filter rules', async (done) => {
   assertNockRequest(cvFiltersCallbackScope, done);
 });
 
-
 // Add
 test('Can add filter rules', async (done) => {
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, true, [], 2);
+  const autocompleteScope = mockAutocomplete(
+    nockInstance,
+    autocompleteUrl,
+    autocompleteQuery,
+    [],
+    2,
+  );
   const autocompleteNameScope = mockAutocomplete(nockInstance, autocompleteNameUrl, true, [], 2);
-  const inputSearchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0, 2);
-  const inputAutoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', undefined, 2);
+  const searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
+  const autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
 
   const cvFiltersScope = nockInstance
     .get(cvFilterRulesPath)
@@ -161,7 +158,7 @@ test('Can add filter rules', async (done) => {
     .query(true)
     .reply(200, { ...cvFilterFixtures, results: [...cvFilterFixtures.results, addedRule] });
 
-  const { queryByText, getByLabelText, getAllByLabelText } =
+  const { queryByText, getByLabelText } =
     renderWithRedux(
       withCVRoute(<CVContainerImageFilterContent filterId={195} details={details} />),
       renderOptions,
@@ -175,29 +172,23 @@ test('Can add filter rules', async (done) => {
     fireEvent.click(getByLabelText('add_filter_rule'));
   });
 
-
-  await patientlyWaitFor(() => {
-    expect(getAllByLabelText('text input for search')[0]).toBeInTheDocument();
-  });
-
-  fireEvent.change(getAllByLabelText('text input for search')[0], { target: { value: addedRule.name } });
-
   await patientlyWaitFor(() => {
     expect(getByLabelText('add_edit_filter_rule')).toBeInTheDocument();
     expect(getByLabelText('add_edit_filter_rule')).toHaveAttribute('aria-disabled', 'true');
   });
 
-  fireEvent.submit(getAllByLabelText('text input for search')[1]);
+  fireEvent.change(getByLabelText('text input for search'), { target: { value: 'new-rule' } });
+  fireEvent.submit(getByLabelText('add_edit_filter_rule'));
 
   await patientlyWaitFor(() => {
-    expect(queryByText(addedRule.name)).toBeInTheDocument();
+    expect(queryByText('Add rule')).not.toBeInTheDocument();
   });
 
   assertNockRequest(autocompleteScope);
+  assertNockRequest(searchDelayScope);
+  assertNockRequest(autoSearchScope);
   assertNockRequest(cvFiltersScope);
   assertNockRequest(cvFilterAddScope);
-  assertNockRequest(inputSearchDelayScope);
-  assertNockRequest(inputAutoSearchScope);
   assertNockRequest(autocompleteNameScope);
   assertNockRequest(cvFiltersCallbackScope, done);
   act(done);
@@ -206,10 +197,16 @@ test('Can add filter rules', async (done) => {
 
 // Edit
 test('Can edit filter rules', async (done) => {
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, true, [], 2);
+  const autocompleteScope = mockAutocomplete(
+    nockInstance,
+    autocompleteUrl,
+    autocompleteQuery,
+    [],
+    2,
+  );
   const autocompleteNameScope = mockAutocomplete(nockInstance, autocompleteNameUrl, true, [], 2);
-  const inputSearchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0, 2);
-  const inputAutoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', undefined, 2);
+  const searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
+  const autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
 
   const cvFiltersScope = nockInstance
     .get(cvFilterRulesPath)
@@ -256,26 +253,85 @@ test('Can edit filter rules', async (done) => {
     fireEvent.click(queryByText('Edit'));
   });
 
-  fireEvent.change(getAllByLabelText('text input for search')[0], { target: { value: addedRule.name } });
-
   await patientlyWaitFor(() => {
     expect(getByLabelText('add_edit_filter_rule')).toBeInTheDocument();
     expect(getByLabelText('add_edit_filter_rule')).toHaveAttribute('aria-disabled', 'false');
   });
 
-  fireEvent.submit(getAllByLabelText('text input for search')[1]);
+  fireEvent.change(getByLabelText('text input for search'), { target: { value: 'changed-name' } });
+  fireEvent.submit(getByLabelText('add_edit_filter_rule'));
 
   await patientlyWaitFor(() => {
-    expect(queryByText(firstResultName)).not.toBeInTheDocument();
-    expect(queryByText(addedRule.name)).toBeInTheDocument();
+    expect(queryByText('Edit rule')).not.toBeInTheDocument();
   });
 
   assertNockRequest(autocompleteScope);
+  assertNockRequest(searchDelayScope);
+  assertNockRequest(autoSearchScope);
   assertNockRequest(cvFiltersScope);
   assertNockRequest(cvFilterAddScope);
-  assertNockRequest(inputSearchDelayScope);
-  assertNockRequest(inputAutoSearchScope);
   assertNockRequest(autocompleteNameScope);
   assertNockRequest(cvFiltersCallbackScope, done);
   act(done);
 });
+
+test('Shows call-to-action when there are no filter rules', async (done) => {
+  const autocompleteScope = mockAutocomplete(
+    nockInstance,
+    autocompleteUrl,
+    autocompleteQuery,
+    [],
+    2,
+  );
+  const autocompleteNameScope = mockAutocomplete(nockInstance, autocompleteNameUrl, true, [], 2);
+  const searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
+  const autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
+  const cvFiltersScope = nockInstance
+    .get(cvFilterRulesPath)
+    .times(2)
+    .query(true)
+    .reply(200, emptyCVContainerImageData);
+
+  const { queryByLabelText, getAllByLabelText } =
+    renderWithRedux(
+      withCVRoute(<CVContainerImageFilterContent filterId={195} details={details} />),
+      renderOptions,
+    );
+
+  expect(queryByLabelText('add_filter_rule_empty_state')).toBeNull();
+  await patientlyWaitFor(() => expect(queryByLabelText('add_filter_rule_empty_state')).toBeInTheDocument());
+  fireEvent.click(queryByLabelText('add_filter_rule_empty_state'));
+  await patientlyWaitFor(() => {
+    expect(getAllByLabelText('text input for search')[0]).toBeInTheDocument();
+  });
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(autocompleteNameScope);
+  assertNockRequest(searchDelayScope);
+  assertNockRequest(autoSearchScope);
+  assertNockRequest(cvFiltersScope, done);
+  act(done);
+});
+
+test('Hides bulk_remove dropdownItem when there are no filter rules', async (done) => {
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
+  const cvFiltersScope = nockInstance
+    .get(cvFilterRulesPath)
+    .query(true)
+    .reply(200, emptyCVContainerImageData);
+
+  const { queryByText, getByText, queryByLabelText } =
+    renderWithRedux(
+      withCVRoute(<CVContainerImageFilterContent filterId={195} details={details} />),
+      renderOptions,
+    );
+  expect(queryByText('Add filter rule')).toBeNull();
+  await patientlyWaitFor(() => {
+    expect(getByText('Add filter rule')).toBeInTheDocument();
+    expect(queryByLabelText('bulk_actions')).not.toBeInTheDocument();
+  });
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(cvFiltersScope, done);
+  act(done);
+});

data/webpack/scenes/ContentViews/Details/Filters/__tests__/CVRpmFilterContent.test.js

@@ -15,6 +15,8 @@ import cvFilterDetails from './cvPackageFilterDetail.fixtures.json';
 import cvPackageFilterRules from './cvPackageFilterRules.fixtures.json';
 import cvFilterFixtures from './contentViewFilters.fixtures.json';
 import details from '../../../__tests__/mockDetails.fixtures.json';
+// import emptyContentViewFiltersData from './emptyContentViewFilters.fixtures.json';
+import emptyCVPackageFilterRules from './emptyCVPackageFilterRules.fixtures.json';
 
 const cvFiltersPath = api.getApiUrl('/content_view_filters');
 const cvFilterDetailsPath = api.getApiUrl('/content_view_filters/2');
@@ -31,13 +33,15 @@ const renderOptions = {
     initialIndex: 1,
   },
 };
+const autocompleteQuery = {
+  organization_id: 1,
+  search: '',
+};
 
 const withCVRoute = component => <Route path="/content_views/:id([0-9]+)#/filters/:filterId([0-9]+)">{component}</Route>;
 
 test('Can show filter details and package groups on page load', async (done) => {
   const { name: cvFilterName } = cvFilterDetails;
-  const searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  const autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
   const cvFilterScope = nockInstance
     .get(cvFilterDetailsPath)
     .query(true)
@@ -50,7 +54,7 @@ test('Can show filter details and package groups on page load', async (done) =>
     .get(cvPackageFilterRulesPath)
     .query(true)
     .reply(200, cvPackageFilterRules);
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
 
   const { getByText, queryByText } =
     renderWithRedux(withCVRoute(<ContentViewFilterDetails
@@ -65,11 +69,9 @@ test('Can show filter details and package groups on page load', async (done) =>
   });
 
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
   assertNockRequest(cvFilterScope);
   assertNockRequest(cvFiltersScope);
-  assertNockRequest(cvPackageFilterRulesScope, done);
+  assertNockRequest(cvPackageFilterRulesScope);
   act(done);
 });
 
@@ -79,10 +81,24 @@ test('Can search for package rules in package filter details', async (done) => {
   const { name: cvFilterName } = cvFilterDetails;
   const { name: firstPackageRuleName } = firstPackageRule;
   const { name: lastPackageRuleName } = lastPackageRule;
-  const searchQueryMatcher = actualParams =>
-    actualParams?.search?.includes(lastPackageRuleName);
-  const searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0);
-  const autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing');
+  const searchQueryMatcher = {
+    organization_id: 1,
+    search: `name = ${lastPackageRuleName}`,
+  };
+  const searchResults = [
+    {
+      completed: `name = ${lastPackageRuleName}`,
+      part: 'and',
+      label: `name = ${lastPackageRuleName} and`,
+      category: 'Operators',
+    },
+    {
+      completed: `name = ${lastPackageRuleName}`,
+      part: 'or',
+      label: `name = ${lastPackageRuleName} or`,
+      category: 'Operators',
+    },
+  ];
 
   const cvFilterScope = nockInstance
     .get(cvFilterDetailsPath)
@@ -101,8 +117,13 @@ test('Can search for package rules in package filter details', async (done) => {
     .query(searchQueryMatcher)
     .reply(200, { results: [lastPackageRule] });
 
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
-  const withSearchScope = mockAutocomplete(nockInstance, autocompleteUrl, searchQueryMatcher);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, autocompleteQuery);
+  const withSearchScope = mockAutocomplete(
+    nockInstance,
+    autocompleteUrl,
+    searchQueryMatcher,
+    searchResults,
+  );
   const { getByText, queryByText, getByLabelText } =
     renderWithRedux(withCVRoute(<ContentViewFilterDetails
       cvId={1}
@@ -115,27 +136,33 @@ test('Can search for package rules in package filter details', async (done) => {
   });
 
   // Search and only searched result shows
-  fireEvent.change(getByLabelText(/text input for search/i), { target: { value: lastPackageRuleName } });
+  getByLabelText('Search input').focus();
+  fireEvent.change(getByLabelText('Search input'), { target: { value: `name = ${lastPackageRuleName}` } });
   await patientlyWaitFor(() => {
-    expect(getByText(lastPackageRuleName)).toBeInTheDocument();
-    expect(queryByText(firstPackageRuleName)).not.toBeInTheDocument();
+    expect(getByText(`name = ${lastPackageRuleName} and`)).toBeInTheDocument();
+    expect(queryByText(`name = ${firstPackageRuleName} and`)).not.toBeInTheDocument();
   });
 
   assertNockRequest(autocompleteScope);
-  assertNockRequest(searchDelayScope);
-  assertNockRequest(autoSearchScope);
   assertNockRequest(cvFilterScope);
   assertNockRequest(cvFiltersScope);
   assertNockRequest(cvPackageFilterRulesScope);
   assertNockRequest(withSearchScope);
-  assertNockRequest(packageRuleSearchScope, done);
+  assertNockRequest(packageRuleSearchScope);
+  act(done);
 });
 
 test('Can add package rules to filter in a self-closing modal', async (done) => {
   const { name: cvFilterName } = cvFilterDetails;
-  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
-  const autocompleteNameScope = mockAutocomplete(nockInstance, autocompleteNameUrl);
-  const autocompleteArchScope = mockAutocomplete(nockInstance, autocompleteArchUrl);
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, true, undefined, 2);
+  const autocompleteNameScope = mockAutocomplete(
+    nockInstance, autocompleteNameUrl, true,
+    undefined, 2,
+  );
+  const autocompleteArchScope = mockAutocomplete(
+    nockInstance, autocompleteArchUrl, true,
+    undefined, 2,
+  );
   const searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0, 3);
   const autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', undefined, 3);
 
@@ -187,12 +214,12 @@ test('Can add package rules to filter in a self-closing modal', async (done) =>
   });
   getByLabelText('add_rpm_rule').click();
   await patientlyWaitFor(() => {
+    expect(getAllByLabelText('text input for search')[0]).toBeInTheDocument();
     expect(getAllByLabelText('text input for search')[1]).toBeInTheDocument();
-    expect(getAllByLabelText('text input for search')[2]).toBeInTheDocument();
     expect(getByLabelText('add_package_filter_rule')).toBeInTheDocument();
   });
-  fireEvent.change(getAllByLabelText('text input for search')[1], { target: { value: 'elephant' } });
-  fireEvent.change(getAllByLabelText('text input for search')[2], { target: { value: 'noarch' } });
+  fireEvent.change(getAllByLabelText('text input for search')[0], { target: { value: 'elephant' } });
+  fireEvent.change(getAllByLabelText('text input for search')[1], { target: { value: 'noarch' } });
   fireEvent.submit(getByLabelText('add_package_filter_rule'));
 
   await patientlyWaitFor(() => {
@@ -207,7 +234,8 @@ test('Can add package rules to filter in a self-closing modal', async (done) =>
   assertNockRequest(cvFilterDetailsScope);
   assertNockRequest(cvPackageFilterRulesScope);
   assertNockRequest(createscope);
-  assertNockRequest(cvPackageFilterRulesScope, done);
+  assertNockRequest(cvPackageFilterRulesScope);
+  act(done);
 });
 
 test('Remove rpm filter rule in a self-closing modal', async (done) => {
@@ -245,16 +273,20 @@ test('Remove rpm filter rule in a self-closing modal', async (done) => {
   expect(queryByText(cvFilterName)).toBeNull();
   await patientlyWaitFor(() => {
     expect(getByText(cvFilterName)).toBeInTheDocument();
-    expect(getAllByLabelText('Actions')[0]).toBeInTheDocument();
+    expect(getAllByLabelText('Actions')[1]).toBeInTheDocument();
   });
 
-  getAllByLabelText('Actions')[0].click();
+  getAllByLabelText('Actions')[1].click();
 
   await patientlyWaitFor(() => {
     expect(getByText('Remove')).toBeInTheDocument();
   });
 
   getByText('Remove').click();
+  await patientlyWaitFor(() => {
+    expect(getByText(cvFilterName)).toBeInTheDocument();
+    expect(getAllByLabelText('Actions')[1]).toBeInTheDocument();
+  });
 
   assertNockRequest(autocompleteScope);
   assertNockRequest(searchDelayScope);
@@ -263,14 +295,21 @@ test('Remove rpm filter rule in a self-closing modal', async (done) => {
   assertNockRequest(cvFilterDetailsScope);
   assertNockRequest(cvPackageFilterRulesScope);
   assertNockRequest(removeScope);
-  assertNockRequest(cvPackageFilterRulesScope, done);
+  assertNockRequest(cvPackageFilterRulesScope);
+  act(done);
 });
 
 test('Edit rpm filter rule in a self-closing modal', async (done) => {
   const { name: cvFilterName } = cvFilterDetails;
   const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl, true, undefined, 2);
-  const autocompleteNameScope = mockAutocomplete(nockInstance, autocompleteNameUrl);
-  const autocompleteArchScope = mockAutocomplete(nockInstance, autocompleteArchUrl);
+  const autocompleteNameScope = mockAutocomplete(
+    nockInstance, autocompleteNameUrl, true,
+    undefined, 2,
+  );
+  const autocompleteArchScope = mockAutocomplete(
+    nockInstance, autocompleteArchUrl, true,
+    undefined, 2,
+  );
   const searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0, 3);
   const autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', undefined, 3);
   const cvFiltersScope = nockInstance
@@ -284,8 +323,8 @@ test('Edit rpm filter rule in a self-closing modal', async (done) => {
     .query(true)
     .reply(200, cvFilterDetails);
   const cvPackageFilterRulesScope = nockInstance
+    .persist()
     .get(cvPackageFilterRulesPath)
-    .times(2) // One on initial page load and one after rule create
     .query(true)
     .reply(200, cvPackageFilterRules);
 
@@ -306,10 +345,10 @@ test('Edit rpm filter rule in a self-closing modal', async (done) => {
   expect(queryByText(cvFilterName)).toBeNull();
   await patientlyWaitFor(() => {
     expect(getByText(cvFilterName)).toBeInTheDocument();
-    expect(getAllByLabelText('Actions')[0]).toBeInTheDocument();
+    expect(getAllByLabelText('Actions')[1]).toBeInTheDocument();
   });
 
-  getAllByLabelText('Actions')[0].click();
+  getAllByLabelText('Actions')[1].click();
 
   await patientlyWaitFor(() => {
     expect(getByText('Edit')).toBeInTheDocument();
@@ -319,10 +358,10 @@ test('Edit rpm filter rule in a self-closing modal', async (done) => {
 
   await patientlyWaitFor(() => {
     expect(getByText('Edit RPM rule')).toBeInTheDocument();
-    fireEvent.submit(getByLabelText('add_package_filter_rule'));
   });
-
+  fireEvent.submit(getByLabelText('add_package_filter_rule'));
   await patientlyWaitFor(() => {
+    expect(queryByText('Edit RPM rule')).not.toBeInTheDocument();
     expect(getByText(cvFilterName)).toBeInTheDocument();
   });
 
@@ -334,6 +373,55 @@ test('Edit rpm filter rule in a self-closing modal', async (done) => {
   assertNockRequest(cvFiltersScope);
   assertNockRequest(cvFilterDetailsScope);
   assertNockRequest(cvPackageFilterRulesScope);
-  assertNockRequest(editScope, done);
+  assertNockRequest(editScope);
+  act(done);
+});
+
+test('Shows call-to-action when there are no RPM filters', async (done) => {
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const autocompleteNameScope = mockAutocomplete(nockInstance, autocompleteNameUrl);
+  const autocompleteArchScope = mockAutocomplete(nockInstance, autocompleteArchUrl);
+  const searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 0, 3);
+  const autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', undefined, 3);
+  const cvFilterDetailScope = nockInstance
+    .get(cvFilterDetailsPath)
+    .query(true)
+    .reply(200, cvFilterDetails);
+  const cvFiltersScope = nockInstance
+    .get(cvFiltersPath)
+    .query(true)
+    .reply(200, cvFilterFixtures);
+  const cvPackageFilterRulesScope = nockInstance
+    .get(cvPackageFilterRulesPath)
+    .times(1)
+    .query(true)
+    .reply(200, emptyCVPackageFilterRules);
+  const {
+    queryByLabelText, getAllByLabelText, queryByText,
+  } =
+    renderWithRedux(withCVRoute(<ContentViewFilterDetails
+      cvId={1}
+      details={details}
+    />), renderOptions);
+  expect(queryByLabelText('add_rpm_rule_empty_state')).not.toBeInTheDocument();
+  await patientlyWaitFor(() => expect(queryByLabelText('add_rpm_rule_empty_state')).toBeInTheDocument());
+  fireEvent.click(queryByLabelText('add_rpm_rule_empty_state'));
+
+  await patientlyWaitFor(() => {
+    expect(getAllByLabelText('text input for search')[0]).toBeInTheDocument();
+    expect(queryByText('Cancel')).toBeInTheDocument();
+  });
+  fireEvent.click(queryByText('Cancel'));
+  await patientlyWaitFor(() => {
+    expect(queryByLabelText('add-edit-package-modal-cancel')).not.toBeInTheDocument();
+  });
+  assertNockRequest(autocompleteNameScope);
+  assertNockRequest(autocompleteArchScope);
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(searchDelayScope);
+  assertNockRequest(autoSearchScope);
+  assertNockRequest(cvFiltersScope);
+  assertNockRequest(cvFilterDetailScope);
+  assertNockRequest(cvPackageFilterRulesScope);
   act(done);
 });