revert changes (#3387)

lib/core/directives/node-favorite.directive.spec.ts

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 
+import { SimpleChange } from '@angular/core';
 import { fakeAsync, tick } from '@angular/core/testing';
 import { NodeFavoriteDirective } from './node-favorite.directive';
 import { AlfrescoApiServiceMock } from '../mock/alfresco-api.service.mock';
@@ -31,7 +32,139 @@ describe('NodeFavoriteDirective', () => {
         directive = new NodeFavoriteDirective( alfrescoApiService);
     });
 
-    describe('toggle node as favorite', () => {
+    describe('selection input change event', () => {
+        it('should not call markFavoritesNodes() if input list is empty', () => {
+            spyOn(directive, 'markFavoritesNodes');
+
+            const change = new SimpleChange(null, [], true);
+            directive.ngOnChanges({'selection': change});
+
+            expect(directive.markFavoritesNodes).not.toHaveBeenCalledWith();
+        });
+
+        it('should call markFavoritesNodes() on input change', () => {
+            spyOn(directive, 'markFavoritesNodes');
+
+            let selection = [{ entry: { id: '1', name: 'name1' } }];
+
+            let change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+
+            expect(directive.markFavoritesNodes).toHaveBeenCalledWith(selection);
+
+            selection = [
+                { entry: { id: '1', name: 'name1' } },
+                { entry: { id: '2', name: 'name2' } }
+            ];
+
+            change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+
+            expect(directive.markFavoritesNodes).toHaveBeenCalledWith(selection);
+        });
+
+        it('should reset favorites if selection is empty', fakeAsync(() => {
+            spyOn(alfrescoApiService.getInstance().core.favoritesApi, 'getFavorite').and.returnValue(Promise.resolve());
+
+            let selection = [
+                { entry: { id: '1', name: 'name1' } }
+            ];
+
+            let change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+            tick();
+
+            expect(directive.hasFavorites()).toBe(true);
+
+            change = new SimpleChange(null, [], true);
+            directive.ngOnChanges({'selection': change});
+            tick();
+
+            expect(directive.hasFavorites()).toBe(false);
+        }));
+    });
+
+    describe('markFavoritesNodes()', () => {
+        let favoritesApiSpy;
+
+        beforeEach(() => {
+            favoritesApiSpy = spyOn(alfrescoApiService.getInstance().core.favoritesApi, 'getFavorite')
+                .and.returnValue(Promise.resolve());
+        });
+
+        it('should check each selected node if it is a favorite', fakeAsync(() => {
+            const selection = [
+                { entry: { id: '1', name: 'name1' } },
+                { entry: { id: '2', name: 'name2' } }
+            ];
+
+            let change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+
+            tick();
+            expect(favoritesApiSpy.calls.count()).toBe(2);
+
+        }));
+
+        it('should not check processed node when another is unselected', fakeAsync(() => {
+            let selection = [
+                { entry: { id: '1', name: 'name1' } },
+                { entry: { id: '2', name: 'name2' } }
+            ];
+
+            let change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+
+            tick();
+            expect(directive.favorites.length).toBe(2);
+            expect(favoritesApiSpy.calls.count()).toBe(2);
+
+            favoritesApiSpy.calls.reset();
+
+            selection = [
+                { entry: { id: '2', name: 'name2' } }
+            ];
+
+            change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+
+            tick();
+            expect(directive.favorites.length).toBe(1);
+            expect(favoritesApiSpy).not.toHaveBeenCalled();
+        }));
+
+        it('should not check processed nodes when another is selected', fakeAsync(() => {
+            let selection = [
+                { entry: { id: '1', name: 'name1' } },
+                { entry: { id: '2', name: 'name2' } }
+            ];
+
+            let change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+
+            tick();
+
+            expect(directive.favorites.length).toBe(2);
+            expect(favoritesApiSpy.calls.count()).toBe(2);
+
+            favoritesApiSpy.calls.reset();
+
+            selection = [
+                { entry: { id: '1', name: 'name1' } },
+                { entry: { id: '2', name: 'name2' } },
+                { entry: { id: '3', name: 'name3' } }
+            ];
+
+            change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+            tick();
+
+            expect(directive.favorites.length).toBe(3);
+            expect(favoritesApiSpy.calls.count()).toBe(1);
+        }));
+    });
+
+    describe('toggleFavorite()', () => {
         let removeFavoriteSpy;
         let addFavoriteSpy;
 
@@ -46,7 +179,8 @@ describe('NodeFavoriteDirective', () => {
         });
 
         it('should not perform action if favorites collection is empty', fakeAsync(() => {
-            directive.selection = [];
+            let change = new SimpleChange(null, [], true);
+            directive.ngOnChanges({'selection': change});
             tick();
 
             directive.toggleFavorite();
@@ -58,7 +192,7 @@ describe('NodeFavoriteDirective', () => {
         it('should call addFavorite() if none is a favorite', () => {
             addFavoriteSpy.and.returnValue(Promise.resolve());
 
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFavorite: false } },
                 { entry: { id: '2', name: 'name2', isFavorite: false } }
             ];
@@ -71,7 +205,7 @@ describe('NodeFavoriteDirective', () => {
         it('should call addFavorite() on node that is not a favorite in selection', () => {
             addFavoriteSpy.and.returnValue(Promise.resolve());
 
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFile: true, isFolder: false, isFavorite: false } },
                 { entry: { id: '2', name: 'name2', isFile: true, isFolder: false, isFavorite: true } }
             ];
@@ -88,7 +222,7 @@ describe('NodeFavoriteDirective', () => {
         it('should call removeFavoriteSite() if all are favorites', () => {
             removeFavoriteSpy.and.returnValue(Promise.resolve());
 
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFavorite: true } },
                 { entry: { id: '2', name: 'name2', isFavorite: true } }
             ];
@@ -102,7 +236,7 @@ describe('NodeFavoriteDirective', () => {
             removeFavoriteSpy.and.returnValue(Promise.resolve());
             spyOn(directive.toggle, 'emit');
 
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFavorite: true } }
             ];
 
@@ -116,7 +250,7 @@ describe('NodeFavoriteDirective', () => {
             addFavoriteSpy.and.returnValue(Promise.resolve());
             spyOn(directive.toggle, 'emit');
 
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFavorite: false } }
             ];
 
@@ -130,7 +264,7 @@ describe('NodeFavoriteDirective', () => {
             removeFavoriteSpy.and.returnValue(Promise.reject('error'));
             spyOn(directive.error, 'emit');
 
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFavorite: true } }
             ];
 
@@ -144,7 +278,7 @@ describe('NodeFavoriteDirective', () => {
             addFavoriteSpy.and.returnValue(Promise.reject('error'));
             spyOn(directive.error, 'emit');
 
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFavorite: false } }
             ];
 
@@ -153,11 +287,67 @@ describe('NodeFavoriteDirective', () => {
 
             expect(directive.error.emit).toHaveBeenCalledWith('error');
         }));
+
+        it('should set isFavorites items to false', fakeAsync(() => {
+            removeFavoriteSpy.and.returnValue(Promise.resolve());
+
+            directive.favorites = [
+                { entry: { id: '1', name: 'name1', isFavorite: true } }
+            ];
+
+            directive.toggleFavorite();
+            tick();
+
+            expect(directive.hasFavorites()).toBe(false);
+        }));
+
+        it('should set isFavorites items to true', fakeAsync(() => {
+            addFavoriteSpy.and.returnValue(Promise.resolve());
+
+            directive.favorites = [
+                { entry: { id: '1', name: 'name1', isFavorite: false } }
+            ];
+
+            directive.toggleFavorite();
+            tick();
+
+            expect(directive.hasFavorites()).toBe(true);
+        }));
+    });
+
+    describe('getFavorite()', () => {
+        it('should process node as favorite', fakeAsync(() => {
+            spyOn(alfrescoApiService.getInstance().core.favoritesApi, 'getFavorite').and.returnValue(Promise.resolve());
+
+            const selection = [
+                { entry: { id: '1', name: 'name1' } }
+            ];
+
+            let change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+            tick();
+
+            expect(directive.favorites[0].entry.isFavorite).toBe(true);
+        }));
+
+        it('should not process node as favorite', fakeAsync(() => {
+            spyOn(alfrescoApiService.getInstance().core.favoritesApi, 'getFavorite').and.returnValue(Promise.reject({}));
+
+            const selection = [
+                { entry: { id: '1', name: 'name1' } }
+            ];
+
+            let change = new SimpleChange(null, selection, true);
+            directive.ngOnChanges({'selection': change});
+            tick();
+
+            expect(directive.favorites[0].entry.isFavorite).toBe(false);
+        }));
     });
 
     describe('hasFavorites()', () => {
         it('should return false when favorites collection is empty', () => {
-            directive.selection = [];
+            directive.favorites = [];
 
             const hasFavorites = directive.hasFavorites();
 
@@ -165,7 +355,7 @@ describe('NodeFavoriteDirective', () => {
         });
 
         it('should return false when some are not favorite', () => {
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFavorite: true } },
                 { entry: { id: '2', name: 'name2', isFavorite: false } }
             ];
@@ -176,7 +366,7 @@ describe('NodeFavoriteDirective', () => {
         });
 
         it('return true when all are favorite', () => {
-            directive.selection = [
+            directive.favorites = [
                 { entry: { id: '1', name: 'name1', isFavorite: true } },
                 { entry: { id: '2', name: 'name2', isFavorite: true } }
             ];