1 files changed, 39 insertions, 13 deletions

diff --git a/packages/browser/src/methods/startAuthentication.test.ts b/packages/browser/src/methods/startAuthentication.test.ts
index 4be0ad6..658b67c 100644
--- a/packages/browser/src/methods/startAuthentication.test.ts
+++ b/packages/browser/src/methods/startAuthentication.test.ts
@@ -9,6 +9,7 @@ import { browserSupportsWebauthn } from '../helpers/browserSupportsWebauthn';
 import utf8StringToBuffer from '../helpers/utf8StringToBuffer';
 import bufferToBase64URLString from '../helpers/bufferToBase64URLString';
 import { WebAuthnError } from '../helpers/structs';
+import { generateCustomError } from '../helpers/__jest__/generateCustomError';
 
 import startAuthentication from './startAuthentication';
 
@@ -201,8 +202,27 @@ test('should include extension results when no extensions specified', async () =
   expect(response.clientExtensionResults).toEqual({});
 });
 
+test('should support "cable" transport', async () => {
+  const opts: PublicKeyCredentialRequestOptionsJSON = {
+    ...goodOpts1,
+    allowCredentials: [
+      {
+        ...goodOpts1.allowCredentials![0],
+        transports: ["cable"],
+      },
+    ]
+  };
+
+  await startAuthentication(opts);
+
+  expect(mockNavigatorGet.mock.calls[0][0].publicKey.allowCredentials[0].transports[0])
+    .toEqual("cable");
+});
+
 describe('WebAuthnError', () => {
   describe('AbortError', () => {
+    const AbortError = generateCustomError('AbortError');
+
     /**
      * We can't actually test this because nothing in startAuthentication() propagates the abort
      * signal. But if you invoked WebAuthn via this and then manually sent an abort signal I guess
@@ -211,27 +231,29 @@ describe('WebAuthnError', () => {
      * As a matter of fact I couldn't actually get any browser to respect the abort signal...
      */
     test.skip('should identify abort signal', async () => {
-      mockNavigatorGet.mockRejectedValueOnce(new AbortError());
+      mockNavigatorGet.mockRejectedValueOnce(AbortError);
 
       const rejected = await expect(startAuthentication(goodOpts1)).rejects;
       rejected.toThrow(WebAuthnError);
       rejected.toThrow(/abort signal/i);
-      rejected.toThrow(/AbortError/);
+      rejected.toHaveProperty('name', 'AbortError');
     });
   });
 
   describe('NotAllowedError', () => {
+    const NotAllowedError = generateCustomError('NotAllowedError');
+
     test('should identify unrecognized allowed credentials', async () => {
-      mockNavigatorGet.mockRejectedValueOnce(new NotAllowedError());
+      mockNavigatorGet.mockRejectedValueOnce(NotAllowedError);
 
       const rejected = await expect(startAuthentication(goodOpts1)).rejects;
       rejected.toThrow(WebAuthnError);
       rejected.toThrow(/allowed credentials/i);
-      rejected.toThrow(/NotAllowedError/);
+      rejected.toHaveProperty('name', 'NotAllowedError');
     });
 
     test('should identify cancellation or timeout', async () => {
-      mockNavigatorGet.mockRejectedValueOnce(new NotAllowedError());
+      mockNavigatorGet.mockRejectedValueOnce(NotAllowedError);
 
       const opts = {
         ...goodOpts1,
@@ -242,11 +264,13 @@ describe('WebAuthnError', () => {
       rejected.toThrow(WebAuthnError);
       rejected.toThrow(/cancel/i);
       rejected.toThrow(/timed out/i);
-      rejected.toThrow(/NotAllowedError/);
+      rejected.toHaveProperty('name', 'NotAllowedError');
     });
   });
 
   describe('SecurityError', () => {
+    const SecurityError = generateCustomError('SecurityError');
+
     let _originalHostName: string;
 
     beforeEach(() => {
@@ -260,38 +284,40 @@ describe('WebAuthnError', () => {
     test('should identify invalid domain', async () => {
       window.location.hostname = '1.2.3.4';
 
-      mockNavigatorGet.mockRejectedValueOnce(new SecurityError());
+      mockNavigatorGet.mockRejectedValueOnce(SecurityError);
 
       const rejected = await expect(startAuthentication(goodOpts1)).rejects;
       rejected.toThrowError(WebAuthnError);
       rejected.toThrow(/1\.2\.3\.4/);
       rejected.toThrow(/invalid domain/i);
-      rejected.toThrow(/SecurityError/);
+      rejected.toHaveProperty('name', 'SecurityError');
     });
 
     test('should identify invalid RP ID', async () => {
       window.location.hostname = 'simplewebauthn.com';
 
-      mockNavigatorGet.mockRejectedValueOnce(new SecurityError());
+      mockNavigatorGet.mockRejectedValueOnce(SecurityError);
 
       const rejected = await expect(startAuthentication(goodOpts1)).rejects;
       rejected.toThrowError(WebAuthnError);
       rejected.toThrow(goodOpts1.rpId);
       rejected.toThrow(/invalid for this domain/i);
-      rejected.toThrow(/SecurityError/);
+      rejected.toHaveProperty('name', 'SecurityError');
     });
   });
 
   describe('UnknownError', () => {
+    const UnknownError = generateCustomError('UnknownError');
+
     test('should identify potential authenticator issues', async () => {
-      mockNavigatorGet.mockRejectedValueOnce(new UnknownError());
+      mockNavigatorGet.mockRejectedValueOnce(UnknownError);
 
       const rejected = await expect(startAuthentication(goodOpts1)).rejects;
       rejected.toThrow(WebAuthnError);
       rejected.toThrow(/authenticator/i);
       rejected.toThrow(/unable to process the specified options/i);
-      rejected.toThrow(/could not create a new assertion signature /i);
-      rejected.toThrow(/UnknownError/);
+      rejected.toThrow(/could not create a new assertion signature/i);
+      rejected.toHaveProperty('name', 'UnknownError');
     });
   });
 });