@reltio/components 1.4.2154 → 1.4.2155

package/hooks/useCollaboration/useCollaboration.test.js

@@ -56,10 +56,10 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import React from 'react';
 import { renderHook, act } from '@testing-library/react-hooks';
-import { getCommentsCount, getComment, createComment, createReply, deleteComment, updateComment, getComments, deleteReply, updateReply } from '@reltio/mdm-sdk';
+import { getCommentsCount, getTotalCommentsCount, getComment, createComment, createReply, deleteComment, updateComment, getComments, deleteReply, updateReply } from '@reltio/mdm-sdk';
 import { MdmModuleProvider } from '../../contexts/MdmModuleContext';
 import { useCollaboration } from './useCollaboration';
-jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getCommentsCount: jest.fn(), getComment: jest.fn(), createComment: jest.fn(), createReply: jest.fn(), updateComment: jest.fn(), deleteComment: jest.fn(), getComments: jest.fn(), deleteReply: jest.fn(), updateReply: jest.fn() })); });
+jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { getCommentsCount: jest.fn(), getTotalCommentsCount: jest.fn(), getComment: jest.fn(), createComment: jest.fn(), createReply: jest.fn(), updateComment: jest.fn(), deleteComment: jest.fn(), getComments: jest.fn(), deleteReply: jest.fn(), updateReply: jest.fn() })); });
 describe('useCollaboration behaviour', function () {
     var defaultMdmValues = {
         uiPath: 'https://localhost:3000/ui/alenat',
@@ -77,28 +77,54 @@ describe('useCollaboration behaviour', function () {
         return renderHook(useCollaboration, { initialProps: props, wrapper: Providers });
     };
     beforeEach(function () {
-        jest.clearAllMocks();
         getComment.mockResolvedValue({ commentId: 'commentId' });
         getCommentsCount.mockResolvedValue([{ objectId: 'uri1', comments: [] }]);
+        getTotalCommentsCount.mockResolvedValue({ total: 1 });
+    });
+    afterEach(function () {
+        jest.resetAllMocks();
     });
     it('should not call getCommentsCount if collaboration is not enabled', function () {
         var mdmValues = __assign(__assign({}, defaultMdmValues), { collaborationPath: undefined, isCollaborationEnabled: false });
         var result = setUp({ mdmValues: mdmValues }).result;
         expect(result.current.commentsMap).toBe(null);
+        expect(result.current.totalCommentsCount).toBe(null);
         expect(getCommentsCount).not.toHaveBeenCalled();
+        expect(getTotalCommentsCount).not.toHaveBeenCalled();
     });
+    it('should not call getCommentsCount if totalCommentsCount is 0', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    getTotalCommentsCount.mockResolvedValue({ total: 0 });
+                    result = setUp().result;
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, Promise.resolve()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    expect(getCommentsCount).not.toHaveBeenCalled();
+                    expect(result.current.commentsMap).toEqual({});
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should call getCommentsCount if collaboration is enabled and uris is undefined and update commentsMap value', function () { return __awaiter(void 0, void 0, void 0, function () {
         var result;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     getCommentsCount.mockResolvedValueOnce([]);
+                    getTotalCommentsCount.mockResolvedValueOnce({ total: 1 });
                     result = setUp().result;
-                    expect(getCommentsCount).toHaveBeenCalledWith({
-                        uris: [],
-                        tenant: 'alenat',
-                        collaborationPath: defaultMdmValues.collaborationPath
-                    });
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
@@ -111,12 +137,17 @@ describe('useCollaboration behaviour', function () {
                         }); })];
                 case 1:
                     _a.sent();
+                    expect(getCommentsCount).toHaveBeenCalledWith({
+                        uris: [],
+                        tenant: 'alenat',
+                        collaborationPath: defaultMdmValues.collaborationPath
+                    });
                     expect(result.current.commentsMap).toEqual({});
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should call getCommentsCount if collaboration is enabled and update commentsMap value', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should call getCommentsCount if collaboration is enabled and totalCommentsCount is more then 0 and update commentsMap value', function () { return __awaiter(void 0, void 0, void 0, function () {
         var comments, result;
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -126,12 +157,8 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id2', status: 'open', replies: 2 }
                     ];
                     getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: comments }]);
+                    getTotalCommentsCount.mockResolvedValueOnce({ total: 2 });
                     result = setUp({ props: { objectIds: ['uri1'] } }).result;
-                    expect(getCommentsCount).toHaveBeenCalledWith({
-                        uris: ['uri1'],
-                        tenant: 'alenat',
-                        collaborationPath: defaultMdmValues.collaborationPath
-                    });
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
@@ -144,19 +171,24 @@ describe('useCollaboration behaviour', function () {
                         }); })];
                 case 1:
                     _a.sent();
