Update tests to cover more failure cases

Author: millerds

test/end-to-end/src/test-helpers.ts

@@ -23,6 +23,54 @@ export function addTestResult(testValues: any[], resultName: string, resultValue
   testValues.push(data);
 }
 
+export function addErrorResult(testValues: any[], errorMessage: string) {
+  testValues.push({
+    resultName: "test-error",
+    resultValue: errorMessage,
+    expectedValue: "no-error",
+  });
+}
+
+export function formatError(err: any): string {
+  if (!err) {
+    return "Unknown error (null/undefined)";
+  }
+
+  const parts: string[] = [];
+
+  if (err.message) {
+    parts.push(`Message: ${err.message}`);
+  } else {
+    parts.push(`${err}`);
+  }
+
+  if (err.code) {
+    parts.push(`Code: ${err.code}`);
+  }
+
+  if (err.debugInfo) {
+    if (err.debugInfo.code) {
+      parts.push(`DebugCode: ${err.debugInfo.code}`);
+    }
+    if (err.debugInfo.message) {
+      parts.push(`DebugMessage: ${err.debugInfo.message}`);
+    }
+    if (err.debugInfo.errorLocation) {
+      parts.push(`Location: ${err.debugInfo.errorLocation}`);
+    }
+    if (err.debugInfo.innerError) {
+      const inner = err.debugInfo.innerError;
+      parts.push(`InnerError: ${inner.code || ""} ${inner.message || JSON.stringify(inner)}`.trim());
+    }
+  }
+
+  if (err.stack) {
+    parts.push(`Stack: ${err.stack}`);
+  }
+
+  return parts.join(" | ");
+}
+
 export async function closeDesktopApplication(): Promise<boolean> {
   const processName: string = "Excel";
 

test/end-to-end/src/test-taskpane.ts

@@ -1,60 +1,66 @@
 import functionsJsonData from "./test-data.json";
 import { pingTestServer, sendTestResults } from "office-addin-test-helpers";
-import { closeWorkbook, sleep } from "./test-helpers";
+import { addErrorResult, closeWorkbook, formatError, sleep } from "./test-helpers";
 
 /* global Office, document, Excel, run, navigator */
 const customFunctionsData = (<any>functionsJsonData).functions;
 const port: number = 4201;
-let testValues = [];
+let testValues: any[] = [];
 
 Office.onReady(async () => {
   document.getElementById("sideload-msg").style.display = "none";
   document.getElementById("app-body").style.display = "flex";
   document.getElementById("run").onclick = run;
   addTestResult("UserAgent", navigator.userAgent);
 
-  const testServerResponse: object = await pingTestServer(port);
-  if (testServerResponse["status"] === 200) {
-    await runCfTests();
-    await sendTestResults(testValues, port);
-    await closeWorkbook();
+  try {
+    const testServerResponse: object = await pingTestServer(port);
+    if (testServerResponse["status"] === 200) {
+      await runCfTests();
+      await sendTestResults(testValues, port);
+      await closeWorkbook();
+    } else {
+      addErrorResult(testValues, `Ping failed: ${JSON.stringify(testServerResponse)}`);
+      await sendTestResults(testValues, port).catch(() => {});
+    }
+  } catch (err) {
+    testValues = [];
+    addErrorResult(testValues, `Initialization failed: ${formatError(err)}`);
+    await sendTestResults(testValues, port).catch(() => {});
   }
 });
 
 async function runCfTests(): Promise<void> {
-  // Exercise custom functions
-  await Excel.run(async (context) => {
-    for (let key in customFunctionsData) {
-      const formula: string = customFunctionsData[key].formula;
-      const range = context.workbook.getSelectedRange();
-      range.formulas = [[formula]];
-      await context.sync();
+  try {
+    await Excel.run(async (context) => {
+      for (let key in customFunctionsData) {
+        const formula: string = customFunctionsData[key].formula;
+        const range = context.workbook.getSelectedRange();
+        range.formulas = [[formula]];
+        await context.sync();
 
-      await sleep(5000);
+        await sleep(5000);
 
-      // Check to if this is a streaming function
-      await readCFData(key, customFunctionsData[key].streaming != undefined ? 2 : 1);
-    }
-  });
+        await readCFData(key, customFunctionsData[key].streaming != undefined ? 2 : 1);
+      }
+    });
+  } catch (err) {
+    testValues = [];
+    addErrorResult(testValues, `runCfTests failed: ${formatError(err)}`);
+    throw err;
+  }
 }
 
 export async function readCFData(cfName: string, readCount: number): Promise<void> {
   await Excel.run(async (context) => {
-    // if this is a streaming function, we want to capture two values so we can
-    // validate the function is indeed streaming
     for (let i = 0; i < readCount; i++) {
-      try {
-        const range = context.workbook.getSelectedRange();
-        range.load("values");
-        await context.sync();
+      const range = context.workbook.getSelectedRange();
+      range.load("values");
+      await context.sync();
 
-        await sleep(5000);
+      await sleep(5000);
 
-        addTestResult(cfName, range.values[0][0]);
-        Promise.resolve();
-      } catch {
-        Promise.reject();
-      }
+      addTestResult(cfName, range.values[0][0]);
     }
   });
 }

test/end-to-end/tests.ts

@@ -14,6 +14,7 @@ const host: string = "excel";
 const manifestPath = path.resolve(`${process.cwd()}/test/end-to-end/test-manifest.xml`);
 const manifestPathDebugging = path.resolve(`${process.cwd()}/test/end-to-end/test-manifest-debugging.xml`);
 const port: number = 4201;
+const testResultsTimeout: number = 120000;
 const testDataFile: string = `${process.cwd()}/test/end-to-end/src/test-data.json`;
 const testJsonData = JSON.parse(fs.readFileSync(testDataFile).toString());
 const testServer = new officeAddinTestServer.TestServer(port);
@@ -43,9 +44,34 @@ describe("Test Excel Custom Functions", function () {
     });
     describe("Get test results for custom functions and validate results", function () {
       it("should get results from the taskpane application", async function () {
-        this.timeout(0);
+        this.timeout(testResultsTimeout + 10000);
+        let timeoutId: ReturnType<typeof setTimeout>;
+        const timeoutPromise = new Promise<never>((_, reject) => {
+          timeoutId = setTimeout(
+            () =>
+              reject(
+                new Error(
+                  `[${host}] Timed out after ${testResultsTimeout / 1000}s waiting for test results. The add-in likely failed to initialize or encountered an unhandled error.`
+                )
+              ),
+            testResultsTimeout
+          );
+        });
+
+        try {
+          testValues = await Promise.race([testServer.getTestResults(), timeoutPromise]);
+        } finally {
+          clearTimeout(timeoutId);
+        }
+
+        const errorResult = testValues.find((value: any) => value.resultName === "test-error");
+        if (errorResult) {
+          assert.fail(`[${host}] Taskpane reported error: ${errorResult.resultValue}`);
+        }
+
         // Expecting six result values + user agent
-        testValues = await testServer.getTestResults();
+        testValues = testValues.filter((value: any) => value.resultName !== "test-error");
+        assert.strictEqual(testValues.length > 0, true, `No test results received from ${host} add-in`);
         console.log(`User Agent: ${testValues[0].Value}`);
         assert.strictEqual(testValues.length, 7);
       });

tsconfig.json

@@ -1,14 +1,15 @@
 {
   "compilerOptions": {
     "allowJs": true,
-    "baseUrl": ".",
     "esModuleInterop": true,
     "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
     "jsx": "react",
     "noEmitOnError": true,
     "outDir": "lib",
     "sourceMap": true,
-    "target": "es5",
+    "strict": true,
+    "target": "es6",
     "lib": [
       "es2015",
       "dom"