Manual speed up test cases loading, coloring by test case result

Author: veghdev

test/integration/modules/integration-test/test-case/test-case-result.js

@@ -82,6 +82,7 @@ class TestCaseResult {
     this.#testCaseObj.testSuiteResults.PASSED.push(
       this.#testCaseObj.testCase.testName
     );
+    this.#cnsl.writePassedLog(" " + this.#getFormattedTestName());
     this.#cnsl.log(
       ("[ " + "PASSED".padEnd(this.#cnsl.getTestStatusPad(), " ") + " ] ")
         .success +
@@ -180,6 +181,7 @@ class TestCaseResult {
     this.#testCaseObj.testSuiteResults.WARNING.push(
       this.#testCaseObj.testCase.testName
     );
+    this.#cnsl.writeWarningsLog(" " + this.#getFormattedTestName());
     this.#createTestCaseResultManual();
     this.#cnsl.log(
       (
@@ -215,6 +217,7 @@ class TestCaseResult {
     this.#testCaseObj.testSuiteResults.FAILED.push(
       this.#testCaseObj.testCase.testName
     );
+    this.#cnsl.writeFailedLog(" " + this.#getFormattedTestName());
     this.#createTestCaseResultManual();
     this.#createTestCaseResultErrorMsg();
     if (failureMsgs) {
@@ -228,6 +231,7 @@ class TestCaseResult {
     this.#testCaseObj.testSuiteResults.FAILED.push(
       this.#testCaseObj.testCase.testName
     );
+    this.#cnsl.writeFailedLog(" " + this.#getFormattedTestName());
     this.#createTestCaseResultManual();
     this.#createTestCaseResultErrorMsg();
   }
@@ -273,12 +277,9 @@ class TestCaseResult {
 
   #createTestCaseResultManual() {
     this.#testCaseObj.testSuiteResults.MANUAL.push(this.#testCaseObj.testCase);
-    let formatted = path.relative(
-      TestEnv.getTestSuitePath(),
-      path.join(TestEnv.getWorkspacePath(), this.#testCaseObj.testCase.testName)
-    );
+    let formatted = this.#getFormattedTestName()
     this.#testCaseObj.testSuiteResults.MANUAL_FORMATTED.push(formatted);
-    this.#cnsl.writeFailure(" " + formatted);
+    this.#cnsl.writeFailuresLog(" " + formatted);
   }
 
   #deleteTestCaseResult() {
@@ -302,6 +303,13 @@ class TestCaseResult {
     });
   }
 
+  #getFormattedTestName() {
+    return path.relative(
+      TestEnv.getTestSuitePath(),
+      path.join(TestEnv.getWorkspacePath(), this.#testCaseObj.testCase.testName)
+    );
+  }
+
   #createImage(data, fileAdd) {
     return new Promise((resolve, reject) => {
       let testCaseResultPath = path.join(

test/integration/modules/integration-test/test-console.js

@@ -5,9 +5,12 @@ const TestEnv = require("../../modules/integration-test/test-env.js");
 const Console = require("../../modules/console/console.js");
 
 class TestConsole extends Console {
+  #fileLog;
+
   #testSuiteLogPath;
-  #testSuiteFailuresPath;
-  #testSuiteFailuresPathReady;
+
+  #resultTypes = ['passed', 'warnings', 'failed', 'failures'];
+  #testResultsLogsReady;
 
   #testStatusPad = 8;
   #testNumberPad = 0;
@@ -20,15 +23,11 @@ class TestConsole extends Console {
         TestEnv.getTestSuiteReportPath(),
         pathPrefix
       );
-      var testSuiteFailuresPath = path.join(
-        TestEnv.getTestSuiteReportPath(),
-        "failures.log"
-      );
     }
     super(filePrefix, testSuiteLogPath);
+    this.#fileLog = fileLog;
     this.#testSuiteLogPath = testSuiteLogPath;
-    this.#testSuiteFailuresPath = testSuiteFailuresPath;
-    this.#testSuiteFailuresPathReady = this.#createFailuresLog();
+    this.#testResultsLogsReady = this.#createResultsLogs();
   }
 
   getTestSuiteLogPath() {
@@ -59,15 +58,27 @@ class TestConsole extends Console {
     this.#testNumberPad = testNumberPad;
   }
 
-  #createFailuresLog() {
+  #createResultsLogs() {
+    let resultsReadies = [];
+    this.#resultTypes.forEach(resultType => {
+      let logPath = path.join(
+        TestEnv.getTestSuiteReportPath(),
+        resultType + '.log'
+      );
+      resultsReadies.push(this.#createResultLog(logPath));
+    });
+    return Promise.all(resultsReadies);
+  }
+
+  #createResultLog(logPath) {
     return new Promise((resolve, reject) => {
-      if (this.#testSuiteFailuresPath) {
-        fs.mkdir(path.dirname(this.#testSuiteFailuresPath), { recursive: true }, (err) => {
+      if (this.#fileLog) {
+        fs.mkdir(path.dirname(logPath), { recursive: true }, (err) => {
           if (err) {
             console.error('Failed to create directory:', err);
             reject(err);
           } else {
-            fs.writeFile(this.#testSuiteFailuresPath, '', { flag: 'w' }, (err) => {
+            fs.writeFile(logPath, '', { flag: 'w' }, (err) => {
               if (err) {
                 console.error('Failed to write file:', err);
                 reject(err);
@@ -83,11 +94,11 @@ class TestConsole extends Console {
     });
   }
 
-  writeFailure(line) {
-    if (this.#testSuiteFailuresPath) {
-      this.#testSuiteFailuresPathReady.then(() => {
+  #writeResultLog(logPath, line) {
+    if (this.#fileLog) {
+      this.#testResultsLogsReady.then(() => {
         return new Promise((resolve, reject) => {
-          fs.writeFile(this.#testSuiteFailuresPath, line, { flag: 'a' }, (err) => {
+          fs.writeFile(logPath, line, { flag: 'a' }, (err) => {
             if (err) {
               console.error('Failed to write file:', err);
               reject(err);
@@ -99,6 +110,38 @@ class TestConsole extends Console {
       });
     }
   }
+
+  writePassedLog(line) {
+    let logPath = path.join(
+      TestEnv.getTestSuiteReportPath(),
+      'passed.log'
+    );
+    return this.#writeResultLog(logPath, line);
+  }
+
+  writeWarningsLog(line) {
+    let logPath = path.join(
+      TestEnv.getTestSuiteReportPath(),
+      'warnings.log'
+    );
+    return this.#writeResultLog(logPath, line);
+  }
+
+  writeFailedLog(line) {
+    let logPath = path.join(
+      TestEnv.getTestSuiteReportPath(),
+      'failed.log'
+    );
+    return this.#writeResultLog(logPath, line);
+  }
+
+  writeFailuresLog(line) {
+    let logPath = path.join(
+      TestEnv.getTestSuiteReportPath(),
+      'failures.log'
+    );
+    return this.#writeResultLog(logPath, line);
+  }
 }
 
 module.exports = TestConsole;

test/integration/modules/manual/client/index.js

@@ -133,8 +133,8 @@ function populateLibs() {
     .then((data) => {
       for (let name in data) {
         let url = data[name];
-        vizzuUrl.innerHTML += `<option value='${url}'>${name}</option>`;
-        vizzuRef.innerHTML += `<option value='${url}'>${name}</option>`;
+        vizzuUrl.appendChild(getVizzuOption(url, name));
+        vizzuRef.appendChild(getVizzuOption(url, name));
       }
       let lastSelected = localStorage.getItem("vizzuUrl");
       if (urlVizzuUrl) {
@@ -158,6 +158,14 @@ function populateLibs() {
     });
 }
 
+function getVizzuOption(url, name) {
+  const option = document.createElement('option');
+  option.value = url;
+  const text = document.createTextNode(name);
+  option.appendChild(text);
+  return option
+}
+
 function populateCases() {
   fetch("/getTestList")
     .then((response) => response.json())
@@ -167,13 +175,14 @@ function populateCases() {
         let actcase = JSON.stringify(data[i]);
         if (
           data[i].testFile === urlTestFile &&
-          data[i].testIndex == urlTestIndex
+          data[i].testIndex === urlTestIndex
         ) {
           lastSelected = actcase;
         }
         let actcaseName = data[i].testName;
+        let actcaseResult = data[i].testResult;
         let selected = i == 0 ? 'selected="selected"' : "";
-        testCase.innerHTML += `<option ${selected} value='${actcase}'>${actcaseName}</option>`;
+        testCase.appendChild(getTestCaseOption(actcase, actcaseName, actcaseResult, selected));
       }
       if (lastSelected === "") lastSelected = JSON.stringify(data[0]);
       testCase.value = lastSelected;
@@ -183,4 +192,27 @@ function populateCases() {
     });
 }
 
+function getTestCaseOption(testCase, testCaseName, testCaseResult, selected) {
+  const option = document.createElement('option');
+  option.setAttribute('style', getTestCaseStyle(testCaseResult));
+  option.value = testCase;
+  option.selected = selected;
+  let textValue = testCaseName;
+  if (testCaseResult) textValue = `${testCaseName} | ${testCaseResult}`;
+  const text = document.createTextNode(textValue);
+  option.appendChild(text);
+  return option;
+}
+
+function getTestCaseStyle(testCaseResult) {
+  if (testCaseResult === "PASS") {
+    return "background-color: rgba(152, 251, 152, 0.8) !important;";
+  } else if (testCaseResult === "FAIL") {
+    return "background-color: rgba(255, 153, 153, 0.8) !important;";
+  } else if (testCaseResult === "WARN") {
+    return "background-color: rgba(255, 255, 153, 0.8) !important;";
+  }
+  return ";"
+}
+
 populateLibs();

test/integration/modules/manual/manual.js

@@ -1,4 +1,6 @@
 const fetch = require("node-fetch");
+const fs = require("fs");
+const path = require("path");
 
 const WorkspaceHost = require("../../modules/workspace/workspace-host.js");
 const VizzuUrl = require("../../modules/vizzu/vizzu-url.js");
@@ -127,13 +129,83 @@ class Manual {
       let testCasesConfigReady = TestCasesConfig.getConfig(
         this.#configPathList
       );
-      TestCases.getTestCases(testCasesConfigReady, this.#filters).then(
-        (testCases) => {
+      let testResultsReady = this.#getTestResults();
+      let testCasesReady = TestCases.getTestCases(testCasesConfigReady, this.#filters);
+      Promise.all([testCasesReady, testResultsReady]).then(
+        (results) => {
+          let testCases = results[0];
+          let testResults = results[1];
+          testCases.filteredTestCases.forEach(testCase => {
+            testCase.testResult = this.#getTestCaseResult(testCase.testName, testResults);
+          });
           res.send(testCases.filteredTestCases);
         }
       );
     });
   }
+
+  #getTestCaseResult(testName, testResults) {
+    let passed = testResults[0];
+    let warnings = testResults[1];
+    let failed = testResults[2];
+    if (passed.includes(testName)) {
+      return "PASS";
+    } else if (warnings.includes(testName)) {
+      return "WARN"
+    } else if (failed.includes(testName)) {
+      return "FAIL";
+    }
+  }
+
+  #getTestResults() {
+    return Promise.all([
+      this.#getPassed(),
+      this.#getWarnings(),
+      this.#getFailed(),
+    ]);
+  }
+
+  #getPassed() {
+    let logPath = path.join(
+      TestEnv.getTestSuiteReportPath(),
+      'passed.log'
+    );
+    return this.#getTestResult(logPath);
+  }
+
+  #getWarnings() {
+    let logPath = path.join(
+      TestEnv.getTestSuiteReportPath(),
+      'warnings.log'
+    );
+    return this.#getTestResult(logPath);
+  }
+
+  #getFailed() {
+    let logPath = path.join(
+      TestEnv.getTestSuiteReportPath(),
+      'failed.log'
+    );
+    return this.#getTestResult(logPath);
+  }
+
+  #getTestResult(logPath) {
+    return new Promise((resolve, reject) => {
+      fs.readFile(logPath, 'utf8', (err, data) => {
+        if (err) {
+          resolve([]);
+        } else {
+          const prefix = "/test/integration/";
+          let tests = data
+                        .trim()
+                        .split(' ')
+                        .filter((test) => test !== '')
+                        .map((test) => prefix + test);
+          resolve(tests);
+        }
+      });
+    });
+  }
 }
 
 module.exports = Manual;