[fix] [patch] await for result to be written (#33)

* await for result to be written

* fix build

* simplified

* fix

Author: mmisty

src/plugins/allure-reporter-plugin.ts

@@ -367,7 +367,7 @@ export class AllureReporter {
     });
   }
 
-  async attachVideoToTests(arg: AllureTaskArgs<'attachVideoToTests'>) {
+  async attachVideoToTests(arg: { path: string }) {
     // this happens after test has already finished
     const { path: videoPath } = arg;
     log(`attachVideoToTests: ${videoPath}`);
@@ -718,13 +718,27 @@ export class AllureReporter {
     }
 
     this.applyGroupLabels();
+    const uid = this.currentTest.uuid;
     this.currentTest.endTest();
 
     this.tests.pop();
     this.descriptionHtml = [];
     this.testStatusStored = undefined;
     this.testDetailsStored = undefined;
     this.labels = [];
+
+    const waitResultWritten = (results: string, file: string) => {
+      const started = Date.now();
+
+      while (!(Date.now() - started > 10000 || existsSync(file))) {
+        // do sync
+      }
+
+      if (!existsSync(file)) {
+        console.error(`${packageLog} Result file doesn't exist: ${file}`);
+      }
+    };
+    waitResultWritten(this.allureResults, `${this.allureResults}/${uid}-result.json`);
   }
 
   startStep(arg: AllureTaskArgs<'stepStarted'>) {

src/plugins/allure-types.ts

@@ -53,7 +53,7 @@ type AllureTask = {
   delete: { path: string };
   attachScreenshots: { screenshots: AutoScreen[] };
   screenshotOne: { name: string; forStep?: boolean };
-  attachVideoToTests: { path: string };
+  // attachVideoToTests: { path: string };
   testResult: {
     title: string;
     id: string;

src/plugins/allure.ts

@@ -23,6 +23,58 @@ export type ReporterOptions = {
   isTest: boolean;
 };
 
+const copyResultsToWatchFolder = async (allureResults: string, allureResultsWatch: string) => {
+  if (allureResults === allureResultsWatch) {
+    log(`afterSpec allureResultsWatch the same as allureResults ${allureResults}, will not copy`);
+
+    return;
+  }
+
+  const results = glob.sync(`${allureResults}/*.*`);
+
+  if (!existsSync(allureResultsWatch)) {
+    const mkdirSyncWithTry = (dir: string) => {
+      for (let i = 0; i < 5; i++) {
+        try {
+          mkdirSync(dir);
+
+          return;
+        } catch (err) {
+          // ignore
+        }
+      }
+    };
+    mkdirSyncWithTry(allureResultsWatch);
+  }
+  log(`allureResults: ${allureResults}`);
+  log(`allureResultsWatch: ${allureResultsWatch}`);
+  let doneFiles = 0;
+  const started = Date.now();
+  const timeout = 10000;
+
+  results.forEach(res => {
+    const to = `${allureResultsWatch}/${basename(res)}`;
+    log(`copy file ${res} to ${to}`);
+    copyFile(res, to, err => {
+      if (err) {
+        log(err);
+      }
+      rm(res, () => {
+        // ignore
+      });
+      doneFiles = doneFiles + 1;
+    });
+  });
+
+  while (doneFiles < results.length) {
+    if (Date.now() - started >= timeout) {
+      console.error(`${packageLog} Could not write all attachments in ${timeout}ms`);
+      break;
+    }
+    await delay(100);
+  }
+};
+
 export const allureTasks = (opts: ReporterOptions): AllureTasks => {
   // todo config
   let allureReporter = new AllureReporter(opts);
@@ -301,6 +353,7 @@ export const allureTasks = (opts: ReporterOptions): AllureTasks => {
       allureReporter.screenshotOne(arg);
       log('screenshotOne');
     },
+
     // add all screenshots
     attachScreenshots: (arg: AllureTaskArgs<'attachScreenshots'>) => {
       log(`attachScreenshots ${JSON.stringify(arg)}`);
@@ -310,74 +363,25 @@ export const allureTasks = (opts: ReporterOptions): AllureTasks => {
       log('attachScreenshots');
     },
 
-    attachVideoToTests: async (arg: AllureTaskArgs<'attachVideoToTests'>) => {
+    /* attachVideoToTests: async (arg: AllureTaskArgs<'attachVideoToTests'>) => {
       log(`attachScreenshots ${JSON.stringify(arg)}`);
       await allureReporter.attachVideoToTests(arg);
       log('attachVideoToTests');
-    },
+    },*/
 
     async afterSpec(arg: AllureTaskArgs<'afterSpec'>) {
       log(`afterSpec ${JSON.stringify(arg)}`);
 
       if (arg.results && arg.results?.video) {
-        const { video } = arg.results;
+        const { video } = arg.results ?? {};
         log(`afterSpec video path: ${video}`);
 
         await allureReporter.attachVideoToTests({ path: video ?? '' });
       } else {
         console.error(`${packageLog} No video path in afterSpec result`);
       }
 
-      if (allureResults === allureResultsWatch) {
-        log(`afterSpec allureResultsWatch the same as allureResults ${allureResults}, will not copy`);
-
-        return;
-      }
-
-      const results = glob.sync(`${allureResults}/*.*`);
-
-      if (!existsSync(allureResultsWatch)) {
-        const mkdirSyncWithTry = (dir: string) => {
-          for (let i = 0; i < 5; i++) {
-            try {
-              mkdirSync(dir);
-
-              return;
-            } catch (err) {
-              // ignore
-            }
-          }
-        };
-        mkdirSyncWithTry(allureResultsWatch);
-      }
-      log(`allureResults: ${allureResults}`);
-      log(`allureResultsWatch: ${allureResultsWatch}`);
-      let doneFiles = 0;
-      const started = Date.now();
-      const timeout = 10000;
-
-      results.forEach(res => {
-        const to = `${allureResultsWatch}/${basename(res)}`;
-        log(`copy file ${res} to ${to}`);
-        copyFile(res, to, err => {
-          if (err) {
-            log(err);
-          }
-          rm(res, () => {
-            // ignore
-          });
-          doneFiles = doneFiles + 1;
-        });
-      });
-
-      while (doneFiles < results.length) {
-        if (Date.now() - started >= timeout) {
-          console.error(`${packageLog} Could not write all attachments in ${timeout}ms`);
-          break;
-        }
-        await delay(100);
-      }
-
+      await copyResultsToWatchFolder(allureResults, allureResultsWatch);
       log('afterSpec');
     },
 

tests/cy-helper/utils.ts

@@ -255,8 +255,6 @@ export const createResTest2 = (
       err = e as Error;
     }
 
-    await delay(2000);
-
     expect(err).toBeUndefined();
   });