[ML] functional tests

x-pack/test/functional/apps/machine_learning/data_frame_analytics/cloning.ts

@@ -12,7 +12,7 @@ export default function({ getService }: FtrProviderContext) {
   const esArchiver = getService('esArchiver');
   const ml = getService('ml');
   describe('classification cloning', function() {
-    this.tags(['smoke', 'dima']);
+    this.tags(['smoke']);
 
     const testDataList: Array<{
       suiteTitle: string;
@@ -65,21 +65,65 @@ export default function({ getService }: FtrProviderContext) {
 
     for (const testData of testDataList) {
       describe(`${testData.suiteTitle}`, function() {
+        const cloneJobId = `clone_${testData.job.id}`;
+        const cloneDestIndex = `clone_${testData.job!.dest!.index}`;
+
         before(async () => {
           await ml.navigation.navigateToMl();
           await ml.navigation.navigateToDataFrameAnalytics();
           await ml.dataFrameAnalyticsTable.waitForAnalyticsToLoad();
           await ml.dataFrameAnalyticsTable.filterWithSearchString(testData.job.id as string);
+          await ml.dataFrameAnalyticsTable.cloneJob(testData.job.id as string);
         });
 
         after(async () => {
           await ml.api.deleteIndices(testData.job.dest!.index);
         });
 
         it('should open the flyout with a proper header', async () => {
-          await ml.dataFrameAnalyticsTable.cloneJob(testData.job.id as string);
           expect(await ml.dataFrameAnalyticsCreation.getHeaderText()).to.be(
-            'Clone job from bm_classification_job'
+            `Clone job from ${testData.job.id}`
+          );
+        });
+
+        it('should have correct init form values', async () => {
+          await ml.dataFrameAnalyticsCreation.assertInitialCloneJobForm(
+            testData.job as DataFrameAnalyticsConfig
+          );
+        });
+
+        it('should have disabled Create button on open', async () => {
+          expect(await ml.dataFrameAnalyticsCreation.isCreateButtonDisabled()).to.be(true);
+        });
+
+        it('should enable Create button on a valid form input', async () => {
+          await ml.dataFrameAnalyticsCreation.setJobId(cloneJobId);
+          await ml.dataFrameAnalyticsCreation.setDestIndex(cloneDestIndex);
+          expect(await ml.dataFrameAnalyticsCreation.isCreateButtonDisabled()).to.be(false);
+        });
+
+        it('should create a clone job', async () => {
+          await ml.dataFrameAnalyticsCreation.createAnalyticsJob();
+        });
+
+        it('should start the clone analytics job', async () => {
+          await ml.dataFrameAnalyticsCreation.assertStartButtonExists();
+          await ml.dataFrameAnalyticsCreation.startAnalyticsJob();
+        });
+
+        it('should close the create job flyout', async () => {
+          await ml.dataFrameAnalyticsCreation.assertCloseButtonExists();
+          await ml.dataFrameAnalyticsCreation.closeCreateAnalyticsJobFlyout();
+        });
+
+        it('displays the created job in the analytics table', async () => {
+          await ml.dataFrameAnalyticsTable.refreshAnalyticsTable();
+          await ml.dataFrameAnalyticsTable.filterWithSearchString(cloneJobId);
+          const rows = await ml.dataFrameAnalyticsTable.parseAnalyticsTable();
+          const filteredRows = rows.filter(row => row.id === cloneJobId);
+          expect(filteredRows).to.have.length(
+            1,
+            `Filtered analytics table should have 1 row for job id '${cloneJobId}' (got matching items '${filteredRows}')`
           );
         });
       });

x-pack/test/functional/services/machine_learning/data_frame_analytics_creation.ts

@@ -4,6 +4,14 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 import expect from '@kbn/expect';
+import {
+  DataFrameAnalyticsConfig,
+  getAnalysisType,
+} from '../../../../plugins/ml/public/application/data_frame_analytics/common';
+import {
+  isClassificationAnalysis,
+  isRegressionAnalysis,
+} from '../../../../plugins/ml/public/application/data_frame_analytics/common/analytics';
 
 import { FtrProviderContext } from '../../ftr_provider_context';
 import { MlCommon } from './common';
@@ -114,6 +122,16 @@ export function MachineLearningDataFrameAnalyticsCreationProvider(
       );
     },
 
+    async assertExcludedFieldsSelection(expectedSelection: string[]) {
+      const actualSelection = await comboBox.getComboBoxSelectedOptions(
+        'mlAnalyticsCreateJobFlyoutExcludesSelect > comboBoxInput'
+      );
+      expect(actualSelection).to.eql(
+        expectedSelection,
+        `Excluded fields should be '${expectedSelection}' (got '${actualSelection}')`
+      );
+    },
+
     async selectSourceIndex(sourceIndex: string) {
       await comboBox.set(
         'mlAnalyticsCreateJobFlyoutSourceIndexSelect > comboBoxInput',
@@ -297,6 +315,14 @@ export function MachineLearningDataFrameAnalyticsCreationProvider(
       await testSubjects.missingOrFail('mlAnalyticsCreateJobFlyoutCreateButton');
     },
 
+    async isCreateButtonDisabled() {
+      const attrValue = await testSubjects.getAttribute(
+        'mlAnalyticsCreateJobFlyoutCreateButton',
+        'disabled'
+      );
+      return attrValue === '';
+    },
+
     async createAnalyticsJob() {
       await testSubjects.click('mlAnalyticsCreateJobFlyoutCreateButton');
       await retry.tryForTime(5000, async () => {
@@ -335,5 +361,20 @@ export function MachineLearningDataFrameAnalyticsCreationProvider(
     async getHeaderText() {
       return await testSubjects.getVisibleText('mlDataFrameAnalyticsFlyoutHeaderTitle');
     },
+
+    async assertInitialCloneJobForm(job: DataFrameAnalyticsConfig) {
+      const jobType = getAnalysisType(job.analysis);
+      await this.assertJobTypeSelection(jobType);
+      await this.assertJobIdValue(''); // id should be empty
+      await this.assertJobDescriptionValue(String(job.description));
+      await this.assertSourceIndexSelection(job.source.index as string[]);
+      await this.assertDestIndexValue(''); // destination index should be empty
+      if (isClassificationAnalysis(job.analysis) || isRegressionAnalysis(job.analysis)) {
+        await this.assertDependentVariableSelection([job.analysis[jobType].dependent_variable]);
+        await this.assertTrainingPercentValue(String(job.analysis[jobType].training_percent));
+      }
+      await this.assertExcludedFieldsSelection(job.analyzed_fields.excludes);
+      await this.assertModelMemoryValue(job.model_memory_limit);
+    },
   };
 }