@protontech/drive-sdk 0.0.13 → 0.1.1

package/dist/internal/sharing/sharingManagement.test.js

@@ -3,30 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("../../tests/logger");
 const interface_1 = require("../../interface");
 const sharingManagement_1 = require("./sharingManagement");
-describe("SharingManagement", () => {
+describe('SharingManagement', () => {
     let apiService;
     let cryptoService;
     let accountService;
     let sharesService;
     let nodesService;
-    let nodesEvents;
     let sharingManagement;
     beforeEach(() => {
         // @ts-expect-error No need to implement all methods for mocking
         apiService = {
-            createStandardShare: jest.fn().mockReturnValue("newShareId"),
+            createStandardShare: jest.fn().mockReturnValue('newShareId'),
             getShareInvitations: jest.fn().mockResolvedValue([]),
             getShareExternalInvitations: jest.fn().mockResolvedValue([]),
             getShareMembers: jest.fn().mockResolvedValue([]),
             inviteProtonUser: jest.fn().mockImplementation((_, invitation) => ({
                 ...invitation,
-                uid: "created-invitation",
+                uid: 'created-invitation',
             })),
             updateInvitation: jest.fn(),
             deleteInvitation: jest.fn(),
             inviteExternalUser: jest.fn().mockImplementation((_, invitation) => ({
                 ...invitation,
-                uid: "created-external-invitation",
+                uid: 'created-external-invitation',
                 state: interface_1.NonProtonInvitationState.Pending,
             })),
             updateExternalInvitation: jest.fn(),
@@ -39,14 +38,18 @@ describe("SharingManagement", () => {
             resendInvitationEmail: jest.fn(),
             resendExternalInvitationEmail: jest.fn(),
             createPublicLink: jest.fn().mockResolvedValue({
-                uid: "publicLinkUid",
-                publicUrl: "publicLinkUrl",
+                uid: 'publicLinkUid',
+                publicUrl: 'publicLinkUrl',
             }),
             updatePublicLink: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
-            generateShareKeys: jest.fn().mockResolvedValue({ shareKey: { encrypted: "encrypted-key", decrypted: { passphraseSessionKey: "pass-session-key", } } }),
+            generateShareKeys: jest
+                .fn()
+                .mockResolvedValue({
+                shareKey: { encrypted: 'encrypted-key', decrypted: { passphraseSessionKey: 'pass-session-key' } },
+            }),
             decryptShare: jest.fn().mockImplementation((share) => share),
             decryptInvitation: jest.fn().mockImplementation((invitation) => invitation),
             decryptExternalInvitation: jest.fn().mockImplementation((invitation) => invitation),
@@ -54,13 +57,13 @@ describe("SharingManagement", () => {
             encryptInvitation: jest.fn().mockImplementation(() => { }),
             encryptExternalInvitation: jest.fn().mockImplementation((invitation) => ({
                 ...invitation,
-                base64ExternalInvitationSignature: "extenral-signature",
+                base64ExternalInvitationSignature: 'extenral-signature',
             })),
             decryptPublicLink: jest.fn().mockImplementation((publicLink) => publicLink),
-            generatePublicLinkPassword: jest.fn().mockResolvedValue("generatedPassword"),
+            generatePublicLinkPassword: jest.fn().mockResolvedValue('generatedPassword'),
             encryptPublicLink: jest.fn().mockImplementation(() => ({
-                crypto: "publicLinkCrypto",
-                srp: "publicLinkSrp",
+                crypto: 'publicLinkCrypto',
+                srp: 'publicLinkSrp',
             })),
         };
         // @ts-expect-error No need to implement all methods for mocking
@@ -69,36 +72,43 @@ describe("SharingManagement", () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            loadEncryptedShare: jest.fn().mockResolvedValue({ id: "shareId", addressId: "addressId", creatorEmail: "address@example.com", passphraseSessionKey: "sharePassphraseSessionKey" }),
-            getContextShareMemberEmailKey: jest.fn().mockResolvedValue({ email: "volume-email", addressId: "addressId", addressKey: "volume-key" }),
+            loadEncryptedShare: jest
+                .fn()
+                .mockResolvedValue({
+                id: 'shareId',
+                addressId: 'addressId',
+                creatorEmail: 'address@example.com',
+                passphraseSessionKey: 'sharePassphraseSessionKey',
+            }),
+            getContextShareMemberEmailKey: jest
+                .fn()
+                .mockResolvedValue({ email: 'volume-email', addressId: 'addressId', addressKey: 'volume-key' }),
         };
         // @ts-expect-error No need to implement all methods for mocking
         nodesService = {
-            getNode: jest.fn().mockImplementation((nodeUid) => ({ nodeUid, shareId: "shareId", name: { ok: true, value: "name" } })),
-            getNodeKeys: jest.fn().mockImplementation((nodeUid) => ({ key: "node-key" })),
+            getNode: jest
+                .fn()
+                .mockImplementation((nodeUid) => ({ nodeUid, shareId: 'shareId', name: { ok: true, value: 'name' } })),
+            getNodeKeys: jest.fn().mockImplementation((nodeUid) => ({ key: 'node-key' })),
             getNodePrivateAndSessionKeys: jest.fn().mockImplementation((nodeUid) => ({})),
-            getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: "volume-email", addressKey: "volume-key" }),
-        };
-        nodesEvents = {
-            nodeUpdated: jest.fn(),
+            getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: 'volume-email', addressKey: 'volume-key' }),
+            notifyNodeChanged: jest.fn(),
         };
-        sharingManagement = new sharingManagement_1.SharingManagement((0, logger_1.getMockLogger)(), apiService, cryptoService, accountService, sharesService, nodesService, nodesEvents);
+        sharingManagement = new sharingManagement_1.SharingManagement((0, logger_1.getMockLogger)(), apiService, cryptoService, accountService, sharesService, nodesService);
     });
-    describe("getSharingInfo", () => {
-        it("should return empty sharing info for unshared node", async () => {
-            nodesService.getNode = jest.fn().mockResolvedValue({ nodeUid: "nodeUid", shareId: undefined });
-            const sharingInfo = await sharingManagement.getSharingInfo("nodeUid");
+    describe('getSharingInfo', () => {
+        it('should return empty sharing info for unshared node', async () => {
+            nodesService.getNode = jest.fn().mockResolvedValue({ nodeUid: 'nodeUid', shareId: undefined });
+            const sharingInfo = await sharingManagement.getSharingInfo('nodeUid');
             expect(sharingInfo).toEqual(undefined);
             expect(apiService.getShareInvitations).not.toHaveBeenCalled();
             expect(apiService.getShareExternalInvitations).not.toHaveBeenCalled();
             expect(apiService.getShareMembers).not.toHaveBeenCalled();
         });
-        it("should return invitations", async () => {
-            const invitation = { uid: "invitaiton", addedByEmail: "email" };
-            apiService.getShareInvitations = jest.fn().mockResolvedValue([
-                invitation,
-            ]);
-            const sharingInfo = await sharingManagement.getSharingInfo("nodeUid");
+        it('should return invitations', async () => {
+            const invitation = { uid: 'invitaiton', addedByEmail: 'email' };
+            apiService.getShareInvitations = jest.fn().mockResolvedValue([invitation]);
+            const sharingInfo = await sharingManagement.getSharingInfo('nodeUid');
             expect(sharingInfo).toEqual({
                 protonInvitations: [invitation],
                 nonProtonInvitations: [],
@@ -107,12 +117,10 @@ describe("SharingManagement", () => {
             });
             expect(cryptoService.decryptInvitation).toHaveBeenCalledWith(invitation);
         });
-        it("should return external invitations", async () => {
-            const externalInvitation = { uid: "external-invitation", addedByEmail: "email" };
-            apiService.getShareExternalInvitations = jest.fn().mockResolvedValue([
-                externalInvitation,
-            ]);
-            const sharingInfo = await sharingManagement.getSharingInfo("nodeUid");
+        it('should return external invitations', async () => {
+            const externalInvitation = { uid: 'external-invitation', addedByEmail: 'email' };
+            apiService.getShareExternalInvitations = jest.fn().mockResolvedValue([externalInvitation]);
+            const sharingInfo = await sharingManagement.getSharingInfo('nodeUid');
             expect(sharingInfo).toEqual({
                 protonInvitations: [],
                 nonProtonInvitations: [externalInvitation],
@@ -121,12 +129,10 @@ describe("SharingManagement", () => {
             });
             expect(cryptoService.decryptExternalInvitation).toHaveBeenCalledWith(externalInvitation);
         });
-        it("should return members", async () => {
-            const member = { uid: "member", addedByEmail: "email" };
-            apiService.getShareMembers = jest.fn().mockResolvedValue([
-                member,
-            ]);
-            const sharingInfo = await sharingManagement.getSharingInfo("nodeUid");
+        it('should return members', async () => {
+            const member = { uid: 'member', addedByEmail: 'email' };
+            apiService.getShareMembers = jest.fn().mockResolvedValue([member]);
+            const sharingInfo = await sharingManagement.getSharingInfo('nodeUid');
             expect(sharingInfo).toEqual({
                 protonInvitations: [],
                 nonProtonInvitations: [],
@@ -135,12 +141,12 @@ describe("SharingManagement", () => {
             });
             expect(cryptoService.decryptMember).toHaveBeenCalledWith(member);
         });
-        it("should return public link", async () => {
+        it('should return public link', async () => {
             const publicLink = {
                 uid: 'shared~publicLink',
             };
             apiService.getPublicLink = jest.fn().mockResolvedValue(publicLink);
-            const sharingInfo = await sharingManagement.getSharingInfo("nodeUid");
+            const sharingInfo = await sharingManagement.getSharingInfo('nodeUid');
             expect(sharingInfo).toEqual({
                 protonInvitations: [],
                 nonProtonInvitations: [],
@@ -150,124 +156,134 @@ describe("SharingManagement", () => {
             expect(cryptoService.decryptPublicLink).toHaveBeenCalledWith(publicLink);
         });
     });
-    describe("shareNode with share creation", () => {
-        const nodeUid = "volumeId~nodeUid";
-        it("should create share if no exists", async () => {
-            nodesService.getNode = jest.fn().mockImplementation((nodeUid) => ({ nodeUid, parentUid: 'parentUid', name: { ok: true, value: "name" } }));
-            const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ["email"] });
+    describe('shareNode with share creation', () => {
+        const nodeUid = 'volumeId~nodeUid';
+        it('should create share if no exists', async () => {
+            nodesService.getNode = jest
+                .fn()
+                .mockImplementation((nodeUid) => ({
+                nodeUid,
+                parentUid: 'parentUid',
+                name: { ok: true, value: 'name' },
+            }));
+            nodesService.notifyNodeChanged = jest.fn();
+            const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ['email'] });
             expect(sharingInfo).toEqual({
-                protonInvitations: [{
-                        uid: "created-invitation",
-                        addedByEmail: { ok: true, value: "volume-email" },
-                        inviteeEmail: "email",
-                        role: "viewer",
-                    }],
+                protonInvitations: [
+                    {
+                        uid: 'created-invitation',
+                        addedByEmail: { ok: true, value: 'volume-email' },
+                        inviteeEmail: 'email',
+                        role: 'viewer',
+                    },
+                ],
                 nonProtonInvitations: [],
                 members: [],
                 publicLink: undefined,
             });
             expect(apiService.updateInvitation).not.toHaveBeenCalled();
             expect(apiService.inviteProtonUser).toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith({
-                uid: nodeUid,
-                shareId: "newShareId",
-                isShared: true,
-            });
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith(nodeUid);
         });
     });
-    describe("shareNode with share re-use", () => {
-        const nodeUid = "volumeId~nodeUid";
+    describe('shareNode with share re-use', () => {
+        const nodeUid = 'volumeId~nodeUid';
         let invitation;
         let externalInvitation;
         let member;
         beforeEach(async () => {
             invitation = {
-                uid: "invitation",
-                addedByEmail: (0, interface_1.resultOk)("added-email"),
-                inviteeEmail: "internal-email",
+                uid: 'invitation',
+                addedByEmail: (0, interface_1.resultOk)('added-email'),
+                inviteeEmail: 'internal-email',
                 role: interface_1.MemberRole.Viewer,
                 invitationTime: new Date(),
             };
             externalInvitation = {
-                uid: "external-invitation",
-                addedByEmail: (0, interface_1.resultOk)("added-email"),
-                inviteeEmail: "external-email",
+                uid: 'external-invitation',
+                addedByEmail: (0, interface_1.resultOk)('added-email'),
+                inviteeEmail: 'external-email',
                 role: interface_1.MemberRole.Viewer,
                 invitationTime: new Date(),
                 state: interface_1.NonProtonInvitationState.Pending,
             };
             member = {
-                uid: "member",
-                addedByEmail: (0, interface_1.resultOk)("added-email"),
-                inviteeEmail: "member-email",
+                uid: 'member',
+                addedByEmail: (0, interface_1.resultOk)('added-email'),
+                inviteeEmail: 'member-email',
                 role: interface_1.MemberRole.Viewer,
                 invitationTime: new Date(),
             };
-            apiService.getShareInvitations = jest.fn().mockResolvedValue([
-                invitation,
-            ]);
-            apiService.getShareExternalInvitations = jest.fn().mockResolvedValue([
-                externalInvitation,
-            ]);
-            apiService.getShareMembers = jest.fn().mockResolvedValue([
-                member,
-            ]);
+            apiService.getShareInvitations = jest.fn().mockResolvedValue([invitation]);
+            apiService.getShareExternalInvitations = jest.fn().mockResolvedValue([externalInvitation]);
+            apiService.getShareMembers = jest.fn().mockResolvedValue([member]);
         });
-        describe("invitations", () => {
+        describe('invitations', () => {
             beforeEach(() => {
                 accountService.hasProtonAccount = jest.fn().mockResolvedValue(true);
             });
-            it("should share node with proton email with default role", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ["email"] });
+            it('should share node with proton email with default role', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ['email'] });
                 expect(sharingInfo).toEqual({
-                    protonInvitations: [invitation, {
-                            uid: "created-invitation",
-                            addedByEmail: { ok: true, value: "volume-email" },
-                            inviteeEmail: "email",
-                            role: "viewer",
-                        }],
+                    protonInvitations: [
+                        invitation,
+                        {
+                            uid: 'created-invitation',
+                            addedByEmail: { ok: true, value: 'volume-email' },
+                            inviteeEmail: 'email',
+                            role: 'viewer',
+                        },
+                    ],
                     nonProtonInvitations: [externalInvitation],
                     members: [member],
                     publicLink: undefined,
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should share node with proton email with specific role", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "email", role: interface_1.MemberRole.Editor }] });
+            it('should share node with proton email with specific role', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'email', role: interface_1.MemberRole.Editor }],
+                });
                 expect(sharingInfo).toEqual({
-                    protonInvitations: [invitation, {
-                            uid: "created-invitation",
-                            addedByEmail: { ok: true, value: "volume-email" },
-                            inviteeEmail: "email",
-                            role: "editor",
-                        }],
+                    protonInvitations: [
+                        invitation,
+                        {
+                            uid: 'created-invitation',
+                            addedByEmail: { ok: true, value: 'volume-email' },
+                            inviteeEmail: 'email',
+                            role: 'editor',
+                        },
+                    ],
                     nonProtonInvitations: [externalInvitation],
                     members: [member],
                     publicLink: undefined,
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should update existing role", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "internal-email", role: interface_1.MemberRole.Editor }] });
+            it('should update existing role', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'internal-email', role: interface_1.MemberRole.Editor }],
+                });
                 expect(sharingInfo).toEqual({
-                    protonInvitations: [{
+                    protonInvitations: [
+                        {
                             ...invitation,
-                            role: "editor",
-                        }],
+                            role: 'editor',
+                        },
+                    ],
                     nonProtonInvitations: [externalInvitation],
                     members: [member],
                     publicLink: undefined,
                 });
                 expect(apiService.updateInvitation).toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should be no-op if no change", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "internal-email", role: interface_1.MemberRole.Viewer }] });
+            it('should be no-op if no change', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'internal-email', role: interface_1.MemberRole.Viewer }],
+                });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
                     nonProtonInvitations: [externalInvitation],
@@ -276,66 +292,76 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
         });
-        describe("external invitations", () => {
+        describe('external invitations', () => {
             beforeEach(() => {
                 accountService.hasProtonAccount = jest.fn().mockResolvedValue(false);
             });
-            it("should share node with external email with default role", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ["email"] });
+            it('should share node with external email with default role', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ['email'] });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
-                    nonProtonInvitations: [externalInvitation, {
-                            uid: "created-external-invitation",
-                            addedByEmail: { ok: true, value: "volume-email" },
-                            inviteeEmail: "email",
-                            role: "viewer",
-                            state: "pending",
-                        }],
+                    nonProtonInvitations: [
+                        externalInvitation,
+                        {
+                            uid: 'created-external-invitation',
+                            addedByEmail: { ok: true, value: 'volume-email' },
+                            inviteeEmail: 'email',
+                            role: 'viewer',
+                            state: 'pending',
+                        },
+                    ],
                     members: [member],
                     publicLink: undefined,
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should share node with external email with specific role", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "email", role: interface_1.MemberRole.Editor }] });
+            it('should share node with external email with specific role', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'email', role: interface_1.MemberRole.Editor }],
+                });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
-                    nonProtonInvitations: [externalInvitation, {
-                            uid: "created-external-invitation",
-                            addedByEmail: { ok: true, value: "volume-email" },
-                            inviteeEmail: "email",
-                            role: "editor",
-                            state: "pending",
-                        }],
+                    nonProtonInvitations: [
+                        externalInvitation,
+                        {
+                            uid: 'created-external-invitation',
+                            addedByEmail: { ok: true, value: 'volume-email' },
+                            inviteeEmail: 'email',
+                            role: 'editor',
+                            state: 'pending',
+                        },
+                    ],
                     members: [member],
                     publicLink: undefined,
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should update existing role", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "external-email", role: interface_1.MemberRole.Editor }] });
+            it('should update existing role', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'external-email', role: interface_1.MemberRole.Editor }],
+                });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
-                    nonProtonInvitations: [{
+                    nonProtonInvitations: [
+                        {
                             ...externalInvitation,
-                            role: "editor",
-                        }],
+                            role: 'editor',
+                        },
+                    ],
                     members: [member],
                     publicLink: undefined,
                 });
                 expect(apiService.updateExternalInvitation).toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should be no-op if no change", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "external-email", role: interface_1.MemberRole.Viewer }] });
+            it('should be no-op if no change', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'external-email', role: interface_1.MemberRole.Viewer }],
+                });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
                     nonProtonInvitations: [externalInvitation],
@@ -344,63 +370,70 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
         });
-        describe("mix of internal and external invitations", () => {
+        describe('mix of internal and external invitations', () => {
             beforeEach(() => {
-                accountService.hasProtonAccount = jest.fn()
-                    .mockResolvedValueOnce(true)
-                    .mockResolvedValueOnce(false);
+                accountService.hasProtonAccount = jest.fn().mockResolvedValueOnce(true).mockResolvedValueOnce(false);
             });
-            it("should share node with proton and external email with default role", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ["email", "email2"] });
+            it('should share node with proton and external email with default role', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ['email', 'email2'] });
                 expect(sharingInfo).toEqual({
-                    protonInvitations: [invitation, {
-                            uid: "created-invitation",
-                            addedByEmail: { ok: true, value: "volume-email" },
-                            inviteeEmail: "email",
-                            role: "viewer",
-                        }],
-                    nonProtonInvitations: [externalInvitation, {
-                            uid: "created-external-invitation",
-                            addedByEmail: { ok: true, value: "volume-email" },
-                            inviteeEmail: "email2",
-                            role: "viewer",
-                            state: "pending",
-                        }],
+                    protonInvitations: [
+                        invitation,
+                        {
+                            uid: 'created-invitation',
+                            addedByEmail: { ok: true, value: 'volume-email' },
+                            inviteeEmail: 'email',
+                            role: 'viewer',
+                        },
+                    ],
+                    nonProtonInvitations: [
+                        externalInvitation,
+                        {
+                            uid: 'created-external-invitation',
+                            addedByEmail: { ok: true, value: 'volume-email' },
+                            inviteeEmail: 'email2',
+                            role: 'viewer',
+                            state: 'pending',
+                        },
+                    ],
                     members: [member],
                     publicLink: undefined,
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
-                expect(apiService.inviteProtonUser).toHaveBeenCalledWith("shareId", expect.objectContaining({
-                    inviteeEmail: "email",
+                expect(apiService.inviteProtonUser).toHaveBeenCalledWith('shareId', expect.objectContaining({
+                    inviteeEmail: 'email',
                 }), expect.anything());
-                expect(apiService.inviteExternalUser).toHaveBeenCalledWith("shareId", expect.objectContaining({
-                    inviteeEmail: "email2",
+                expect(apiService.inviteExternalUser).toHaveBeenCalledWith('shareId', expect.objectContaining({
+                    inviteeEmail: 'email2',
                 }), expect.anything());
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
         });
-        describe("members", () => {
-            it("should update member via proton user", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "member-email", role: interface_1.MemberRole.Editor }] });
+        describe('members', () => {
+            it('should update member via proton user', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'member-email', role: interface_1.MemberRole.Editor }],
+                });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
                     nonProtonInvitations: [externalInvitation],
-                    members: [{
+                    members: [
+                        {
                             ...member,
-                            role: "editor",
-                        }],
+                            role: 'editor',
+                        },
+                    ],
                     publicLink: undefined,
                 });
                 expect(apiService.updateMember).toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should be no-op if no change via proton user", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "member-email", role: interface_1.MemberRole.Viewer }] });
+            it('should be no-op if no change via proton user', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'member-email', role: interface_1.MemberRole.Viewer }],
+                });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
                     nonProtonInvitations: [externalInvitation],
@@ -410,26 +443,30 @@ describe("SharingManagement", () => {
                 expect(apiService.updateMember).not.toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should update member via non-proton user", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "member-email", role: interface_1.MemberRole.Editor }] });
+            it('should update member via non-proton user', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'member-email', role: interface_1.MemberRole.Editor }],
+                });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
                     nonProtonInvitations: [externalInvitation],
-                    members: [{
+                    members: [
+                        {
                             ...member,
-                            role: "editor",
-                        }],
+                            role: 'editor',
+                        },
+                    ],
                     publicLink: undefined,
                 });
                 expect(apiService.updateMember).toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
-            it("should be no-op if no change via non-proton user", async () => {
-                const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: [{ email: "member-email", role: interface_1.MemberRole.Viewer }] });
+            it('should be no-op if no change via non-proton user', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    users: [{ email: 'member-email', role: interface_1.MemberRole.Viewer }],
+                });
                 expect(sharingInfo).toEqual({
                     protonInvitations: [invitation],
                     nonProtonInvitations: [externalInvitation],
@@ -439,11 +476,10 @@ describe("SharingManagement", () => {
                 expect(apiService.updateMember).not.toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
         });
-        describe("public link", () => {
-            it("should share node with public link", async () => {
+        describe('public link', () => {
+            it('should share node with public link', async () => {
                 jest.useFakeTimers();
                 jest.setSystemTime(new Date('2025-01-01'));
                 const sharingInfo = await sharingManagement.shareNode(nodeUid, {
@@ -458,32 +494,33 @@ describe("SharingManagement", () => {
                     nonProtonInvitations: [externalInvitation],
                     members: [member],
                     publicLink: {
-                        uid: "publicLinkUid",
+                        uid: 'publicLinkUid',
                         role: interface_1.MemberRole.Viewer,
-                        url: "publicLinkUrl#generatedPassword",
+                        url: 'publicLinkUrl#generatedPassword',
                         creationTime: new Date(),
                         expirationTime: undefined,
                         customPassword: undefined,
-                        creatorEmail: "volume-email",
+                        creatorEmail: 'volume-email',
+                        numberOfInitializedDownloads: 0,
                     },
                 });
                 expect(cryptoService.generatePublicLinkPassword).toHaveBeenCalled();
-                expect(cryptoService.encryptPublicLink).toHaveBeenCalledWith("volume-email", "sharePassphraseSessionKey", "generatedPassword");
-                expect(apiService.createPublicLink).toHaveBeenCalledWith("shareId", expect.objectContaining({
+                expect(cryptoService.encryptPublicLink).toHaveBeenCalledWith('volume-email', 'sharePassphraseSessionKey', 'generatedPassword');
+                expect(apiService.createPublicLink).toHaveBeenCalledWith('shareId', expect.objectContaining({
                     role: interface_1.MemberRole.Viewer,
                     includesCustomPassword: false,
                     expirationTime: undefined,
-                    crypto: "publicLinkCrypto",
-                    srp: "publicLinkSrp",
+                    crypto: 'publicLinkCrypto',
+                    srp: 'publicLinkSrp',
                 }));
             });
-            it("should share node with custom password and expiration", async () => {
+            it('should share node with custom password and expiration', async () => {
                 jest.useFakeTimers();
                 jest.setSystemTime(new Date('2025-01-01'));
                 const sharingInfo = await sharingManagement.shareNode(nodeUid, {
                     publicLink: {
                         role: interface_1.MemberRole.Viewer,
-                        customPassword: "customPassword",
+                        customPassword: 'customPassword',
                         expiration: new Date('2025-01-02'),
                     },
                 });
@@ -492,42 +529,43 @@ describe("SharingManagement", () => {
                     nonProtonInvitations: [externalInvitation],
                     members: [member],
                     publicLink: {
-                        uid: "publicLinkUid",
+                        uid: 'publicLinkUid',
                         role: interface_1.MemberRole.Viewer,
-                        url: "publicLinkUrl#generatedPassword",
+                        url: 'publicLinkUrl#generatedPassword',
                         creationTime: new Date(),
                         expirationTime: new Date('2025-01-02'),
-                        customPassword: "customPassword",
-                        creatorEmail: "volume-email",
+                        customPassword: 'customPassword',
+                        creatorEmail: 'volume-email',
+                        numberOfInitializedDownloads: 0,
                     },
                 });
                 expect(cryptoService.generatePublicLinkPassword).toHaveBeenCalled();
-                expect(cryptoService.encryptPublicLink).toHaveBeenCalledWith("volume-email", "sharePassphraseSessionKey", "generatedPasswordcustomPassword");
-                expect(apiService.createPublicLink).toHaveBeenCalledWith("shareId", expect.objectContaining({
+                expect(cryptoService.encryptPublicLink).toHaveBeenCalledWith('volume-email', 'sharePassphraseSessionKey', 'generatedPasswordcustomPassword');
+                expect(apiService.createPublicLink).toHaveBeenCalledWith('shareId', expect.objectContaining({
                     role: interface_1.MemberRole.Viewer,
                     includesCustomPassword: true,
                     expirationTime: 1735776000,
-                    crypto: "publicLinkCrypto",
-                    srp: "publicLinkSrp",
+                    crypto: 'publicLinkCrypto',
+                    srp: 'publicLinkSrp',
                 }));
             });
-            it("should update public link with custom password and expiration", async () => {
+            it('should update public link with custom password and expiration', async () => {
                 jest.useFakeTimers();
                 jest.setSystemTime(new Date('2025-01-01'));
                 const publicLink = {
                     uid: 'publicLinkUid',
-                    url: "publicLinkUrl#generatedpas", // Generated password must be 12 chararacters long.
+                    url: 'publicLinkUrl#generatedpas', // Generated password must be 12 chararacters long.
                     creationTime: new Date('2025-01-01'),
                     role: interface_1.MemberRole.Viewer,
                     customPassword: undefined,
                     expirationTime: undefined,
-                    creatorEmail: "publicLinkCreatorEmail",
+                    creatorEmail: 'publicLinkCreatorEmail',
                 };
                 apiService.getPublicLink = jest.fn().mockResolvedValue(publicLink);
                 const sharingInfo = await sharingManagement.shareNode(nodeUid, {
                     publicLink: {
                         role: interface_1.MemberRole.Editor,
-                        customPassword: "customPassword",
+                        customPassword: 'customPassword',
                         expiration: new Date('2025-01-02'),
                     },
                 });
@@ -536,43 +574,43 @@ describe("SharingManagement", () => {
                     nonProtonInvitations: [externalInvitation],
                     members: [member],
                     publicLink: {
-                        uid: "publicLinkUid",
+                        uid: 'publicLinkUid',
                         role: interface_1.MemberRole.Editor,
-                        url: "publicLinkUrl#generatedpas",
+                        url: 'publicLinkUrl#generatedpas',
                         creationTime: new Date('2025-01-01'),
                         expirationTime: new Date('2025-01-02'),
-                        customPassword: "customPassword",
-                        creatorEmail: "publicLinkCreatorEmail",
+                        customPassword: 'customPassword',
+                        creatorEmail: 'publicLinkCreatorEmail',
                     },
                 });
-                expect(cryptoService.encryptPublicLink).toHaveBeenCalledWith("publicLinkCreatorEmail", "sharePassphraseSessionKey", "generatedpascustomPassword");
-                expect(apiService.updatePublicLink).toHaveBeenCalledWith("publicLinkUid", expect.objectContaining({
+                expect(cryptoService.encryptPublicLink).toHaveBeenCalledWith('publicLinkCreatorEmail', 'sharePassphraseSessionKey', 'generatedpascustomPassword');
+                expect(apiService.updatePublicLink).toHaveBeenCalledWith('publicLinkUid', expect.objectContaining({
                     role: interface_1.MemberRole.Editor,
                     includesCustomPassword: true,
                     expirationTime: 1735776000,
-                    crypto: "publicLinkCrypto",
-                    srp: "publicLinkSrp",
+                    crypto: 'publicLinkCrypto',
+                    srp: 'publicLinkSrp',
                 }));
             });
-            it("should not allow updating legacy public link", async () => {
+            it('should not allow updating legacy public link', async () => {
                 apiService.getPublicLink = jest.fn().mockResolvedValue({
                     uid: 'publicLinkUid',
-                    url: "publicLinkUrl#aaa", // Legacy public links doesn't have 12 chars.
+                    url: 'publicLinkUrl#aaa', // Legacy public links doesn't have 12 chars.
                 });
                 await expect(sharingManagement.shareNode(nodeUid, {
                     publicLink: true,
-                })).rejects.toThrow("Legacy public link cannot be updated. Please re-create a new public link.");
+                })).rejects.toThrow('Legacy public link cannot be updated. Please re-create a new public link.');
             });
-            it("should not allow updating legacy public link without generated password", async () => {
+            it('should not allow updating legacy public link without generated password', async () => {
                 apiService.getPublicLink = jest.fn().mockResolvedValue({
                     uid: 'publicLinkUid',
-                    url: "publicLinkUrl",
+                    url: 'publicLinkUrl',
                 });
                 await expect(sharingManagement.shareNode(nodeUid, {
                     publicLink: true,
-                })).rejects.toThrow("Legacy public link cannot be updated. Please re-create a new public link.");
+                })).rejects.toThrow('Legacy public link cannot be updated. Please re-create a new public link.');
             });
-            it("should not allow creating public link with expiration in the past", async () => {
+            it('should not allow creating public link with expiration in the past', async () => {
                 jest.useFakeTimers();
                 jest.setSystemTime(new Date('2025-01-01'));
                 await expect(sharingManagement.shareNode(nodeUid, {
@@ -580,60 +618,55 @@ describe("SharingManagement", () => {
                         role: interface_1.MemberRole.Viewer,
                         expiration: new Date('2024-01-01'),
                     },
-                })).rejects.toThrow("Expiration date cannot be in the past");
+                })).rejects.toThrow('Expiration date cannot be in the past');
                 expect(apiService.createStandardShare).not.toHaveBeenCalled();
                 expect(apiService.createPublicLink).not.toHaveBeenCalled();
             });
         });
     });
-    describe("unsahreNode", () => {
-        const nodeUid = "volumeId~nodeUid";
+    describe('unshareNode', () => {
+        const nodeUid = 'volumeId~nodeUid';
         let invitation;
         let externalInvitation;
         let member;
         let publicLink;
         beforeEach(async () => {
             invitation = {
-                uid: "invitation",
-                addedByEmail: (0, interface_1.resultOk)("added-email"),
-                inviteeEmail: "internal-email",
+                uid: 'invitation',
+                addedByEmail: (0, interface_1.resultOk)('added-email'),
+                inviteeEmail: 'internal-email',
                 role: interface_1.MemberRole.Viewer,
                 invitationTime: new Date(),
             };
             externalInvitation = {
-                uid: "external-invitation",
-                addedByEmail: (0, interface_1.resultOk)("added-email"),
-                inviteeEmail: "external-email",
+                uid: 'external-invitation',
+                addedByEmail: (0, interface_1.resultOk)('added-email'),
+                inviteeEmail: 'external-email',
                 role: interface_1.MemberRole.Viewer,
                 invitationTime: new Date(),
                 state: interface_1.NonProtonInvitationState.Pending,
             };
             member = {
-                uid: "member",
-                addedByEmail: (0, interface_1.resultOk)("added-email"),
-                inviteeEmail: "member-email",
+                uid: 'member',
+                addedByEmail: (0, interface_1.resultOk)('added-email'),
+                inviteeEmail: 'member-email',
                 role: interface_1.MemberRole.Viewer,
                 invitationTime: new Date(),
             };
             publicLink = {
-                uid: "publicLink",
+                uid: 'publicLink',
                 creationTime: new Date(),
                 role: interface_1.MemberRole.Viewer,
-                url: "url",
+                url: 'url',
+                numberOfInitializedDownloads: 0,
             };
-            apiService.getShareInvitations = jest.fn().mockResolvedValue([
-                invitation,
-            ]);
-            apiService.getShareExternalInvitations = jest.fn().mockResolvedValue([
-                externalInvitation,
-            ]);
-            apiService.getShareMembers = jest.fn().mockResolvedValue([
-                member,
-            ]);
+            apiService.getShareInvitations = jest.fn().mockResolvedValue([invitation]);
+            apiService.getShareExternalInvitations = jest.fn().mockResolvedValue([externalInvitation]);
+            apiService.getShareMembers = jest.fn().mockResolvedValue([member]);
             apiService.getPublicLink = jest.fn().mockResolvedValue(publicLink);
         });
-        it("should delete invitation", async () => {
-            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { users: ["internal-email"] });
+        it('should delete invitation', async () => {
+            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { users: ['internal-email'] });
             expect(sharingInfo).toEqual({
                 protonInvitations: [],
                 nonProtonInvitations: [externalInvitation],
@@ -645,10 +678,9 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
-        it("should delete external invitation", async () => {
-            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { users: ["external-email"] });
+        it('should delete external invitation', async () => {
+            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { users: ['external-email'] });
             expect(sharingInfo).toEqual({
                 protonInvitations: [invitation],
                 nonProtonInvitations: [],
@@ -660,10 +692,9 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
-        it("should remove member", async () => {
-            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { users: ["member-email"] });
+        it('should remove member', async () => {
+            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { users: ['member-email'] });
             expect(sharingInfo).toEqual({
                 protonInvitations: [invitation],
                 nonProtonInvitations: [externalInvitation],
@@ -675,10 +706,9 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
-        it("should be no-op if not shared with email", async () => {
-            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { users: ["non-existing-email"] });
+        it('should be no-op if not shared with email', async () => {
+            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { users: ['non-existing-email'] });
             expect(sharingInfo).toEqual({
                 protonInvitations: [invitation],
                 nonProtonInvitations: [externalInvitation],
@@ -690,10 +720,9 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
-        it("should remove public link", async () => {
-            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { publicLink: "remove" });
+        it('should remove public link', async () => {
+            const sharingInfo = await sharingManagement.unshareNode(nodeUid, { publicLink: 'remove' });
             expect(sharingInfo).toEqual({
                 protonInvitations: [invitation],
                 nonProtonInvitations: [externalInvitation],
@@ -705,9 +734,8 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
-        it("should remove share if all is removed", async () => {
+        it('should remove share if all is removed', async () => {
             const sharingInfo = await sharingManagement.unshareNode(nodeUid);
             expect(sharingInfo).toEqual(undefined);
             expect(apiService.deleteShare).toHaveBeenCalled();
@@ -715,16 +743,12 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith({
-                uid: nodeUid,
-                shareId: undefined,
-                isShared: false,
-            });
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalled();
         });
-        it("should remove share if everything is manually removed", async () => {
+        it('should remove share if everything is manually removed', async () => {
             const sharingInfo = await sharingManagement.unshareNode(nodeUid, {
-                users: ["internal-email", "external-email", "member-email"],
-                publicLink: "remove",
+                users: ['internal-email', 'external-email', 'member-email'],
+                publicLink: 'remove',
             });
             expect(sharingInfo).toEqual(undefined);
             expect(apiService.deleteShare).toHaveBeenCalled();
@@ -732,26 +756,21 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).toHaveBeenCalled();
             expect(apiService.removeMember).toHaveBeenCalled();
             expect(apiService.removePublicLink).toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith({
-                uid: nodeUid,
-                shareId: undefined,
-                isShared: false,
-            });
         });
     });
-    describe("resendInvitationEmail", () => {
-        const nodeUid = "volumeId~nodeUid";
+    describe('resendInvitationEmail', () => {
+        const nodeUid = 'volumeId~nodeUid';
         const invitation = {
-            uid: "invitation",
-            addedByEmail: (0, interface_1.resultOk)("added-email"),
-            inviteeEmail: "internal-email",
+            uid: 'invitation',
+            addedByEmail: (0, interface_1.resultOk)('added-email'),
+            inviteeEmail: 'internal-email',
             role: interface_1.MemberRole.Viewer,
             invitationTime: new Date(),
         };
         const externalInvitation = {
-            uid: "external-invitation",
-            addedByEmail: (0, interface_1.resultOk)("added-email"),
-            inviteeEmail: "external-email",
+            uid: 'external-invitation',
+            addedByEmail: (0, interface_1.resultOk)('added-email'),
+            inviteeEmail: 'external-email',
             role: interface_1.MemberRole.Viewer,
             invitationTime: new Date(),
             state: interface_1.NonProtonInvitationState.Pending,
@@ -762,24 +781,24 @@ describe("SharingManagement", () => {
             apiService.getShareMembers = jest.fn().mockResolvedValue([]);
             apiService.getPublicLink = jest.fn().mockResolvedValue(undefined);
         });
-        it("should resend email for proton invitation", async () => {
+        it('should resend email for proton invitation', async () => {
             await sharingManagement.resendInvitationEmail(nodeUid, invitation.uid);
             expect(apiService.resendInvitationEmail).toHaveBeenCalledWith(invitation.uid);
             expect(apiService.resendExternalInvitationEmail).not.toHaveBeenCalled();
         });
-        it("should resend email for external invitation", async () => {
+        it('should resend email for external invitation', async () => {
             await sharingManagement.resendInvitationEmail(nodeUid, externalInvitation.uid);
             expect(apiService.resendExternalInvitationEmail).toHaveBeenCalledWith(externalInvitation.uid);
             expect(apiService.resendInvitationEmail).not.toHaveBeenCalled();
         });
-        it("should throw error when no sharing found for node", async () => {
+        it('should throw error when no sharing found for node', async () => {
             nodesService.getNode = jest.fn().mockResolvedValue({ nodeUid, shareId: undefined });
-            await expect(sharingManagement.resendInvitationEmail(nodeUid, invitation.uid)).rejects.toThrow("Node is not shared");
+            await expect(sharingManagement.resendInvitationEmail(nodeUid, invitation.uid)).rejects.toThrow('Node is not shared');
             expect(apiService.resendInvitationEmail).not.toHaveBeenCalled();
             expect(apiService.resendExternalInvitationEmail).not.toHaveBeenCalled();
         });
-        it("should log when no invitation found", async () => {
-            await expect(sharingManagement.resendInvitationEmail(nodeUid, "non-existent-uid")).rejects.toThrow("Invitation not found");
+        it('should log when no invitation found', async () => {
+            await expect(sharingManagement.resendInvitationEmail(nodeUid, 'non-existent-uid')).rejects.toThrow('Invitation not found');
             expect(apiService.resendInvitationEmail).not.toHaveBeenCalled();
             expect(apiService.resendExternalInvitationEmail).not.toHaveBeenCalled();
         });