cozy-sharing 28.4.4 → 28.6.0

package/src/SharingProvider.spec.jsx

@@ -5,7 +5,7 @@ import { createMockClient } from 'cozy-client'
 
 import { SharingProvider } from './SharingProvider'
 import SharingContext from './context'
-// import { receiveSharings } from './state'
+import reducer, { addSharingLink, getDocumentPermissions } from './state'
 import AppLike from '../test/AppLike'
 
 const AppWrapper = ({ children, client, isPublic }) => {
@@ -105,6 +105,229 @@ describe('SharingProvider', () => {
   })
 })
 
+describe('shareByLink', () => {
+  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('dispatches addSharingLink exactly once for a shared drive file', async () => {
+    const mockCreateSharingLink = jest
+      .fn()
+      .mockResolvedValue({ data: PERM_DRIVE_FILE })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({
+      createSharingLink: mockCreateSharingLink
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.state = reducer()
+    provider.dispatch = jest.fn(action => {
+      provider.state = reducer(provider.state, action)
+    })
+
+    await provider.shareByLink(driveFile, { verbs: ['GET'] })
+
+    expect(provider.dispatch).toHaveBeenCalledTimes(1)
+    const permissions = getDocumentPermissions(provider.state, driveFile._id)
+    expect(permissions).toHaveLength(1)
+    expect(permissions[0].id).toBe(PERM_DRIVE_FILE.id)
+  })
+
+  it('dispatches addSharingLink once for a regular file (non shared drive)', async () => {
+    const PERM_REGULAR_FILE = {
+      type: 'io.cozy.permissions',
+      id: 'perm_regular_file',
+      attributes: {
+        type: 'share',
+        permissions: {
+          rule0: {
+            type: 'io.cozy.files',
+            verbs: ['GET'],
+            values: ['regular_file_id']
+          }
+        },
+        shortcodes: { code: 'shortcode456' }
+      }
+    }
+    const regularFile = { _id: 'regular_file_id', id: 'regular_file_id' }
+    const mockCreateSharingLink = jest
+      .fn()
+      .mockResolvedValue({ data: PERM_REGULAR_FILE })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({
+      createSharingLink: mockCreateSharingLink
+    })
+
+    const provider = new SharingProvider({ client: mockClient })
+    provider.state = reducer()
+    provider.permissionCol = { createSharingLink: mockCreateSharingLink }
+    provider.dispatch = jest.fn(action => {
+      provider.state = reducer(provider.state, action)
+    })
+
+    await provider.shareByLink(regularFile, { verbs: ['GET'] })
+
+    expect(provider.dispatch).toHaveBeenCalledTimes(1)
+    const permissions = getDocumentPermissions(provider.state, regularFile._id)
+    expect(permissions).toHaveLength(1)
+    expect(permissions[0].id).toBe(PERM_REGULAR_FILE.id)
+  })
+})
+
+describe('updateDocumentPermissions', () => {
+  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' }
+    }
+  }
+
+  it('sends only one PATCH request for a shared drive file', async () => {
+    const driveFile = {
+      _id: 'file_in_drive',
+      id: 'file_in_drive',
+      driveId: 'drive_123'
+    }
+    const mockAdd = jest.fn().mockResolvedValue({ data: PERM_DRIVE_FILE })
+    const mockClient = createMockClient({})
+    mockClient.collection = jest.fn().mockReturnValue({ add: mockAdd })
+
+    const provider = new SharingProvider({ client: mockClient })
+    // Seed the state with exactly one permission (as it would be after a correct shareByLink)
+    provider.state = reducer(undefined, addSharingLink(PERM_DRIVE_FILE))
+    provider.dispatch = jest.fn()
+
+    await provider.updateDocumentPermissions(driveFile, {
+      verbs: ['GET'],
+      expiresAt: '',
+      password: ''
+    })
+
+    expect(mockAdd).toHaveBeenCalledTimes(1)
+  })
+})
+
+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', () => {

package/src/components/FederatedFolder/DumbFederatedFolderModal.jsx

@@ -3,7 +3,7 @@ import React from 'react'
 import { useI18n } from 'twake-i18n'
 
 import withLocales from '../../hoc/withLocales'
