@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/sharing/cache.test.ts

@@ -1,7 +1,7 @@
-import { MemoryCache } from "../../cache";
-import { SharingCache } from "./cache";
+import { MemoryCache } from '../../cache';
+import { SharingCache } from './cache';
 
-describe("SharingCache", () => {
+describe('SharingCache', () => {
     let memoryCache: MemoryCache<string>;
     let cache: SharingCache;
 
@@ -10,76 +10,76 @@ describe("SharingCache", () => {
         cache = new SharingCache(memoryCache);
     });
 
-    describe("set and get shared by me nodes", () => {
-        it("should set node uids", async () => {
-            await cache.setSharedByMeNodeUids(["nodeUid"]);
+    describe('set and get shared by me nodes', () => {
+        it('should set node uids', async () => {
+            await cache.setSharedByMeNodeUids(['nodeUid']);
 
             const result = await cache.getSharedByMeNodeUids();
 
-            expect(result).toEqual(["nodeUid"]);
+            expect(result).toEqual(['nodeUid']);
         });
     });
 
-    describe("addSharedByMeNodeUid", () => {
-        it("should throw if adding before setting", async () => {
+    describe('addSharedByMeNodeUid', () => {
+        it('should throw if adding before setting', async () => {
             try {
-                await cache.addSharedByMeNodeUid("nodeUid");
-                fail("Should have thrown an error");
+                await cache.addSharedByMeNodeUid('nodeUid');
+                fail('Should have thrown an error');
             } catch (error) {
-                expect(`${error}`).toBe("Error: Calling add before setting the loaded items");
+                expect(`${error}`).toBe('Error: Calling add before setting the loaded items');
             }
         });
 
-        it("should add node uid", async () => {
-            await cache.setSharedByMeNodeUids(["nodeUid"]);
+        it('should add node uid', async () => {
+            await cache.setSharedByMeNodeUids(['nodeUid']);
             const spy = jest.spyOn(memoryCache, 'setEntity');
 
-            await cache.addSharedByMeNodeUid("newNodeUid");
+            await cache.addSharedByMeNodeUid('newNodeUid');
 
             const result = await cache.getSharedByMeNodeUids();
-            expect(result).toEqual(["nodeUid", "newNodeUid"]);
+            expect(result).toEqual(['nodeUid', 'newNodeUid']);
             expect(spy).toHaveBeenCalled();
         });
 
-        it("should not add duplicate node uid", async () => {
-            await cache.setSharedByMeNodeUids(["nodeUid"]);
+        it('should not add duplicate node uid', async () => {
+            await cache.setSharedByMeNodeUids(['nodeUid']);
             const spy = jest.spyOn(memoryCache, 'setEntity');
 
-            await cache.addSharedByMeNodeUid("nodeUid");
-            await cache.addSharedByMeNodeUid("nodeUid");
+            await cache.addSharedByMeNodeUid('nodeUid');
+            await cache.addSharedByMeNodeUid('nodeUid');
 
             const result = await cache.getSharedByMeNodeUids();
-            expect(result).toEqual(["nodeUid"]);
+            expect(result).toEqual(['nodeUid']);
             expect(spy).not.toHaveBeenCalled();
         });
     });
 
-    describe("removeSharedByMeNodeUid", () => {
-        it("should throw if removing before setting", async () => {
+    describe('removeSharedByMeNodeUid', () => {
+        it('should throw if removing before setting', async () => {
             try {
-                await cache.removeSharedByMeNodeUid("nodeUid");
-                fail("Should have thrown an error");
+                await cache.removeSharedByMeNodeUid('nodeUid');
+                fail('Should have thrown an error');
             } catch (error) {
-                expect(`${error}`).toBe("Error: Calling remove before setting the loaded items");
+                expect(`${error}`).toBe('Error: Calling remove before setting the loaded items');
             }
         });
 
-        it("should remove node uid", async () => {
-            await cache.setSharedByMeNodeUids(["nodeUid"]);
+        it('should remove node uid', async () => {
+            await cache.setSharedByMeNodeUids(['nodeUid']);
             const spy = jest.spyOn(memoryCache, 'setEntity');
 
-            await cache.removeSharedByMeNodeUid("nodeUid");
+            await cache.removeSharedByMeNodeUid('nodeUid');
 
             const result = await cache.getSharedByMeNodeUids();
             expect(result).toEqual([]);
             expect(spy).toHaveBeenCalled();
         });
 
-        it("should handle removing of missing node uid", async () => {
+        it('should handle removing of missing node uid', async () => {
             await cache.setSharedByMeNodeUids([]);
             const spy = jest.spyOn(memoryCache, 'setEntity');
 
-            await cache.removeSharedByMeNodeUid("nodeUid");
+            await cache.removeSharedByMeNodeUid('nodeUid');
 
             const result = await cache.getSharedByMeNodeUids();
             expect(result).toEqual([]);
@@ -87,13 +87,13 @@ describe("SharingCache", () => {
         });
     });
 
-    describe("set and get shared with me nodes", () => {
-        it("should set node uids", async () => {
-            await cache.setSharedWithMeNodeUids(["nodeUid"]);
+    describe('set and get shared with me nodes', () => {
+        it('should set node uids', async () => {
+            await cache.setSharedWithMeNodeUids(['nodeUid']);
 
             const result = await cache.getSharedWithMeNodeUids();
 
-            expect(result).toEqual(["nodeUid"]);
+            expect(result).toEqual(['nodeUid']);
         });
     });
 });

package/src/internal/sharing/cache.ts

@@ -1,9 +1,9 @@
-import { ProtonDriveEntitiesCache } from "../../interface";
-import { SharingType } from "./interface";
+import { ProtonDriveEntitiesCache } from '../../interface';
+import { SharingType } from './interface';
 
 /**
  * Provides caching for shared by me and with me listings.
- * 
+ *
  * The cache is responsible for serialising and deserialising the node
  * UIDs for each sharing type. Also, ensuring that only full lists are
  * cached.

package/src/internal/sharing/cryptoService.test.ts

@@ -1,10 +1,17 @@
-import { DriveCrypto, PrivateKey } from "../../crypto";
-import { MetricVolumeType, NodeType, ProtonDriveAccount, ProtonDriveTelemetry, resultError, resultOk } from "../../interface";
-import { getMockTelemetry } from "../../tests/telemetry";
-import { SharesService } from "./interface";
-import { SharingCryptoService } from "./cryptoService";
-
-describe("SharingCryptoService", () => {
+import { DriveCrypto, PrivateKey } from '../../crypto';
+import {
+    MetricVolumeType,
+    NodeType,
+    ProtonDriveAccount,
+    ProtonDriveTelemetry,
+    resultError,
+    resultOk,
+} from '../../interface';
+import { getMockTelemetry } from '../../tests/telemetry';
+import { SharesService } from './interface';
+import { SharingCryptoService } from './cryptoService';
+
+describe('SharingCryptoService', () => {
     let telemetry: ProtonDriveTelemetry;
     let driveCrypto: DriveCrypto;
     let account: ProtonDriveAccount;
@@ -15,75 +22,80 @@ describe("SharingCryptoService", () => {
         telemetry = getMockTelemetry();
         // @ts-expect-error No need to implement all methods for mocking
         driveCrypto = {
-            decryptShareUrlPassword: jest.fn().mockResolvedValue("urlPassword"),
+            decryptShareUrlPassword: jest.fn().mockResolvedValue('urlPassword'),
             decryptKeyWithSrpPassword: jest.fn().mockResolvedValue({
-                key: "decryptedKey" as unknown as PrivateKey,
+                key: 'decryptedKey' as unknown as PrivateKey,
             }),
             decryptNodeName: jest.fn().mockResolvedValue({
-                name: "nodeName",
+                name: 'nodeName',
             }),
         };
         account = {
             // @ts-expect-error No need to implement full response for mocking
             getOwnAddress: jest.fn(async () => ({
-                keys: [{ key: "addressKey" as unknown as PrivateKey }],
+                keys: [{ key: 'addressKey' as unknown as PrivateKey }],
             })),
         };
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
             getMyFilesShareMemberEmailKey: jest.fn().mockResolvedValue({
-                addressId: "addressId",
+                addressId: 'addressId',
             }),
         };
         cryptoService = new SharingCryptoService(telemetry, driveCrypto, account, sharesService);
     });
 
-    describe("decryptBookmark", () => {
+    describe('decryptBookmark', () => {
         const encryptedBookmark = {
-            tokenId: "tokenId",
+            tokenId: 'tokenId',
             creationTime: new Date(),
             url: {
-                encryptedUrlPassword: "encryptedUrlPassword",
-                base64SharePasswordSalt: "base64SharePasswordSalt",
+                encryptedUrlPassword: 'encryptedUrlPassword',
+                base64SharePasswordSalt: 'base64SharePasswordSalt',
             },
             share: {
-                armoredKey: "armoredKey",
-                armoredPassphrase: "armoredPassphrase",
+                armoredKey: 'armoredKey',
+                armoredPassphrase: 'armoredPassphrase',
             },
             node: {
                 type: NodeType.File,
-                mediaType: "mediaType",
-                encryptedName: "encryptedName",
-                armoredKey: "armoredKey",
-                armoredNodePassphrase: "armoredNodePassphrase",
+                mediaType: 'mediaType',
+                encryptedName: 'encryptedName',
+                armoredKey: 'armoredKey',
+                armoredNodePassphrase: 'armoredNodePassphrase',
                 file: {
-                    base64ContentKeyPacket: "base64ContentKeyPacket",
+                    base64ContentKeyPacket: 'base64ContentKeyPacket',
                 },
             },
-        }
+        };
 
-        it("should decrypt bookmark", async () => {
+        it('should decrypt bookmark', async () => {
             const result = await cryptoService.decryptBookmark(encryptedBookmark);
 
             expect(result).toMatchObject({
-                url: resultOk("https://drive.proton.me/urls/tokenId#urlPassword"),
-                nodeName: resultOk("nodeName"),
+                url: resultOk('https://drive.proton.me/urls/tokenId#urlPassword'),
+                nodeName: resultOk('nodeName'),
             });
-            expect(driveCrypto.decryptShareUrlPassword).toHaveBeenCalledWith("encryptedUrlPassword", ["addressKey"]);
-            expect(driveCrypto.decryptKeyWithSrpPassword).toHaveBeenCalledWith("urlPassword", "base64SharePasswordSalt", "armoredKey", "armoredPassphrase");
-            expect(driveCrypto.decryptNodeName).toHaveBeenCalledWith("encryptedName", "decryptedKey", []);
+            expect(driveCrypto.decryptShareUrlPassword).toHaveBeenCalledWith('encryptedUrlPassword', ['addressKey']);
+            expect(driveCrypto.decryptKeyWithSrpPassword).toHaveBeenCalledWith(
+                'urlPassword',
+                'base64SharePasswordSalt',
+                'armoredKey',
+                'armoredPassphrase',
+            );
+            expect(driveCrypto.decryptNodeName).toHaveBeenCalledWith('encryptedName', 'decryptedKey', []);
             expect(telemetry.logEvent).not.toHaveBeenCalled();
         });
 
-        it("should handle undecryptable URL password", async () => {
-            const error = new Error("Failed to decrypt URL password");
+        it('should handle undecryptable URL password', async () => {
+            const error = new Error('Failed to decrypt URL password');
             driveCrypto.decryptShareUrlPassword = jest.fn().mockRejectedValue(error);
 
             const result = await cryptoService.decryptBookmark(encryptedBookmark);
 
             expect(result).toMatchObject({
-                url: resultError(new Error("Failed to decrypt bookmark password: Failed to decrypt URL password")),
-                nodeName: resultError(new Error("Failed to decrypt bookmark password: Failed to decrypt URL password")),
+                url: resultError(new Error('Failed to decrypt bookmark password: Failed to decrypt URL password')),
+                nodeName: resultError(new Error('Failed to decrypt bookmark password: Failed to decrypt URL password')),
             });
             expect(telemetry.logEvent).toHaveBeenCalledWith({
                 eventName: 'decryptionError',
@@ -93,15 +105,15 @@ describe("SharingCryptoService", () => {
             });
         });
 
-        it("should handle undecryptable share key", async () => {
-            const error = new Error("Failed to decrypt share key");
+        it('should handle undecryptable share key', async () => {
+            const error = new Error('Failed to decrypt share key');
             driveCrypto.decryptKeyWithSrpPassword = jest.fn().mockRejectedValue(error);
 
             const result = await cryptoService.decryptBookmark(encryptedBookmark);
 
             expect(result).toMatchObject({
-                url: resultOk("https://drive.proton.me/urls/tokenId#urlPassword"),
-                nodeName: resultError(new Error("Failed to decrypt bookmark key: Failed to decrypt share key")),
+                url: resultOk('https://drive.proton.me/urls/tokenId#urlPassword'),
+                nodeName: resultError(new Error('Failed to decrypt bookmark key: Failed to decrypt share key')),
             });
             expect(telemetry.logEvent).toHaveBeenCalledWith({
                 eventName: 'decryptionError',
@@ -111,15 +123,15 @@ describe("SharingCryptoService", () => {
             });
         });
 
-        it("should handle undecryptable node name", async () => {
-            const error = new Error("Failed to decrypt node name");
+        it('should handle undecryptable node name', async () => {
+            const error = new Error('Failed to decrypt node name');
             driveCrypto.decryptNodeName = jest.fn().mockRejectedValue(error);
 
             const result = await cryptoService.decryptBookmark(encryptedBookmark);
 
             expect(result).toMatchObject({
-                url: resultOk("https://drive.proton.me/urls/tokenId#urlPassword"),
-                nodeName: resultError(new Error("Failed to decrypt bookmark name: Failed to decrypt node name")),
+                url: resultOk('https://drive.proton.me/urls/tokenId#urlPassword'),
+                nodeName: resultError(new Error('Failed to decrypt bookmark name: Failed to decrypt node name')),
             });
             expect(telemetry.logEvent).toHaveBeenCalledWith({
                 eventName: 'decryptionError',
@@ -129,17 +141,17 @@ describe("SharingCryptoService", () => {
             });
         });
 
-        it("should handle invalid node name", async () => {
+        it('should handle invalid node name', async () => {
             driveCrypto.decryptNodeName = jest.fn().mockResolvedValue({
-                name: "invalid/name",
+                name: 'invalid/name',
             });
 
             const result = await cryptoService.decryptBookmark(encryptedBookmark);
 
             expect(result).toMatchObject({
-                url: resultOk("https://drive.proton.me/urls/tokenId#urlPassword"),
+                url: resultOk('https://drive.proton.me/urls/tokenId#urlPassword'),
                 nodeName: resultError({
-                    name: "invalid/name",
+                    name: 'invalid/name',
                     error: "Name must not contain the character '/'",
                 }),
             });