cozy-sharing 28.5.0 → 28.7.0

package/dist/components/Recipient/MemberRecipientPermissions.spec.js

@@ -0,0 +1,214 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _extends from "@babel/runtime/helpers/extends";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { render, fireEvent, screen, act, waitFor } from '@testing-library/react';
+import React from 'react';
+import { createMockClient } from 'cozy-client';
+import MemberRecipientPermissions from './MemberRecipientPermissions';
+import AppLike from '../../../test/AppLike';
+var mockUpdateSharingMemberType = jest.fn();
+var mockShowAlert = jest.fn();
+jest.mock('../../hooks/useSharingContext', function () {
+  return {
+    useSharingContext: function useSharingContext() {
+      return {
+        updateSharingMemberType: mockUpdateSharingMemberType
+      };
+    }
+  };
+});
+jest.mock('cozy-ui/transpiled/react/providers/Alert', function () {
+  return {
+    __esModule: true,
+    default: function _default(_ref) {
+      var children = _ref.children;
+      return children;
+    },
+    useAlert: function useAlert() {
+      return {
+        showAlert: mockShowAlert
+      };
+    }
+  };
+});
+describe('MemberRecipientPermissions component', function () {
+  var client = createMockClient({});
+  client.options = {
+    uri: 'http://cozy.local:8080'
+  };
+  var defaultProps = {
+    isOwner: true,
+    isSharedDrive: false,
+    status: 'ready',
+    instance: 'http://cozy.local:8080',
+    type: 'two-way',
+    document: {
+      id: 'doc-123',
+      type: 'io.cozy.files',
+      path: '/test'
+    },
+    sharingId: 'sharing-123',
+    memberIndex: 1,
+    onRevoke: jest.fn(),
+    onRevokeSelf: jest.fn()
+  };
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+
+  var setup = function setup(props) {
+    return render( /*#__PURE__*/React.createElement(AppLike, {
+      client: client
+    }, /*#__PURE__*/React.createElement(MemberRecipientPermissions, _extends({}, defaultProps, props))));
+  };
+
+  var createRangeBackup;
+  beforeAll(function () {
+    createRangeBackup = global.document.createRange;
+    global.document.createRange = jest.fn(function () {
+      return {
+        setStart: function setStart() {},
+        setEnd: function setEnd() {},
+        commonAncestorContainer: {
+          nodeName: 'BODY',
+          ownerDocument: document
+        }
+      };
+    });
+  });
+  afterAll(function () {
+    global.document.createRange = createRangeBackup;
+  });
+  it('should render the current permission type', function () {
+    setup();
+    expect(screen.getByText('can change')).toBeInTheDocument();
+  });
+  it('should call updateSharingMemberType when changing to one-way', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _setup, getByText;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          mockUpdateSharingMemberType.mockResolvedValue(undefined);
+          _setup = setup({
+            type: 'two-way'
+          }), getByText = _setup.getByText;
+          fireEvent.click(getByText('can change'));
+          fireEvent.click(getByText('Can view'));
+          expect(mockUpdateSharingMemberType).toHaveBeenCalledWith('sharing-123', 1, 'one-way');
+
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('should call updateSharingMemberType when changing to two-way', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _setup2, getByText;
+
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          mockUpdateSharingMemberType.mockResolvedValue(undefined);
+          _setup2 = setup({
+            type: 'one-way'
+          }), getByText = _setup2.getByText;
+          fireEvent.click(getByText('can view'));
+          fireEvent.click(getByText('Can change'));
+          expect(mockUpdateSharingMemberType).toHaveBeenCalledWith('sharing-123', 1, 'two-way');
+
+        case 5:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('should show error alert when updateSharingMemberType fails', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _setup3, getByText;
+
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          mockUpdateSharingMemberType.mockRejectedValue(new Error('Network error'));
+          _setup3 = setup({
+            type: 'two-way'
+          }), getByText = _setup3.getByText;
+          _context4.next = 4;
+          return act( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  fireEvent.click(getByText('can change'));
+                  fireEvent.click(getByText('Can view'));
+
+                case 2:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+
+        case 4:
+          _context4.next = 6;
+          return waitFor(function () {
+            expect(mockShowAlert).toHaveBeenCalledWith({
+              message: 'An error occurred while changing the permissions. Please try again.',
+              severity: 'error',
+              variant: 'filled'
+            });
+          });
+
+        case 6:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('should not call updateSharingMemberType when selecting same type', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var _setup4, getByText;
+
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          mockUpdateSharingMemberType.mockResolvedValue(undefined);
+          _setup4 = setup({
+            type: 'two-way'
+          }), getByText = _setup4.getByText;
+          fireEvent.click(getByText('can change'));
+          fireEvent.click(getByText('Can change'));
+          expect(mockUpdateSharingMemberType).not.toHaveBeenCalled();
+
+        case 5:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  it('should not render menu when user is not owner and not the shared drive contact', function () {
+    var _setup5 = setup({
+      isOwner: false,
+      instance: 'http://other-cozy.local:8080'
+    }),
+        queryByText = _setup5.queryByText;
+
+    expect(queryByText('can change')).not.toBeInTheDocument();
+    expect(queryByText('can view')).not.toBeInTheDocument();
+  });
+  it('should render menu for owner', function () {
+    var _setup6 = setup({
+      isOwner: true
+    }),
+        getByText = _setup6.getByText;
+
+    expect(getByText('can change')).toBeInTheDocument();
+  });
+  it('should render menu for the user themselves', function () {
+    var _setup7 = setup({
+      isOwner: false,
+      instance: 'http://cozy.local:8080'
+    }),
+        getByText = _setup7.getByText;
+
+    expect(getByText('can change')).toBeInTheDocument();
+  });
+});

package/dist/components/Recipient/actions/revokeLink.js

@@ -0,0 +1,34 @@
+import _extends from "@babel/runtime/helpers/extends";
+import React, { forwardRef } from 'react';
+import ActionsMenuItem from 'cozy-ui/transpiled/react/ActionsMenu/ActionsMenuItem';
+import Icon from 'cozy-ui/transpiled/react/Icon';
+import TrashIcon from 'cozy-ui/transpiled/react/Icons/Trash';
+import ListItemIcon from 'cozy-ui/transpiled/react/ListItemIcon';
+import ListItemText from 'cozy-ui/transpiled/react/ListItemText';
+import Typography from 'cozy-ui/transpiled/react/Typography';
+
+var revokeLink = function revokeLink(_ref) {
+  var t = _ref.t,
+      handleRevocation = _ref.handleRevocation;
+  var title = t('Share.permissionLink.deactivate');
+  return {
+    name: 'revokeLink',
+    label: title,
+    icon: TrashIcon,
+    action: handleRevocation,
+    Component: /*#__PURE__*/forwardRef(function RevokeLinkItem(props, ref) {
+      return /*#__PURE__*/React.createElement(ActionsMenuItem, _extends({}, props, {
+        ref: ref
+      }), /*#__PURE__*/React.createElement(ListItemIcon, null, /*#__PURE__*/React.createElement(Icon, {
+        icon: TrashIcon,
+        color: "var(--errorColor)"
+      })), /*#__PURE__*/React.createElement(ListItemText, {
+        primary: /*#__PURE__*/React.createElement(Typography, {
+          color: "error"
+        }, title)
+      }));
+    })
+  };
+};
+
+export { revokeLink };

package/dist/components/Recipient/actions/setReadOnlySharedPermission.js

@@ -12,7 +12,6 @@ var makeComponent = function makeComponent(_ref) {
   var Component = /*#__PURE__*/forwardRef(function (props, ref) {
     return /*#__PURE__*/React.createElement(ActionsMenuItem, _extends({}, props, {
       ref: ref,
-      button: false,
       onClick: onClick
     }), /*#__PURE__*/React.createElement(ListItemIcon, null, /*#__PURE__*/React.createElement(Radios, {
       checked: type === 'one-way'

package/dist/components/Recipient/actions/setReadOnlySharedPermission.spec.js

@@ -0,0 +1,72 @@
+import { render, screen, fireEvent } from '@testing-library/react';
+import React from 'react';
+import { setReadOnlySharedPermission } from './setReadOnlySharedPermission';
+import AppLike from '../../../../test/AppLike';
+
+var mockT = function mockT(key) {
+  var translations = {
+    'Share.type.one-way': 'Can view',
+    'Share.type.two-way': 'Can change'
+  };
+  return translations[key] || key;
+};
+
+describe('setReadOnlySharedPermission', function () {
+  var setType;
+  beforeEach(function () {
+    setType = jest.fn();
+  });
+  it('should return correct action structure', function () {
+    var action = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'one-way',
+      setType: setType
+    });
+    expect(action.name).toBe('setReadOnlySharedPermission');
+    expect(action.label).toBe('Can view');
+    expect(action.icon).toBeNull();
+  });
+  it('should call setType with one-way when action is triggered', function () {
+    var action = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'two-way',
+      setType: setType
+    });
+    action.action();
+    expect(setType).toHaveBeenCalledWith('one-way');
+  });
+  it('should render radio as checked when type is one-way', function () {
+    var _setReadOnlySharedPer = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'one-way',
+      setType: setType
+    }),
+        Component = _setReadOnlySharedPer.Component;
+
+    render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(Component, null)));
+    expect(screen.getByRole('radio')).toBeChecked();
+  });
+  it('should render radio as unchecked when type is two-way', function () {
+    var _setReadOnlySharedPer2 = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'two-way',
+      setType: setType
+    }),
+        Component = _setReadOnlySharedPer2.Component;
+
+    render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(Component, null)));
+    expect(screen.getByRole('radio')).not.toBeChecked();
+  });
+  it('should call setType with one-way when the component is clicked', function () {
+    var _setReadOnlySharedPer3 = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'two-way',
+      setType: setType
+    }),
+        Component = _setReadOnlySharedPer3.Component;
+
+    render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(Component, null)));
+    fireEvent.click(screen.getByText('Can view'));
+    expect(setType).toHaveBeenCalledWith('one-way');
+  });
+});