-import DumbBatchSharedFolderModal from '../SharedFolder/DumbBatchSharedFolderModal'
+import { DumbBatchSharedFolderModal } from '../SharedFolder/DumbBatchSharedFolderModal'
 
 export const DumbFederatedFolderModal = withLocales(
   ({
@@ -18,7 +18,8 @@ export const DumbFederatedFolderModal = withLocales(
     onSend,
     onClose,
     onShare,
-    sharingLink
+    sharingLink,
+    showShareByEmail
   }) => {
     const { t } = useI18n()
     return (
@@ -39,6 +40,7 @@ export const DumbFederatedFolderModal = withLocales(
         addPeopleLabel={t('FederatedFolder.addPeople')}
         addButtonLabel={t('FederatedFolder.add')}
         shareLabel={t('FederatedFolder.share')}
+        showShareByEmail={showShareByEmail}
       />
     )
   }
@@ -56,7 +58,8 @@ DumbFederatedFolderModal.propTypes = {
   onSend: PropTypes.func.isRequired,
   onClose: PropTypes.func.isRequired,
   onShare: PropTypes.func.isRequired,
-  sharingLink: PropTypes.string
+  sharingLink: PropTypes.string,
+  showShareByEmail: PropTypes.bool
 }
 
 export default DumbFederatedFolderModal

package/src/components/FederatedFolder/FederatedFolderModal.jsx

@@ -1,5 +1,5 @@
 import PropTypes from 'prop-types'
-import React, { useState } from 'react'
+import React, { useState, useEffect } from 'react'
 import { useI18n } from 'twake-i18n'
 
 import { useClient } from 'cozy-client'
@@ -19,13 +19,43 @@ export const FederatedFolderModal = withLocales(
   ({ onClose, document: existingDocument }) => {
     const client = useClient()
     const { t } = useI18n()
-    const { share, getSharingLink } = useSharingContext()
+    const {
+      share,
+      getSharingLink,
+      getFederatedShareLink,
+      getDocumentPermissions,
+      getOwner,
+      getSharingById
+    } = useSharingContext()
     const { showAlert } = useAlert()
 
-    // Get sharing link
-    const sharingLink = existingDocument
-      ? getSharingLink(existingDocument._id)
-      : null
+    const [sharingLink, setSharingLink] = useState(null)
+
+    const documentPermissions = existingDocument
+      ? getDocumentPermissions(existingDocument._id)
+      : []
+
+    useEffect(() => {
+      const fetchSharingLink = async () => {
+        if (!existingDocument) return
+
+        if (existingDocument.driveId) {
+          const link = await getFederatedShareLink(existingDocument)
+          setSharingLink(link)
+        } else {
+          setSharingLink(getSharingLink(existingDocument._id))
+        }
+      }
+
+      fetchSharingLink()
+    }, [
+      existingDocument,
+      documentPermissions,
+      getFederatedShareLink,
+      getSharingLink,
+      getOwner,
+      getSharingById
+    ]) // eslint-disable-line react-hooks/exhaustive-deps
 
     const [federatedRecipients, setFederatedRecipients] = useState({
       recipients: [],
@@ -92,6 +122,8 @@ export const FederatedFolderModal = withLocales(
 
     const modalTitle = t('FederatedFolder.shareTitle', { name: folderName })
 
+    const isSharedDrive = Boolean(existingDocument?.driveId)
+
     return (
       <DumbFederatedFolderModal
         title={modalTitle}
@@ -106,6 +138,7 @@ export const FederatedFolderModal = withLocales(
         onClose={onClose}
         onShare={onShare}
         sharingLink={sharingLink}
+        showShareByEmail={!isSharedDrive}
       />
     )
   }

package/src/components/Recipient/LinkRecipient.jsx

@@ -26,8 +26,7 @@ const LinkRecipient = props => {
   const { isMobile } = useBreakpoints()
   const { getDocumentPermissions } = useSharingContext()
 
-  const { recipientConfirmationData, verifyRecipient, link, fadeIn, document } =
-    props
+  const { recipientConfirmationData, verifyRecipient, fadeIn, document } = props
 
   const permissions = getDocumentPermissions(document?._id)
   const hasPassword = checkIsPermissionHasPassword(permissions)
@@ -44,7 +43,7 @@ const LinkRecipient = props => {
     ? t('Share.recipients.expires', {
         date: dateFormatted
       })
-    : link
+    : ''
 
   const RightPart = recipientConfirmationData ? (
     <RecipientConfirm
@@ -74,7 +73,14 @@ const LinkRecipient = props => {
 }
 
 LinkRecipient.propTypes = {
-  link: PropTypes.string.isRequired
+  recipientConfirmationData: PropTypes.oneOfType([
+    PropTypes.bool,
+    PropTypes.object
+  ]),
+  verifyRecipient: PropTypes.func,
+  fadeIn: PropTypes.bool,
+  document: PropTypes.object,
+  permissions: PropTypes.arrayOf(PropTypes.object)
 }
 
 export default LinkRecipient

package/src/components/Recipient/LinkRecipient.stories.jsx

@@ -5,7 +5,6 @@ const meta = {
   args: {
     recipientConfirmationData: false,
     verifyRecipient: () => true,
-    link: 'test',
     fadeIn: false
   }
 }

package/src/components/Recipient/MemberRecipient.spec.jsx

@@ -6,6 +6,17 @@ import { createMockClient } from 'cozy-client'
 import MemberRecipient from './MemberRecipient'
 import AppLike from '../../../test/AppLike'
 
+const mockUpdateDocumentPermissions = jest.fn()
+const mockUpdateSharingMemberType = jest.fn()
+
+jest.mock('../../hooks/useSharingContext', () => ({
+  // eslint-disable-next-line react/display-name
+  useSharingContext: () => ({
+    updateDocumentPermissions: mockUpdateDocumentPermissions,
+    updateSharingMemberType: mockUpdateSharingMemberType
+  })
+}))
+
 describe('MemberRecipient component', () => {
   const client = createMockClient({})
   client.options = {

package/src/components/Recipient/MemberRecipientPermissions.jsx

@@ -2,6 +2,7 @@ import React, { useState, useRef, useCallback } from 'react'
 import { useI18n } from 'twake-i18n'
 
 import { useClient } from 'cozy-client'
+import minilog from 'cozy-minilog'
 import ActionsMenu from 'cozy-ui/transpiled/react/ActionsMenu'
 import {
   makeActions,
@@ -10,9 +11,14 @@ import {
 import DropdownButton from 'cozy-ui/transpiled/react/DropdownButton'
 import Spinner from 'cozy-ui/transpiled/react/Spinner'
 import Typography from 'cozy-ui/transpiled/react/Typography'
+import { useAlert } from 'cozy-ui/transpiled/react/providers/Alert'
 
-import { permission } from './actions/permission'
 import { revokeMember } from './actions/revokeMember'
+import { setReadOnlySharedPermission } from './actions/setReadOnlySharedPermission'
+import { setReadWriteSharedPermission } from './actions/setReadWriteSharedPermission'
+import { useSharingContext } from '../../hooks/useSharingContext'
+
+const log = minilog('MemberRecipientPermissions')
 
 const MemberRecipientPermissions = ({
   isOwner,
@@ -30,6 +36,8 @@ const MemberRecipientPermissions = ({
   const { t } = useI18n()
   const buttonRef = useRef()
   const client = useClient()
+  const { updateSharingMemberType } = useSharingContext()
+  const { showAlert } = useAlert()
 
   const [revoking, setRevoking] = useState(false)
   const [isMenuDisplayed, setMenuDisplayed] = useState(false)
@@ -42,27 +50,72 @@ const MemberRecipientPermissions = ({
     !contactIsOwner &&
     ((instanceMatchesClient && !isOwner) || isOwner)
 
-  const toggleMenu = () => setMenuDisplayed(!isMenuDisplayed)
-  const hideMenu = () => setMenuDisplayed(false)
+  const toggleMenu = useCallback(() => {
+    setMenuDisplayed(displayed => !displayed)
+  }, [])
+  const hideMenu = useCallback(() => {
+    setMenuDisplayed(false)
+  }, [])
 
   const handleRevocation = useCallback(async () => {
     setRevoking(true)
-    if (isOwner) {
-      await onRevoke(document, sharingId, memberIndex)
-    } else {
-      await onRevokeSelf(document)
+    try {
+      if (isOwner) {
+        await onRevoke(document, sharingId, memberIndex)
+      } else {
+        await onRevokeSelf(document)
+      }
+    } finally {
+      setRevoking(false)
     }
-    setRevoking(false)
   }, [isOwner, onRevoke, onRevokeSelf, document, sharingId, memberIndex])
 
-  const actions = makeActions([permission, divider, revokeMember], {
-    client,
-    t,
-    type: type ?? 'one-way',
-    isOwner,
-    isSharedDrive,
-    handleRevocation
-  })
+  const setType = useCallback(
+    async newType => {
+      if (newType === type) {
+        hideMenu()
+        return
+      }
+      try {
+        await updateSharingMemberType(sharingId, memberIndex, newType)
+      } catch (error) {
+        log.error('Failed to change member permission type', error)
+        showAlert({
+          message: t('Share.members.error.changePermission'),
+          severity: 'error',
+          variant: 'filled'
+        })
+      }
+      hideMenu()
+    },
+    [
+      hideMenu,
+      memberIndex,
+      sharingId,
+      showAlert,
+      t,
+      type,
+      updateSharingMemberType
+    ]
+  )
+
+  const actions = makeActions(
+    [
+      setReadOnlySharedPermission,
+      setReadWriteSharedPermission,
+      divider,
+      revokeMember
+    ],
+    {
+      client,
+      t,
+      type: type ?? 'one-way',
+      isOwner,
+      isSharedDrive,
+      setType,
+      handleRevocation
+    }
+  )
 
   return (
     <div className={className}>

package/src/components/Recipient/MemberRecipientPermissions.spec.jsx

@@ -0,0 +1,165 @@
+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'
+
+const mockUpdateSharingMemberType = jest.fn()
+const mockShowAlert = jest.fn()
+
+jest.mock('../../hooks/useSharingContext', () => ({
+  useSharingContext: () => ({
+    updateSharingMemberType: mockUpdateSharingMemberType
+  })
+}))
+
+jest.mock('cozy-ui/transpiled/react/providers/Alert', () => ({
+  __esModule: true,
+  default: ({ children }) => children,
+  useAlert: () => ({
+    showAlert: mockShowAlert
+  })
+}))
+
+describe('MemberRecipientPermissions component', () => {
+  const client = createMockClient({})
+  client.options = {
+    uri: 'http://cozy.local:8080'
+  }
+
+  const 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(() => {
+    jest.clearAllMocks()
+  })
+
+  const setup = props => {
+    return render(
+      <AppLike client={client}>
+        <MemberRecipientPermissions {...defaultProps} {...props} />
+      </AppLike>
+    )
+  }
+
+  let createRangeBackup
+
+  beforeAll(() => {
+    createRangeBackup = global.document.createRange
+    global.document.createRange = jest.fn(() => ({
+      setStart: () => {},
+      setEnd: () => {},
+      commonAncestorContainer: {
+        nodeName: 'BODY',
+        ownerDocument: document
+      }
+    }))
+  })
+
+  afterAll(() => {
+    global.document.createRange = createRangeBackup
+  })
+
+  it('should render the current permission type', () => {
+    setup()
+    expect(screen.getByText('can change')).toBeInTheDocument()
+  })
+
+  it('should call updateSharingMemberType when changing to one-way', async () => {
+    mockUpdateSharingMemberType.mockResolvedValue(undefined)
+
+    const { getByText } = setup({ type: 'two-way' })
+
+    fireEvent.click(getByText('can change'))
+    fireEvent.click(getByText('Can view'))
+
+    expect(mockUpdateSharingMemberType).toHaveBeenCalledWith(
+      'sharing-123',
+      1,
+      'one-way'
+    )
+  })
+
+  it('should call updateSharingMemberType when changing to two-way', async () => {
+    mockUpdateSharingMemberType.mockResolvedValue(undefined)
+
+    const { getByText } = setup({ type: 'one-way' })
+
+    fireEvent.click(getByText('can view'))
+    fireEvent.click(getByText('Can change'))
+
+    expect(mockUpdateSharingMemberType).toHaveBeenCalledWith(
+      'sharing-123',
+      1,
+      'two-way'
+    )
+  })
+
+  it('should show error alert when updateSharingMemberType fails', async () => {
+    mockUpdateSharingMemberType.mockRejectedValue(new Error('Network error'))
+
+    const { getByText } = setup({ type: 'two-way' })
+
+    await act(async () => {
+      fireEvent.click(getByText('can change'))
+      fireEvent.click(getByText('Can view'))
+    })
+
+    await waitFor(() => {
+      expect(mockShowAlert).toHaveBeenCalledWith({
+        message:
+          'An error occurred while changing the permissions. Please try again.',
+        severity: 'error',
+        variant: 'filled'
+      })
+    })
+  })
+
+  it('should not call updateSharingMemberType when selecting same type', async () => {
+    mockUpdateSharingMemberType.mockResolvedValue(undefined)
+
+    const { getByText } = setup({ type: 'two-way' })
+
+    fireEvent.click(getByText('can change'))
+    fireEvent.click(getByText('Can change'))
+
+    expect(mockUpdateSharingMemberType).not.toHaveBeenCalled()
+  })
+
+  it('should not render menu when user is not owner and not the shared drive contact', () => {
+    const { queryByText } = setup({
+      isOwner: false,
+      instance: 'http://other-cozy.local:8080'
+    })
+
+    expect(queryByText('can change')).not.toBeInTheDocument()
+    expect(queryByText('can view')).not.toBeInTheDocument()
+  })
+
+  it('should render menu for owner', () => {
+    const { getByText } = setup({ isOwner: true })
+
+    expect(getByText('can change')).toBeInTheDocument()
+  })
+
+  it('should render menu for the user themselves', () => {
+    const { getByText } = setup({
+      isOwner: false,
+      instance: 'http://cozy.local:8080'
+    })
+
+    expect(getByText('can change')).toBeInTheDocument()
+  })
+})