adds workflow to go from explain log rate spikes to log pattern analy…

…sis to functional tests

x-pack/plugins/aiops/public/components/spike_analysis_table/table_action_button.tsx

@@ -11,6 +11,7 @@ import { EuiLink, EuiIcon, EuiText, EuiToolTip, type IconType } from '@elastic/e
 
 interface TableActionButtonProps {
   iconType: IconType;
+  dataTestSubjPostfix: string;
   isDisabled: boolean;
   label: string;
   message?: string;
@@ -19,6 +20,7 @@ interface TableActionButtonProps {
 
 export const TableActionButton: FC<TableActionButtonProps> = ({
   iconType,
+  dataTestSubjPostfix,
   isDisabled,
   label,
   message,
@@ -33,7 +35,7 @@ export const TableActionButton: FC<TableActionButtonProps> = ({
 
   const unwrappedButton = !isDisabled ? (
     <EuiLink
-      data-test-subj="aiopsTableActionButtonEnabled"
+      data-test-subj={`aiopsTableActionButton${dataTestSubjPostfix} enabled`}
       onClick={onClick}
       color={'text'}
       aria-label={message}
@@ -42,7 +44,7 @@ export const TableActionButton: FC<TableActionButtonProps> = ({
     </EuiLink>
   ) : (
     <EuiText
-      data-test-subj="aiopsTableActionButtonDisabled"
+      data-test-subj={`aiopsTableActionButton${dataTestSubjPostfix} disabled`}
       size="s"
       color={'subdued'}
       aria-label={message}

x-pack/plugins/aiops/public/components/spike_analysis_table/use_copy_to_clipboard_action.tsx

@@ -47,6 +47,7 @@ export const useCopyToClipboardAction = (): TableItemAction => ({
         <EuiCopy textToCopy={getTableItemAsKQL(tableItem)}>
           {(copy) => (
             <TableActionButton
+              dataTestSubjPostfix="CopyToClipboard"
               iconType="copyClipboard"
               isDisabled={false}
               label={copyToClipboardButtonLabel}

x-pack/plugins/aiops/public/components/spike_analysis_table/use_view_in_discover_action.tsx

@@ -94,6 +94,7 @@ export const useViewInDiscoverAction = (dataViewId?: string): TableItemAction =>
 
       return (
         <TableActionButton
+          dataTestSubjPostfix="Discover"
           iconType="discoverApp"
           isDisabled={discoverUrlError !== undefined}
           label={viewInDiscoverMessage}

x-pack/plugins/aiops/public/components/spike_analysis_table/use_view_in_log_pattern_analysis_action.tsx

@@ -80,6 +80,7 @@ export const useViewInLogPatternAnalysisAction = (dataViewId?: string): TableIte
 
       return (
         <TableActionButton
+          dataTestSubjPostfix="LogPatternAnalysis"
           iconType="logstashQueue"
           isDisabled={isDisabled}
           label={viewInLogPatternAnalysisMessage}

x-pack/test/functional/apps/aiops/explain_log_rate_spikes.ts

@@ -208,6 +208,28 @@ export default function ({ getPageObjects, getService }: FtrProviderContext) {
           );
         }
       }
+
+      if (testData.action !== undefined) {
+        await ml.testExecution.logTestStep('check all table row actions are present');
+        await aiops.explainLogRateSpikesAnalysisGroupsTable.assertRowActions(
+          testData.action.tableRowId
+        );
+
+        await ml.testExecution.logTestStep('click log pattern analysis action');
+        await aiops.explainLogRateSpikesAnalysisGroupsTable.clickRowAction(
+          testData.action.tableRowId,
+          testData.action.type
+        );
+
+        await ml.testExecution.logTestStep('check log pattern analysis page loaded correctly');
+        await aiops.logPatternAnalysisPageProvider.assertLogCategorizationPageExists();
+        await aiops.logPatternAnalysisPageProvider.assertTotalDocumentCount(
+          testData.action.expected.totalDocCount
+        );
+        await aiops.logPatternAnalysisPageProvider.assertQueryInput(
+          testData.action.expected.queryBar
+        );
+      }
     });
   }
 
@@ -242,7 +264,9 @@ export default function ({ getPageObjects, getService }: FtrProviderContext) {
 
         after(async () => {
           await elasticChart.setNewChartUiDebugFlag(false);
-          await ml.testResources.deleteIndexPatternByTitle(testData.sourceIndexOrSavedSearch);
+          if (testData.dataGenerator !== 'kibana_sample_data_logs') {
+            await ml.testResources.deleteIndexPatternByTitle(testData.sourceIndexOrSavedSearch);
+          }
           await aiops.explainLogRateSpikesDataGenerator.removeGeneratedData(testData.dataGenerator);
         });
 

x-pack/test/functional/apps/aiops/test_data.ts

@@ -16,6 +16,15 @@ export const kibanaLogsDataViewTestData: TestData = {
   chartClickCoordinates: [235, 0],
   fieldSelectorSearch: 'referer',
   fieldSelectorApplyAvailable: true,
+  action: {
+    type: 'LogPatternAnalysis',
+    tableRowId: '488337254',
+    expected: {
+      queryBar:
+        'clientip:30.156.16.164 AND host.keyword:elastic-elastic-elastic.org AND ip:30.156.16.163 AND response.keyword:404 AND machine.os.keyword:win xp AND geo.dest:IN AND geo.srcdest:US\\:IN',
+      totalDocCount: '100',
+    },
+  },
   expected: {
     totalDocCountFormatted: '14,074',
     analysisGroupsTable: [

x-pack/test/functional/apps/aiops/types.ts

@@ -7,6 +7,15 @@
 
 import { isPopulatedObject } from '@kbn/ml-is-populated-object';
 
+interface TestDataTableActionLogPatternAnalysis {
+  type: 'LogPatternAnalysis';
+  tableRowId: string;
+  expected: {
+    queryBar: string;
+    totalDocCount: string;
+  };
+}
+
 interface TestDataExpectedWithSampleProbability {
   totalDocCountFormatted: string;
   sampleProbabilityFormatted: string;
@@ -46,5 +55,6 @@ export interface TestData {
   fieldSelectorSearch: string;
   fieldSelectorApplyAvailable: boolean;
   query?: string;
+  action?: TestDataTableActionLogPatternAnalysis;
   expected: TestDataExpectedWithSampleProbability | TestDataExpectedWithoutSampleProbability;
 }

x-pack/test/functional/services/aiops/explain_log_rate_spikes_analysis_groups_table.ts

@@ -5,12 +5,17 @@
  * 2.0.
  */
 
+import expect from '@kbn/expect';
+
 import { FtrProviderContext } from '../../ftr_provider_context';
 
 export function ExplainLogRateSpikesAnalysisGroupsTableProvider({
   getService,
 }: FtrProviderContext) {
+  const find = getService('find');
   const testSubjects = getService('testSubjects');
+  const retry = getService('retry');
+  const browser = getService('browser');
 
   return new (class AnalysisTable {
     public async assertSpikeAnalysisTableExists() {
@@ -55,5 +60,50 @@ export function ExplainLogRateSpikesAnalysisGroupsTableProvider({
 
       return rows;
     }
+
+    public rowSelector(rowId: string, subSelector?: string) {
+      const row = `~aiopsSpikeAnalysisGroupsTable > ~row-${rowId}`;
+      return !subSelector ? row : `${row} > ${subSelector}`;
+    }
+
+    public async ensureActionsMenuOpen(rowId: string) {
+      await retry.tryForTime(30 * 1000, async () => {
+        await this.ensureActionsMenuClosed();
+
+        if (!(await find.existsByCssSelector('.euiContextMenuPanel', 1000))) {
+          await testSubjects.click(this.rowSelector(rowId, 'euiCollapsedItemActionsButton'));
+          expect(await find.existsByCssSelector('.euiContextMenuPanel', 1000)).to.eql(
+            true,
+            'Actions popover should exist'
+          );
+        }
+      });
+    }
+
+    public async ensureActionsMenuClosed() {
+      await retry.tryForTime(30 * 1000, async () => {
+        await browser.pressKeys(browser.keys.ESCAPE);
+        expect(await find.existsByCssSelector('.euiContextMenuPanel', 1000)).to.eql(
+          false,
+          'Actions popover should not exist'
+        );
+      });
+    }
+
+    public async assertRowActions(rowId: string) {
+      await this.ensureActionsMenuOpen(rowId);
+
+      await testSubjects.existOrFail('aiopsTableActionButtonCopyToClipboard enabled');
+      await testSubjects.existOrFail('aiopsTableActionButtonDiscover enabled');
+      await testSubjects.existOrFail('aiopsTableActionButtonLogPatternAnalysis enabled');
+
+      await this.ensureActionsMenuClosed();
+    }
+
+    public async clickRowAction(rowId: string, action: string) {
+      await this.ensureActionsMenuOpen(rowId);
+      await testSubjects.click(`aiopsTableActionButton${action} enabled`);
+      await testSubjects.missingOrFail(`aiopsTableActionButton${action} enabled`);
+    }
   })();
 }

x-pack/test/functional/services/aiops/explain_log_rate_spikes_data_generator.ts

@@ -195,6 +195,10 @@ export function ExplainLogRateSpikesDataGeneratorProvider({ getService }: FtrPro
 
     public async removeGeneratedData(dataGenerator: string) {
       switch (dataGenerator) {
+        case 'kibana_sample_data_logs':
+          // do not remove
+          break;
+
         case 'farequote_with_spike':
           await esArchiver.unload('x-pack/test/functional/es_archives/ml/farequote');
           break;

x-pack/test/functional/services/aiops/index.ts

@@ -11,18 +11,21 @@ import { ExplainLogRateSpikesPageProvider } from './explain_log_rate_spikes_page
 import { ExplainLogRateSpikesAnalysisTableProvider } from './explain_log_rate_spikes_analysis_table';
 import { ExplainLogRateSpikesAnalysisGroupsTableProvider } from './explain_log_rate_spikes_analysis_groups_table';
 import { ExplainLogRateSpikesDataGeneratorProvider } from './explain_log_rate_spikes_data_generator';
+import { LogPatternAnalysisPageProvider } from './log_pattern_analysis_page';
 
 export function AiopsProvider(context: FtrProviderContext) {
   const explainLogRateSpikesPage = ExplainLogRateSpikesPageProvider(context);
   const explainLogRateSpikesAnalysisTable = ExplainLogRateSpikesAnalysisTableProvider(context);
   const explainLogRateSpikesAnalysisGroupsTable =
     ExplainLogRateSpikesAnalysisGroupsTableProvider(context);
   const explainLogRateSpikesDataGenerator = ExplainLogRateSpikesDataGeneratorProvider(context);
+  const logPatternAnalysisPageProvider = LogPatternAnalysisPageProvider(context);
 
   return {
     explainLogRateSpikesPage,
     explainLogRateSpikesAnalysisTable,
     explainLogRateSpikesAnalysisGroupsTable,
     explainLogRateSpikesDataGenerator,
+    logPatternAnalysisPageProvider,
   };
 }

x-pack/test/functional/services/aiops/log_pattern_analysis_page.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import expect from '@kbn/expect';
+
+import type { FtrProviderContext } from '../../ftr_provider_context';
+
+export function LogPatternAnalysisPageProvider({ getService, getPageObject }: FtrProviderContext) {
+  const retry = getService('retry');
+  const testSubjects = getService('testSubjects');
+
+  return {
+    async assertLogCategorizationPageExists() {
+      await retry.tryForTime(30 * 1000, async () => {
+        await testSubjects.existOrFail('aiopsLogCategorizationPage');
+      });
+    },
+
+    async assertQueryInput(expectedQueryString: string) {
+      const aiopsQueryInput = await testSubjects.find('aiopsQueryInput');
+      const actualQueryString = await aiopsQueryInput.getVisibleText();
+      expect(actualQueryString).to.eql(
+        expectedQueryString,
+        `Expected query bar text to be '${expectedQueryString}' (got '${actualQueryString}')`
+      );
+    },
+
+    async assertTotalDocumentCount(expectedFormattedTotalDocCount: string) {
+      await retry.tryForTime(5000, async () => {
+        const docCount = await testSubjects.getVisibleText('aiopsTotalDocCount');
+        expect(docCount).to.eql(
+          expectedFormattedTotalDocCount,
+          `Expected total document count to be '${expectedFormattedTotalDocCount}' (got '${docCount}')`
+        );
+      });
+    },
+  };
+}