package/dist/components/Recipient/actions/setReadWriteSharedPermission.js

@@ -12,7 +12,6 @@ var makeComponent = function makeComponent(_ref) {
   var Component = /*#__PURE__*/forwardRef(function (props, ref) {
     return /*#__PURE__*/React.createElement(ActionsMenuItem, _extends({}, props, {
       ref: ref,
-      button: false,
       onClick: onClick
     }), /*#__PURE__*/React.createElement(ListItemIcon, null, /*#__PURE__*/React.createElement(Radios, {
       checked: type === 'two-way'

package/dist/components/Recipient/actions/setReadWriteSharedPermission.spec.js

@@ -0,0 +1,72 @@
+import { render, screen, fireEvent } from '@testing-library/react';
+import React from 'react';
+import { setReadWriteSharedPermission } from './setReadWriteSharedPermission';
+import AppLike from '../../../../test/AppLike';
+
+var mockT = function mockT(key) {
+  var translations = {
+    'Share.type.one-way': 'Can view',
+    'Share.type.two-way': 'Can change'
+  };
+  return translations[key] || key;
+};
+
+describe('setReadWriteSharedPermission', function () {
+  var setType;
+  beforeEach(function () {
+    setType = jest.fn();
+  });
+  it('should return correct action structure', function () {
+    var action = setReadWriteSharedPermission({
+      t: mockT,
+      type: 'two-way',
+      setType: setType
+    });
+    expect(action.name).toBe('setReadWriteSharedPermission');
+    expect(action.label).toBe('Can change');
+    expect(action.icon).toBeNull();
+  });
+  it('should call setType with two-way when action is triggered', function () {
+    var action = setReadWriteSharedPermission({
+      t: mockT,
+      type: 'one-way',
+      setType: setType
+    });
+    action.action();
+    expect(setType).toHaveBeenCalledWith('two-way');
+  });
+  it('should render radio as checked when type is two-way', function () {
+    var _setReadWriteSharedPe = setReadWriteSharedPermission({
+      t: mockT,
+      type: 'two-way',
+      setType: setType
+    }),
+        Component = _setReadWriteSharedPe.Component;
+
+    render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(Component, null)));
+    expect(screen.getByRole('radio')).toBeChecked();
+  });
+  it('should render radio as unchecked when type is one-way', function () {
+    var _setReadWriteSharedPe2 = setReadWriteSharedPermission({
+      t: mockT,
+      type: 'one-way',
+      setType: setType
+    }),
+        Component = _setReadWriteSharedPe2.Component;
+
+    render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(Component, null)));
+    expect(screen.getByRole('radio')).not.toBeChecked();
+  });
+  it('should call setType with two-way when the component is clicked', function () {
+    var _setReadWriteSharedPe3 = setReadWriteSharedPermission({
+      t: mockT,
+      type: 'one-way',
+      setType: setType
+    }),
+        Component = _setReadWriteSharedPe3.Component;
+
+    render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(Component, null)));
+    fireEvent.click(screen.getByText('Can change'));
+    expect(setType).toHaveBeenCalledWith('two-way');
+  });
+});

package/dist/components/ShareDialogCozyToCozy.spec.js

@@ -29,6 +29,15 @@ jest.mock('cozy-client', function () {
     }
   });
 });