+                    expect(getCommentsCount).toHaveBeenCalledWith({
+                        uris: ['uri1'],
+                        tenant: 'alenat',
+                        collaborationPath: defaultMdmValues.collaborationPath
+                    });
                     expect(result.current.commentsMap).toEqual({ uri1: comments });
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should set commentsMap value as null in case of unsuccessful request', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('should set commentsMap value as null in case of unsuccessful getCommentsCount request', function () { return __awaiter(void 0, void 0, void 0, function () {
         var result;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    getCommentsCount.mockRejectedValueOnce(null);
+                    getTotalCommentsCount.mockResolvedValueOnce({ total: 1 });
+                    getCommentsCount.mockRejectedValueOnce(new Error('Fail'));
                     result = setUp().result;
-                    expect(getCommentsCount).toHaveBeenCalled();
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
@@ -169,6 +201,7 @@ describe('useCollaboration behaviour', function () {
                         }); })];
                 case 1:
                     _a.sent();
+                    expect(getCommentsCount).toHaveBeenCalled();
                     expect(result.current.commentsMap).toBe(null);
                     return [2 /*return*/];
             }
@@ -190,7 +223,20 @@ describe('useCollaboration behaviour', function () {
                             return Promise.resolve([{ objectId: 'uri2', comments: secondComments }]);
                         }
                     });
+                    getTotalCommentsCount.mockResolvedValueOnce({ total: 3 });
                     result = setUp({ props: { objectIds: ['uri1'] } }).result;
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, Promise.resolve()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
                     expect(getCommentsCount).toHaveBeenCalledWith({
                         uris: ['uri1'],
                         tenant: 'alenat',
@@ -202,7 +248,7 @@ describe('useCollaboration behaviour', function () {
                                 return [2 /*return*/];
                             });
                         }); })];
-                case 1:
+                case 2:
                     _a.sent();
                     expect(getCommentsCount).toHaveBeenCalledWith({
                         uris: ['uri2'],
@@ -230,7 +276,20 @@ describe('useCollaboration behaviour', function () {
                             return Promise.resolve([{ objectId: 'uri2', comments: secondComments }]);
                         }
                     });
+                    getTotalCommentsCount.mockResolvedValue({ total: 3 });
                     _a = setUp({ props: { objectIds: ['uri1'] } }), result = _a.result, rerender = _a.rerender;
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, Promise.resolve()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 1:
+                    _b.sent();
                     expect(getCommentsCount).toHaveBeenCalledWith({
                         uris: ['uri1'],
                         tenant: 'alenat',
@@ -248,7 +307,7 @@ describe('useCollaboration behaviour', function () {
                                 }
                             });
                         }); })];
