[botbuilder-core] TestAdapter unhandled promises

Description

TestAdapter throws unhalded promise rejections on errors

- The testadapter should handle errors
- For that, TestFlow must implement the thenable implementation correctly

Specific Changes

  - Implemented further the tenable on TestFlow to allow handling catch clauses correctly

Testing

A test is added to verify the behavior change (If you run that test on main before this PR is merged, it fails)

libraries/botbuilder-core/src/testAdapter.ts

@@ -978,8 +978,17 @@ export class TestFlow {
      * Adds a `then()` step to the tests promise chain.
      * @param onFulfilled Code to run if the test is currently passing.
      */
-    public then(onFulfilled?: () => void): TestFlow {
-        return new TestFlow(this.previous.then(onFulfilled), this.adapter, this.callback);
+    public then(onFulfilled?: () => void, onRejected?: (err) => void): TestFlow {
+        return new TestFlow(this.previous.then(onFulfilled, onRejected), this.adapter, this.callback);
+    }
+
+    /**
+     * Adds a finally clause. Note that you can't keep chaining afterwards.
+     * @param onFinally 
+     * @returns 
+     */
+    public finally(onFinally: () => void): Promise<void> {
+        return Promise.resolve(this.previous.finally(onFinally));
     }
 
     /**

libraries/botbuilder-core/tests/testAdapter.test.js

@@ -25,6 +25,41 @@ describe(`TestAdapter`, function () {
         await adapter.receiveActivity('test');
     });
 
+    it(`should reject on unhandled error.`, async function () {
+        const adapter = new TestAdapter((context) => {
+            throw new Error('Intentional Error');
+        });
+        await assert.rejects(async () => {
+            await adapter.send('Message');
+        })
+    });
+
+    it(`should call finally when no error happens`, async function () {
+        const adapter = new TestAdapter(async (context) => undefined);
+        let runFinally = false;
+
+        await adapter.send('Message').finally(() => {
+            runFinally = true
+        })
+        assert(runFinally, "Finally was not called");
+
+    });    
+
+    it(`should call finally when an error happens`, async function () {
+        const adapter = new TestAdapter((context) => {
+            throw new Error('Intentional Error');
+        });
+        let runFinally = false;
+
+        await assert.rejects(async () => {
+            await adapter.send('Message')
+                .finally(() => {
+                    runFinally = true
+                })
+        });
+        assert(runFinally, "Finally was not called");
+    });
+
     it(`should support receiveActivity() called with an Activity.`, async function () {
         const adapter = new TestAdapter((context) => {
             assert(context.activity.type === ActivityTypes.Message, `wrong type.`);