cozy-sharing 33.3.4 → 33.4.1

package/dist/components/Recipient/OwnerRecipientDefaultLite.js

@@ -2,7 +2,10 @@ import React from 'react';
 import { useClient, useQuery, hasQueryBeenLoaded } from 'cozy-client';
 import MemberRecipientLite from './MemberRecipientLite';
 import withLocales from '../../hoc/withLocales';
-import { buildInstanceSettingsQuery } from '../../queries/queries';
+import { buildInstanceSettingsQuery } from '../../queries/queries'; // See OwnerRecipientDefault: show the instance public avatar (with an initials
+// fallback) when the owner has no per-sharing avatar to reference.
+
+var OWNER_PUBLIC_AVATAR_PATH = '/public/avatar?fallback=initials';
 
 var OwnerRecipientDefaultLite = function OwnerRecipientDefaultLite() {
   var _instanceSettingsResu;
@@ -14,6 +17,7 @@ var OwnerRecipientDefaultLite = function OwnerRecipientDefaultLite() {
     recipient: {
       status: 'owner',
       instance: client.options.uri,
+      avatarPath: OWNER_PUBLIC_AVATAR_PATH,
       public_name: instanceSettingsResult === null || instanceSettingsResult === void 0 || (_instanceSettingsResu = instanceSettingsResult.data) === null || _instanceSettingsResu === void 0 || (_instanceSettingsResu = _instanceSettingsResu.attributes) === null || _instanceSettingsResu === void 0 ? void 0 : _instanceSettingsResu.public_name
     },
     isOwner: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "33.3.4",
+  "version": "33.4.1",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -53,7 +53,7 @@
     "babel-jest": "30.3.0",
     "babel-plugin-css-modules-transform": "1.6.2",
     "babel-plugin-inline-react-svg": "1.1.2",
-    "cozy-client": "^60.27.0",
+    "cozy-client": "^60.28.0",
     "cozy-device-helper": "^4.0.0",
     "cozy-intent": "^2.31.1",
     "cozy-minilog": "^3.10.1",
@@ -68,7 +68,7 @@
     "twake-i18n": "^0.4.1"
   },
   "peerDependencies": {
-    "cozy-client": ">=60.27.0",
+    "cozy-client": ">=60.28.0",
     "cozy-device-helper": ">=4.0.0",
     "cozy-flags": ">=4.8.1",
     "cozy-intent": ">=2.29.1",
@@ -83,5 +83,5 @@
   "sideEffects": [
     "*.css"
   ],
-  "gitHead": "05ad9ddb799d8a239d336c0a31c3a87552394d48"
+  "gitHead": "a2e29d6c728ebf0fdc890666a9ec3505e90551ed"
 }

package/src/SharingProvider.jsx

@@ -87,6 +87,7 @@ export class SharingProvider extends Component {
       revokeSelf: this.revokeSelf,
       shareByLink: this.shareByLink,
       getFederatedShareLink: this.getFederatedShareLink,
+      fetchSharedDriveSharingLinks: this.fetchSharedDriveSharingLinks,
       updateDocumentPermissions: this.updateDocumentPermissions,
       revokeSharingLink: this.revokeSharingLink,
       hasLoadedAtLeastOnePage: false,
@@ -373,17 +374,30 @@ export class SharingProvider extends Component {
   }
 
   shareByLink = async (document, options) => {
-    const resp = document.driveId
-      ? await this.createSharedDriveSharingLink(document, options)
-      : await this.permissionCol.createSharingLink(document, options)
-    this.dispatch(addSharingLink(resp.data))
-    return resp
+    try {
+      const resp = document.driveId
+        ? await this.createSharedDriveSharingLink(document, options)
+        : await this.permissionCol.createSharingLink(document, options)
+      this.dispatch(addSharingLink(resp.data))
+      return resp
+    } catch (error) {
+      if (document.driveId && error && error.status === 409) {
+        const permissions = await this.fetchSharedDriveSharingLinks(document)
+        if (permissions && permissions.length > 0) {
+          return { data: permissions[0] }
+        }
+      }
+      throw error
+    }
   }
 
   getFederatedShareLink = document => {
-    if (!document.driveId) return null
+    if (!document?.driveId) return null
+
+    const documentId = document._id || document.id
+    if (!documentId) return null
 
-    const permissions = getDocumentPermissions(this.state, document._id)
+    const permissions = getDocumentPermissions(this.state, documentId)
     const perm = permissions.find(p => getShortcode(p))
     if (!perm) return null
 
@@ -413,6 +427,34 @@ export class SharingProvider extends Component {
     return resp
   }
 
+  fetchSharedDriveSharingLinks = async document => {
+    if (!document || !document.driveId) return []
+
+    const { client } = this.props
+    const drivePermissionCollection = client.collection('io.cozy.permissions', {
+      driveId: document.driveId
+    })
+    const documentId = document._id || document.id
+    if (!documentId) return []
+
+    const resp = await drivePermissionCollection.findLinksByIds([documentId])
+    const permissions = resp.data || []
+
+    const existingPermissions = getDocumentPermissions(this.state, documentId)
+    const existingPermissionIds = existingPermissions.map(
+      permission => permission.id
+    )
+    const newPermissions = permissions.filter(
+      permission => !existingPermissionIds.includes(permission.id)
+    )
+
+    if (newPermissions.length > 0) {
+      this.dispatch(addSharingLink(newPermissions))
+    }
+
+    return permissions
+  }
+
   updateSharedDrivePermissions = async (
     document,
     permissionDocument,

package/src/SharingProvider.spec.jsx

@@ -291,6 +291,210 @@ describe('updateDocumentPermissions', () => {
   })
 })
 
+describe('fetchSharedDriveSharingLinks', () => {
+  const PERM_DRIVE_FILE = {
+    type: 'io.cozy.permissions',
+    id: 'perm_drive_file',
+    attributes: {
+      type: 'share',
+      permissions: {
+        rule0: {
+          type: 'io.cozy.files',
+          verbs: ['GET'],
+          values: ['file_in_drive']
+        }
+      },
+      shortcodes: { code: 'shortcode123' }
+    }
+  }
+
+  const driveFile = {
+    _id: 'file_in_drive',
+    id: 'file_in_drive',
+    driveId: 'drive_123'
+  }
+
+  it('fetches shared drive sharing links by file id', async () => {
+    const mockFindLinksByIds = jest
+      .fn()
+      .mockResolvedValue({ data: [PERM_DRIVE_FILE] })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({
+      findLinksByIds: mockFindLinksByIds
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.state = reducer()
+    provider.dispatch = jest.fn(action => {
+      provider.state = reducer(provider.state, action)
+    })
+
+    const result = await provider.fetchSharedDriveSharingLinks(driveFile)
+
+    expect(mockClient.collection).toHaveBeenCalledWith('io.cozy.permissions', {
+      driveId: 'drive_123'
+    })
+    expect(mockFindLinksByIds).toHaveBeenCalledWith(['file_in_drive'])
+    expect(provider.dispatch).toHaveBeenCalled()
+    const permissions = getDocumentPermissions(provider.state, 'file_in_drive')
+    expect(permissions).toHaveLength(1)
+    expect(permissions[0].id).toBe(PERM_DRIVE_FILE.id)
+    expect(result).toEqual([PERM_DRIVE_FILE])
+  })
+
+  it('returns an empty array and skips the API call for non-shared-drive documents', async () => {
+    const mockClient = createMockClient({})
+    const findLinksByIds = jest.fn()
+    mockClient.collection = jest.fn().mockReturnValue({
+      findLinksByIds
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.dispatch = jest.fn()
+
+    const result = await provider.fetchSharedDriveSharingLinks({
+      _id: 'regular_file'
+    })
+
+    expect(result).toEqual([])
+    expect(findLinksByIds).not.toHaveBeenCalled()
+    expect(provider.dispatch).not.toHaveBeenCalled()
+  })
+
+  it('uses document.id as a fallback when _id is missing', async () => {
+    const mockFindLinksByIds = jest
+      .fn()
+      .mockResolvedValue({ data: [PERM_DRIVE_FILE] })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({
+      findLinksByIds: mockFindLinksByIds
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.state = reducer()
+    provider.dispatch = jest.fn(action => {
+      provider.state = reducer(provider.state, action)
+    })
+
+    await provider.fetchSharedDriveSharingLinks({
+      id: 'file_in_drive',
+      driveId: 'drive_123'
+    })
+
+    expect(mockFindLinksByIds).toHaveBeenCalledWith(['file_in_drive'])
+  })
+
+  it('does not dispatch when the response has no data', async () => {
+    const mockFindLinksByIds = jest.fn().mockResolvedValue({ data: [] })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({
+      findLinksByIds: mockFindLinksByIds
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.dispatch = jest.fn()
+
+    const result = await provider.fetchSharedDriveSharingLinks(driveFile)
+
+    expect(result).toEqual([])
+    expect(provider.dispatch).not.toHaveBeenCalled()
+  })
+})
+
+describe('shareByLink shared drive 409 recovery', () => {
+  const PERM_DRIVE_FILE = {
+    type: 'io.cozy.permissions',
+    id: 'perm_drive_file',
+    attributes: {
+      type: 'share',
+      permissions: {
+        rule0: {
+          type: 'io.cozy.files',
+          verbs: ['GET'],
+          values: ['file_in_drive']
+        }
+      },
+      shortcodes: { code: 'shortcode123' }
+    }
+  }
+
+  const driveFile = {
+    _id: 'file_in_drive',
+    id: 'file_in_drive',
+    driveId: 'drive_123'
+  }
+
+  it('falls back to fetching existing links when create returns 409', async () => {
+    const conflict = Object.assign(new Error('Conflict'), { status: 409 })
+    const mockCreateSharingLink = jest.fn().mockRejectedValue(conflict)
+    const mockFindLinksByIds = jest
+      .fn()
+      .mockResolvedValue({ data: [PERM_DRIVE_FILE] })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({
+      createSharingLink: mockCreateSharingLink,
+      findLinksByIds: mockFindLinksByIds
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.state = reducer()
+    provider.dispatch = jest.fn(action => {
+      provider.state = reducer(provider.state, action)
+    })
+
+    const resp = await provider.shareByLink(driveFile, { verbs: ['GET'] })
+
+    expect(mockCreateSharingLink).toHaveBeenCalled()
+    expect(mockFindLinksByIds).toHaveBeenCalledWith(['file_in_drive'])
+    expect(resp.data.id).toBe(PERM_DRIVE_FILE.id)
+  })
+
+  it('does not duplicate existing links when 409 recovery refetches them', async () => {
+    const conflict = Object.assign(new Error('Conflict'), { status: 409 })
+    const mockCreateSharingLink = jest.fn().mockRejectedValue(conflict)
+    const mockFindLinksByIds = jest
+      .fn()
+      .mockResolvedValue({ data: [PERM_DRIVE_FILE] })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({
+      createSharingLink: mockCreateSharingLink,
+      findLinksByIds: mockFindLinksByIds
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.state = reducer(undefined, addSharingLink(PERM_DRIVE_FILE))
+    provider.dispatch = jest.fn(action => {
+      provider.state = reducer(provider.state, action)
+    })
+
+    const resp = await provider.shareByLink(driveFile, { verbs: ['GET'] })
+
+    const permissions = getDocumentPermissions(provider.state, 'file_in_drive')
+    expect(resp.data.id).toBe(PERM_DRIVE_FILE.id)
+    expect(provider.dispatch).not.toHaveBeenCalled()
+    expect(permissions).toHaveLength(1)
+  })
+
+  it('rethrows the original error when 409 happens and no link is found', async () => {
+    const conflict = Object.assign(new Error('Conflict'), { status: 409 })
+    const mockCreateSharingLink = jest.fn().mockRejectedValue(conflict)
+    const mockFindLinksByIds = jest.fn().mockResolvedValue({ data: [] })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({
+      createSharingLink: mockCreateSharingLink,
+      findLinksByIds: mockFindLinksByIds
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.state = reducer()
+    provider.dispatch = jest.fn()
+
+    await expect(
+      provider.shareByLink(driveFile, { verbs: ['GET'] })
+    ).rejects.toBe(conflict)
+  })
+})
+
 describe('updateSharingMemberType', () => {
   const mockSharing = {
     id: 'sharing-123',

package/src/components/Avatar/MemberAvatar.jsx

@@ -1,4 +1,4 @@
-import React from 'react'
+import React, { useState } from 'react'
 
 import { useClient } from 'cozy-client'
 import Avatar from 'cozy-ui/transpiled/react/Avatar'
@@ -8,6 +8,10 @@ import { getInitials } from '../../models'
 
 const MemberAvatar = ({ recipient, ...rest }) => {
   const client = useClient()
+  // Remember which image url failed to load so we can fall back to the
+  // initials. Storing the url (instead of a boolean) means a new url is
+  // retried automatically, without an effect to reset the error state.
+  const [erroredSrc, setErroredSrc] = useState(null)
 
   // There are cases when due to apparent memory leaks, the recipient does not exist
   // This will trigger an unhanded error in the Avatar component and crash the app
@@ -31,13 +35,24 @@ const MemberAvatar = ({ recipient, ...rest }) => {
    */
   const image =
     recipient.avatarPath && recipient.status
-      ? `${client.options.uri}${recipient.avatarPath}?v=${recipient.status}`
+      ? `${client.options.uri}${recipient.avatarPath}${
+          recipient.avatarPath.includes('?') ? '&' : '?'
+        }v=${recipient.status}`
       : null
 
+  // The avatar can become unreachable (eg. the related sharing is revoked
+  // while its members are still rendered), in which case the image request
+  // fails. Without a fallback the browser shows a broken-image icon, so we
+  // render the initials instead.
   return (
     <Avatar {...rest}>
-      {image ? (
-        <img width="100%" height="100%" src={image} />
+      {image && erroredSrc !== image ? (
+        <img
+          width="100%"
+          height="100%"
+          src={image}
+          onError={() => setErroredSrc(image)}
+        />
       ) : (
         getInitials(recipient)
       )}

package/src/components/Avatar/MemberAvatar.spec.jsx

@@ -0,0 +1,80 @@
+import { render, fireEvent } from '@testing-library/react'
+import React from 'react'
+
+import { createMockClient } from 'cozy-client'
+
+import { MemberAvatar } from './MemberAvatar'
+import AppLike from '../../../test/AppLike'
+
+describe('MemberAvatar', () => {
+  const client = createMockClient({})
+  client.options = { uri: 'http://cozy.example.com' }
+
+  const setup = recipient =>
+    render(
+      <AppLike client={client}>
+        <MemberAvatar recipient={recipient} />
+      </AppLike>
+    )
+
+  it('renders nothing when the recipient is missing', () => {
+    const { container } = setup(undefined)
+
+    // The component returns null; only the provider wrappers remain, with no
+    // avatar rendered inside.
+    expect(container.querySelector('[class*="MuiAvatar-root"]')).toBeNull()
+    expect(container.querySelector('img')).toBeNull()
+  })
+
+  it('renders the avatar image when the recipient has an avatarPath and a status', () => {
+    const { container } = setup({
+      public_name: 'Bob',
+      status: 'owner',
+      avatarPath: '/sharings/123/recipients/0/avatar'
+    })
+
+    const img = container.querySelector('img')
+    expect(img).toBeTruthy()
+    expect(img.getAttribute('src')).toBe(
+      'http://cozy.example.com/sharings/123/recipients/0/avatar?v=owner'
+    )
+  })
+
+  it('appends the cache-busting param with & when avatarPath already has a query string', () => {
+    const { container } = setup({
+      public_name: 'Bob',
+      status: 'owner',
+      avatarPath: '/public/avatar?fallback=initials'
+    })
+
+    expect(container.querySelector('img').getAttribute('src')).toBe(
+      'http://cozy.example.com/public/avatar?fallback=initials&v=owner'
+    )
+  })
+
+  it('renders the initials when there is no avatarPath', () => {
+    const { container, getByText } = setup({
+      public_name: 'Bob',
+      status: 'owner'
+    })
+
+    expect(container.querySelector('img')).toBeNull()
+    expect(getByText('B')).toBeTruthy()
+  })
+
+  it('falls back to the initials when the avatar image fails to load', () => {
+    const { container, getByText } = setup({
+      public_name: 'Bob',
+      status: 'owner',
+      avatarPath: '/sharings/123/recipients/0/avatar'
+    })
+
+    const img = container.querySelector('img')
+    expect(img).toBeTruthy()
+
+    fireEvent.error(img)
+
+    expect(container.querySelector('img')).toBeNull()
+    expect(getByText('B')).toBeTruthy()
+  })
+})

package/src/components/FederatedFolder/FederatedFolderModal.jsx

@@ -1,7 +1,8 @@
 import PropTypes from 'prop-types'
-import React, { useCallback, useState } from 'react'
+import React, { useCallback, useEffect, useState } from 'react'
 
 import { useClient } from 'cozy-client'
+import minilog from 'cozy-minilog'
 import Button from 'cozy-ui/transpiled/react/Buttons'
 import { FixedDialog } from 'cozy-ui/transpiled/react/CozyDialogs'
 import Typography from 'cozy-ui/transpiled/react/Typography'
@@ -21,6 +22,8 @@ import { default as DumbShareByEmail } from '../ShareByEmail'
 import ShareByLink from '../ShareByLink'
 import WhoHasAccess from '../WhoHasAccess'
 
+const log = minilog('FederatedFolderModal')
+
 const FederatedFolderModalContent = ({
   onClose,
   document: existingDocument,
@@ -34,6 +37,8 @@ const FederatedFolderModalContent = ({
     getSharingById,
     getSharingLink,
     getFederatedShareLink,
+    getDocumentPermissions,
+    fetchSharedDriveSharingLinks,
     getRecipients,
     hasSharedChild,
     hasSharedParent,
@@ -56,6 +61,9 @@ const FederatedFolderModalContent = ({
   // in members before the modal closes. That's why when clicking on "Share"
   // we do not use the reactive existingDocument and existingRecipients.
   const [isSending, setIsSending] = useState(false)
+  const [isFetchingSharingLinks, setIsFetchingSharingLinks] = useState(false)
+  const [fetchedSharingLinksDocumentId, setFetchedSharingLinksDocumentId] =
+    useState(null)
   const [frozenDoc, setFrozenDoc] = useState(null)
   const [frozenRecipients, setFrozenRecipients] = useState(null)
 
@@ -169,13 +177,46 @@ const FederatedFolderModalContent = ({
     }
   }
 
-  const existingRecipients = existingDocument
-    ? getRecipients(existingDocument._id)
+  const documentId = existingDocument?._id || existingDocument?.id
+  const existingRecipients = documentId ? getRecipients(documentId) : []
+  const documentPermissions = documentId
+    ? getDocumentPermissions(documentId)
     : []
   const displayedLink = existingDocument?.driveId
     ? getFederatedShareLink(existingDocument)
     : getSharingLink(existingDocument?._id)
 
+  useEffect(() => {
+    if (!existingDocument?.driveId) return
+    if (!documentId) return
+    if (!fetchSharedDriveSharingLinks) return
+    if (documentPermissions.length > 0) return
+    if (isFetchingSharingLinks) return
+    if (fetchedSharingLinksDocumentId === documentId) return
+
+    const fetchSharingLinks = async () => {
+      setIsFetchingSharingLinks(true)
+
+      try {
+        await fetchSharedDriveSharingLinks(existingDocument)
+      } catch (error) {
+        log.error('Failed to fetch shared drive sharing links', error)
+      } finally {
+        setFetchedSharingLinksDocumentId(documentId)
+        setIsFetchingSharingLinks(false)
+      }
+    }
+
+    fetchSharingLinks()
+  }, [
+    documentId,
+    existingDocument,
+    documentPermissions.length,
+    fetchedSharingLinksDocumentId,
+    fetchSharedDriveSharingLinks,
+    isFetchingSharingLinks
+  ])
+
   const modalTitle = t('FederatedFolder.shareTitle', { name: folderName })
 
   return (

package/src/components/FederatedFolder/FederatedFolderModal.spec.jsx

@@ -17,6 +17,8 @@ const mockGetRecipients = jest.fn().mockReturnValue([])
 const mockGetSharingById = jest.fn()
 const mockHasSharedChild = jest.fn()
 const mockHasSharedParent = jest.fn()
+const mockFetchSharedDriveSharingLinks = jest.fn()
+const mockGetDocumentPermissions = jest.fn().mockReturnValue([])
 const mockShowAlert = jest.fn()
 const mockOnClose = jest.fn()
 
@@ -27,7 +29,8 @@ jest.mock('../../hooks/useSharingContext', () => ({
     revoke: mockRevoke,
     getSharingLink: mockGetSharingLink,
     getFederatedShareLink: mockGetFederatedShareLink,
-    getDocumentPermissions: jest.fn().mockReturnValue([]),
+    getDocumentPermissions: mockGetDocumentPermissions,
+    fetchSharedDriveSharingLinks: mockFetchSharedDriveSharingLinks,
     getOwner: jest.fn(),
     getRecipients: mockGetRecipients,
     getSharingById: mockGetSharingById,
@@ -65,7 +68,8 @@ const createSharingContextValue = () => ({
   hasWriteAccess: jest.fn(),
   getRecipients: jest.fn(),
   getSharingLink: mockGetSharingLink,
-  getDocumentPermissions: jest.fn().mockReturnValue([]),
+  getDocumentPermissions: mockGetDocumentPermissions,
+  fetchSharedDriveSharingLinks: mockFetchSharedDriveSharingLinks,
   share: mockShare
 })
 
@@ -96,6 +100,8 @@ describe('FederatedFolderModal', () => {
 
   beforeEach(() => {
     jest.clearAllMocks()
+    mockGetDocumentPermissions.mockReturnValue([])
+    mockFetchSharedDriveSharingLinks.mockResolvedValue([])
     mockGetSharingLink.mockReturnValue('https://example.com/share/abc123')
     mockGetFederatedShareLink.mockReturnValue(
       'https://example.com/share/federated-abc123'
@@ -227,6 +233,85 @@ describe('FederatedFolderModal', () => {
     })
   })
 
+  describe('shared drive link fetch on mount', () => {
+    it('should fetch shared drive sharing links when document has a driveId and no permissions yet', async () => {
+      mockGetDocumentPermissions.mockReturnValue([])
+
+      setup({
+        document: { ...mockDocument, driveId: 'federated-folder-id' }
+      })
+
+      await waitFor(() => {
+        expect(mockFetchSharedDriveSharingLinks).toHaveBeenCalledTimes(1)
+      })
+      expect(mockFetchSharedDriveSharingLinks).toHaveBeenCalledWith(
+        expect.objectContaining({
+          _id: mockDocument._id,
+          driveId: 'federated-folder-id'
+        })
+      )
+    })
+
+    it('should use document.id when _id is missing', async () => {
+      const document = {
+        id: 'folder-id-only',
+        name: 'My Test Folder',
+        path: '/test/folder',
+        driveId: 'federated-folder-id'
+      }
+
+      setup({ document })
+
+      await waitFor(() => {
+        expect(mockFetchSharedDriveSharingLinks).toHaveBeenCalledWith(document)
+      })
+      expect(mockGetDocumentPermissions).toHaveBeenCalledWith('folder-id-only')
+    })
+
+    it('should not fetch shared drive sharing links when document has no driveId', async () => {
+      const { findByText } = setup({ document: mockDocument })
+
+      await findByText('Copy link')
+
+      expect(mockFetchSharedDriveSharingLinks).not.toHaveBeenCalled()
+    })
+
+    it('should not refetch after one attempt when permissions stay empty', async () => {
+      const document = { ...mockDocument, driveId: 'federated-folder-id' }
+      const { rerender } = setup({ document })
+
+      await waitFor(() => {
+        expect(mockFetchSharedDriveSharingLinks).toHaveBeenCalledTimes(1)
+      })
+
+      rerender(
+        <AppLike client={client} sharingContextValue={sharingContextValue}>
+          <FederatedFolderModal document={document} onClose={mockOnClose} />
+        </AppLike>
+      )
+
+      expect(mockFetchSharedDriveSharingLinks).toHaveBeenCalledTimes(1)
+    })
+
+    it('should not fetch shared drive sharing links when permissions are already loaded', async () => {
+      mockGetDocumentPermissions.mockReturnValue([
+        {
+          id: 'perm-1',
+          type: 'io.cozy.permissions',
+          attributes: { shortcodes: { code: 'abc' } }
+        }
+      ])
+
+      const { findByText } = setup({
+        document: { ...mockDocument, driveId: 'federated-folder-id' }
+      })
+
+      await findByText('Copy link')
+
+      expect(mockFetchSharedDriveSharingLinks).not.toHaveBeenCalled()
+    })
+  })
+
   describe('onSend callback', () => {
     const pendingRecipient = { name: 'Alice', email: 'alice@example.com' }