box-ui-elements 16.0.0-beta.9 → 16.0.0

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

@@ -1,73 +1,26 @@
+import cloneDeep from 'lodash/cloneDeep';
 import commonMessages from '../../elements/common/messages';
 import messages from '../messages';
 import * as sorter from '../../utils/sorter';
 import * as error from '../../utils/error';
-import { IS_ERROR_DISPLAYED, TASK_NEW_NOT_STARTED, TASK_MAX_GROUP_ASSIGNEES } from '../../constants';
+import { FEED_FILE_VERSIONS_FIELDS_TO_FETCH } from '../../utils/fields';
+import {
+    FEED_ITEM_TYPE_APP_ACTIVITY,
+    FEED_ITEM_TYPE_ANNOTATION,
+    FEED_ITEM_TYPE_COMMENT,
+    FEED_ITEM_TYPE_VERSION,
+    IS_ERROR_DISPLAYED,
+    TASK_MAX_GROUP_ASSIGNEES,
+} from '../../constants';
 import Feed from '../Feed';
 import { annotation as mockAnnotation } from '../../__mocks__/annotations';
-
-const mockTask = {
-    created_by: {
-        type: 'task_collaborator',
-        target: { name: 'Jay-Z', id: '100' },
-        id: '000',
-        role: 'CREATOR',
-        status: TASK_NEW_NOT_STARTED,
-    },
-    created_at: '2019-01-01',
-    due_at: '2019-02-02',
-    id: '0',
-    name: 'task message',
-    type: 'task',
-    assigned_to: {
-        entries: [
-            {
-                id: '1',
-                target: { name: 'Beyonce', id: '2', avatar_url: '', type: 'user' },
-                status: TASK_NEW_NOT_STARTED,
-                permissions: {
-                    can_delete: false,
-                    can_update: false,
-                },
-                role: 'ASSIGNEE',
-                type: 'task_collaborator',
-            },
-        ],
-        limit: 10,
-        next_marker: null,
-    },
-    permissions: {
-        can_update: false,
-        can_delete: false,
-        can_create_task_collaborator: false,
-        can_create_task_link: false,
-    },
-    task_links: {
-        entries: [
-            {
-                id: '03',
-                type: 'task_link',
-                target: {
-                    type: 'file',
-                    id: '4',
-                },
-                permissions: {
-                    can_delete: false,
-                    can_update: false,
-                },
-            },
-        ],
-        limit: 1,
-        next_marker: null,
-    },
-    status: TASK_NEW_NOT_STARTED,
-};
+import { task as mockTask, threadedComments as mockThreadedComments, threadedCommentsFormatted } from '../fixtures';
 
 const mockErrors = [{ code: 'error_code_0' }, { code: 'error_code_1' }];
 
 const mockFirstVersion = {
     action: 'upload',
-    type: 'file_version',
+    type: FEED_ITEM_TYPE_VERSION,
     id: 123,
     created_at: 'Thu Sep 20 33658 19:45:39 GMT-0600 (CST)',
     trashed_at: 1234567891,
@@ -77,13 +30,13 @@ const mockFirstVersion = {
 
 const mockCurrentVersion = {
     action: 'restore',
-    type: 'file_version',
+    type: FEED_ITEM_TYPE_VERSION,
     id: '123',
 };
 
 const deleted_version = {
     action: 'delete',
-    type: 'file_version',
+    type: FEED_ITEM_TYPE_VERSION,
     id: 234,
     created_at: 'Thu Sep 20 33658 19:45:39 GMT-0600 (CST)',
     trashed_at: 1234567891,
@@ -107,6 +60,12 @@ const annotations = {
     next_marker: null,
 };
 
+const threadedComments = {
+    entries: mockThreadedComments,
+    limit: 1000,
+    next_marker: null,
+};
+
 jest.mock('lodash/uniqueId', () => () => 'uniqueId');
 
 const mockCreateTaskWithDeps = jest.fn().mockImplementation(({ successCallback }) => {
@@ -114,7 +73,6 @@ const mockCreateTaskWithDeps = jest.fn().mockImplementation(({ successCallback }
 });
 
 jest.mock('../tasks/TasksNew', () => {
-    const task = mockTask;
     return jest.fn().mockImplementation(() => ({
         createTaskWithDeps: mockCreateTaskWithDeps,
         updateTaskWithDeps: jest.fn().mockImplementation(({ successCallback }) => {
@@ -123,9 +81,9 @@ jest.mock('../tasks/TasksNew', () => {
         deleteTask: jest.fn().mockImplementation(({ successCallback }) => {
             successCallback();
         }),
-        getTasksForFile: jest.fn().mockReturnValue({ entries: [task], next_marker: null, limit: 1000 }),
+        getTasksForFile: jest.fn().mockReturnValue({ entries: [mockTask], next_marker: null, limit: 1000 }),
         getTask: jest.fn(({ successCallback }) => {
-            successCallback(task);
+            successCallback(mockTask);
         }),
     }));
 });
@@ -239,6 +197,35 @@ jest.mock('../Comments', () =>
     })),
 );
 
+jest.mock('../ThreadedComments', () =>
+    jest.fn().mockImplementation(() => ({
+        getComments: jest.fn().mockReturnValue({
+            entries: mockThreadedComments,
+            limit: 1000,
+            next_marker: null,
+        }),
+        getCommentReplies: jest.fn().mockImplementation(({ successCallback }) => {
+            successCallback({
+                entries: mockThreadedComments,
+                limit: 1000,
+                next_marker: null,
+            });
+        }),
+        deleteComment: jest.fn().mockImplementation(({ successCallback }) => {
+            successCallback();
+        }),
+        updateComment: jest.fn().mockImplementation(({ successCallback }) => {
+            successCallback();
+        }),
+        createComment: jest.fn().mockImplementation(({ successCallback }) => {
+            successCallback();
+        }),
+        createCommentReply: jest.fn().mockImplementation(({ successCallback }) => {
+            successCallback();
+        }),
+    })),
+);
+
 jest.mock('../Versions', () => {
     return jest.fn().mockImplementation(() => ({
         getVersions: jest.fn(() => mockFirstVersion),
@@ -255,6 +242,18 @@ jest.mock('../Annotations', () =>
             successCallback();
         }),
         getAnnotations: jest.fn(),
+        getAnnotationReplies: jest.fn().mockImplementation((fileId, annotationId, permissions, successCallback) => {
+            successCallback({
+                entries: mockThreadedComments,
+                limit: 1000,
+                next_marker: null,
+            });
+        }),
+        createAnnotationReply: jest
+            .fn()
+            .mockImplementation((fileId, annotationId, permissions, message, successCallback) => {
+                successCallback();
+            }),
     })),
 );
 
@@ -278,7 +277,7 @@ const MOCK_APP_ACTIVITY_ITEM = {
     id: '3782',
     occurred_at: '2019-02-21T04:00:00Z',
     rendered_text: 'You shared this file in <a href="https://some-app.com" rel="noreferrer noopener">Some App</a>',
-    type: 'app_activity',
+    type: FEED_ITEM_TYPE_APP_ACTIVITY,
 };
 
 jest.mock('../AppActivity', () =>
@@ -299,7 +298,7 @@ describe('api/Feed', () => {
         total_count: 1,
         entries: [
             {
-                type: 'comment',
+                type: FEED_ITEM_TYPE_COMMENT,
                 id: '123',
                 created_at: 'Thu Sep 26 33658 19:46:39 GMT-0600 (CST)',
                 tagged_message: 'test @[123:Jeezy] @[10:Kanye West]',
@@ -414,6 +413,7 @@ describe('api/Feed', () => {
             feed.fetchCurrentVersion = jest.fn().mockResolvedValue(mockCurrentVersion);
             feed.fetchTasksNew = jest.fn().mockResolvedValue(tasks);
             feed.fetchComments = jest.fn().mockResolvedValue(comments);
+            feed.fetchThreadedComments = jest.fn().mockResolvedValue(threadedComments);
             feed.fetchAppActivity = jest.fn().mockReturnValue(appActivities);
             feed.fetchAnnotations = jest.fn().mockReturnValue(annotations);
             feed.setCachedItems = jest.fn();
@@ -488,6 +488,22 @@ describe('api/Feed', () => {
             });
         });
 
+        test.each`
+            shouldShowReplies | expected
+            ${undefined}      | ${false}
+            ${false}          | ${false}
+            ${true}           | ${true}
+        `(
+            'should pass $expected as shouldShowReplies when calling fetchAnnotations when $shouldShowReplies is given as shouldShowReplies',
+            ({ shouldShowReplies, expected }) => {
+                feed.feedItems(file, false, successCb, errorCb, errorCb, {
+                    shouldShowAnnotations: true,
+                    shouldShowReplies,
+                });
+                expect(feed.fetchAnnotations).toBeCalledWith(expect.anything(), expected);
+            },
+        );
+
         test('should not use the annotations api if shouldShowannotations is false', done => {
             feed.feedItems(file, false, successCb, errorCb, errorCb, { shouldShowAnnotations: false });
             setImmediate(() => {
@@ -496,6 +512,14 @@ describe('api/Feed', () => {
             });
         });
 
+        test('should use the threaded comments api if shouldShowReplies is true', done => {
+            feed.feedItems(file, false, successCb, errorCb, errorCb, { shouldShowReplies: true });
+            setImmediate(() => {
+                expect(feed.fetchThreadedComments).toBeCalledWith(file.permissions);
+                done();
+            });
+        });
+
         test('should not call success or error callback if it is destroyed', done => {
             feed.isDestroyed = jest.fn().mockReturnValue(true);
             feed.feedItems(file, false, successCb, errorCb);
@@ -569,6 +593,21 @@ describe('api/Feed', () => {
             expect(annotationItems instanceof Promise).toBeTruthy();
             expect(feed.annotationsAPI.getAnnotations).toBeCalled();
         });
+
+        test('when called with shouldFetchReplies = true, should return a promise and call the annotations api with shouldFetchReplies param as true', () => {
+            const annotationItems = feed.fetchAnnotations({ can_edit: true }, true);
+            expect(annotationItems instanceof Promise).toBeTruthy();
+            expect(feed.annotationsAPI.getAnnotations).toBeCalledWith(
+                feed.file.id,
+                undefined,
+                { can_edit: true },
+                expect.any(Function),
+                expect.any(Function),
+                undefined,
+                undefined,
+                true,
+            );
+        });
     });
 
     describe('fetchComments()', () => {
@@ -584,6 +623,72 @@ describe('api/Feed', () => {
         });
     });
 
+    describe('fetchThreadedComments()', () => {
+        beforeEach(() => {
+            feed.file = file;
+            feed.fetchFeedItemErrorCallback = jest.fn();
+        });
+
+        test('should return a promise and call the threaded comments api', () => {
+            const permissions = { can_edit: true, can_delete: true, can_resolve: true };
+            const commentItems = feed.fetchThreadedComments(permissions);
+            expect(commentItems instanceof Promise).toBeTruthy();
+            expect(feed.threadedCommentsAPI.getComments).toBeCalledWith({
+                errorCallback: expect.any(Function),
+                fileId: feed.file.id,
+                permissions,
+                successCallback: expect.any(Function),
+            });
+        });
+    });
+
+    describe('fetchReplies()', () => {
+        beforeEach(() => {
+            feed.file = file;
+            feed.updateFeedItem = jest.fn();
+        });
+
+        test('should throw if no file id', () => {
+            expect(() => feed.fetchReplies({ permissions: { can_comment: true } })).toThrow(fileError);
+        });
+
+        test('should throw if no file permissions', () => {
+            expect(() => feed.fetchReplies({ id: '1234' })).toThrow(fileError);
+        });
+
+        test('should call the threaded comments api and call passed successCallback if itemType is comment', () => {
+            const commentId = '123';
+            const successCallback = jest.fn();
+            const errorCallback = jest.fn();
+            feed.fetchReplies(file, commentId, FEED_ITEM_TYPE_COMMENT, successCallback, errorCallback);
+            expect(feed.updateFeedItem).toBeCalledWith({ isRepliesLoading: true }, commentId);
+            expect(feed.threadedCommentsAPI.getCommentReplies).toBeCalledWith({
+                fileId: feed.file.id,
+                commentId,
+                permissions: feed.file.permissions,
+                successCallback: expect.any(Function),
+                errorCallback: expect.any(Function),
+            });
+            expect(successCallback).toBeCalled();
+        });
+
+        test('should call the annotations api and call passed successCallback if itemType is annotation', () => {
+            const annotationId = '1234';
+            const successCallback = jest.fn();
+            const errorCallback = jest.fn();
+            feed.fetchReplies(file, annotationId, FEED_ITEM_TYPE_ANNOTATION, successCallback, errorCallback);
+            expect(feed.updateFeedItem).toBeCalledWith({ isRepliesLoading: true }, annotationId);
+            expect(feed.annotationsAPI.getAnnotationReplies).toBeCalledWith(
+                feed.file.id,
+                annotationId,
+                feed.file.permissions,
+                expect.any(Function),
+                expect.any(Function),
+            );
+            expect(successCallback).toBeCalled();
+        });
+    });
+
     describe('Fetching Base Items', () => {
         beforeEach(() => {
             feed.file = file;
@@ -596,6 +701,18 @@ describe('api/Feed', () => {
                 expect(versionItems instanceof Promise).toBeTruthy();
                 expect(feed.versionsAPI.getVersions).toBeCalled();
             });
+
+            test('should call the versions api with the correct fields', () => {
+                feed.fetchVersions();
+                expect(feed.versionsAPI.getVersions).toBeCalledWith(
+                    file.id,
+                    expect.any(Function),
+                    expect.any(Function),
+                    undefined,
+                    undefined,
+                    FEED_FILE_VERSIONS_FIELDS_TO_FETCH,
+                );
+            });
         });
 
         describe('fetchCurrentVersion()', () => {
@@ -663,7 +780,7 @@ describe('api/Feed', () => {
                 successCb,
             );
             expect(feed.tasksNewAPI.getTask).toBeCalled();
-            expect(feed.updateFeedItem).toBeCalledWith({ isPending: false }, taskId);
+            expect(feed.updateFeedItem).toBeCalledWith({ ...mockTask, isPending: false }, taskId);
             expect(successCb).toBeCalled();
         });
     });
@@ -919,6 +1036,96 @@ describe('api/Feed', () => {
         });
     });
 
+    describe('updateThreadedComment()', () => {
+        beforeEach(() => {
+            feed.updateFeedItem = jest.fn();
+        });
+
+        test('should throw if no file id', () => {
+            expect(() => feed.updateThreadedComment({})).toThrow(fileError);
+        });
+
+        test('should throw if no text or status', () => {
+            expect(() =>
+                feed.updateThreadedComment(
+                    file,
+                    '123',
+                    undefined,
+                    undefined,
+                    { can_delete: true },
+                    undefined,
+                    jest.fn(),
+                    jest.fn(),
+                ),
+            ).toThrowError();
+        });
+
+        describe('should call the threaded comments api and update the feed items', () => {
+            test.each`
+                testText     | testStatus   | expected
+                ${'hello'}   | ${undefined} | ${{ message: 'hello' }}
+                ${undefined} | ${'open'}    | ${{ status: 'open' }}
+                ${'hello'}   | ${'open'}    | ${{ message: 'hello', status: 'open' }}
+            `('given text=$testText and status=$testStatus', ({ testText, testStatus, expected }) => {
+                const successCallback = jest.fn();
+                const errorCallback = jest.fn();
+                const comment = {
+                    id: '1',
+                    permissions: { can_edit: true },
+                };
+                feed.updateThreadedComment(
+                    file,
+                    comment.id,
+                    testText,
+                    testStatus,
+                    comment.permissions,
+                    successCallback,
+                    errorCallback,
+                );
+                expect(feed.threadedCommentsAPI.updateComment).toBeCalledWith({
+                    fileId: file.id,
+                    commentId: comment.id,
+                    permissions: comment.permissions,
+                    ...expected,
+                    successCallback: expect.any(Function),
+                    errorCallback: expect.any(Function),
+                });
+                expect(feed.updateFeedItem).toBeCalled();
+                expect(successCallback).toBeCalled();
+            });
+        });
+    });
+
+    describe('updateReply()', () => {
+        test('should throw if no file id', () => {
+            expect(() => feed.updateReply({})).toThrow(fileError);
+        });
+
+        test('should call the threaded comments api and update the feed items', () => {
+            feed.updateReplyItem = jest.fn();
+            const successCallback = jest.fn();
+            const errorCallback = jest.fn();
+            const parentId = '123';
+            const text = 'abc';
+            const reply = {
+                id: '1',
+                permissions: { can_edit: true },
+            };
+            feed.updateReply(file, reply.id, parentId, text, reply.permissions, successCallback, errorCallback);
+            expect(feed.threadedCommentsAPI.updateComment).toBeCalledWith({
+                fileId: file.id,
+                commentId: reply.id,
+                permissions: reply.permissions,
+                message: text,
+                status: undefined,
+                successCallback: expect.any(Function),
+                errorCallback: expect.any(Function),
+            });
+            expect(feed.updateReplyItem).toBeCalled();
+            expect(successCallback).toBeCalled();
+        });
+    });
+
     describe('deleteComment()', () => {
         beforeEach(() => {
             feed.updateFeedItem = jest.fn();
@@ -930,12 +1137,87 @@ describe('api/Feed', () => {
         });
 
         test('should call the comments api and if successful, the success callback', () => {
-            feed.deleteComment(file);
-            expect(feed.commentsAPI.deleteComment).toBeCalled();
+            const successCallback = jest.fn();
+            const errorCallback = jest.fn();
+            const comment = {
+                id: '1',
+                permissions: { can_edit: true },
+            };
+
+            feed.deleteComment(file, comment.id, comment.permissions, successCallback, errorCallback);
+            expect(feed.commentsAPI.deleteComment).toBeCalledWith({
+                file,
+                commentId: comment.id,
+                permissions: comment.permissions,
+                successCallback: expect.any(Function),
+                errorCallback: expect.any(Function),
+            });
             expect(feed.deleteFeedItem).toBeCalled();
         });
     });
 
+    describe('deleteThreadedComment()', () => {
+        beforeEach(() => {
+            feed.updateFeedItem = jest.fn();
+            feed.deleteFeedItem = jest.fn();
+        });
+
+        test('should throw if no file id', () => {
+            expect(() => feed.deleteComment({})).toThrow(fileError);
+        });
+
+        test('should call the threaded comments api and if successful, the success callback', () => {
+            const successCallback = jest.fn();
+            const errorCallback = jest.fn();
+            const comment = {
+                id: '1',
+                permissions: { can_edit: true },
+            };
+
+            feed.deleteThreadedComment(file, comment.id, comment.permissions, true, successCallback, errorCallback);
+            expect(feed.threadedCommentsAPI.deleteComment).toBeCalledWith({
+                fileId: file.id,
+                commentId: comment.id,
+                permissions: comment.permissions,
+                successCallback: expect.any(Function),
+                errorCallback: expect.any(Function),
+            });
+            expect(feed.deleteFeedItem).toBeCalled();
+        });
+    });
+
+    describe('deleteReply()', () => {
+        beforeEach(() => {
+            feed.updateReplyItem = jest.fn();
+            feed.deleteReplyItem = jest.fn();
+        });
+
+        test('should throw if no file id', () => {
+            expect(() => feed.deleteReply({})).toThrow(fileError);
+        });
+
+        test('should call the threaded comments api and if successful, the success callback', () => {
+            const successCallback = jest.fn();
+            const errorCallback = jest.fn();
+            const reply = {
+                id: '1',
+                permissions: { can_edit: true },
+            };
+            const parentId = '123';
+
+            feed.deleteReply(file, reply.id, parentId, reply.permissions, true, successCallback, errorCallback);
+            expect(feed.updateReplyItem).toBeCalledWith({ isPending: true }, parentId, reply.id);
+            expect(feed.threadedCommentsAPI.deleteComment).toBeCalledWith({
+                fileId: file.id,
+                commentId: reply.id,
+                permissions: reply.permissions,
+                successCallback: expect.any(Function),
+                errorCallback: expect.any(Function),
+            });
+            expect(feed.deleteReplyItem).toBeCalled();
+        });
+    });
+
     describe('deleteCommentErrorCallback()', () => {
         const e = new Error('foo');
 
@@ -953,6 +1235,20 @@ describe('api/Feed', () => {
         });
     });
 
+    describe('deleteReplyErrorCallback()', () => {
+        test('should update the reply item and call the error callback', () => {
+            feed.updateReplyItem = jest.fn();
+            feed.createFeedError = jest.fn().mockReturnValue(error);
+            feed.feedErrorCallback = jest.fn();
+            const e = new Error('foo');
+            const replyId = '12';
+            const parentId = '123';
+            feed.deleteReplyErrorCallback(e, errorCode, replyId, parentId);
+            expect(feed.updateReplyItem).toBeCalledWith(error, parentId, replyId);
+            expect(feed.feedErrorCallback).toBeCalledWith(true, e, errorCode);
+        });
+    });
+
     describe('deleteAppActivity()', () => {
         beforeEach(() => {
             feed.updateFeedItem = jest.fn();
@@ -1015,6 +1311,37 @@ describe('api/Feed', () => {
         });
     });
 
+    describe('deleteReplyItem()', () => {
+        beforeEach(() => {
+            feed.file = file;
+            feed.getCachedItems = jest.fn().mockReturnValue({
+                errors: [],
+                items: cloneDeep(mockThreadedComments),
+            });
+        });
+
+        test('should delete the feed item and call success callback', () => {
+            const replyId = '21';
+            const parentId = '20';
+            const successCallback = jest.fn();
+            feed.setCachedItems = jest.fn();
+            feed.deleteReplyItem(replyId, parentId, successCallback);
+            const expectedFeedItems = cloneDeep(mockThreadedComments);
+            expectedFeedItems[0].replies = [];
+            expect(feed.setCachedItems).toBeCalledWith(feed.file.id, expectedFeedItems);
+            expect(successCallback).toBeCalledWith(replyId, parentId);
+        });
+
+        test('not call the success callback if Feed is destroyed', () => {
+            const replyId = '1234';
+            const parentId = '123';
+            const successCallback = jest.fn();
+            feed.isDestroyed = jest.fn().mockReturnValue(true);
+            feed.deleteReplyItem(replyId, parentId, successCallback);
+            expect(successCallback).not.toBeCalled();
+        });
+    });
+
     describe('feedErrorCallback()', () => {
         const code = 'foo';
         const e = new Error('bar');
@@ -1089,6 +1416,36 @@ describe('api/Feed', () => {
         });
     });
 
+    describe('addPendingReply()', () => {
+        test('should create a comment and add it to the replies array of the parent item in feed with populated cache', () => {
+            const feedComments = cloneDeep(threadedCommentsFormatted);
+            const { id: parentId } = feedComments[0];
+            const commentBase = {
+                id: '1234',
+                tagged_message: 'abc',
+                type: FEED_ITEM_TYPE_COMMENT,
+            };
+
+            feed.file = file;
+            feed.setCachedItems = jest.fn();
+            feed.getCachedItems = jest.fn().mockReturnValue({
+                errors: [],
+                items: feedComments,
+            });
+
+            const reply = feed.addPendingReply(parentId, user, commentBase);
+
+            const updatedFeedComments = cloneDeep(threadedCommentsFormatted);
+            updatedFeedComments[0].replies = [...updatedFeedComments[0].replies, reply];
+
+            expect(typeof reply.created_at).toBe('string');
+            expect(reply.created_by).toBe(user);
+            expect(typeof reply.modified_at).toBe('string');
+            expect(reply.isPending).toBe(true);
+            expect(feed.setCachedItems).toBeCalledWith(file.id, updatedFeedComments);
+        });
+    });
+
     describe('createCommentSuccessCallback()', () => {
         let successCb;
         beforeEach(() => {
@@ -1182,6 +1539,36 @@ describe('api/Feed', () => {
         });
     });
 
+    describe('updateReplyItem()', () => {
+        test('should throw if no file id', () => {
+            feed.file = {};
+            expect(() => feed.updateReplyItem({}, '123', '456')).toThrow(fileError);
+        });
+
+        test('should update the cache with the updated reply', () => {
+            const feedComments = cloneDeep(threadedCommentsFormatted);
+            const { id: parentId, replies } = feedComments[0];
+            const updates = {
+                tagged_message: 'updated',
+                isPending: true,
+            };
+            const { id } = replies[0];
+
+            feed.setCachedItems = jest.fn();
+            feed.getCachedItems = jest.fn().mockReturnValue({
+                errors: [],
+                items: feedComments,
+            });
+
+            const updatedFeedComments = cloneDeep(feedComments);
+            updatedFeedComments[0].replies[0] = { ...updatedFeedComments[0].replies[0], ...updates };
+
+            feed.file = file;
+            feed.updateReplyItem(updates, parentId, id);
+            expect(feed.setCachedItems).toBeCalledWith(file.id, updatedFeedComments);
+        });
+    });
+
     describe('createComment()', () => {
         let successCb;
         let errorCb;
@@ -1210,14 +1597,66 @@ describe('api/Feed', () => {
             expect(feed.addPendingItem).toBeCalledWith(file.id, currentUser, {
                 id: 'uniqueId',
                 tagged_message: text,
-                type: 'comment',
+                type: FEED_ITEM_TYPE_COMMENT,
             });
         });
 
         test('should create the comment and invoke the success callback', done => {
             feed.createComment(file, currentUser, text, hasMention, successCb, errorCb);
             setImmediate(() => {
-                expect(feed.commentsAPI.createComment).toBeCalled();
+                expect(feed.commentsAPI.createComment).toBeCalledWith({
+                    file,
+                    taggedMessage: text,
+                    successCallback: expect.any(Function),
+                    errorCallback: expect.any(Function),
+                });
+                expect(feed.createCommentSuccessCallback).toBeCalled();
+                expect(feed.createCommentErrorCallback).not.toBeCalled();
+                done();
+            });
+        });
+    });
+
+    describe('createThreadedComment()', () => {
+        let successCb;
+        let errorCb;
+        const currentUser = {
+            id: 'bar',
+        };
+        const text = 'textfoo';
+
+        beforeEach(() => {
+            successCb = jest.fn();
+            errorCb = jest.fn();
+            feed.addPendingItem = jest.fn();
+            feed.createCommentSuccessCallback = jest.fn();
+            feed.createCommentErrorCallback = jest.fn();
+            feed.createFeedError = jest.fn().mockReturnValue('foo');
+        });
+
+        test('should throw if no file id', () => {
+            expect(() => feed.createComment({}, currentUser, text, true, successCb, errorCb)).toThrow(fileError);
+        });
+
+        test('should create a pending item', () => {
+            feed.createComment(file, currentUser, text, true, successCb, errorCb);
+
+            expect(feed.addPendingItem).toBeCalledWith(file.id, currentUser, {
+                id: 'uniqueId',
+                tagged_message: text,
+                type: FEED_ITEM_TYPE_COMMENT,
+            });
+        });
+
+        test('should create the comment using threaded comments api and invoke the success callback', done => {
+            feed.createThreadedComment(file, currentUser, text, true, successCb, errorCb);
+            setImmediate(() => {
+                expect(feed.threadedCommentsAPI.createComment).toBeCalledWith({
+                    file,
+                    message: text,
+                    successCallback: expect.any(Function),
+                    errorCallback: expect.any(Function),
+                });
                 expect(feed.createCommentSuccessCallback).toBeCalled();
                 expect(feed.createCommentErrorCallback).not.toBeCalled();
                 done();
@@ -1225,6 +1664,94 @@ describe('api/Feed', () => {
         });
     });
 
+    describe('createReply()', () => {
+        test('should throw if no file id', () => {
+            const currentUser = {
+                id: '123',
+            };
+
+            expect(() =>
+                feed.createReply({}, currentUser, '123', FEED_ITEM_TYPE_COMMENT, 'abc', jest.fn(), jest.fn()),
+            ).toThrow(fileError);
+        });
+
+        test('should create a pending reply', () => {
+            feed.addPendingReply = jest.fn();
+            const successCb = jest.fn();
+            const errorCb = jest.fn();
+            const parentId = '123';
+            const parentType = FEED_ITEM_TYPE_COMMENT;
+            const text = 'abc';
+            const currentUser = {
+                id: '123',
+            };
+
+            feed.createReply(file, currentUser, parentId, parentType, text, successCb, errorCb);
+
+            expect(feed.addPendingReply).toBeCalledWith(parentId, currentUser, {
+                id: 'uniqueId',
+                tagged_message: text,
+                type: FEED_ITEM_TYPE_COMMENT,
+            });
+        });
+
+        test('given parentType=annotation, should create the reply using annotationsAPI and invoke the success callback', done => {
+            feed.createReplySuccessCallback = jest.fn();
+            feed.createReplyErrorCallback = jest.fn();
+            const successCb = jest.fn();
+            const errorCb = jest.fn();
+            const annotationId = '123';
+            const parentType = FEED_ITEM_TYPE_ANNOTATION;
+            const text = 'abc';
+            const currentUser = {
+                id: '123',
+            };
+
+            feed.createReply(file, currentUser, annotationId, parentType, text, successCb, errorCb);
+            setImmediate(() => {
+                expect(feed.annotationsAPI.createAnnotationReply).toBeCalledWith(
+                    file.id,
+                    annotationId,
+                    file.permissions,
+                    text,
+                    expect.any(Function),
+                    expect.any(Function),
+                );
+                expect(feed.createReplySuccessCallback).toBeCalled();
+                expect(feed.createReplyErrorCallback).not.toBeCalled();
+                done();
+            });
+        });
+
+        test('given parentType=comment, should create the reply using threadedCommentsAPI and invoke the success callback', done => {
+            feed.createReplySuccessCallback = jest.fn();
+            feed.createReplyErrorCallback = jest.fn();
+            const successCb = jest.fn();
+            const errorCb = jest.fn();
+            const commentId = '123';
+            const parentType = FEED_ITEM_TYPE_COMMENT;
+            const text = 'abc';
+            const currentUser = {
+                id: '123',
+            };
+
+            feed.createReply(file, currentUser, commentId, parentType, text, successCb, errorCb);
+            setImmediate(() => {
+                expect(feed.threadedCommentsAPI.createCommentReply).toBeCalledWith({
+                    fileId: file.id,
+                    commentId,
+                    permissions: file.permissions,
+                    message: text,
+                    successCallback: expect.any(Function),
+                    errorCallback: expect.any(Function),
+                });
+                expect(feed.createReplySuccessCallback).toBeCalled();
+                expect(feed.createReplyErrorCallback).not.toBeCalled();
+                done();
+            });
+        });
+    });
+
     describe('createCommentErrorCallback()', () => {
         const message = 'foo';
         const id = 'uniqueId';
@@ -1254,12 +1781,14 @@ describe('api/Feed', () => {
     describe('destroy()', () => {
         let annotationFn;
         let commentFn;
+        let theadedCommentFn;
         let versionFn;
         let taskFn;
 
         beforeEach(() => {
             annotationFn = jest.fn();
             commentFn = jest.fn();
+            theadedCommentFn = jest.fn();
             versionFn = jest.fn();
             taskFn = jest.fn();
 
@@ -1275,6 +1804,9 @@ describe('api/Feed', () => {
             feed.commentsAPI = {
                 destroy: commentFn,
             };
+            feed.threadedCommentsAPI = {
+                destroy: theadedCommentFn,
+            };
         });
 
         test('should destroy the APIs', () => {
@@ -1333,7 +1865,7 @@ describe('api/Feed', () => {
             const expectedAnnotation = {
                 created_by: user,
                 id: '123',
-                type: 'annotation',
+                type: FEED_ITEM_TYPE_ANNOTATION,
             };
 
             feed.addAnnotation(file, user, {}, '123', true);
@@ -1367,31 +1899,81 @@ describe('api/Feed', () => {
 
         test('should throw if file does not have an id', () => {
             expect(() =>
-                feed.updateAnnotation({}, annotationId, text, permissions, successCallback, errorCallback),
+                feed.updateAnnotation({}, annotationId, text, undefined, permissions, successCallback, errorCallback),
             ).toThrow(fileError);
         });
 
+        test('should throw if no text or status', () => {
+            expect(() =>
+                feed.updateAnnotation(
+                    file,
+                    annotationId,
+                    undefined,
+                    undefined,
+                    permissions,
+                    successCallback,
+                    errorCallback,
+                ),
+            ).toThrowError();
+        });
+
         test('should set error callback and file', () => {
-            feed.updateAnnotation(file, annotationId, text, permissions, successCallback, errorCallback);
+            feed.updateAnnotation(file, annotationId, text, undefined, permissions, successCallback, errorCallback);
 
             expect(feed.errorCallback).toEqual(errorCallback);
             expect(feed.file).toEqual(file);
         });
 
-        test('should updateFeedItem with isPending set to true', () => {
-            feed.updateFeedItem = jest.fn();
-            feed.updateAnnotation(file, annotationId, text, permissions, successCallback, errorCallback);
+        describe('should updateFeedItem with isPending set to true', () => {
+            test.each`
+                testText     | testStatus   | expected
+                ${'hello'}   | ${undefined} | ${{ message: 'hello', isPending: true }}
+                ${undefined} | ${'open'}    | ${{ status: 'open', isPending: true }}
+                ${'hello'}   | ${'open'}    | ${{ message: 'hello', status: 'open', isPending: true }}
+            `('given text=$testText and status=$testStatus', ({ testText, testStatus, expected }) => {
+                feed.updateFeedItem = jest.fn();
+                feed.updateAnnotation(
+                    file,
+                    annotationId,
+                    testText,
+                    testStatus,
+                    permissions,
+                    successCallback,
+                    errorCallback,
+                );
 
-            expect(feed.updateFeedItem).toBeCalledWith({ message: text, isPending: true }, annotationId);
+                expect(feed.updateFeedItem).toBeCalledWith(expected, annotationId);
+            });
         });
 
-        test('should call the updateAnnotation API and call updateFeedItem on success', () => {
-            feed.updateFeedItem = jest.fn();
-            feed.updateAnnotation(file, annotationId, permissions, text, successCallback, errorCallback);
-
-            expect(feed.annotationsAPI.updateAnnotation).toHaveBeenCalled();
-            expect(feed.updateFeedItem).toHaveBeenCalled();
-            expect(successCallback).toHaveBeenCalled();
+        describe('should call the updateAnnotation API and call updateFeedItem on success', () => {
+            test.each`
+                testText     | testStatus   | expected
+                ${'hello'}   | ${undefined} | ${{ message: 'hello' }}
+                ${undefined} | ${'open'}    | ${{ status: 'open' }}
+                ${'hello'}   | ${'open'}    | ${{ message: 'hello', status: 'open' }}
+            `('given text=$testText and status=$testStatus', ({ testText, testStatus, expected }) => {
+                feed.updateFeedItem = jest.fn();
+                feed.updateAnnotation(
+                    file,
+                    annotationId,
+                    testText,
+                    testStatus,
+                    permissions,
+                    successCallback,
+                    errorCallback,
+                );
+                expect(feed.annotationsAPI.updateAnnotation).toBeCalledWith(
+                    file.id,
+                    annotationId,
+                    permissions,
+                    expected,
+                    expect.any(Function),
+                    expect.any(Function),
+                );
+                expect(feed.updateFeedItem).toBeCalled();
+                expect(successCallback).toBeCalled();
+            });
         });
     });
 
@@ -1413,6 +1995,37 @@ describe('api/Feed', () => {
         });
     });
 
+    describe('updateReplyErrorCallback()', () => {
+        test('should update the reply item and call the error callback', () => {
+            feed.updateReplyItem = jest.fn();
+            feed.createFeedError = jest.fn().mockReturnValue(error);
+            feed.feedErrorCallback = jest.fn();
+            const e = new Error('foo');
+            const id = '1';
+            const parentId = '123';
+            feed.updateReplyErrorCallback(e, errorCode, id, parentId);
+
+            expect(feed.createFeedError).toBeCalledWith(messages.commentUpdateErrorMessage);
+            expect(feed.updateReplyItem).toBeCalledWith(error, parentId, id);
+            expect(feed.feedErrorCallback).toBeCalledWith(true, e, errorCode);
+        });
+    });
+
+    describe('fetchRepliesErrorCallback()', () => {
+        test('should update the parent item and call the error callback', () => {
+            feed.updateFeedItem = jest.fn();
+            feed.createFeedError = jest.fn().mockReturnValue(error);
+            feed.feedErrorCallback = jest.fn();
+            const e = new Error('foo');
+            const id = '1';
+            feed.fetchRepliesErrorCallback(e, errorCode, id);
+
+            expect(feed.createFeedError).toBeCalledWith(messages.repliesFetchErrorMessage);
+            expect(feed.updateFeedItem).toBeCalledWith(error, id);
+            expect(feed.feedErrorCallback).toBeCalledWith(true, e, errorCode);
+        });
+    });
+
     describe('deleteAnnotation()', () => {
         const annotationId = '123';
         let successCallback;