mirror of
https://github.com/Alfresco/alfresco-content-app.git
synced 2025-05-12 17:04:46 +00:00
b28eabc63d
* upgrade to ADF 2.2.0-beta1 * upgrade and cleanup unit tests * cleanup unused locals * cleanup test files
458 lines
15 KiB
TypeScript
458 lines
15 KiB
TypeScript
/*!
|
|
* @license
|
|
* Alfresco Example Content Application
|
|
*
|
|
* Copyright (C) 2005 - 2017 Alfresco Software Limited
|
|
*
|
|
* This file is part of the Alfresco Example Content Application.
|
|
* If the software was purchased under a paid Alfresco license, the terms of
|
|
* the paid license agreement will prevail. Otherwise, the software is
|
|
* provided under the following open source license terms:
|
|
*
|
|
* The Alfresco Example Content Application is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* The Alfresco Example Content Application is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import { Observable } from 'rxjs/Rx';
|
|
import { Router } from '@angular/router';
|
|
import { RouterTestingModule } from '@angular/router/testing';
|
|
import { TestBed, async } from '@angular/core/testing';
|
|
import { UploadService, NodesApiService, ContentService } from '@alfresco/adf-core';
|
|
|
|
import { CommonModule } from '../../common/common.module';
|
|
import { ContentManagementService } from '../../common/services/content-management.service';
|
|
import { BrowsingFilesService } from '../../common/services/browsing-files.service';
|
|
import { NodeActionsService } from '../../common/services/node-actions.service';
|
|
import { GenericErrorComponent } from '../generic-error/generic-error.component';
|
|
import { FilesComponent } from './files.component';
|
|
|
|
describe('FilesComponent', () => {
|
|
let node;
|
|
let page;
|
|
let fixture;
|
|
let component: FilesComponent;
|
|
let contentManagementService: ContentManagementService;
|
|
let alfrescoContentService: ContentService;
|
|
let uploadService: UploadService;
|
|
let nodesApi: NodesApiService;
|
|
let router: Router;
|
|
let browsingFilesService: BrowsingFilesService;
|
|
let nodeActionsService: NodeActionsService;
|
|
|
|
beforeEach(async(() => {
|
|
TestBed.configureTestingModule({
|
|
imports: [
|
|
RouterTestingModule,
|
|
CommonModule
|
|
],
|
|
declarations: [
|
|
FilesComponent,
|
|
GenericErrorComponent
|
|
]
|
|
}).compileComponents()
|
|
.then(() => {
|
|
|
|
fixture = TestBed.createComponent(FilesComponent);
|
|
component = fixture.componentInstance;
|
|
|
|
contentManagementService = TestBed.get(ContentManagementService);
|
|
uploadService = TestBed.get(UploadService);
|
|
nodesApi = TestBed.get(NodesApiService);
|
|
router = TestBed.get(Router);
|
|
alfrescoContentService = TestBed.get(ContentService);
|
|
browsingFilesService = TestBed.get(BrowsingFilesService);
|
|
nodeActionsService = TestBed.get(NodeActionsService);
|
|
});
|
|
}));
|
|
|
|
beforeEach(() => {
|
|
node = { id: 'node-id', isFolder: true };
|
|
page = {
|
|
list: {
|
|
entries: ['a', 'b', 'c'],
|
|
pagination: {}
|
|
}
|
|
};
|
|
});
|
|
|
|
describe('OnInit', () => {
|
|
it('set current node', () => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
|
|
fixture.detectChanges();
|
|
|
|
expect(component.node).toBe(node);
|
|
});
|
|
|
|
it('get current node children', () => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
|
|
fixture.detectChanges();
|
|
|
|
expect(component.paging).toBe(page);
|
|
});
|
|
|
|
it('emits onChangeParent event', () => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
spyOn(browsingFilesService.onChangeParent, 'next').and.callFake((val) => val);
|
|
|
|
fixture.detectChanges();
|
|
|
|
expect(browsingFilesService.onChangeParent.next)
|
|
.toHaveBeenCalledWith(node);
|
|
});
|
|
|
|
it('raise error when fetchNode() fails', () => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.throw(null));
|
|
spyOn(component, 'onFetchError');
|
|
|
|
fixture.detectChanges();
|
|
|
|
expect(component.onFetchError).toHaveBeenCalled();
|
|
});
|
|
|
|
it('raise error when fetchNodes() fails', () => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.throw(null));
|
|
spyOn(component, 'onFetchError');
|
|
|
|
fixture.detectChanges();
|
|
|
|
expect(component.onFetchError).toHaveBeenCalled();
|
|
});
|
|
|
|
it('if should navigate to parent if node is not a folder', () => {
|
|
node.isFolder = false;
|
|
node.parentId = 'parent-id';
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(router, 'navigate');
|
|
|
|
fixture.detectChanges();
|
|
|
|
expect(router.navigate['calls'].argsFor(0)[0]).toEqual(['/personal-files', 'parent-id']);
|
|
});
|
|
});
|
|
|
|
describe('refresh on events', () => {
|
|
beforeEach(() => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
spyOn(component, 'load');
|
|
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('calls refresh onContentCopied event if parent is the same', () => {
|
|
const nodes = [
|
|
{ entry: { parentId: '1' } },
|
|
{ entry: { parentId: '2' } }
|
|
];
|
|
|
|
component.node = <any>{ id: '1' };
|
|
|
|
nodeActionsService.contentCopied.next(<any>nodes);
|
|
|
|
expect(component.load).toHaveBeenCalled();
|
|
});
|
|
|
|
it('does not call refresh onContentCopied event when parent mismatch', () => {
|
|
const nodes = [
|
|
{ entry: { parentId: '1' } },
|
|
{ entry: { parentId: '2' } }
|
|
];
|
|
|
|
component.node = <any>{ id: '3' };
|
|
|
|
nodeActionsService.contentCopied.next(<any>nodes);
|
|
|
|
expect(component.load).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('calls refresh onCreateFolder event', () => {
|
|
alfrescoContentService.folderCreate.next();
|
|
|
|
expect(component.load).toHaveBeenCalled();
|
|
});
|
|
|
|
it('calls refresh editFolder event', () => {
|
|
alfrescoContentService.folderEdit.next();
|
|
|
|
expect(component.load).toHaveBeenCalled();
|
|
});
|
|
|
|
it('calls refresh deleteNode event', () => {
|
|
contentManagementService.deleteNode.next();
|
|
|
|
expect(component.load).toHaveBeenCalled();
|
|
});
|
|
|
|
it('calls refresh moveNode event', () => {
|
|
contentManagementService.moveNode.next();
|
|
|
|
expect(component.load).toHaveBeenCalled();
|
|
});
|
|
|
|
it('calls refresh restoreNode event', () => {
|
|
contentManagementService.restoreNode.next();
|
|
|
|
expect(component.load).toHaveBeenCalled();
|
|
});
|
|
|
|
it('calls refresh on fileUploadComplete event if parent node match', () => {
|
|
const file = { file: { options: { parentId: 'parentId' } } };
|
|
component.node = <any>{ id: 'parentId' };
|
|
|
|
uploadService.fileUploadComplete.next(<any>file);
|
|
|
|
expect(component.load).toHaveBeenCalled();
|
|
});
|
|
|
|
it('does not call refresh on fileUploadComplete event if parent mismatch', () => {
|
|
const file = { file: { options: { parentId: 'otherId' } } };
|
|
component.node = <any>{ id: 'parentId' };
|
|
|
|
uploadService.fileUploadComplete.next(<any>file);
|
|
|
|
expect(component.load).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('calls refresh on fileUploadDeleted event if parent node match', () => {
|
|
const file = { file: { options: { parentId: 'parentId' } } };
|
|
component.node = <any>{ id: 'parentId' };
|
|
|
|
uploadService.fileUploadDeleted.next(<any>file);
|
|
|
|
expect(component.load).toHaveBeenCalled();
|
|
});
|
|
|
|
it('does not call refresh on fileUploadDeleted event if parent mismatch', () => {
|
|
const file = { file: { options: { parentId: 'otherId' } } };
|
|
component.node = <any>{ id: 'parentId' };
|
|
|
|
uploadService.fileUploadDeleted.next(<any>file);
|
|
|
|
expect(component.load).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('fetchNode()', () => {
|
|
beforeEach(() => {
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
spyOn(nodesApi, 'getNode').and.returnValue(Observable.of(node));
|
|
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('calls getNode api with node id', () => {
|
|
component.fetchNode('nodeId');
|
|
|
|
expect(nodesApi.getNode).toHaveBeenCalledWith('nodeId');
|
|
});
|
|
});
|
|
|
|
describe('fetchNodes()', () => {
|
|
beforeEach(() => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(nodesApi, 'getNodeChildren').and.returnValue(Observable.of(page));
|
|
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('calls getNode api with node id', () => {
|
|
component.fetchNodes('nodeId');
|
|
|
|
expect(nodesApi.getNodeChildren).toHaveBeenCalledWith('nodeId', jasmine.any(Object));
|
|
});
|
|
});
|
|
|
|
describe('Create permission', () => {
|
|
beforeEach(() => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('returns false when node is not provided', () => {
|
|
expect(component.canCreateContent(null)).toBe(false);
|
|
});
|
|
|
|
it('returns false when node does not have permission', () => {
|
|
spyOn(alfrescoContentService, 'hasPermission').and.returnValue(false);
|
|
|
|
expect(component.canCreateContent(node)).toBe(false);
|
|
});
|
|
|
|
it('returns false when node has permission', () => {
|
|
spyOn(alfrescoContentService, 'hasPermission').and.returnValue(true);
|
|
|
|
expect(component.canCreateContent(node)).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('onNodeDoubleClick()', () => {
|
|
beforeEach(() => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('opens preview if node is file', () => {
|
|
spyOn(router, 'navigate').and.stub();
|
|
node.isFile = true;
|
|
node.isFolder = false;
|
|
|
|
const event: any = {
|
|
detail: {
|
|
node: {
|
|
entry: node
|
|
}
|
|
}
|
|
};
|
|
component.onNodeDoubleClick(event);
|
|
|
|
expect(router.navigate['calls'].argsFor(0)[0]).toEqual(['./preview', node.id]);
|
|
});
|
|
|
|
it('navigate if node is folder', () => {
|
|
spyOn(component, 'navigate').and.stub();
|
|
node.isFolder = true;
|
|
|
|
|
|
const event: any = {
|
|
detail: {
|
|
node: {
|
|
entry: node
|
|
}
|
|
}
|
|
};
|
|
component.onNodeDoubleClick(event);
|
|
|
|
expect(component.navigate).toHaveBeenCalledWith(node.id);
|
|
});
|
|
});
|
|
|
|
describe('load()', () => {
|
|
let fetchNodesSpy;
|
|
|
|
beforeEach(() => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
fetchNodesSpy = spyOn(component, 'fetchNodes');
|
|
|
|
fetchNodesSpy.and.returnValue(Observable.of(page));
|
|
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
afterEach(() => {
|
|
fetchNodesSpy.calls.reset();
|
|
});
|
|
|
|
it('shows load indicator', () => {
|
|
spyOn(component, 'onPageLoaded');
|
|
component.node = <any>{ id: 'currentNode' };
|
|
|
|
expect(component.isLoading).toBe(false);
|
|
|
|
component.load(true);
|
|
|
|
expect(component.isLoading).toBe(true);
|
|
});
|
|
|
|
it('does not show load indicator', () => {
|
|
spyOn(component, 'onPageLoaded');
|
|
component.node = <any>{ id: 'currentNode' };
|
|
|
|
expect(component.isLoading).toBe(false);
|
|
|
|
component.load();
|
|
|
|
expect(component.isLoading).toBe(false);
|
|
});
|
|
|
|
it('sets data on success', () => {
|
|
component.node = <any>{ id: 'currentNode' };
|
|
|
|
component.load();
|
|
|
|
expect(component.paging).toBe(page);
|
|
expect(component.pagination).toBe(page.list.pagination);
|
|
});
|
|
|
|
it('raise error on fail', () => {
|
|
fetchNodesSpy.and.returnValue(Observable.throw(null));
|
|
spyOn(component, 'onFetchError');
|
|
|
|
component.load();
|
|
|
|
expect(component.onFetchError).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('onBreadcrumbNavigate()', () => {
|
|
beforeEach(() => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('navigates to node id', () => {
|
|
const routeData = <any>{ id: 'some-where-over-the-rainbow' };
|
|
spyOn(component, 'navigate');
|
|
|
|
component.onBreadcrumbNavigate(routeData);
|
|
|
|
expect(component.navigate).toHaveBeenCalledWith(routeData.id);
|
|
});
|
|
});
|
|
|
|
describe('Node navigation', () => {
|
|
beforeEach(() => {
|
|
spyOn(component, 'fetchNode').and.returnValue(Observable.of(node));
|
|
spyOn(component, 'fetchNodes').and.returnValue(Observable.of(page));
|
|
spyOn(router, 'navigate');
|
|
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('navigates to node when id provided', () => {
|
|
component.navigate(node.id);
|
|
|
|
expect(router.navigate).toHaveBeenCalledWith(['./', node.id], jasmine.any(Object));
|
|
});
|
|
|
|
it('navigates to home when id not provided', () => {
|
|
component.navigate();
|
|
|
|
expect(router.navigate).toHaveBeenCalledWith(['./'], jasmine.any(Object));
|
|
});
|
|
|
|
it('it navigate home if node is root', () => {
|
|
(<any>component).node = {
|
|
path: {
|
|
elements: [ {id: 'node-id'} ]
|
|
}
|
|
};
|
|
|
|
component.navigate(node.id);
|
|
|
|
expect(router.navigate).toHaveBeenCalledWith(['./'], jasmine.any(Object));
|
|
});
|
|
});
|
|
});
|