Fix expected failures in tests with timeouts.

diff --git a/test/test.ledger.mjs b/test/test.ledger.mjs
index 34c52ed97397aac90686e09b4c93815c7e85dfb8..c1a2759c6c22ae7aed5a20a5b2d043495f4cd69c 100644 (file)
--- a/test/test.ledger.mjs
+++ b/test/test.ledger.mjs
@@ -56,13 +56,17 @@ await Promise.all([
                        assert.equal(wallet.isLocked, true)
                        assert.equal(Ledger.status, 'BUSY')
 
-                       await new Promise(async (resolve) => {
+                       await new Promise(async (resolve, reject) => {
                                console.log('Waiting 6 seconds...')
                                setTimeout(async () => {
-                                       // should still be locked and busy
-                                       assert.equal(wallet.isLocked, true)
-                                       assert.equal(Ledger.status, 'BUSY')
-                                       resolve(null)
+                                       try {
+                                               // should still be locked and busy
+                                               assert.equal(wallet.isLocked, true)
+                                               assert.equal(Ledger.status, 'BUSY')
+                                               resolve(null)
+                                       } catch (err) {
+                                               reject(err)
+                                       }
                                }, 6000)
                        })
 
@@ -75,13 +79,17 @@ await Promise.all([
                        assert.equal(wallet.isLocked, true)
                        assert.equal(Ledger.status, 'LOCKED')
 
-                       await new Promise(async (resolve) => {
+                       await new Promise(async (resolve, reject) => {
                                console.log('Waiting 6 seconds...')
                                setTimeout(async () => {
-                                       // should still be locked
-                                       assert.equal(wallet.isLocked, true)
-                                       assert.equal(Ledger.status, 'LOCKED')
-                                       resolve(null)
+                                       try {
+                                               // should still be locked
+                                               assert.equal(wallet.isLocked, true)
+                                               assert.equal(Ledger.status, 'LOCKED')
+                                               resolve(null)
+                                       } catch (err) {
+                                               reject(err)
+                                       }
                                }, 6000)
                        })
 
@@ -94,23 +102,31 @@ await Promise.all([
                        assert.equal(wallet.isLocked, false)
                        assert.equal(Ledger.status, 'CONNECTED')
 
-                       await new Promise(async (resolve) => {
+                       await new Promise(async (resolve, reject) => {
                                console.log('Waiting 6 seconds...')
                                setTimeout(async () => {
-                                       // should still be unlocked
-                                       assert.equal(wallet.isLocked, false)
-                                       assert.equal(Ledger.status, 'CONNECTED')
-                                       resolve(null)
+                                       try {
+                                               // should still be unlocked
+                                               assert.equal(wallet.isLocked, false)
+                                               assert.equal(Ledger.status, 'CONNECTED')
+                                               resolve(null)
+                                       } catch (err) {
+                                               reject(err)
+                                       }
                                }, 6000)
                        })
 
-                       await new Promise(async (resolve) => {
+                       await new Promise(async (resolve, reject) => {
                                console.log('Waiting 90 seconds...')
                                setTimeout(async () => {
-                                       // should now be locked
-                                       assert.equal(wallet.isLocked, true)
-                                       assert.equal(Ledger.status, 'LOCKED')
-                                       resolve(null)
+                                       try {
+                                               // should now be locked
+                                               assert.equal(wallet.isLocked, true)
+                                               assert.equal(Ledger.status, 'LOCKED')
+                                               resolve(null)
+                                       } catch (err) {
+                                               reject(err)
+                                       }
                                }, 90000)
                        })
 

diff --git a/test/test.lock-unlock.mjs b/test/test.lock-unlock.mjs
index f87f88f31beea8f9f1d5f99eab9f1fe778197930..db3b6367b5ff96de69a646899ccdeb727583cfb5 100644 (file)
--- a/test/test.lock-unlock.mjs
+++ b/test/test.lock-unlock.mjs
@@ -135,37 +135,49 @@ await Promise.all([
                        assert.ok(await wallet.verify(NANO_TEST_VECTORS.MNEMONIC))\r
                        assert.ok(await wallet.verify(NANO_TEST_VECTORS.BIP39_SEED))\r
 \r
-                       await new Promise(async (resolve) => {\r
+                       await new Promise(async (resolve, reject) => {\r
                                console.log('Waiting 1 minute...')\r
                                setTimeout(async () => {\r
-                                       // should still be unlocked\r
-                                       assert.equal(wallet.isLocked, false)\r
-                                       const account = await wallet.account(0)\r
-                                       assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_0)\r
-                                       resolve(null)\r
+                                       try {\r
+                                               // should still be unlocked\r
+                                               assert.equal(wallet.isLocked, false)\r
+                                               const account = await wallet.account(0)\r
+                                               assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_0)\r
+                                               resolve(null)\r
+                                       } catch (err) {\r
+                                               reject(err)\r
+                                       }\r
                                }, 60000)\r
                        })\r
 \r
-                       await new Promise(async (resolve) => {\r
+                       await new Promise(async (resolve, reject) => {\r
                                console.log('Timer should be reset, waiting 1 minute...')\r
                                setTimeout(async () => {\r
-                                       // should still be unlocked from account() reset and not initial unlock\r
-                                       assert.equal(wallet.isLocked, false)\r
-                                       assert.equal(await wallet.verify(NANO_TEST_VECTORS.MNEMONIC), true)\r
-                                       assert.equal(await wallet.verify(NANO_TEST_VECTORS.BIP39_SEED), true)\r
-                                       resolve(null)\r
+                                       try {\r
+                                               // should still be unlocked from account() reset and not initial unlock\r
+                                               assert.equal(wallet.isLocked, false)\r
+                                               assert.equal(await wallet.verify(NANO_TEST_VECTORS.MNEMONIC), true)\r
+                                               assert.equal(await wallet.verify(NANO_TEST_VECTORS.BIP39_SEED), true)\r
+                                               resolve(null)\r
+                                       } catch (err) {\r
+                                               reject(err)\r
+                                       }\r
                                }, 60000)\r
                        })\r
 \r
-                       await new Promise(async (resolve) => {\r
+                       await new Promise(async (resolve, reject) => {\r
                                console.log('Timer should not be reset by verify, waiting 1 minute...')\r
                                setTimeout(async () => {\r
-                                       // should be locked from account() reset and not reset by verify()\r
-                                       assert.equal(wallet.isLocked, true)\r
-                                       await assert.rejects(wallet.verify(NANO_TEST_VECTORS.MNEMONIC))\r
-                                       await assert.rejects(wallet.verify(NANO_TEST_VECTORS.BIP39_SEED))\r
-                                       await assert.resolves(wallet.destroy())\r
-                                       resolve(null)\r
+                                       try {\r
+                                               // should be locked from account() reset and not reset by verify()\r
+                                               assert.equal(wallet.isLocked, true)\r
+                                               await assert.rejects(wallet.verify(NANO_TEST_VECTORS.MNEMONIC))\r
+                                               await assert.rejects(wallet.verify(NANO_TEST_VECTORS.BIP39_SEED))\r
+                                               await assert.resolves(wallet.destroy())\r
+                                               resolve(null)\r
+                                       } catch (err) {\r
+                                               reject(err)\r
+                                       }\r
                                }, 60000)\r
                        })\r
                })\r
@@ -177,24 +189,32 @@ await Promise.all([
                        assert.equal(wallet.isLocked, false)\r
                        await wallet.config({ timeout: 10 })\r
 \r
-                       await new Promise(async (resolve) => {\r
+                       await new Promise(async (resolve, reject) => {\r
                                console.log('Waiting 6 seconds...')\r
                                setTimeout(async () => {\r
-                                       // should still be unlocked\r
-                                       assert.equal(wallet.isLocked, false)\r
-                                       assert.ok(await wallet.verify(NANO_TEST_VECTORS.MNEMONIC))\r
-                                       resolve(null)\r
+                                       try {\r
+                                               // should still be unlocked\r
+                                               assert.equal(wallet.isLocked, false)\r
+                                               assert.ok(await wallet.verify(NANO_TEST_VECTORS.MNEMONIC))\r
+                                               resolve(null)\r
+                                       } catch (err) {\r
+                                               reject(err)\r
+                                       }\r
                                }, 6000)\r
                        })\r
 \r
-                       await new Promise(async (resolve) => {\r
+                       await new Promise(async (resolve, reject) => {\r
                                console.log('Timer should not be reset by verify, waiting 6 more seconds...')\r
                                setTimeout(async () => {\r
-                                       // should be locked from account() reset and not reset by verify()\r
-                                       assert.equal(wallet.isLocked, true)\r
-                                       await assert.rejects(wallet.verify(NANO_TEST_VECTORS.MNEMONIC))\r
-                                       await assert.resolves(wallet.destroy())\r
-                                       resolve(null)\r
+                                       try {\r
+                                               // should be locked from account() reset and not reset by verify()\r
+                                               assert.equal(wallet.isLocked, true)\r
+                                               await assert.rejects(wallet.verify(NANO_TEST_VECTORS.MNEMONIC))\r
+                                               await assert.resolves(wallet.destroy())\r
+                                               resolve(null)\r
+                                       } catch (err) {\r
+                                               reject(err)\r
+                                       }\r
                                }, 6000)\r
                        })\r
                })\r