[Reporting][Serverless E2E Tests]

x-pack/plugins/reporting/public/management/__test__/report_listing.test.helpers.tsx

@@ -166,7 +166,7 @@ export const setup = async (props?: Partial<Props>) => {
       flyout: {
         open: async (jobId: string) => {
           await act(async () => {
-            find(`viewReportingLink${jobId}`).simulate('click');
+            find(`viewReportingLink-${jobId}`).simulate('click');
           });
           component.update();
         },

x-pack/plugins/reporting/public/management/report_listing.tsx

@@ -326,7 +326,7 @@ class ReportListingUi extends Component<Props, State> {
           return (
             <div data-test-subj="reportingListItemObjectTitle">
               <EuiLink
-                data-test-subj={`viewReportingLink${job.id}`}
+                data-test-subj={`viewReportingLink-${job.id}`}
                 onClick={() => this.setState({ selectedJob: job })}
               >
                 {objectTitle ||

x-pack/test_serverless/api_integration/services/index.ts

@@ -11,6 +11,7 @@ import { services as xpackApiIntegrationServices } from '../../../test/api_integ
 import { services as svlSharedServices } from '../../shared/services';
 
 import { SvlCommonApiServiceProvider } from './svl_common_api';
+import { SvlReportingServiceProvider } from './svl_reporting';
 import { AlertingApiProvider } from './alerting_api';
 import { SamlToolsProvider } from './saml_tools';
 import { DataViewApiProvider } from './data_view_api';
@@ -20,6 +21,7 @@ export const services = {
   ...svlSharedServices,
 
   svlCommonApi: SvlCommonApiServiceProvider,
+  svlReportingAPI: SvlReportingServiceProvider,
   alertingApi: AlertingApiProvider,
   samlTools: SamlToolsProvider,
   dataViewApi: DataViewApiProvider,

x-pack/test_serverless/api_integration/services/svl_reporting.ts

@@ -0,0 +1,182 @@
+/*
+ * 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 { X_ELASTIC_INTERNAL_ORIGIN_REQUEST } from '@kbn/core-http-common';
+import { INTERNAL_ROUTES } from '@kbn/reporting-plugin/common/constants';
+import expect from '@kbn/expect';
+import type { ReportingJobResponse } from '@kbn/reporting-plugin/server/types';
+import rison from '@kbn/rison';
+import { FtrProviderContext } from '../ftr_provider_context';
+
+const API_HEADER: [string, string] = ['kbn-xsrf', 'reporting'];
+const INTERNAL_HEADER: [string, string] = [X_ELASTIC_INTERNAL_ORIGIN_REQUEST, 'Kibana'];
+
+const DATA_ANALYST_PASSWORD = 'data_analyst-password';
+const DATA_ANALYST_ROLE = 'data_analyst_role';
+const DATA_ANALYST_USERNAME = 'data_analyst';
+const REPORTING_ROLE = 'reporting_user_role';
+const REPORTING_USER_PASSWORD = 'reporting_user-password';
+const REPORTING_USER_USERNAME = 'reporting_user';
+
+/**
+ * Services to create roles and users for security testing
+ */
+export function SvlReportingServiceProvider({ getService }: FtrProviderContext) {
+  const security = getService('security');
+  const log = getService('log');
+  const supertest = getService('supertestWithoutAuth');
+  const retry = getService('retry');
+  const config = getService('config');
+
+  return {
+    DATA_ANALYST_PASSWORD,
+    DATA_ANALYST_USERNAME,
+    REPORTING_USER_PASSWORD,
+    REPORTING_USER_USERNAME,
+
+    /**
+     * Define a role that DOES NOT grant privileges to create any type of report.
+     */
+    async createDataAnalystRole() {
+      await security.role.create(DATA_ANALYST_ROLE, {
+        metadata: {},
+        elasticsearch: {
+          cluster: [],
+          indices: [
+            {
+              names: ['ecommerce'],
+              privileges: ['read', 'view_index_metadata'],
+              allow_restricted_indices: false,
+            },
+          ],
+          run_as: [],
+        },
+        kibana: [
+          {
+            base: ['read'],
+            feature: {},
+            spaces: ['*'],
+          },
+        ],
+      });
+    },
+
+    async createDataAnalystUser() {
+      await security.user.create(DATA_ANALYST_USERNAME, {
+        password: DATA_ANALYST_PASSWORD,
+        roles: [DATA_ANALYST_ROLE],
+        full_name: 'Data Analyst User',
+      });
+    },
+
+    /**
+     * Define a role that DOES grant privileges to create certain types of reports.
+     */
+    async createReportingRole() {
+      await security.role.create(REPORTING_ROLE, {
+        metadata: {},
+        elasticsearch: {
+          cluster: [],
+          indices: [
+            {
+              names: ['ecommerce'],
+              privileges: ['read', 'view_index_metadata'],
+              allow_restricted_indices: false,
+            },
+          ],
+          run_as: [],
+        },
+        kibana: [
+          {
+            base: [],
+            feature: { discover: ['minimal_read', 'generate_report'] },
+            spaces: ['*'],
+          },
+        ],
+      });
+    },
+
+    async createReportingUser(
+      username = REPORTING_USER_USERNAME,
+      password = REPORTING_USER_PASSWORD
+    ) {
+      await security.user.create(username, {
+        password,
+        roles: [REPORTING_ROLE],
+        full_name: 'Reporting User',
+      });
+    },
+
+    /**
+     * Use the internal API to create any kind of report job
+     */
+    async createReportJobInternal(
+      jobType: string,
+      job: object,
+      username: string,
+      password: string
+    ) {
+      const requestPath = `${INTERNAL_ROUTES.GENERATE_PREFIX}/${jobType}`;
+      log.debug(`POST request to ${requestPath}`);
+
+      const { status, body } = await supertest
+        .post(requestPath)
+        .auth(username, password)
+        .set(...API_HEADER)
+        .set(...INTERNAL_HEADER)
+        .send({ jobParams: rison.encode(job) });
+
+      expect(status).to.be(200);
+
+      return {
+        job: (body as ReportingJobResponse).job,
+        path: (body as ReportingJobResponse).path,
+      };
+    },
+
+    async waitForJobToFinish(
+      downloadReportPath: string,
+      username: string,
+      password: string,
+      options?: { timeout?: number }
+    ) {
+      await retry.waitForWithTimeout(
+        `job ${downloadReportPath} finished`,
+        options?.timeout ?? config.get('timeouts.kibanaReportCompletion'),
+        async () => {
+          const response = await supertest
+            .get(`${downloadReportPath}?elasticInternalOrigin=true`)
+            .auth(username, password)
+            .responseType('blob')
+            .set(...API_HEADER)
+            .set(...INTERNAL_HEADER);
+
+          if (response.status === 503) {
+            log.debug(`Report at path ${downloadReportPath} is pending`);
+            return false;
+          }
+
+          log.debug(`Report at path ${downloadReportPath} returned code ${response.status}`);
+
+          if (response.status === 200) {
+            log.debug(`Report at path ${downloadReportPath} is complete`);
+            return true;
+          }
+
+          throw new Error(`unexpected status code ${response.status}`);
+        }
+      );
+    },
+
+    async getCompletedJobOutput(downloadReportPath: string, username: string, password: string) {
+      const response = await supertest
+        .get(`${downloadReportPath}?elasticInternalOrigin=true`)
+        .auth(username, password);
+      return response.text as unknown;
+    },
+  };
+}

x-pack/test_serverless/api_integration/test_suites/common/index.ts

@@ -28,5 +28,6 @@ export default function ({ loadTestFile }: FtrProviderContext) {
     loadTestFile(require.resolve('./index_management'));
     loadTestFile(require.resolve('./alerting'));
     loadTestFile(require.resolve('./ingest_pipelines'));
+    loadTestFile(require.resolve('./reporting'));
   });
 }