mirror of
https://github.com/Alfresco/alfresco-ng2-components.git
synced 2025-05-12 17:04:57 +00:00
392 lines
12 KiB
TypeScript
392 lines
12 KiB
TypeScript
/*!
|
|
* @license
|
|
* Copyright 2016 Alfresco Software, Ltd.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import { Component, NgZone } from '@angular/core';
|
|
import { ComponentFixture, TestBed, fakeAsync, tick } from '@angular/core/testing';
|
|
import { TranslationService, UploadService, setupTestBed, CoreModule, FileModel } from '@alfresco/adf-core';
|
|
import { UploadBase } from './upload-base';
|
|
import { TranslationMock } from '@alfresco/adf-core';
|
|
import { NoopAnimationsModule } from '@angular/platform-browser/animations';
|
|
import { UploadFilesEvent } from '../upload-files.event';
|
|
|
|
@Component({
|
|
selector: 'adf-upload-button-test',
|
|
template: 'test component'
|
|
})
|
|
export class UploadTestComponent extends UploadBase {
|
|
|
|
constructor(protected uploadService: UploadService,
|
|
protected translationService: TranslationService,
|
|
protected ngZone: NgZone) {
|
|
super(uploadService, translationService, ngZone);
|
|
}
|
|
}
|
|
|
|
describe('UploadBase', () => {
|
|
|
|
let component: UploadTestComponent;
|
|
let fixture: ComponentFixture<UploadTestComponent>;
|
|
let uploadService: UploadService;
|
|
|
|
setupTestBed({
|
|
imports: [
|
|
NoopAnimationsModule,
|
|
CoreModule.forRoot()
|
|
],
|
|
declarations: [
|
|
UploadTestComponent
|
|
],
|
|
providers: [
|
|
UploadService,
|
|
{ provide: TranslationService, useClass: TranslationMock }
|
|
]
|
|
});
|
|
|
|
beforeEach(() => {
|
|
fixture = TestBed.createComponent(UploadTestComponent);
|
|
uploadService = TestBed.get(UploadService);
|
|
|
|
component = fixture.componentInstance;
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
afterEach(() => {
|
|
fixture.destroy();
|
|
TestBed.resetTestingModule();
|
|
});
|
|
|
|
describe('beginUpload', () => {
|
|
|
|
it('should raise event', done => {
|
|
spyOn(uploadService, 'addToQueue').and.stub();
|
|
spyOn(uploadService, 'uploadFilesInTheQueue').and.stub();
|
|
|
|
component.beginUpload.subscribe(() => done());
|
|
const file = <File> { name: 'bigFile.png', size: 1000 };
|
|
component.uploadFiles([file]);
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('should pause upload', fakeAsync(() => {
|
|
spyOn(uploadService, 'addToQueue').and.stub();
|
|
spyOn(uploadService, 'uploadFilesInTheQueue').and.stub();
|
|
|
|
let prevented = false;
|
|
component.beginUpload.subscribe(event => {
|
|
event.preventDefault();
|
|
prevented = true;
|
|
});
|
|
const file = <File> { name: 'bigFile.png', size: 1000 };
|
|
component.uploadFiles([file]);
|
|
|
|
tick();
|
|
expect(prevented).toBeTruthy();
|
|
expect(uploadService.addToQueue).not.toHaveBeenCalled();
|
|
expect(uploadService.uploadFilesInTheQueue).not.toHaveBeenCalled();
|
|
}));
|
|
|
|
it('should resume upload', fakeAsync(() => {
|
|
const addToQueue = spyOn(uploadService, 'addToQueue').and.stub();
|
|
const uploadFilesInTheQueue = spyOn(uploadService, 'uploadFilesInTheQueue').and.stub();
|
|
|
|
let prevented = false;
|
|
let uploadEvent: UploadFilesEvent;
|
|
component.beginUpload.subscribe(event => {
|
|
uploadEvent = event;
|
|
event.preventDefault();
|
|
prevented = true;
|
|
});
|
|
const file = <File> { name: 'bigFile.png', size: 1000 };
|
|
component.uploadFiles([file]);
|
|
|
|
tick();
|
|
expect(prevented).toBeTruthy();
|
|
expect(addToQueue).not.toHaveBeenCalled();
|
|
expect(uploadFilesInTheQueue).not.toHaveBeenCalled();
|
|
|
|
addToQueue.calls.reset();
|
|
uploadFilesInTheQueue.calls.reset();
|
|
|
|
uploadEvent.resumeUpload();
|
|
|
|
expect(addToQueue).toHaveBeenCalled();
|
|
expect(uploadFilesInTheQueue).toHaveBeenCalled();
|
|
}));
|
|
|
|
it('should emit callback events on resume', fakeAsync((done) => {
|
|
spyOn(uploadService, 'addToQueue').and.stub();
|
|
spyOn(uploadService, 'uploadFilesInTheQueue').and.stub();
|
|
|
|
let uploadEvent: UploadFilesEvent;
|
|
component.beginUpload.subscribe(event => {
|
|
uploadEvent = event;
|
|
event.preventDefault();
|
|
});
|
|
const file = <File> { name: 'bigFile.png', size: 1000 };
|
|
component.uploadFiles([file]);
|
|
|
|
tick();
|
|
uploadEvent.resumeUpload();
|
|
|
|
component.success.subscribe(() => {
|
|
done();
|
|
});
|
|
}));
|
|
|
|
});
|
|
|
|
describe('filesize', () => {
|
|
|
|
const files: File[] = [
|
|
<File> { name: 'bigFile.png', size: 1000 },
|
|
<File> { name: 'smallFile.png', size: 10 }
|
|
];
|
|
|
|
let addToQueueSpy;
|
|
|
|
beforeEach(() => {
|
|
addToQueueSpy = spyOn(uploadService, 'addToQueue');
|
|
});
|
|
|
|
it('should filter out file, which are too big if max file size is set', () => {
|
|
component.maxFilesSize = 100;
|
|
|
|
component.uploadFiles(files);
|
|
|
|
const filesCalledWith = addToQueueSpy.calls.mostRecent().args;
|
|
expect(filesCalledWith.length).toBe(1);
|
|
expect(filesCalledWith[0].name).toBe('smallFile.png');
|
|
});
|
|
|
|
it('should filter out all files if maxFilesSize is 0', () => {
|
|
component.maxFilesSize = 0;
|
|
|
|
component.uploadFiles(files);
|
|
|
|
expect(addToQueueSpy.calls.mostRecent()).toBeUndefined();
|
|
});
|
|
|
|
it('should allow file of 0 size when the max file size is set to 0', () => {
|
|
const zeroFiles: File[] = [
|
|
<File> { name: 'zeroFile.png', size: 0 }
|
|
];
|
|
component.maxFilesSize = 0;
|
|
|
|
component.uploadFiles(zeroFiles);
|
|
|
|
expect(addToQueueSpy.calls.mostRecent()).toBeDefined();
|
|
});
|
|
|
|
it('should filter out all files if maxFilesSize is <0', () => {
|
|
component.maxFilesSize = -2;
|
|
|
|
component.uploadFiles(files);
|
|
|
|
expect(addToQueueSpy.calls.mostRecent()).toBeUndefined();
|
|
});
|
|
|
|
it('should output an error when you try to upload a file too big', (done) => {
|
|
component.maxFilesSize = 100;
|
|
|
|
component.error.subscribe(() => {
|
|
done();
|
|
});
|
|
|
|
component.uploadFiles(files);
|
|
});
|
|
|
|
it('should not filter out files if max file size is not set', () => {
|
|
component.maxFilesSize = null;
|
|
|
|
component.uploadFiles(files);
|
|
|
|
const filesCalledWith = addToQueueSpy.calls.mostRecent().args;
|
|
expect(filesCalledWith.length).toBe(2);
|
|
});
|
|
});
|
|
|
|
describe('uploadFiles', () => {
|
|
|
|
const files: File[] = [
|
|
<File> { name: 'phobos.jpg' },
|
|
<File> { name: 'deimos.png' },
|
|
<File> { name: 'ganymede.bmp' }
|
|
];
|
|
|
|
let addToQueueSpy;
|
|
|
|
beforeEach(() => {
|
|
addToQueueSpy = spyOn(uploadService, 'addToQueue');
|
|
});
|
|
|
|
it('should filter out file, which is not part of the acceptedFilesType', () => {
|
|
component.acceptedFilesType = '.jpg';
|
|
|
|
component.uploadFiles(files);
|
|
|
|
const filesCalledWith = addToQueueSpy.calls.mostRecent().args;
|
|
expect(filesCalledWith.length).toBe(1, 'Files should contain only one element');
|
|
expect(filesCalledWith[0].name).toBe('phobos.jpg', 'png file should be filtered out');
|
|
});
|
|
|
|
it('should filter out files, which are not part of the acceptedFilesType', () => {
|
|
component.acceptedFilesType = '.jpg,.png';
|
|
|
|
component.uploadFiles(files);
|
|
|
|
const filesCalledWith = addToQueueSpy.calls.mostRecent().args;
|
|
expect(filesCalledWith.length).toBe(2, 'Files should contain two elements');
|
|
expect(filesCalledWith[0].name).toBe('phobos.jpg');
|
|
expect(filesCalledWith[1].name).toBe('deimos.png');
|
|
});
|
|
|
|
it('should not filter out anything if acceptedFilesType is wildcard', () => {
|
|
component.acceptedFilesType = '*';
|
|
|
|
component.uploadFiles(files);
|
|
|
|
const filesCalledWith = addToQueueSpy.calls.mostRecent().args;
|
|
expect(filesCalledWith.length).toBe(3, 'Files should contain all elements');
|
|
expect(filesCalledWith[0].name).toBe('phobos.jpg');
|
|
expect(filesCalledWith[1].name).toBe('deimos.png');
|
|
expect(filesCalledWith[2].name).toBe('ganymede.bmp');
|
|
});
|
|
|
|
it('should not add any file to que if everything is filtered out', () => {
|
|
component.acceptedFilesType = 'doc';
|
|
|
|
component.uploadFiles(files);
|
|
|
|
expect(addToQueueSpy).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('Comments', () => {
|
|
|
|
let addToQueueSpy;
|
|
|
|
const files: File[] = [
|
|
<File> { name: 'phobos.jpg' }
|
|
];
|
|
|
|
beforeEach(() => {
|
|
addToQueueSpy = spyOn(uploadService, 'addToQueue');
|
|
});
|
|
|
|
it('should add the comment in the uploaded files', () => {
|
|
component.comment = 'example-comment';
|
|
|
|
component.uploadFiles(files);
|
|
|
|
expect(addToQueueSpy).toHaveBeenCalledWith(new FileModel(files[0], {
|
|
comment: 'example-comment',
|
|
newVersion: false,
|
|
majorVersion: false,
|
|
parentId: '-root-',
|
|
path: '',
|
|
nodeType: 'cm:content'
|
|
}));
|
|
});
|
|
});
|
|
|
|
describe('Versions', () => {
|
|
|
|
let addToQueueSpy;
|
|
|
|
const files: File[] = [
|
|
<File> { name: 'phobos.jpg' }
|
|
];
|
|
|
|
beforeEach(() => {
|
|
addToQueueSpy = spyOn(uploadService, 'addToQueue');
|
|
});
|
|
|
|
it('should be a major version upload if majorVersion is true', () => {
|
|
component.majorVersion = true;
|
|
component.versioning = true;
|
|
|
|
component.uploadFiles(files);
|
|
|
|
expect(addToQueueSpy).toHaveBeenCalledWith(new FileModel(files[0], {
|
|
comment: undefined,
|
|
newVersion: true,
|
|
majorVersion: true,
|
|
parentId: '-root-',
|
|
path: '',
|
|
nodeType: 'cm:content'
|
|
}));
|
|
});
|
|
|
|
it('should not be a major version upload if majorVersion is false', () => {
|
|
component.majorVersion = false;
|
|
component.versioning = true;
|
|
|
|
component.uploadFiles(files);
|
|
|
|
expect(addToQueueSpy).toHaveBeenCalledWith(new FileModel(files[0], {
|
|
comment: undefined,
|
|
newVersion: true,
|
|
majorVersion: false,
|
|
parentId: '-root-',
|
|
path: '',
|
|
nodeType: 'cm:content'
|
|
}));
|
|
});
|
|
});
|
|
|
|
describe('Node Type', () => {
|
|
|
|
let addToQueueSpy;
|
|
|
|
const files: File[] = [
|
|
<File> { name: 'process.pbmn' }
|
|
];
|
|
|
|
beforeEach(() => {
|
|
addToQueueSpy = spyOn(uploadService, 'addToQueue');
|
|
});
|
|
|
|
it('should have custom nodeType if it is set', () => {
|
|
component.nodeType = 'ama:process';
|
|
|
|
component.uploadFiles(files);
|
|
|
|
expect(addToQueueSpy).toHaveBeenCalledWith(new FileModel(files[0], {
|
|
comment: undefined,
|
|
newVersion: false,
|
|
majorVersion: false,
|
|
parentId: '-root-',
|
|
path: '',
|
|
nodeType: 'ama:process'
|
|
}));
|
|
});
|
|
|
|
it('should have default nodeType if it is not set', () => {
|
|
component.uploadFiles(files);
|
|
|
|
expect(addToQueueSpy).toHaveBeenCalledWith(new FileModel(files[0], {
|
|
comment: undefined,
|
|
newVersion: false,
|
|
majorVersion: false,
|
|
parentId: '-root-',
|
|
path: '',
|
|
nodeType: 'cm:content'
|
|
}));
|
|
});
|
|
});
|
|
});
|