cozy-sharing 40.1.2 → 40.1.3

package/dist/components/FederatedFolder/FederatedFolderModal.revokeSelf.spec.js

@@ -0,0 +1,294 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import React, { useState } from 'react';
+import { createMockClient } from 'cozy-client';
+import { FederatedFolderModal } from './FederatedFolderModal';
+import AppLike from '../../../test/AppLike';
+import { SharingProvider } from '../../SharingProvider';
+import { useSharingContext } from '../../hooks/useSharingContext';
+jest.mock('../ShareByEmail', function () {
+  return function () {
+    return null;
+  };
+});
+jest.mock('../ShareByLink', function () {
+  return function () {
+    return null;
+  };
+});
+var document = {
+  id: 'received-folder',
+  _id: 'received-folder',
+  name: 'Received drive',
+  type: 'directory',
+  driveId: 'received-sharing'
+};
+var instance = 'https://me.mycozy.cloud';
+var members = [{
+  status: 'owner',
+  instance: 'https://owner.mycozy.cloud',
+  name: 'Owner',
+  email: 'owner@test.com'
+}, {
+  status: 'ready',
+  instance: instance,
+  name: 'Me',
+  email: 'me@test.com'
+}];
+var sharing = {
+  id: document.driveId,
+  _id: document.driveId,
+  type: 'io.cozy.sharings',
+  attributes: {
+    owner: false,
+    drive: true,
+    active: true,
+    rules: [{
+      values: [document.id]
+    }],
+    members: members
+  }
+};
+
+function RevocationView() {
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      hasLeft = _useState2[0],
+      setHasLeft = _useState2[1];
+
+  var _useSharingContext = useSharingContext(),
+      allLoaded = _useSharingContext.allLoaded,
+      getSharingForSelf = _useSharingContext.getSharingForSelf;
+
+  if (!allLoaded) return null;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("output", null, getSharingForSelf(document.id) ? 'Member of drive' : 'Not a member'), hasLeft ? /*#__PURE__*/React.createElement("h1", null, "Shared drives") : /*#__PURE__*/React.createElement(FederatedFolderModal, {
+    document: document,
+    onClose: function onClose() {
+      return setHasLeft(true);
+    },
+    onRevokeSuccess: function onRevokeSuccess() {
+      return setHasLeft(true);
+    }
+  }));
+}
+
+describe('FederatedFolderModal self-revocation with SharingProvider', function () {
+  it('closes and runs the success transition after leaving, without refreshing forbidden members', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+    var hasRevoked, client, sharingCol;
+    return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          hasRevoked = false;
+          client = createMockClient({});
+          client.options.uri = instance;
+          client.getStackClient().uri = instance;
+          client.isLogged = true;
+          client.plugins.realtime = {
+            subscribe: jest.fn(),
+            unsubscribe: jest.fn()
+          };
+          sharingCol = {
+            findByDoctype: function () {
+              var _findByDoctype = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+                return _regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      return _context.abrupt("return", {
+                        data: [sharing]
+                      });
+
+                    case 1:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee);
+              }));
+
+              function findByDoctype() {
+                return _findByDoctype.apply(this, arguments);
+              }
+
+              return findByDoctype;
+            }(),
+            revokeSelf: function () {
+              var _revokeSelf = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+                return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                  while (1) switch (_context2.prev = _context2.next) {
+                    case 0:
+                      hasRevoked = true;
+
+                    case 1:
+                    case "end":
+                      return _context2.stop();
+                  }
+                }, _callee2);
+              }));
+
+              function revokeSelf() {
+                return _revokeSelf.apply(this, arguments);
+              }
+
+              return revokeSelf;
+            }(),
+            fetchEffectiveRecipients: function () {
+              var _fetchEffectiveRecipients = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+                return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+                  while (1) switch (_context3.prev = _context3.next) {
+                    case 0:
+                      if (!hasRevoked) {
+                        _context3.next = 2;
+                        break;
+                      }
+
+                      throw Object.assign(new Error('Forbidden'), {
+                        status: 403
+                      });
+
+                    case 2:
+                      return _context3.abrupt("return", {
+                        data: members.map(function (member, memberIndex) {
+                          return _objectSpread(_objectSpread({}, member), {}, {
+                            sources: [{
+                              kind: 'self',
+                              sharing_id: sharing.id,
+                              member_index: memberIndex
+                            }]
+                          });
+                        })
+                      });
+
+                    case 3:
+                    case "end":
+                      return _context3.stop();
+                  }
+                }, _callee3);
+              }));
+
+              function fetchEffectiveRecipients() {
+                return _fetchEffectiveRecipients.apply(this, arguments);
+              }
+
+              return fetchEffectiveRecipients;
+            }()
+          };
+
+          client.collection = function (doctype) {
+            if (doctype === 'io.cozy.sharings') return sharingCol;
+
+            if (doctype === 'io.cozy.permissions') {
+              return {
+                findLinksByDoctype: function () {
+                  var _findLinksByDoctype = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+                    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+                      while (1) switch (_context4.prev = _context4.next) {
+                        case 0:
+                          return _context4.abrupt("return", {
+                            data: []
+                          });
+
+                        case 1:
+                        case "end":
+                          return _context4.stop();
+                      }
+                    }, _callee4);
+                  }));
+
+                  function findLinksByDoctype() {
+                    return _findLinksByDoctype.apply(this, arguments);
+                  }
+
+                  return findLinksByDoctype;
+                }(),
+                findLinksByIds: function () {
+                  var _findLinksByIds = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+                    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+                      while (1) switch (_context5.prev = _context5.next) {
+                        case 0:
+                          return _context5.abrupt("return", {
+                            data: []
+                          });
+
+                        case 1:
+                        case "end":
+                          return _context5.stop();
+                      }
+                    }, _callee5);
+                  }));
+
+                  function findLinksByIds() {
+                    return _findLinksByIds.apply(this, arguments);
+                  }
+
+                  return findLinksByIds;
+                }()
+              };
+            }
+
+            return {
+              all: function () {
+                var _all = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+                  return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+                    while (1) switch (_context6.prev = _context6.next) {
+                      case 0:
+                        return _context6.abrupt("return", {
+                          data: []
+                        });
+
+                      case 1:
+                      case "end":
+                        return _context6.stop();
+                    }
+                  }, _callee6);
+                }));
+
+                function all() {
+                  return _all.apply(this, arguments);
+                }
+
+                return all;
+              }()
+            };
+          };
+
+          render( /*#__PURE__*/React.createElement(AppLike, {
+            client: client
+          }, /*#__PURE__*/React.createElement(SharingProvider, {
+            client: client,
+            doctype: "io.cozy.files"
+          }, /*#__PURE__*/React.createElement(RevocationView, null))));
+          _context7.t0 = fireEvent;
+          _context7.next = 12;
+          return screen.findByLabelText('Remove from sharing');
+
+        case 12:
+          _context7.t1 = _context7.sent;
+
+          _context7.t0.click.call(_context7.t0, _context7.t1);
+
+          _context7.next = 16;
+          return waitFor(function () {
+            expect(screen.queryByRole('dialog')).toBe(null);
+            expect(screen.queryByRole('heading', {
+              name: 'Shared drives'
+            })).toBeInTheDocument();
+            expect(screen.queryByText('Not a member')).toBeInTheDocument();
+          });
+
+        case 16:
+          expect(hasRevoked).toBe(true);
+
+        case 17:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "40.1.2",
+  "version": "40.1.3",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -58,7 +58,7 @@
     "cozy-intent": "^2.31.1",
     "cozy-minilog": "^3.10.1",
     "cozy-ui": "^140.5.0",
