box-ui-elements 17.2.0-beta.2 → 17.2.0-beta.4

package/src/api/Feed.js

@@ -3,8 +3,8 @@
  * @file Helper for activity feed API's
  * @author Box
  */
-import uniqueId from 'lodash/uniqueId';
 import noop from 'lodash/noop';
+import uniqueId from 'lodash/uniqueId';
 import type { MessageDescriptor } from 'react-intl';
 import { getBadItemError, getBadUserError, getMissingItemTextOrStatus, isUserCorrectableError } from '../utils/error';
 import commonMessages from '../elements/common/messages';
@@ -15,6 +15,7 @@ import Base from './Base';
 import AnnotationsAPI from './Annotations';
 import CommentsAPI from './Comments';
 import ThreadedCommentsAPI from './ThreadedComments';
+import FileActivitiesAPI from './FileActivities';
 import VersionsAPI from './Versions';
 import TasksNewAPI from './tasks/TasksNew';
 import GroupsAPI from './Groups';
@@ -28,6 +29,10 @@ import {
     FEED_ITEM_TYPE_ANNOTATION,
     FEED_ITEM_TYPE_COMMENT,
     FEED_ITEM_TYPE_TASK,
+    FILE_ACTIVITY_TYPE_ANNOTATION,
+    FILE_ACTIVITY_TYPE_APP_ACTIVITY,
+    FILE_ACTIVITY_TYPE_COMMENT,
+    FILE_ACTIVITY_TYPE_TASK,
     HTTP_STATUS_CODE_CONFLICT,
     IS_ERROR_DISPLAYED,
     TASK_NEW_APPROVED,
@@ -71,6 +76,8 @@ import type {
     FeedItem,
     FeedItems,
     FeedItemStatus,
+    FileActivity,
+    FileActivityTypes,
     Task,
     Tasks,
     ThreadedComments as ThreadedCommentsType,
@@ -95,6 +102,97 @@ const getItemWithPendingReply = <T: { replies?: Array<Comment> }>(item: T, reply
     return { replies: [...replies, reply], ...rest };
 };
 
+const parseReplies = (replies: Comment[]): Comment[] => {
+    const parsedReplies = [...replies];
+
+    return parsedReplies.map(reply => {
+        return { ...reply, tagged_message: reply.tagged_message || reply.message || '' };
+    });
+};
+
+export const getParsedFileActivitiesResponse = (response?: { entries: FileActivity[] }) => {
+    if (!response || !response.entries || !response.entries.length) {
+        return { entries: [] };
+    }
+
+    const data = response.entries;
+
+    const parsedData: Array<Object> = data
+        .map(item => {
+            if (!item.source) {
+                return null;
+            }
+
+            const source = { ...item.source };
+
+            switch (item.activity_type) {
+                case FILE_ACTIVITY_TYPE_TASK: {
+                    const taskItem = { ...source[FILE_ACTIVITY_TYPE_TASK] };
+                    // UAA follows a lowercased enum naming convention, convert to uppercase to align with task api
+                    if (taskItem.assigned_to?.entries) {
+                        const assignedToEntries = taskItem.assigned_to.entries.map(entry => {
+                            const assignedToEntry = { ...entry };
+
+                            assignedToEntry.role = entry.role.toUpperCase();
+                            assignedToEntry.status = entry.status.toUpperCase();
+
+                            return assignedToEntry;
+                        });
+                        // $FlowFixMe Using the toUpperCase method makes Flow assume role and status is a string type, which is incompatible with string literal
+                        taskItem.assigned_to.entries = assignedToEntries;
+                    }
+                    if (taskItem.completion_rule) {
+                        taskItem.completion_rule = taskItem.completion_rule.toUpperCase();
+                    }
+                    if (taskItem.status) {
+                        taskItem.status = taskItem.status.toUpperCase();
+                    }
+                    if (taskItem.task_type) {
+                        taskItem.task_type = taskItem.task_type.toUpperCase();
+                    }
+                    // $FlowFixMe File Activities only returns a created_by user, Flow type fix is needed
+                    taskItem.created_by = { target: taskItem.created_by };
+
+                    return taskItem;
+                }
+                case FILE_ACTIVITY_TYPE_COMMENT: {
+                    const commentItem = { ...source[FILE_ACTIVITY_TYPE_COMMENT] };
+
+                    if (commentItem.replies && commentItem.replies.length) {
+                        const replies = parseReplies(commentItem.replies);
+
+                        commentItem.replies = replies;
+                    }
+
+                    commentItem.tagged_message = commentItem.tagged_message || commentItem.message || '';
+
+                    return commentItem;
+                }
+                case FILE_ACTIVITY_TYPE_ANNOTATION: {
+                    const annotationItem = { ...source[FILE_ACTIVITY_TYPE_ANNOTATION] };
+
+                    if (annotationItem.replies && annotationItem.replies.length) {
+                        const replies = parseReplies(annotationItem.replies);
+
+                        annotationItem.replies = replies;
+                    }
+
+                    return annotationItem;
+                }
+                case FILE_ACTIVITY_TYPE_APP_ACTIVITY: {
+                    return { ...source[FILE_ACTIVITY_TYPE_APP_ACTIVITY] };
+                }
+
+                default: {
+                    return null;
+                }
+            }
+        })
+        .filter(item => !!item);
+
+    return { entries: parsedData };
+};
+
 class Feed extends Base {
     /**
      * @property {AnnotationsAPI}
@@ -136,6 +234,11 @@ class Feed extends Base {
      */
     threadedCommentsAPI: ThreadedCommentsAPI;
 
+    /**
+     * @property {FileActivitiesAPI}
+     */
+    fileActivitiesAPI: FileActivitiesAPI;
+
     /**
      * @property {BoxItem}
      */
@@ -368,12 +471,14 @@ class Feed extends Base {
             shouldShowReplies = false,
             shouldShowTasks = true,
             shouldShowVersions = true,
+            shouldUseUAA = false,
         }: {
             shouldShowAnnotations?: boolean,
             shouldShowAppActivity?: boolean,
             shouldShowReplies?: boolean,
             shouldShowTasks?: boolean,
             shouldShowVersions?: boolean,
+            shouldUseUAA?: boolean,
         } = {},
     ): void {
         const { id, permissions = {} } = file;
@@ -394,38 +499,78 @@ class Feed extends Base {
         this.file = file;
         this.errors = [];
         this.errorCallback = onError;
-        const annotationsPromise = shouldShowAnnotations
-            ? this.fetchAnnotations(permissions, shouldShowReplies)
-            : Promise.resolve();
+
+        // Using the UAA File Activities endpoint replaces the need for these calls
+        const annotationsPromise =
+            !shouldUseUAA && shouldShowAnnotations
+                ? this.fetchAnnotations(permissions, shouldShowReplies)
+                : Promise.resolve();
+        const commentsPromise = () => {
+            if (shouldUseUAA) {
+                return Promise.resolve();
+            }
+
+            return shouldShowReplies ? this.fetchThreadedComments(permissions) : this.fetchComments(permissions);
+        };
+        const tasksPromise = !shouldUseUAA && shouldShowTasks ? this.fetchTasksNew() : Promise.resolve();
+        const appActivityPromise =
+            !shouldUseUAA && shouldShowAppActivity ? this.fetchAppActivity(permissions) : Promise.resolve();
+
         const versionsPromise = shouldShowVersions ? this.fetchVersions() : Promise.resolve();
         const currentVersionPromise = shouldShowVersions ? this.fetchCurrentVersion() : Promise.resolve();
-        const commentsPromise = shouldShowReplies
-            ? this.fetchThreadedComments(permissions)
-            : this.fetchComments(permissions);
-        const tasksPromise = shouldShowTasks ? this.fetchTasksNew() : Promise.resolve();
-        const appActivityPromise = shouldShowAppActivity ? this.fetchAppActivity(permissions) : Promise.resolve();
-
-        Promise.all([
-            versionsPromise,
-            currentVersionPromise,
-            commentsPromise,
-            tasksPromise,
-            appActivityPromise,
-            annotationsPromise,
-        ]).then(([versions: ?FileVersions, currentVersion: ?BoxItemVersion, ...feedItems]) => {
-            const versionsWithCurrent = currentVersion
-                ? this.versionsAPI.addCurrentVersion(currentVersion, versions, this.file)
-                : undefined;
-            const sortedFeedItems = sortFeedItems(versionsWithCurrent, ...feedItems);
+        const fileActivitiesPromise = shouldUseUAA
+            ? this.fetchFileActivities(permissions, [
+                  FILE_ACTIVITY_TYPE_ANNOTATION,
+                  FILE_ACTIVITY_TYPE_APP_ACTIVITY,
+                  FILE_ACTIVITY_TYPE_COMMENT,
+                  FILE_ACTIVITY_TYPE_TASK,
+              ])
+            : Promise.resolve();
+
+        const handleFeedItems = (feedItems: FeedItems) => {
             if (!this.isDestroyed()) {
-                this.setCachedItems(id, sortedFeedItems);
+                this.setCachedItems(id, feedItems);
                 if (this.errors.length) {
-                    errorCallback(sortedFeedItems, this.errors);
+                    errorCallback(feedItems, this.errors);
                 } else {
-                    successCallback(sortedFeedItems);
+                    successCallback(feedItems);
                 }
             }
-        });
+        };
+
+        if (shouldUseUAA) {
+            Promise.all([versionsPromise, currentVersionPromise, fileActivitiesPromise]).then(
+                ([versions: ?FileVersions, currentVersion: ?BoxItemVersion, ...feedItems]) => {
+                    if (!feedItems || !feedItems.length) {
+                        return;
+                    }
+
+                    const fileActivitiesResponse = feedItems[0];
+                    const versionsWithCurrent = currentVersion
+                        ? this.versionsAPI.addCurrentVersion(currentVersion, versions, this.file)
+                        : undefined;
+                    const parsedFeedItems = getParsedFileActivitiesResponse(fileActivitiesResponse);
+                    // $FlowFixMe Does not need to be sorted once we include versions in the file activities call
+                    const sortedFeedItems = sortFeedItems(versionsWithCurrent, parsedFeedItems);
+                    handleFeedItems(sortedFeedItems);
+                },
+            );
+        } else {
+            Promise.all([
+                versionsPromise,
+                currentVersionPromise,
+                commentsPromise(),
+                tasksPromise,
+                appActivityPromise,
+                annotationsPromise,
+            ]).then(([versions: ?FileVersions, currentVersion: ?BoxItemVersion, ...feedItems]) => {
+                const versionsWithCurrent = currentVersion
+                    ? this.versionsAPI.addCurrentVersion(currentVersion, versions, this.file)
+                    : undefined;
+                const sortedFeedItems = sortFeedItems(versionsWithCurrent, ...feedItems);
+                handleFeedItems(sortedFeedItems);
+            });
+        }
     }
 
     fetchAnnotations(permissions: BoxItemPermission, shouldFetchReplies?: boolean): Promise<?Annotations> {
@@ -525,6 +670,26 @@ class Feed extends Base {
         });
     }
 
+    /**
+     * Fetches the file activities for a file
+     *
+     * @param {BoxItemPermission} permissions - the file permissions
+     * @param {FileActivityTypes[]} activityTypes - the activity types to filter by
+     * @return {Promise} - the file comments
+     */
+    fetchFileActivities(permissions: BoxItemPermission, activityTypes: FileActivityTypes[]): Promise<Object> {
+        this.fileActivitiesAPI = new FileActivitiesAPI(this.options);
+        return new Promise(resolve => {
+            this.fileActivitiesAPI.getActivities({
+                errorCallback: this.fetchFeedItemErrorCallback.bind(this, resolve),
+                fileID: this.file.id,
+                permissions,
+                successCallback: resolve,
+                activityTypes,
+            });
+        });
+    }
+
     /**
      * Fetches replies (comments) of a comment or annotation
      *

package/src/api/FileActivities.js

@@ -0,0 +1,88 @@
+/**
+ * @flow
+ * @file Helper for the box File Activity API
+ * @author Box
+ */
+
+import Base from './Base';
+import { PERMISSION_CAN_COMMENT, PERMISSION_CAN_VIEW_ANNOTATIONS, ERROR_CODE_FETCH_ACTIVITY } from '../constants';
+import type { BoxItemPermission } from '../common/types/core';
+import type { ElementsXhrError } from '../common/types/api';
+import type { FileActivity, FileActivityTypes } from '../common/types/feed';
+
+// We only show the latest reply in the UI
+const REPLY_LIMIT = 1;
+
+const getFileActivityQueryParams = (fileID: string, activityTypes?: FileActivityTypes[] = []) => {
+    const baseEndpoint = `/file_activities?file_id=${fileID}`;
+    const hasActivityTypes = !!activityTypes && !!activityTypes.length;
+    const enabledRepliesQueryParam = `&enable_replies=true&reply_limit=${REPLY_LIMIT}`;
+    const activityTypeQueryParam = hasActivityTypes ? `&activity_types=${activityTypes.join()}` : '';
+
+    return `${baseEndpoint}${activityTypeQueryParam}${enabledRepliesQueryParam}`;
+};
+
+class FileActivities extends Base {
+    /**
+     * API URL for filtered file activities
+     *
+     * @param {string} [id] - a box file id
+     * @param {Array<FileActivityTypes>} activityTypes - optional. Array of File Activity types to filter by, returns all Activity Types if omitted.
+     * @return {string} base url for files
+     */
+    getFilteredUrl(id: string, activityTypes?: FileActivityTypes[]): string {
+        return `${this.getBaseApiUrl()}${getFileActivityQueryParams(id, activityTypes)}`;
+    }
+
+    /**
+     * API for fetching file activities
+     *
+     * @param {Array<FileActivityTypes>} activityTypes - optional. Array of File Activity types to filter by, returns all Activity Types if omitted.
+     * @param {Function} errorCallback - the error callback
+     * @param {string} fileId - the file id
+     * @param {BoxItemPermission} permissions - the permissions for the file
+     * @param {number} repliesCount - number of replies to return, by default all replies are returned
+     * @param {Function} successCallback - the success callback
+     * @returns {void}
+     */
+    getActivities({
+        activityTypes,
+        errorCallback,
+        fileID,
+        permissions,
+        repliesCount,
+        successCallback,
+    }: {
+        activityTypes: FileActivityTypes[],
+        errorCallback: (e: ElementsXhrError, code: string) => void,
+        fileID: string,
+        permissions: BoxItemPermission,
+        repliesCount?: number,
+        successCallback: (activity: FileActivity) => void,
+    }): void {
+        this.errorCode = ERROR_CODE_FETCH_ACTIVITY;
+        try {
+            if (!fileID) {
+                throw new Error('Missing file id!');
+            }
+
+            this.checkApiCallValidity(PERMISSION_CAN_COMMENT, permissions, fileID);
+            this.checkApiCallValidity(PERMISSION_CAN_VIEW_ANNOTATIONS, permissions, fileID);
+        } catch (e) {
+            errorCallback(e, this.errorCode);
+            return;
+        }
+
+        this.get({
+            id: fileID,
+            successCallback,
+            errorCallback,
+            requestData: {
+                ...(repliesCount ? { replies_count: repliesCount } : null),
+            },
+            url: this.getFilteredUrl(fileID, activityTypes),
+        });
+    }
+}
+
+export default FileActivities;

package/src/api/Item.js

@@ -20,6 +20,7 @@ import {
 } from '../constants';
 import type { ElementsErrorCallback, RequestData, RequestOptions } from '../common/types/api';
 import type {
+    Access,
     BoxItem,
     BoxItemPermission,
     FlattenedBoxItem,
@@ -165,7 +166,7 @@ class Item extends Base {
     /**
      * API to delete an Item
      *
-     * @param {Object} item - Item to delete
+     * @param {BoxItem} item - Item to delete
      * @param {Function} successCallback - Success callback
      * @param {Function} errorCallback - Error callback
      * @return {void}
@@ -221,7 +222,7 @@ class Item extends Base {
     /**
      * API to rename an Item
      *
-     * @param {Object} item - Item to rename
+     * @param {BoxItem} item - Item to rename
      * @param {string} name - Item new name
      * @param {Function} successCallback - Success callback
      * @param {Function} errorCallback - Error callback
@@ -286,32 +287,38 @@ class Item extends Base {
     };
 
     /**
-     * Validate an item update request
+     * Validate request to update an item shared link
      *
      * @param {string|void} itemID - ID of item to share
      * @param {BoxItemPermission|void} itemPermissions - Permissions for item
-     * @param {boolean|void} canSkipSetShareAccess - skip the check for can_set_share_access when creating a new shared link
+     * @param {boolean|void} canSkipSetShareAccessPermission - skip `can_set_share_access` permission check
      * @throws {Error}
      * @return {void}
      */
-    validateRequest(itemID: ?string, itemPermissions: ?BoxItemPermission, canSkipSetShareAccess: boolean = false) {
+    validateSharedLinkRequest(
+        itemID: ?string,
+        itemPermissions: ?BoxItemPermission,
+        canSkipSetShareAccessPermission: boolean = false,
+    ) {
         if (!itemID || !itemPermissions) {
             this.errorCode = ERROR_CODE_SHARE_ITEM;
             throw getBadItemError();
         }
 
+        // It is sometimes necessary to skip `can_set_share_access` permission check
+        // e.g. Viewer permission can create shared links but cannot update access level
         const { can_share, can_set_share_access }: BoxItemPermission = itemPermissions;
-        if (!can_share || (!canSkipSetShareAccess && !can_set_share_access)) {
+        if (!can_share || (!canSkipSetShareAccessPermission && !can_set_share_access)) {
             this.errorCode = ERROR_CODE_SHARE_ITEM;
             throw getBadPermissionsError();
         }
     }
 
     /**
-     * API to create, modify (change access) or remove a shared link
+     * API to create, modify (change access), or remove a shared link
      *
-     * @param {Object} item - Item to share
-     * @param {string} access - Shared access level
+     * @param {BoxItem} item - Item to share
+     * @param {Access} access - Shared access level
      * @param {Function} successCallback - Success callback
      * @param {Function|void} errorCallback - Error callback
      * @param {Array<string>|void} [options.fields] - Optionally include specific fields
@@ -319,7 +326,7 @@ class Item extends Base {
      */
     async share(
         item: BoxItem,
-        access: ?string, // if "access" is undefined, the backend will set the default access level for the shared link
+        access?: Access, // if "access" is undefined, the backend will set the default access level for the shared link
         successCallback: Function,
         errorCallback: ElementsErrorCallback = noop,
         options: RequestOptions = {},
@@ -329,14 +336,14 @@ class Item extends Base {
         }
 
         try {
-            const { id, permissions }: BoxItem = item;
+            const { id, permissions, shared_link: sharedLink }: BoxItem = item;
             this.id = id;
             this.successCallback = successCallback;
             this.errorCallback = errorCallback;
 
-            // if we use the default access level, we don't need permission to set the access level
-            const canSkipSetShareAccess = access === undefined;
-            this.validateRequest(id, permissions, canSkipSetShareAccess);
+            // skip permission check when creating links with default access level
+            const canSkipSetShareAccessPermission = !sharedLink && access === undefined;
+            this.validateSharedLinkRequest(id, permissions, canSkipSetShareAccessPermission);
 
             const { fields } = options;
             const requestData: RequestData = {
@@ -383,7 +390,7 @@ class Item extends Base {
             this.successCallback = successCallback;
             this.errorCallback = errorCallback;
 
-            this.validateRequest(id, permissions);
+            this.validateSharedLinkRequest(id, permissions);
 
             const { fields } = options;
             const requestData: RequestData = {

package/src/api/__tests__/Feed.test.js

@@ -9,14 +9,24 @@ import {
     FEED_ITEM_TYPE_ANNOTATION,
     FEED_ITEM_TYPE_COMMENT,
     FEED_ITEM_TYPE_VERSION,
+    FILE_ACTIVITY_TYPE_ANNOTATION,
+    FILE_ACTIVITY_TYPE_APP_ACTIVITY,
+    FILE_ACTIVITY_TYPE_COMMENT,
+    FILE_ACTIVITY_TYPE_TASK,
     IS_ERROR_DISPLAYED,
     TASK_MAX_GROUP_ASSIGNEES,
 } from '../../constants';
 import AnnotationsAPI from '../Annotations';
-import Feed from '../Feed';
+import Feed, { getParsedFileActivitiesResponse } from '../Feed';
 import ThreadedCommentsAPI from '../ThreadedComments';
 import { annotation as mockAnnotation } from '../../__mocks__/annotations';
-import { task as mockTask, threadedComments as mockThreadedComments, threadedCommentsFormatted } from '../fixtures';
+import {
+    fileActivities as mockFileActivities,
+    task as mockTask,
+    threadedComments as mockThreadedComments,
+    threadedCommentsFormatted,
+    annotationsWithFormattedReplies as mockFormattedAnnotations,
+} from '../fixtures';
 
 const mockErrors = [{ code: 'error_code_0' }, { code: 'error_code_1' }];
 
@@ -297,6 +307,14 @@ jest.mock('../AppActivity', () =>
     })),
 );
 
+jest.mock('../FileActivities', () => {
+    return jest.fn().mockImplementation(() => ({
+        getActivities: jest.fn().mockReturnValue({
+            entries: mockFileActivities,
+        }),
+    }));
+});
+
 describe('api/Feed', () => {
     let feed;
     const comments = {
@@ -417,6 +435,7 @@ describe('api/Feed', () => {
             feed.fetchVersions = jest.fn().mockResolvedValue(versions);
             feed.fetchCurrentVersion = jest.fn().mockResolvedValue(mockCurrentVersion);
             feed.fetchTasksNew = jest.fn().mockResolvedValue(tasks);
+            feed.fetchFileActivities = jest.fn().mockResolvedValue({ entries: mockFileActivities });
             feed.fetchComments = jest.fn().mockResolvedValue(comments);
             feed.fetchThreadedComments = jest.fn().mockResolvedValue(threadedComments);
             feed.fetchAppActivity = jest.fn().mockReturnValue(appActivities);
@@ -585,6 +604,21 @@ describe('api/Feed', () => {
                 done();
             });
         });
+
+        test('should use the file activities api if shouldUseUAA is true', done => {
+            feed.feedItems(file, false, successCb, errorCb, errorCb, { shouldUseUAA: true });
+            setImmediate(() => {
+                expect(feed.fetchFileActivities).toBeCalledWith(file.permissions, [
+                    FILE_ACTIVITY_TYPE_ANNOTATION,
+                    FILE_ACTIVITY_TYPE_APP_ACTIVITY,
+                    FILE_ACTIVITY_TYPE_COMMENT,
+                    FILE_ACTIVITY_TYPE_TASK,
+                ]);
+                expect(feed.fetchComments).not.toBeCalled();
+                expect(feed.fetchThreadedComments).not.toBeCalled();
+                done();
+            });
+        });
     });
 
     describe('fetchAnnotations()', () => {
@@ -800,6 +834,37 @@ describe('api/Feed', () => {
                 expect(feed.tasksNewAPI.getTasksForFile).toBeCalled();
             });
         });
+
+        describe('fetchFileActivities()', () => {
+            beforeEach(() => {
+                feed.file = file;
+                feed.fetchFeedItemErrorCallback = jest.fn();
+            });
+
+            test('should return a promise and call the file activities api', () => {
+                const permissions = { can_edit: true, can_delete: true, can_resolve: true };
+                const fileActivityItems = feed.fetchFileActivities(permissions, [
+                    FILE_ACTIVITY_TYPE_ANNOTATION,
+                    FILE_ACTIVITY_TYPE_APP_ACTIVITY,
+                    FILE_ACTIVITY_TYPE_COMMENT,
+                    FILE_ACTIVITY_TYPE_TASK,
+                ]);
+                expect(fileActivityItems instanceof Promise).toBeTruthy();
+                expect(feed.fileActivitiesAPI.getActivities).toBeCalledWith({
+                    activityTypes: [
+                        FILE_ACTIVITY_TYPE_ANNOTATION,
+                        FILE_ACTIVITY_TYPE_APP_ACTIVITY,
+                        FILE_ACTIVITY_TYPE_COMMENT,
+                        FILE_ACTIVITY_TYPE_TASK,
+                    ],
+                    errorCallback: expect.any(Function),
+                    fileID: feed.file.id,
+                    permissions,
+                    successCallback: expect.any(Function),
+                });
+                expect(fileActivityItems).resolves.toEqual({ entries: mockFileActivities });
+            });
+        });
     });
 
     describe('updateTaskCollaborator()', () => {
@@ -2235,4 +2300,31 @@ describe('api/Feed', () => {
             expect(feed.updateFeedItem).toBeCalledWith({ total_reply_count: total_reply_count + 1 }, id);
         });
     });
+
+    describe('getParsedFileActivitiesResponse()', () => {
+        test.each`
+            response
+            ${undefined}
+            ${{}}
+            ${{ entries: { test: 'invalid' } }}
+            ${{ entries: [{ test: 'invalid' }] }}
+            ${{ entries: [{ source: { activity: 'invalid' } }] }}
+        `('should return an empty entries array when the response is $response', ({ response }) => {
+            expect(getParsedFileActivitiesResponse(response)).toEqual({ entries: [] });
+        });
+
+        test.each`
+            response
+            ${{ entries: mockFileActivities }}
+            ${{ entries: [...mockFileActivities, { test: 'filtered out' }] }}
+        `('should return a parsed entries array when response is valid', ({ response }) => {
+            expect(getParsedFileActivitiesResponse(response)).toEqual({
+                entries: [
+                    mockFormattedAnnotations[0],
+                    threadedCommentsFormatted[0],
+                    { ...mockTask, task_type: 'GENERAL', created_by: { target: mockTask.created_by.target } },
+                ],
+            });
+        });
+    });
 });