-                case 1:
+                case 2:
                     _b.sent();
                     expect(getCommentsCount).toHaveBeenCalledWith({
                         uris: ['uri2'],
@@ -385,7 +444,12 @@ describe('useCollaboration behaviour', function () {
                             replies: 2
                         }
                     ];
-                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: comments }]);
+                    getTotalCommentsCount.mockResolvedValueOnce({ total: 3 });
+                    getCommentsCount
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: comments }])
+                        .mockResolvedValueOnce([
+                        { objectId: 'uri1', comments: __spreadArray(__spreadArray([], comments, true), [{ commentId: 'commentId', replies: 0, status: 'open' }], false) }
+                    ]);
                     createComment.mockResolvedValueOnce([{ commentId: 'commentId' }]);
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -403,33 +467,16 @@ describe('useCollaboration behaviour', function () {
                     expect(result.current.commentsMap).toEqual({ uri1: comments });
                     expect(result.current.currentComment).toBe(null);
                     expect(result.current.sending).toBe(false);
-                    act(function () {
-                        result.current.createComment({
-                            content: 'content',
-                            namedUsers: [],
-                            objectType: 'entity',
-                            relatedObjectUris: ['uri1'],
-                            uri: 'uri1'
-                        });
-                    });
-                    expect(result.current.sending).toBe(true);
-                    expect(createComment).toHaveBeenCalledWith({
-                        collaborationPath: '123',
-                        tenant: 'alenat',
-                        data: {
-                            objectId: 'uri1',
-                            content: 'content',
-                            relatedObjectUris: ['uri1'],
-                            objectType: 'entity',
-                            visibility: 'public',
-                            namedUsers: [],
-                            permanentLink: 'https://tst-01.reltio.com/nui/alenat/profile?entityUri=entities%2F2jWtLtNc&commentId=%7BcommentId%7D'
-                        }
-                    });
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0: return [4 /*yield*/, Promise.resolve()];
+                                    case 0: return [4 /*yield*/, result.current.createComment({
+                                            content: 'content',
+                                            namedUsers: [],
+                                            objectType: 'entity',
+                                            relatedObjectUris: ['uri1'],
+                                            uri: 'uri1'
+                                        })];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -446,15 +493,23 @@ describe('useCollaboration behaviour', function () {
                         uri1: __spreadArray(__spreadArray([], comments, true), [{ commentId: 'commentId', replies: 0, status: 'open' }], false)
                     });
                     createComment.mockResolvedValueOnce([{ commentId: 'commentId2' }]);
+                    getCommentsCount.mockResolvedValueOnce([
+                        { objectId: 'uri1', comments: __spreadArray(__spreadArray([], comments, true), [{ commentId: 'commentId', replies: 0, status: 'open' }], false) },
+                        { objectId: 'uri2', comments: [{ commentId: 'commentId2', replies: 0, status: 'open' }] }
+                    ]);
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
-                                result.current.createComment({
-                                    content: 'content',
-                                    namedUsers: [],
-                                    objectType: 'entity',
-                                    uri: 'uri2'
-                                });
-                                return [2 /*return*/];
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, result.current.createComment({
+                                            content: 'content',
+                                            namedUsers: [],
+                                            objectType: 'entity',
+                                            uri: 'uri2'
+                                        })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
                             });
                         }); })];
                 case 3:
@@ -483,7 +538,14 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', content: 'first comment', status: 'open', replies: [] },
                         { commentId: 'id2', content: 'second comment', status: 'open', replies: [] }
                     ];
-                    getCommentsCount.mockResolvedValue([{ objectId: 'uri1', comments: commentsCount }]);
+                    getCommentsCount
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
+                        .mockResolvedValueOnce([
+                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'open', replies: 3 }] }
+                    ])
+                        .mockResolvedValueOnce([
+                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'resolved', replies: 4 }] }
+                    ]);
                     getComments.mockResolvedValue({ items: comments });
                     getComment.mockResolvedValueOnce({
                         commentId: 'id2',
@@ -616,7 +678,11 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', status: 'open', content: 'first comment', replies: [] },
                         { commentId: 'id2', status: 'open', content: 'second comment', replies: [] }
                     ];
-                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
+                    getCommentsCount
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
+                        .mockResolvedValueOnce([
+                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'resolved', replies: 3 }] }
+                    ]);
                     getComment.mockResolvedValueOnce({ commentId: 'id2', replies: [] });
                     getComments.mockResolvedValue({ items: comments });
                     createReply.mockResolvedValueOnce([{ content: '', action: 'resolve' }]);
@@ -689,7 +755,11 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', status: 'open', content: 'first comment', replies: [] },
                         { commentId: 'id2', status: 'open', content: 'second comment', replies: [] }
                     ];