-    "cozy-ui-plus": "^14.0.7",
+    "cozy-ui-plus": "^14.0.8",
     "jest": "30.3.0",
     "jest-environment-jsdom": "30.3.0",
     "react": "16.12.0",
@@ -84,5 +84,5 @@
   "sideEffects": [
     "*.css"
   ],
-  "gitHead": "b1c4088b4d66cf6a5ec727284773283c55d474ce"
+  "gitHead": "958de80707ab26c724df5384bac265e676d80295"
 }

package/src/SharingProvider.jsx

@@ -381,10 +381,8 @@ export class SharingProvider extends Component {
     const sharing = getSharingForSelf(this.state, document.id)
     await this.sharingCol.revokeSelf(sharing)
     this.dispatch(revokeSelf(sharing))
-    await this.fetchEffectiveRecipients(
-      getDocumentId(document),
-      document.driveId
-    )
+    // Leaving removes our access to the sharing's effective recipients.
+    this.dispatch(receiveEffectiveRecipients(getDocumentId(document), []))
   }
 
   /**

package/src/SharingProvider.spec.jsx

@@ -632,6 +632,83 @@ describe('shared drive recipient revocation', () => {
   })
 })
 
+describe('revokeSelf', () => {
+  const document = { id: 'received-folder', _id: 'received-folder' }
+  const sharing = {
+    id: 'received-sharing',
+    type: 'io.cozy.sharings',
+    attributes: {
+      owner: false,
+      drive: true,
+      rules: [{ values: [document.id] }],
+      members: []
+    }
+  }
+  const recipients = [{ sharingId: sharing.id, memberIndex: 1 }]
+  const forbidden = Object.assign(new Error('Forbidden'), { status: 403 })
+  let provider
+  let sharingCol
+
+  beforeEach(() => {
+    const client = createMockClient({})
+    sharingCol = {
+      revokeSelf: jest.fn().mockResolvedValue({}),
+      fetchEffectiveRecipients: jest.fn().mockRejectedValue(forbidden)
+    }
+    client.collection = () => sharingCol
+    provider = setupProvider(
+      client,
+      {},
+      reducer(undefined, receiveSharings({ sharings: [sharing] }))
+    )
+    provider.dispatch(receiveEffectiveRecipients(document.id, recipients))
+    provider.dispatch(receiveEffectiveRecipients('other-folder', recipients))
+  })
+
+  it.each([true, false])(
+    'forgets the sharing and clears its recipients without reloading lost access (drive: %s)',
+    async drive => {
+      provider.state.sharings = [
+        { ...sharing, attributes: { ...sharing.attributes, drive } }
+      ]
+
+      await provider.revokeSelf(document)
+
+      expect(getDocumentSharing(provider.state, document.id)).toBeNull()
+      expect(getEffectiveRecipients(provider.state, document.id)).toEqual([])
+      expect(getEffectiveRecipients(provider.state, 'other-folder')).toEqual(
+        recipients
+      )
+      expect(sharingCol.fetchEffectiveRecipients).not.toHaveBeenCalled()
+    }
+  )
+
+  it.each([403, 500])(
+    'preserves sharing state and rejects when self-revocation fails (%s)',
+    async status => {
+      const error = Object.assign(new Error('Revocation failed'), { status })
+      sharingCol.revokeSelf.mockRejectedValue(error)
+
+      await expect(provider.revokeSelf(document)).rejects.toBe(error)
+
+      expect(getDocumentSharing(provider.state, document.id)).toEqual(sharing)
+      expect(getEffectiveRecipients(provider.state, document.id)).toEqual(
+        recipients
+      )
+    }
+  )
+
+  it('still rejects forbidden recipient refreshes outside self-revocation', async () => {
+    await expect(provider.fetchEffectiveRecipients(document.id)).rejects.toBe(
+      forbidden
+    )
+
+    expect(getEffectiveRecipients(provider.state, document.id)).toEqual(
+      recipients
+    )
+  })
+})
+
 describe('share flow reused by PermissionTypeMenu upgrade', () => {
   const PARENT_SHARING = {
     _id: 'parent_sharing',

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

@@ -0,0 +1,133 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+import React, { useState } from 'react'
+
+import { createMockClient } from 'cozy-client'
+
+import { FederatedFolderModal } from './FederatedFolderModal'
+import AppLike from '../../../test/AppLike'
+import { SharingProvider } from '../../SharingProvider'
+import { useSharingContext } from '../../hooks/useSharingContext'
+
+jest.mock('../ShareByEmail', () => () => null)
+jest.mock('../ShareByLink', () => () => null)
+
+const document = {
+  id: 'received-folder',
+  _id: 'received-folder',
+  name: 'Received drive',
+  type: 'directory',
+  driveId: 'received-sharing'
+}
+const instance = 'https://me.mycozy.cloud'
+const members = [
+  {
+    status: 'owner',
+    instance: 'https://owner.mycozy.cloud',
+    name: 'Owner',
+    email: 'owner@test.com'
+  },
+  {
+    status: 'ready',
+    instance,
+    name: 'Me',
+    email: 'me@test.com'
+  }
+]
+const sharing = {
+  id: document.driveId,
+  _id: document.driveId,
+  type: 'io.cozy.sharings',
+  attributes: {
+    owner: false,
+    drive: true,
+    active: true,
+    rules: [{ values: [document.id] }],
+    members
+  }
+}
+
+function RevocationView() {
+  const [hasLeft, setHasLeft] = useState(false)
+  const { allLoaded, getSharingForSelf } = useSharingContext()
+  if (!allLoaded) return null
+
+  return (
+    <>
+      <output>
+        {getSharingForSelf(document.id) ? 'Member of drive' : 'Not a member'}
+      </output>
+      {hasLeft ? (
+        <h1>Shared drives</h1>
+      ) : (
+        <FederatedFolderModal
+          document={document}
+          onClose={() => setHasLeft(true)}
+          onRevokeSuccess={() => setHasLeft(true)}
+        />
+      )}
+    </>
+  )
+}
+
+describe('FederatedFolderModal self-revocation with SharingProvider', () => {
+  it('closes and runs the success transition after leaving, without refreshing forbidden members', async () => {
+    let hasRevoked = false
+    const client = createMockClient({})
+    client.options.uri = instance
+    client.getStackClient().uri = instance
+    client.isLogged = true
+    client.plugins.realtime = { subscribe: jest.fn(), unsubscribe: jest.fn() }
+    const sharingCol = {
+      findByDoctype: async () => ({ data: [sharing] }),
+      revokeSelf: async () => {
+        hasRevoked = true
+      },
+      fetchEffectiveRecipients: async () => {
+        if (hasRevoked) {
+          throw Object.assign(new Error('Forbidden'), { status: 403 })
+        }
+        return {
+          data: members.map((member, memberIndex) => ({
+            ...member,
+            sources: [
+              {
+                kind: 'self',
+                sharing_id: sharing.id,
+                member_index: memberIndex
+              }
+            ]
+          }))
+        }
+      }
+    }
+    client.collection = doctype => {
+      if (doctype === 'io.cozy.sharings') return sharingCol
+      if (doctype === 'io.cozy.permissions') {
+        return {
+          findLinksByDoctype: async () => ({ data: [] }),
+          findLinksByIds: async () => ({ data: [] })
+        }
+      }
+      return { all: async () => ({ data: [] }) }
+    }
+
+    render(
+      <AppLike client={client}>
+        <SharingProvider client={client} doctype="io.cozy.files">
+          <RevocationView />
+        </SharingProvider>
+      </AppLike>
+    )
+
+    fireEvent.click(await screen.findByLabelText('Remove from sharing'))
+
+    await waitFor(() => {
+      expect(screen.queryByRole('dialog')).toBe(null)
+      expect(
+        screen.queryByRole('heading', { name: 'Shared drives' })
+      ).toBeInTheDocument()
+      expect(screen.queryByText('Not a member')).toBeInTheDocument()
+    })
+    expect(hasRevoked).toBe(true)
+  })
+})