+jest.mock('../hooks/useSharingContext', function () {
+  return {
+    useSharingContext: function useSharingContext() {
+      return {
+        updateSharingMemberType: jest.fn()
+      };
+    }
+  };
+});
 describe('ShareDialogCozyToCozy', function () {
   var client = createMockClient({});
   client.options = {

package/dist/components/WhoHasAccess.js

@@ -55,7 +55,6 @@ var WhoHasAccess = function WhoHasAccess(_ref2) {
     documentType: documentType,
     onRevoke: onRevoke,
     onRevokeSelf: onRevokeSelf,
-    link: link,
     permissions: permissions,
     fadeIn: linkHasBeenJustCreated
   }), /*#__PURE__*/React.createElement(OwnerRecipient, {

package/locales/en.json

@@ -34,7 +34,10 @@
     "members": {
       "count": "%{smart_count} member |||| %{smart_count} members",
       "others": "and 1 other… |||| and %{smart_count} others…",
-      "otherContacts": "other contact |||| other contacts"
+      "otherContacts": "other contact |||| other contacts",
+      "error": {
+        "changePermission": "An error occurred while changing the permissions. Please try again."
+      }
     },
     "contacts": {
       "whoHasAccess": "Who has access?",

package/locales/fr.json

@@ -34,7 +34,10 @@
     "members": {
       "count": "%{smart_count} membre |||| %{smart_count} membres",
       "others": "et 1 autre… |||| et %{smart_count} autres…",
-      "otherContacts": "autre contact |||| autres contacts"
+      "otherContacts": "autre contact |||| autres contacts",
+      "error": {
+        "changePermission": "Une erreur s'est produite lors du changement des permissions. Veuillez réessayer."
+      }
     },
     "contacts": {
       "whoHasAccess": "Qui a accès ?",

package/locales/ru.json

@@ -34,7 +34,10 @@
     "members": {
       "count": "%{smart_count} участник |||| %{smart_count} участника |||| %{smart_count} участников",
       "others": "и 1 другой… |||| и %{smart_count} других…",
-      "otherContacts": "другой контакт |||| других контакта"
+      "otherContacts": "другой контакт |||| других контакта",
+      "error": {
+        "changePermission": "Произошла ошибка при изменении разрешений. Пожалуйста, попробуйте снова."
+      }
     },
     "contacts": {
       "whoHasAccess": "У кого есть доступ?",

package/locales/vi.json

@@ -34,7 +34,10 @@
     "members": {
       "count": "%{smart_count} thành viên |||| %{smart_count} thành viên",
       "others": "và 1 người khác… |||| và %{smart_count} người khác…",
-      "otherContacts": "người liên hệ khác |||| người liên hệ khác"
+      "otherContacts": "người liên hệ khác |||| người liên hệ khác",
+      "error": {
+        "changePermission": "Đã xảy ra lỗi khi thay đổi quyền. Vui lòng thử lại."
+      }
     },
     "contacts": {
       "whoHasAccess": "Ai có quyền truy cập?",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "28.5.0",
+  "version": "28.7.0",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -83,5 +83,5 @@
   "sideEffects": [
     "*.css"
   ],
-  "gitHead": "598f2e27b115ca69eda056332c6ab91fa92096d3"
+  "gitHead": "421077ecc24c9a15a3a1c22d9c3442917292f8ba"
 }

package/src/SharingProvider.jsx

@@ -94,7 +94,8 @@ export class SharingProvider extends Component {
       revokeAllRecipients: this.revokeAllRecipients,
       refresh: this.fetchAllSharings,
       hasWriteAccess: this.hasWriteAccess,
-      renameSharedDrive: this.renameSharedDrive
+      renameSharedDrive: this.renameSharedDrive,
+      updateSharingMemberType: this.updateSharingMemberType
     }
     this.isPublic = props.isPublic ?? false
     this.realtime = null
@@ -339,6 +340,55 @@ export class SharingProvider extends Component {
     this.dispatch(revokeSelf(sharing))
   }
 
+  /**
+   * Update a sharing member's read_only field to change permission type
+   * @param {string} sharingId - The ID of the sharing
+   * @param {number} memberIndex - The index of the member in the sharing members array
+   * @param {string} newType - 'one-way' for read-only, 'two-way' for read-write
+   */
+  updateSharingMemberType = async (sharingId, memberIndex, newType) => {
+    const sharing = getSharingById(this.state, sharingId)
+    if (!sharing) throw new Error('Sharing not found')
+
+    const member = sharing.attributes.members[memberIndex]
+    if (!member) throw new Error('Member not found')
+
+    // Find the contact by email (same pattern as helpers/contacts.js)
+    const matchedContacts = await this.props.client
+      .collection('io.cozy.contacts')
+      .find(
+        {
+          email: { $elemMatch: { address: member.email } },
+          _id: { $gt: null }
+        },
+        { indexedFields: ['_id'] }
+      )
+
+    if (!matchedContacts.data.length) {
+      throw new Error(`Contact not found for member ${member.email}`)
+    }
+    const contact = matchedContacts.data[0]
+
+    // Revoke (API call only, no state dispatch to avoid UI flickering)
+    await this.sharingCol.revokeRecipient(sharing, memberIndex)
+
+    // Re-add with the new permission type
+    const readOnly = newType === 'one-way'
+    try {
+      await this.addRecipients({
+        document: sharing,
+        recipients: readOnly ? [] : [contact],
+        readOnlyRecipients: readOnly ? [contact] : []
+      })
+    } catch (error) {
+      log.error(
+        `Failed to re-add member ${member.email} after revocation. The member has been revoked but could not be re-added with the new permission type.`,
+        error
+      )
+      throw error
+    }
+  }
+
   shareByLink = async (document, options) => {
     const resp = document.driveId
       ? await this.createSharedDriveSharingLink(document, options)
@@ -438,6 +488,7 @@ export class SharingProvider extends Component {
               updatedPermissions,
               { expiresAt, password }
             )
+        this.dispatch(updateSharingLink(resp.data))
         return resp
       })
     )

package/src/SharingProvider.spec.jsx

@@ -234,6 +234,100 @@ describe('updateDocumentPermissions', () => {
   })
 })
 
+describe('updateSharingMemberType', () => {
+  const mockContact = { _id: 'contact-1', email: [{ address: 'bob@bob.cozy' }] }
+  const mockSharing = {
+    id: 'sharing-123',
+    type: 'io.cozy.sharings',
+    attributes: {
+      members: [
+        { status: 'owner', email: 'owner@cozy.local' },
+        { status: 'ready', email: 'bob@bob.cozy' }
+      ]
+    }
+  }
+
+  let instance
+  let mockContactsCollection
+
+  beforeEach(() => {
+    mockContactsCollection = {
+      find: jest.fn().mockResolvedValue({ data: [mockContact] })
+    }
+
+    const mockClient = {
+      getStackClient: () => ({ uri: 'http://cozy.local' }),
+      collection: jest.fn().mockReturnValue(mockContactsCollection)
+    }
+
+    instance = new SharingProvider({ client: mockClient })
+    instance.state = {
+      ...instance.state,
+      sharings: [mockSharing]
+    }
+    instance.sharingCol = {
+      revokeRecipient: jest.fn().mockResolvedValue({})
+    }
+    jest.spyOn(instance, 'addRecipients').mockResolvedValue({})
+  })
+
+  it('should throw when sharing is not found', async () => {
+    await expect(
+      instance.updateSharingMemberType('unknown-id', 1, 'one-way')
+    ).rejects.toThrow('Sharing not found')
+  })
+
+  it('should throw when member is not found', async () => {
+    await expect(
+      instance.updateSharingMemberType('sharing-123', 99, 'one-way')
+    ).rejects.toThrow('Member not found')
+  })
+
+  it('should throw when contact is not found', async () => {
+    mockContactsCollection.find.mockResolvedValue({ data: [] })
+
+    await expect(
+      instance.updateSharingMemberType('sharing-123', 1, 'one-way')
+    ).rejects.toThrow('Contact not found')
+  })
+
+  it('should revoke and re-add with readOnly when switching to one-way', async () => {
+    await instance.updateSharingMemberType('sharing-123', 1, 'one-way')
+
+    expect(instance.sharingCol.revokeRecipient).toHaveBeenCalledWith(
+      mockSharing,
+      1
+    )
+    expect(instance.addRecipients).toHaveBeenCalledWith({
+      document: mockSharing,
+      recipients: [],
+      readOnlyRecipients: [mockContact]
+    })
+  })
+
+  it('should revoke and re-add as read-write when switching to two-way', async () => {
+    await instance.updateSharingMemberType('sharing-123', 1, 'two-way')
+
+    expect(instance.sharingCol.revokeRecipient).toHaveBeenCalledWith(
+      mockSharing,
+      1
+    )
+    expect(instance.addRecipients).toHaveBeenCalledWith({
+      document: mockSharing,
+      recipients: [mockContact],
+      readOnlyRecipients: []
+    })
+  })
+
+  it('should rethrow error if addRecipients fails after revocation', async () => {
+    instance.addRecipients.mockRejectedValue(new Error('Network error'))
+
+    await expect(
+      instance.updateSharingMemberType('sharing-123', 1, 'one-way')
+    ).rejects.toThrow('Network error')
+  })
+})
+
 // TODO Convert with react-testing-library
 // describe('hasWriteAccess', () => {
 //   it('tells if a doc is writtable', () => {