chore: replace node:assert

Signed-off-by: Timo Glastra <timo@animo.id>

Author: TimoGlastra

packages/askar-nodejs/tests/cryptoBox.test.ts

@@ -1,6 +1,5 @@
-import { deepStrictEqual } from 'node:assert'
 import { CryptoBox, Key, KeyAlgorithm } from '@openwallet-foundation/askar-shared'
-import { describe, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
 
 describe('CryptoBox', () => {
   test('seal', () => {
@@ -14,7 +13,7 @@ describe('CryptoBox', () => {
       ciphertext: sealed,
     })
 
-    deepStrictEqual(opened, message)
+    expect(opened).toEqual(message)
 
     x25519Key.handle.free()
   })

packages/askar-nodejs/tests/error.test.ts

@@ -1,42 +1,40 @@
-import { doesNotReject, doesNotThrow, rejects, throws } from 'node:assert'
 import { AskarError, askar, KeyAlgorithm } from '@openwallet-foundation/askar-shared'
-import { describe, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { setupWallet } from './utils'
 
 describe('Error', () => {
   test('set error code to 0 after correct call', () => {
-    doesNotThrow(() =>
+    expect(() =>
       askar.keyGenerate({
         algorithm: KeyAlgorithm.AesA128CbcHs256,
         ephemeral: true,
       })
-    )
+    ).not.toThrow()
   })
 
   test('set error code to non 0 after incorrect call', () => {
-    throws(
-      () => askar.keyGenerate({ algorithm: 'incorrect-alg' as KeyAlgorithm, ephemeral: true }),
+    expect(() => askar.keyGenerate({ algorithm: 'incorrect-alg' as KeyAlgorithm, ephemeral: true })).toThrow(
       new AskarError({ code: 8, message: 'Unknown key algorithm' })
     )
   })
 
   test('set error code to 0 correct async call', async () => {
     const store = await setupWallet()
 
-    await doesNotReject(() => store.openSession())
+    await expect(store.openSession()).resolves.toBeDefined()
   })
 
   test('set error code to non 0 incorrect async call where the error is outside the callback', async () => {
     const store = await setupWallet()
 
     // @ts-expect-error: testing invalid call
-    await rejects(() => store.removeProfile(), { code: 5, message: 'Profile name not provided' })
+    await expect(store.removeProfile()).rejects.toMatchObject({ code: 5, message: 'Profile name not provided' })
   })
 
   test('set error code to non 0 incorrect async call where the error is inside the callback', async () => {
     const store = await setupWallet()
     await store.close()
 
-    await rejects(() => store.close(), { code: 5, message: 'Invalid store handle' })
+    await expect(store.close()).rejects.toMatchObject({ code: 5, message: 'Invalid store handle' })
   })
 })

packages/askar-nodejs/tests/joseEcdh.test.ts

@@ -1,6 +1,5 @@
-import { deepStrictEqual, strictEqual } from 'node:assert'
 import { Ecdh1PU, EcdhEs, Jwk, Key, KeyAlgorithm } from '@openwallet-foundation/askar-shared'
-import { describe, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { base64url } from './utils'
 
 describe('jose ecdh', () => {
@@ -53,7 +52,7 @@ describe('jose ecdh', () => {
       aad: Uint8Array.from(Buffer.from(protectedB64)),
     })
 
-    strictEqual(Buffer.from(messageReceived).toString(), messageString)
+    expect(Buffer.from(messageReceived).toString()).toBe(messageString)
 
     ephemeralKey.handle.free()
     bobKey.handle.free()
@@ -110,7 +109,7 @@ describe('jose ecdh', () => {
 
     const messageReceived = cekReceiver.aeadDecrypt({ ciphertext, tag, nonce, aad: protectedB64Bytes })
 
-    deepStrictEqual(messageReceived, message)
+    expect(messageReceived).toEqual(message)
 
     ephemeralKey.handle.free()
     bobKey.handle.free()
@@ -171,7 +170,7 @@ describe('jose ecdh', () => {
       aad: protectedB64Bytes,
     })
 
-    deepStrictEqual(messageReceived, message)
+    expect(messageReceived).toEqual(message)
 
     aliceKey.handle.free()
     bobKey.handle.free()
@@ -218,8 +217,8 @@ describe('jose ecdh', () => {
     const base64urlApu = base64url(apu)
     const base64urlApv = base64url(apv)
 
-    strictEqual(base64urlApu, 'QWxpY2U')
-    strictEqual(base64urlApv, 'Qm9iIGFuZCBDaGFybGll')
+    expect(base64urlApu).toBe('QWxpY2U')
+    expect(base64urlApv).toBe('Qm9iIGFuZCBDaGFybGll')
 
     const protectedJson = {
       alg: 'ECDH-1PU+A128KW',
@@ -249,8 +248,8 @@ describe('jose ecdh', () => {
 
     const { ciphertext, tag: ccTag } = enc.parts
 
-    strictEqual(Buffer.from(ciphertext).toString('base64url'), 'Az2IWsISEMDJvyc5XRL-3-d-RgNBOGolCsxFFoUXFYw')
-    strictEqual(Buffer.from(ccTag).toString('base64url'), 'HLb4fTlm8spGmij3RyOs2gJ4DpHM4hhVRwdF_hGb3WQ')
+    expect(Buffer.from(ciphertext).toString('base64url')).toBe('Az2IWsISEMDJvyc5XRL-3-d-RgNBOGolCsxFFoUXFYw')
+    expect(Buffer.from(ccTag).toString('base64url')).toBe('HLb4fTlm8spGmij3RyOs2gJ4DpHM4hhVRwdF_hGb3WQ')
 
     const derived = new Ecdh1PU({
       apv: Uint8Array.from(Buffer.from(apv)),
@@ -265,11 +264,10 @@ describe('jose ecdh', () => {
       receive: false,
     })
 
-    deepStrictEqual(derived.secretBytes, Uint8Array.from(Buffer.from('df4c37a0668306a11e3d6b0074b5d8df', 'hex')))
+    expect(derived.secretBytes).toEqual(Uint8Array.from(Buffer.from('df4c37a0668306a11e3d6b0074b5d8df', 'hex')))
 
     const encryptedKey = derived.wrapKey({ other: cek }).ciphertextWithTag
-    deepStrictEqual(
-      encryptedKey,
+    expect(encryptedKey).toEqual(
       Uint8Array.from(
         Buffer.from(
           'pOMVA9_PtoRe7xXW1139NzzN1UhiFoio8lGto9cf0t8PyU-sjNXH8-LIRLycq8CHJQbDwvQeU1cSl55cQ0hGezJu2N9IY0QN',
@@ -291,7 +289,7 @@ describe('jose ecdh', () => {
       recipientKey: bob,
     })
 
-    deepStrictEqual(encryptedKey2.ciphertextWithTag, encryptedKey)
+    expect(encryptedKey2.ciphertextWithTag).toEqual(encryptedKey)
 
     const derivedReceiver = new Ecdh1PU({
       apv: Uint8Array.from(Buffer.from(apv)),
@@ -315,7 +313,7 @@ describe('jose ecdh', () => {
       tag: ccTag,
     })
 
-    deepStrictEqual(messageReceived, message)
+    expect(messageReceived).toEqual(message)
 
     const cekReceiver2 = new Ecdh1PU({
       apv: Uint8Array.from(Buffer.from(apv)),
@@ -331,7 +329,7 @@ describe('jose ecdh', () => {
       ccTag,
     })
 
-    deepStrictEqual(cekReceiver2.jwkSecret, cek.jwkSecret)
+    expect(cekReceiver2.jwkSecret).toEqual(cek.jwkSecret)
 
     cek.handle.free()
     cekReceiver.handle.free()

packages/askar-nodejs/tests/kdf.test.ts

@@ -1,6 +1,5 @@
-import { ok } from 'node:assert'
 import { Argon2, Argon2Parameters } from '@openwallet-foundation/askar-shared'
-import { describe, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
 
 describe('Argon2', () => {
   test('derive password', () => {
@@ -12,9 +11,8 @@ describe('Argon2', () => {
 
     const derivedPassword = Argon2.derivePassword(Argon2Parameters.Interactive, passwordBytes, saltBytes)
 
-    ok(
-      Buffer.from(derivedPassword).toString('hex') ===
-        '9ef87bcf828c46c0136a0d1d9e391d713f75b327c6dc190455bd36c1bae33259'
+    expect(Buffer.from(derivedPassword).toString('hex')).toBe(
+      '9ef87bcf828c46c0136a0d1d9e391d713f75b327c6dc190455bd36c1bae33259'
     )
   })
 })

packages/askar-nodejs/tests/keys.test.ts

@@ -1,41 +1,39 @@
-import { deepStrictEqual, ok, strictEqual } from 'node:assert'
 import { Jwk, Key, KeyAlgorithm } from '@openwallet-foundation/askar-shared'
-import { describe, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { askarNodeJS } from '../src'
 
 describe('keys', () => {
   test('supported backends', () => {
     const backends = askarNodeJS.keyGetSupportedBackends()
 
-    strictEqual(backends.length, 1)
-    ok(backends.includes('software'))
+    expect(backends.length).toBe(1)
+    expect(backends.includes('software')).toBe(true)
   })
 
   test('aes cbc hmac', () => {
     const key = Key.generate(KeyAlgorithm.AesA128CbcHs256)
 
-    strictEqual(key.algorithm, KeyAlgorithm.AesA128CbcHs256)
+    expect(key.algorithm).toBe(KeyAlgorithm.AesA128CbcHs256)
 
     const messageString = 'test message'
     const message = Uint8Array.from(Buffer.from(messageString))
     const aeadNonce = key.aeadRandomNonce
     const params = key.aeadParams
 
-    strictEqual(params.nonceLength, 16)
-    strictEqual(params.tagLength, 16)
+    expect(params.nonceLength).toBe(16)
+    expect(params.tagLength).toBe(16)
 
     const enc = key.aeadEncrypt({ message, nonce: aeadNonce })
     const dec = key.aeadDecrypt(enc.parts)
 
-    deepStrictEqual(dec, message)
+    expect(dec).toEqual(message)
   })
 
   test('Bls G2 Keygen', () => {
     const seed = Uint8Array.from(Buffer.from('testseed000000000000000000000001'))
     const key = Key.fromSeed({ algorithm: KeyAlgorithm.Bls12381G2, seed })
 
-    deepStrictEqual(
-      key.jwkPublic,
+    expect(key.jwkPublic).toEqual(
       new Jwk({
         crv: 'BLS12381G2',
         kty: 'EC',
@@ -49,8 +47,7 @@ describe('keys', () => {
     const seed = Uint8Array.from(Buffer.from('testseed000000000000000000000001'))
     const key = Key.fromSeed({ algorithm: KeyAlgorithm.Bls12381G1, seed })
 
-    deepStrictEqual(
-      key.jwkPublic,
+    expect(key.jwkPublic).toEqual(
       new Jwk({
         crv: 'BLS12381G1',
         kty: 'EC',
@@ -63,36 +60,33 @@ describe('keys', () => {
   test('ed25519', () => {
     const key = Key.generate(KeyAlgorithm.Ed25519)
 
-    strictEqual(key.algorithm, KeyAlgorithm.Ed25519)
+    expect(key.algorithm).toBe(KeyAlgorithm.Ed25519)
 
     const message = Uint8Array.from(Buffer.from('test message'))
     const messageBuffer = Buffer.from('test message')
     const signature = key.signMessage({ message })
 
-    strictEqual(key.verifySignature({ message, signature }), true)
-    strictEqual(key.verifySignature({ message: messageBuffer, signature }), true)
-    strictEqual(key.verifySignature({ message: Buffer.from('other message'), signature }), false)
-    strictEqual(
+    expect(key.verifySignature({ message, signature })).toBe(true)
+    expect(key.verifySignature({ message: messageBuffer, signature })).toBe(true)
+    expect(key.verifySignature({ message: Buffer.from('other message'), signature })).toBe(false)
+    expect(
       key.verifySignature({
         message: Uint8Array.from(Buffer.from('other message')),
         signature,
-      }),
-      false
-    )
-    strictEqual(
+      })
+    ).toBe(false)
+    expect(
       key.verifySignature({
         message,
         signature: Uint8Array.from([8, 1, 1, 1]),
-      }),
-      false
-    )
-    strictEqual(
+      })
+    ).toBe(false)
+    expect(
       key.verifySignature({
         message,
         signature: Buffer.from('random signature'),
-      }),
-      false
-    )
+      })
+    ).toBe(false)
 
     const x25519Key = key.convertkey({ algorithm: KeyAlgorithm.X25519 })
     const x25519Key2 = Key.generate(KeyAlgorithm.X25519)
@@ -102,29 +96,29 @@ describe('keys', () => {
       publicKey: x25519Key2,
     })
 
-    ok(kex instanceof Key)
+    expect(kex instanceof Key).toBe(true)
 
-    strictEqual(key.jwkPublic.kty, 'OKP')
-    strictEqual(key.jwkPublic.crv, 'Ed25519')
+    expect(key.jwkPublic.kty).toBe('OKP')
+    expect(key.jwkPublic.crv).toBe('Ed25519')
 
-    strictEqual(key.jwkSecret.kty, 'OKP')
-    strictEqual(key.jwkSecret.crv, 'Ed25519')
+    expect(key.jwkSecret.kty).toBe('OKP')
+    expect(key.jwkSecret.crv).toBe('Ed25519')
   })
 
   test('p384', () => {
     const key = Key.generate(KeyAlgorithm.EcSecp384r1)
 
-    strictEqual(key.algorithm, KeyAlgorithm.EcSecp384r1)
+    expect(key.algorithm).toBe(KeyAlgorithm.EcSecp384r1)
 
     const message = Uint8Array.from(Buffer.from('test message'))
     const signature = key.signMessage({ message })
 
-    strictEqual(key.verifySignature({ message, signature }), true)
+    expect(key.verifySignature({ message, signature })).toBe(true)
 
-    strictEqual(key.jwkPublic.kty, 'EC')
-    strictEqual(key.jwkPublic.crv, 'P-384')
+    expect(key.jwkPublic.kty).toBe('EC')
+    expect(key.jwkPublic.crv).toBe('P-384')
 
-    strictEqual(key.jwkSecret.kty, 'EC')
-    strictEqual(key.jwkSecret.crv, 'P-384')
+    expect(key.jwkSecret.kty).toBe('EC')
+    expect(key.jwkSecret.crv).toBe('P-384')
   })
 })

packages/askar-nodejs/tests/migration.test.ts

@@ -1,8 +1,7 @@
-import { doesNotReject, rejects } from 'node:assert'
 import fs from 'node:fs'
 import path from 'node:path'
 import { Migration } from '@openwallet-foundation/askar-shared'
-import { beforeEach, describe, test } from 'vitest'
+import { beforeEach, describe, expect, test } from 'vitest'
 
 const DB_TEMPLATE_PATH = path.join(__dirname, 'indy_wallet_sqlite.db')
 const DB_UPGRADE_PATH = path.join(__dirname, 'indy_wallet_sqlite_upgraded.db')
@@ -26,25 +25,23 @@ describe('migration', () => {
   })
 
   test('migrate', async () => {
-    await doesNotReject(() =>
+    await expect(
       Migration.migrate({
         specUri: DB_UPGRADE_PATH,
         kdfLevel: 'RAW',
         walletName: 'walletwallet.0',
         walletKey: 'GfwU1DC7gEZNs3w41tjBiZYj7BNToDoFEqKY6wZXqs1A',
       })
-    )
+    ).resolves.toBeUndefined()
 
     // Double migrate should not work
-    await rejects(
-      () =>
-        Migration.migrate({
-          specUri: DB_UPGRADE_PATH,
-          kdfLevel: 'RAW',
-          walletName: 'walletwallet.0',
-          walletKey: 'GfwU1DC7gEZNs3w41tjBiZYj7BNToDoFEqKY6wZXqs1A',
-        }),
-      { code: 1, message: 'Database is already migrated' }
-    )
+    await expect(
+      Migration.migrate({
+        specUri: DB_UPGRADE_PATH,
+        kdfLevel: 'RAW',
+        walletName: 'walletwallet.0',
+        walletKey: 'GfwU1DC7gEZNs3w41tjBiZYj7BNToDoFEqKY6wZXqs1A',
+      })
+    ).rejects.toMatchObject({ code: 1, message: 'Database is already migrated' })
   })
 })