Merge branch 'basic-auth' of github.com:shapehq/framna-docs into basic-auth

# Conflicts:
#	src/app/(authed)/(home)/encrypt/page.tsx

Author: simonbs

__test__/encrypt/EncryptionService.test.ts

@@ -0,0 +1,54 @@
+import RsaEncryptionService from '../../src/features/encrypt/EncryptionService'
+import { generateKeyPairSync } from 'crypto'
+
+describe('RsaEncryptionService', () => {
+    const { publicKey, privateKey } = generateKeyPairSync('rsa', {
+        modulusLength: 2048,
+        publicKeyEncoding: {
+            type: 'spki',
+            format: 'pem'
+        },
+        privateKeyEncoding: {
+            type: 'pkcs8',
+            format: 'pem'
+        }
+    })
+
+    const encryptionService = new RsaEncryptionService({ publicKey, privateKey })
+
+    it('should encrypt and decrypt data correctly', () => {
+        const data = 'Hello, World!'
+        const encryptedData = encryptionService.encrypt(data)
+        const decryptedData = encryptionService.decrypt(encryptedData)
+
+        expect(decryptedData).toBe(data)
+    })
+
+    it('should throw an error when decrypting with incorrect data', () => {
+        const incorrectData = 'invalidEncryptedData'
+
+        expect(() => {
+            encryptionService.decrypt(incorrectData)
+        }).toThrow()
+    })
+
+    it('should throw an error when encrypting with an invalid public key', () => {
+        const invalidPublicKey = 'invalidPublicKey'
+        const invalidEncryptionService = new RsaEncryptionService({ publicKey: invalidPublicKey, privateKey })
+
+        expect(() => {
+            invalidEncryptionService.encrypt('test')
+        }).toThrow()
+    })
+
+    it('should throw an error when decrypting with an invalid private key', () => {
+        const data = 'Hello, World!'
+        const encryptedData = encryptionService.encrypt(data)
+        const invalidPrivateKey = 'invalidPrivateKey'
+        const invalidEncryptionService = new RsaEncryptionService({ publicKey, privateKey: invalidPrivateKey })
+
+        expect(() => {
+            invalidEncryptionService.decrypt(encryptedData)
+        }).toThrow()
+    })
+})

__test__/projects/RemoteConfigEncoder.test.ts

@@ -0,0 +1,38 @@
+import RemoteConfigEncoder from "@/features/projects/domain/RemoteConfigEncoder"
+import { IEncryptionService } from "@/features/encrypt/EncryptionService"
+import RemoteConfig from "@/features/projects/domain/RemoteConfig"
+import { ZodError } from "zod"
+
+describe('RemoteConfigEncoder', () => {
+    const encryptionService: IEncryptionService = {
+        encrypt: (data: string) => `encrypted-${data}`,
+        decrypt: (data: string) => data.replace('encrypted-', '')
+    }
+
+    const encoder = new RemoteConfigEncoder(encryptionService)
+
+    it('should encode a remote config by first encrypting and then encoding with base64', () => {
+        const remoteConfig: RemoteConfig = { url: 'https://example.com/spec.yaml' }
+        const encoded = encoder.encode(remoteConfig)
+        const expectedEncoded = Buffer.from('encrypted-{"url":"https://example.com/spec.yaml"}').toString('base64')
+        expect(encoded).toEqual(expectedEncoded)
+    })
+
+    it('should decode an encoded string', () => {
+        const encodedString = Buffer.from('encrypted-{"url":"https://example.com/spec.yaml"}').toString('base64')
+        const decoded = encoder.decode(encodedString)
+        const expectedDecoded: RemoteConfig = { url: 'https://example.com/spec.yaml' }
+        expect(decoded).toEqual(expectedDecoded)
+    })
+
+    it('should throw an error if the decrypted string is not valid JSON', () => {
+        const invalidJson = Buffer.from('encrypted-invalid-json').toString('base64')
+        expect(() => encoder.decode(invalidJson)).toThrow(/Unexpected token/)
+    })
+
+    it('should throw an error if the remote config is not valid', () => {
+        const remoteConfig: RemoteConfig = { url: '' }
+        const encoded = encoder.encode(remoteConfig)
+        expect(() => encoder.decode(encoded)).toThrow(ZodError)
+    })
+})