-                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
+                    getCommentsCount
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
+                        .mockResolvedValueOnce([
+                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'open', replies: 3 }] }
+                    ]);
                     getComment.mockResolvedValueOnce({ commentId: 'id2', replies: [] });
                     getComments.mockResolvedValue({
                         items: comments
@@ -862,9 +932,12 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', content: 'text 1', status: 'open', replies: [] },
                         { commentId: 'id2', content: 'text2', status: 'open', replies: [] }
                     ];
-                    expectedCommentsCount = commentsCount.slice(1);
-                    expectedComments = comments.slice(1);
-                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
+                    expectedCommentsCount = [{ commentId: 'id2', status: 'open', replies: 0 }];
+                    expectedComments = [{ commentId: 'id2', content: 'text2', status: 'open', replies: [] }];
+                    getTotalCommentsCount.mockResolvedValueOnce({ total: 2 });
+                    getCommentsCount
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: expectedCommentsCount }]);
                     getComments.mockResolvedValueOnce({ items: comments });
                     deleteComment.mockResolvedValueOnce('');
                     result = setUp().result;
@@ -879,28 +952,20 @@ describe('useCollaboration behaviour', function () {
                     expect(result.current.comments).toEqual(comments);
                     expect(result.current.commentsMap).toEqual({ uri1: commentsCount });
                     expect(result.current.sending).toBe(false);
-                    act(function () {
-                        result.current.deleteComment({ commentId: 'id1', uri: 'uri1' });
-                    });
-                    expect(result.current.sending).toBe(true);
-                    expect(deleteComment).toHaveBeenCalledWith({
-                        collaborationPath: '123',
-                        tenant: 'alenat',
-                        commentId: 'id1'
-                    });
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, Promise.resolve()];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
+                                result.current.deleteComment({ commentId: 'id1', uri: 'uri1' });
+                                return [2 /*return*/];
                             });
                         }); })];
                 case 2:
                     _a.sent();
                     expect(result.current.sending).toBe(false);
+                    expect(deleteComment).toHaveBeenCalledWith({
+                        collaborationPath: '123',
+                        tenant: 'alenat',
+                        commentId: 'id1'
+                    });
                     expect(result.current.commentsMap).toEqual({
                         uri1: expectedCommentsCount
                     });
@@ -918,13 +983,23 @@ describe('useCollaboration behaviour', function () {
                         { commentId: 'id1', status: 'open', replies: 1 },
                         { commentId: 'id2', status: 'open', replies: 2 }
                     ];
-                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
+                    getTotalCommentsCount.mockResolvedValueOnce({ total: commentsCount.length });
+                    getCommentsCount
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
+                        .mockResolvedValueOnce([
+                        { objectId: 'uri1', comments: [commentsCount[0], { commentId: 'id2', status: 'open', replies: 2 }] },
+                        { objectId: 'uri2', comments: [] }
+                    ]);
                     createReply.mockResolvedValueOnce([{ content: 'reply message' }]);
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
-                                Promise.resolve();
-                                return [2 /*return*/];
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, Promise.resolve()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
                             });
                         }); })];
                 case 1:
@@ -941,6 +1016,9 @@ describe('useCollaboration behaviour', function () {
                                             uri: 'uri2'
                                         })];
                                     case 1:
+                                        _a.sent();
+                                        return [4 /*yield*/, Promise.resolve()];
+                                    case 2:
                                         _a.sent();
                                         return [2 /*return*/];
                                 }
@@ -967,14 +1045,23 @@ describe('useCollaboration behaviour', function () {
                     ];
                     expectedCommentsCount = [{ commentId: 'id1', status: 'open', replies: 0 }];
                     expectedComments = [{ commentId: 'id1', content: 'text 1', status: 'open', replies: [] }];
-                    getCommentsCount.mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }]);
+                    getTotalCommentsCount.mockResolvedValueOnce({ total: 2 }).mockResolvedValueOnce({ total: 1 });
+                    getCommentsCount
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: commentsCount }])
+                        .mockResolvedValueOnce([{ objectId: 'uri1', comments: expectedCommentsCount }]);
                     getComments.mockResolvedValue({ items: comments });
                     deleteReply.mockResolvedValueOnce('');
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
-                                result.current.getComments('uri');
-                                return [2 /*return*/];
+                                switch (_a.label) {
+                                    case 0:
+                                        result.current.getComments('uri');
+                                        return [4 /*yield*/, Promise.resolve()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
                             });
                         }); })];
                 case 1:
