test: add testing for new util

Author: Hweinstock

packages/core/src/shared/clients/clientWrapper.ts

@@ -40,8 +40,7 @@ export abstract class ClientWrapper<C extends AwsClient> implements vscode.Dispo
         const makeRequest = withPerfLogOnFail(
             'API Request',
             () => this.getClient().send(new command(commandOptions)),
-            truncateProps(commandOptions, 20, ['nextToken']),
-            mapNameToCode
+            truncateProps(commandOptions, 20, ['nextToken'])
         )
 
         return makeRequest()
@@ -74,7 +73,3 @@ export abstract class ClientWrapper<C extends AwsClient> implements vscode.Dispo
         this.client?.destroy()
     }
 }
-
-function mapNameToCode<E extends Error>(e: E): E & { code: string } {
-    return { ...e, message: e.message, name: e.name, stack: e.stack, code: e.message }
-}

packages/core/src/shared/logger/perfLogger.ts

@@ -31,34 +31,49 @@ export class PerfLog {
 
 /**
  * Call a function f and if it fails, log the error with performance information included.
- * @param action label of action in the error log.
+ * @param action label of action to include in the error log.
  * @param f action to attempt.
- * @param params params that were passed to f.
- * @param errMap optional mapping to apply to error to potentially add information.
+ * @param params params that were passed to f. Defaults to empty.
+ * @param getCode optional mapping to extract code from error. Defaults to name of error.
  * @returns result of f
  */
-export function withPerfLogOnFail<Result, E extends Error = never>(
+export function withPerfLogOnFail<Result>(
+    action: string,
+    f: () => Result,
+    params?: object,
+    getCode?: (e: Error) => string
+): () => Result
+export function withPerfLogOnFail<Result>(
+    action: string,
+    f: () => Promise<Result>,
+    params?: object,
+    getCode?: (e: Error) => string
+): () => Promise<Result>
+export function withPerfLogOnFail<Result>(
     action: string,
     f: () => Result | Promise<Result>,
-    params: object = {},
-    errMap?: (e: Error) => E
+    params?: object,
+    getCode?: (e: Error) => string
 ) {
-    return async function () {
+    return function () {
         const perflog = new PerfLog(action)
         try {
-            return await f()
+            return f()
         } catch (e) {
             if (e instanceof Error) {
-                const errWithoutStack = errMap ? errMap(e) : { ...e }
+                const errWithoutStack = { ...e, name: e.name, message: e.message }
                 delete errWithoutStack['stack']
                 const timecost = perflog.elapsed().toFixed(1)
                 getLogger().error(
                     `${action} failed (time: %dms) \nparams: %O\nerror: %O`,
                     timecost,
-                    params,
+                    params ?? {},
                     errWithoutStack
                 )
-                throw new ToolkitError(`${action}: ${e.message}`, { code: e.message, cause: e })
+                throw new ToolkitError(`${action}: ${errWithoutStack.message}`, {
+                    code: getCode ? getCode(errWithoutStack) : errWithoutStack.name,
+                    cause: errWithoutStack,
+                })
             }
             throw e
         }

packages/core/src/test/shared/logger/perflog.test.ts

@@ -0,0 +1,50 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'assert'
+import { withPerfLogOnFail } from '../../../shared/logger/perfLogger'
+import { assertLogsContain } from '../../globalSetup.test'
+import { ToolkitError } from '../../../shared'
+
+describe('withPerfLogOnFail', function () {
+    it('only logs when function throws an error', function () {
+        const happyFunction = withPerfLogOnFail('happyFunction', () => 5)
+        const errorFunction = withPerfLogOnFail('errorFunction', () => {
+            throw new Error('error')
+        })
+        assert.ok(happyFunction() === 5)
+        assert.throws(() => assertLogsContain('happyFunction', false, 'error'))
+
+        assert.throws(() => errorFunction())
+        assertLogsContain('errorFunction', false, 'error')
+    })
+
+    it('wraps underlying error in a ToolkitError', function () {
+        const errorFunction = withPerfLogOnFail('errorFunction', () => {
+            throw new Error('error')
+        })
+        assert.throws(() => errorFunction(), ToolkitError)
+    })
+
+    it('accepts custom error code mappings', function () {
+        const errorFunction = withPerfLogOnFail(
+            'errorFunction',
+            () => {
+                throw new Error('error')
+            },
+            {},
+            (e) => e.message.slice(0, 3)
+        )
+        try {
+            errorFunction()
+            assert.fail('should have thrown')
+        } catch (e) {
+            if (!(e instanceof ToolkitError)) {
+                assert.fail('should have thrown a ToolkitError')
+            }
+            assert.equal(e.code, 'err')
+        }
+    })
+})