fix: bug in encryption function, corrected tests

Author: skoshx

src/core/encryption.ts

@@ -164,8 +164,11 @@ export async function encrypt(publicKeyString: string, plaintext: string) {
 	for (let i = 0; i < data.length; i += MAX_CHUNK_SIZE) {
 		const chunk = data.subarray(i, i + MAX_CHUNK_SIZE)
 		const encryptedChunk = await encryptChunk(publicKey, chunk)
-		const base64Chunk = encodeBase64(encryptedChunk)
-		chunks.push(base64Chunk)
+		const base64ChunkResult = encodeBase64(encryptedChunk)
+		if (base64ChunkResult.err) {
+			return base64ChunkResult
+		}
+		chunks.push(base64ChunkResult.val)
 	}
 
 	return Ok(chunks.join(CHUNK_SEPARATOR))

src/core/errors.ts

@@ -80,21 +80,21 @@ export const createHumanLog = createHumanLogs({
 		},
 		encrypt_failed_invalid_key_type: {
 			template:
-				'because encrypting failed due to invalid public key type. Expected "string", received "{publicKey}"',
+				'because encrypting failed due to invalid public key type. Expected "string", received "{publicKey}".',
 			params: {
 				publicKey: ''
 			}
 		},
 		decrypt_failed_invalid_ciphertext_type: {
 			template:
-				'because encrypting failed due to invalid ciphertext type. Expected "string", received "{ciphertext}".',
+				'because decrypting failed due to invalid ciphertext type. Expected "string", received "{ciphertext}".',
 			params: {
 				ciphertext: ''
 			}
 		},
 		decrypt_failed_invalid_key_type: {
 			template:
-				'because encrypting failed due to invalid private key type. Expected "string", received "{privateKey}"',
+				'because decrypting failed due to invalid private key type. Expected "string", received "{privateKey}".',
 			params: {
 				privateKey: ''
 			}

test/encryption.test.ts

@@ -33,15 +33,27 @@ describe('encrypt', () => {
 		expect(encrypted.slice(-2)).toBe('==')
 	})
 	it('throws for anything other than a string', async () => {
-		const keyPair = await generateKeyPair()
+		const keyPair = (await generateKeyPair()).unwrap()
 		// @ts-expect-error
-		await expect(encrypt(keyPair.publicKey, {})).rejects.toThrow()
+		expect(toOneLine((await encrypt(keyPair.publicKey)).val.toString())).toBe(
+			toOneLine(
+				`because encrypting failed due to invalid plaintext type. Expected "string", received ",".`
+			)
+		)
 	})
 
 	it('throws for invalid public key', async () => {
 		// @ts-expect-error
-		await expect(encrypt({}, 'Hello, World!')).rejects.toThrow()
-		await expect(encrypt('invalid public key', 'Hello, World!')).rejects.toThrow()
+		expect(toOneLine((await encrypt({}, 'Hello, World!')).val.toString())).toBe(
+			toOneLine(
+				`because encrypting failed due to invalid public key type. Expected "string", received "[object Object]".`
+			)
+		)
+		expect(toOneLine((await encrypt('invalid public key', 'Hello, World!')).val.toString())).toBe(
+			toOneLine(
+				`because base64 decoding the value "," errored. Error: InvalidCharacterError: The string to be decoded is not correctly encoded.`
+			)
+		)
 	})
 
 	it('encrypts large amount of text', async () => {
@@ -59,10 +71,10 @@ describe('decrypt', () => {
 		const plaintext = 'Hello, World!'
 		const keyPair = (await generateKeyPair()).unwrap()
 		const encrypted = (await encrypt(keyPair.publicKey, plaintext)).unwrap()
-		const decrypted = await decrypt(keyPair.privateKey, encrypted)
+		const decrypted = await (await decrypt(keyPair.privateKey, encrypted)).unwrap()
 		expect(decrypted).toBe(plaintext)
 	})
-	it.only('throws when decrypting with wrong private key', async () => {
+	it('Returns Err result when decrypting with wrong private key', async () => {
 		const plaintext = 'Hello, World!'
 		const keyPair = (await generateKeyPair()).unwrap()
 		const encrypted = (await encrypt(keyPair.publicKey, plaintext)).unwrap()
@@ -75,15 +87,27 @@ describe('decrypt', () => {
 		// @ts-expect-error
 		expect(toOneLine((await decrypt({}, encrypted)).val.toString())).toBe(
 			toOneLine(
-				`because encrypting failed due to invalid private key type. Expected "string", received "[object Object]"`
+				`because decrypting failed due to invalid private key type. Expected "string", received "[object Object]".`
 			)
 		)
 	})
-	it('throws when input isnt a string', async () => {
+	it('Returns Err result when input isnt a string', async () => {
 		const keyPair = (await generateKeyPair()).unwrap()
+
 		// @ts-expect-error
-		await expect(decrypt(keyPair.privateKey, {})).rejects.toThrow()
-		await expect(decrypt(keyPair.privateKey, 'invalid ciphertext')).rejects.toThrow()
+		expect(toOneLine((await decrypt(keyPair.privateKey, {})).val.toString())).toBe(
+			toOneLine(
+				`because decrypting failed due to invalid ciphertext type. Expected "string", received "[object Object]".`
+			)
+		)
+
+		expect(
+			toOneLine((await decrypt(keyPair.privateKey, 'invalid ciphertext')).val.toString())
+		).toBe(
+			toOneLine(
+				`because base64 decoding the value "invalid ciphertext" errored. Error: InvalidCharacterError: The string to be decoded is not correctly encoded.`
+			)
+		)
 	})
 
 	it('decrypts large amount of text', async () => {

test/stringify.test.ts

@@ -29,12 +29,14 @@ it('removes cyclical dependencies', () => {
 
 	const stringifiedWithoutCircular = safeStringify(a).unwrap()
 
-	expect(stringifiedWithoutCircular).toEqual('{"json":{"b":2,"c":{"d":{"e":null}}},"meta":{}}')
+	expect(stringifiedWithoutCircular).toEqual(
+		'{"json":{"b":2,"c":{"d":{"e":"FLYTRAP_UNSERIALIZABLE_VALUE"}}}}'
+	)
 	expect(SuperJSON.parse(stringifiedWithoutCircular)).toEqual({
 		b: 2,
 		c: {
 			d: {
-				e: null
+				e: FLYTRAP_UNSERIALIZABLE_VALUE
 			}
 		}
 	})
@@ -222,7 +224,7 @@ it('processCaptures', () => {
 	]) */
 })
 
-describe.only('new stringify', () => {
+describe('new stringify', () => {
 	// Circulars
 	const a = {
 		b: '23',

test/transform-uff.test.ts

@@ -116,7 +116,7 @@ describe('functions', () => {
 	}
 })
 
-it.only('callee and accessorKey are correct', () => {
+it('callee and accessorKey are correct', () => {
 	const accessorKeyFixtures = [
 		/* {
 			fixture: 'parseFloat',