@@ -982,24 +1069,16 @@ describe('useCollaboration behaviour', function () {
                     expect(result.current.comments).toEqual(comments);
                     expect(result.current.commentsMap).toEqual({ uri1: commentsCount });
                     expect(result.current.sending).toBe(false);
-                    act(function () {
-                        result.current.deleteReply({
-                            commentId: 'id1',
-                            uri: 'uri1',
-                            reply: comments[0].replies[0]
-                        });
-                    });
-                    expect(result.current.sending).toBe(true);
-                    expect(deleteReply).toHaveBeenCalledWith({
-                        collaborationPath: '123',
-                        tenant: 'alenat',
-                        commentId: 'id1',
-                        replyId: 'replyId1'
-                    });
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0: return [4 /*yield*/, Promise.resolve()];
+                                    case 0:
+                                        result.current.deleteReply({
+                                            commentId: 'id1',
+                                            uri: 'uri1',
+                                            reply: comments[0].replies[0]
+                                        });
+                                        return [4 /*yield*/, Promise.resolve()];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -1009,6 +1088,12 @@ describe('useCollaboration behaviour', function () {
                 case 2:
                     _a.sent();
                     expect(result.current.sending).toBe(false);
+                    expect(deleteReply).toHaveBeenCalledWith({
+                        collaborationPath: '123',
+                        tenant: 'alenat',
+                        commentId: 'id1',
+                        replyId: 'replyId1'
+                    });
                     expect(result.current.commentsMap).toEqual({
                         uri1: expectedCommentsCount
                     });
@@ -1040,6 +1125,7 @@ describe('useCollaboration behaviour', function () {
                     updateReply.mockResolvedValueOnce(editedReply);
                     getComment.mockResolvedValueOnce(initialComment);
                     getComments.mockResolvedValueOnce({ items: initialComments });
+                    getTotalCommentsCount.mockResolvedValue({ total: 2 });
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
@@ -1096,6 +1182,7 @@ describe('useCollaboration behaviour', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    getTotalCommentsCount.mockResolvedValue({ total: 1 });
                     result = setUp().result;
                     expect(result.current.getCommentState('attrUri', 'commentUri')).toEqual({});
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -1138,6 +1225,7 @@ describe('useCollaboration behaviour', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    getTotalCommentsCount.mockResolvedValue({ total: 1 });
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
@@ -1174,6 +1262,7 @@ describe('useCollaboration behaviour', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    getTotalCommentsCount.mockResolvedValue({ total: 1 });
                     result = setUp().result;
                     return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
@@ -1230,4 +1319,66 @@ describe('useCollaboration behaviour', function () {
             }
         });
     }); });
+    describe('totalCommentsCount behavior', function () {
+        it('should not call getTotalCommentsCount if collaboration is not enabled', function () {
+            var mdmValues = __assign(__assign({}, defaultMdmValues), { collaborationPath: undefined, isCollaborationEnabled: false });
+            var result = setUp({ mdmValues: mdmValues }).result;
+            expect(result.current.totalCommentsCount).toBe(null);
+            expect(getTotalCommentsCount).not.toHaveBeenCalled();
+        });
+        it('should call getTotalCommentsCount if collaboration is enabled and update totalCommentsCount value', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        getTotalCommentsCount.mockResolvedValueOnce({ total: 15 });
+                        result = setUp().result;
+                        expect(getTotalCommentsCount).toHaveBeenCalledWith({
+                            relatedObjectUri: '1',
+                            collaborationPath: '123',
+                            tenant: 'alenat'
+                        });
+                        return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, Promise.resolve()];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        expect(result.current.totalCommentsCount).toBe(15);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should set totalCommentsCount as null in case of unsuccessful request', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        getTotalCommentsCount.mockRejectedValueOnce(new Error('Network error'));
+                        result = setUp().result;
+                        expect(getTotalCommentsCount).toHaveBeenCalled();
+                        return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, Promise.resolve()];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        expect(result.current.totalCommentsCount).toBe(null);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.2154",
+  "version": "1.4.2155",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./index.js",
@@ -11,7 +11,7 @@
     "@fluentui/react-context-selector": "^9.1.26",
     "@googlemaps/markerclusterer": "^2.5.3",
     "@react-sigma/core": "3.4.0",
-    "@reltio/mdm-sdk": "^1.4.1975",
+    "@reltio/mdm-sdk": "^1.4.1976",
     "@vis.gl/react-google-maps": "^1.3.0",
     "d3-cloud": "^1.2.5",
     "d3-geo": "^2.0.1",