Fix unit test upload

ng2-components/ng2-alfresco-upload/src/assets/AlfrescoApi.mock.ts

@@ -1,60 +0,0 @@
-/*!
- * @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.
- */
-
-export class AlfrescoApiMock {
-
-    static getClientWithTicket(basePath: string, ticket: string) {
-        return {authentications: {basicAuth: {password: 'fake-password', type: 'fake-basic', username: 'fake-user'}}};
-    }
-
-    static get NodesApi() {
-        return NodesApiMock;
-    }
-
-}
-
-export class NodesApiMock {
-
-    constructor(alfrescoClient: any) {
-    }
-
-    addNode(nodeId, nodeBody, opts) {
-        if (nodeId && nodeBody.name !== 'folder-duplicate-fake') {
-            return new Promise(function (resolve, reject) {
-                resolve({
-                    entry: {
-                        isFile: false,
-                        isFolder: true
-                    }
-                });
-            });
-        } else {
-            return new Promise(function (resolve, reject) {
-                reject({
-                    response: {
-                        body: {
-                            error: {
-                                statusCode: 409
-                            }
-                        }
-                    }
-                });
-            });
-        }
-    }
-
-}

ng2-components/ng2-alfresco-upload/src/assets/AlfrescoSettingsService.service.mock.ts

@@ -21,23 +21,15 @@ import { Injectable } from '@angular/core';
 export class AlfrescoSettingsServiceMock {
 
     static DEFAULT_HOST_ADDRESS: string = 'fakehost';
-    static DEFAULT_CONTEXT_PATH: string = '/fake-path-alfresco';
-    static DEFAULT_BASE_API_PATH: string = '/fake-api/fake-public/fake-alfresco/fake-versions/1';
 
     private providers: string[] = ['ECM', 'BPM'];
 
     private _host: string = AlfrescoSettingsServiceMock.DEFAULT_HOST_ADDRESS;
-    private _contextPath = AlfrescoSettingsServiceMock.DEFAULT_CONTEXT_PATH;
-    private _apiBasePath: string = AlfrescoSettingsServiceMock.DEFAULT_BASE_API_PATH;
 
     public get host(): string {
         return this._host;
     }
 
-    getApiBaseUrl(): string {
-        return this._host + this._contextPath + this._apiBasePath;
-    }
-
     getProviders(): string [] {
         return this.providers;
     }

ng2-components/ng2-alfresco-upload/src/assets/upload.service.mock.ts

@@ -1,82 +0,0 @@
-/*!
- * @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 { Observable } from 'rxjs/Observable';
-import { FileModel } from '../models/file.model';
-import { UploadService } from '../services/upload.service';
-import { AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
-
-export class UploadServiceMock extends UploadService {
-
-    filesUpload$: Observable<any>;
-    totalCompleted$: Observable<number>;
-
-    constructor(settings: AlfrescoSettingsService, authService: AlfrescoAuthenticationService) {
-        super(settings, authService);
-    }
-
-    public setOptions(options: any): void {
-        super.setOptions(options);
-    }
-
-    addToQueue(files: any[]): FileModel[] {
-        let result = super.addToQueue(files);
-        this.filesUpload$ = new Observable(observer => {
-            observer.next(files);
-        });
-        return result;
-    }
-
-    createFolder(relativePath: string, name: string) {
-        let promise: Promise<any>;
-        if (name !== 'folder-duplicate-fake') {
-            promise = new Promise(function (resolve, reject) {
-                resolve({
-                    entry: {
-                        isFile: false,
-                        isFolder: true,
-                        name: name,
-                        nodeType: 'cm:folder'
-                    }
-                });
-            });
-        } else {
-            promise = new Promise(function (resolve, reject) {
-                reject({
-                    response: {
-                        body: {
-                            error: {
-                                statusCode: 409
-                            }
-                        }
-                    }
-                });
-            });
-        }
-        return Observable.fromPromise(promise)
-            .map(res => {
-                return res;
-            })
-            .do(data => console.log('Node data', data))
-            .catch((error => {
-                return Observable.throw(error);
-            }));
-    }
-
-    public uploadFilesInTheQueue(directory: string, elementEmit: any): void {
-    };
-}

ng2-components/ng2-alfresco-upload/src/components/file-uploading-dialog.component.spec.ts

@@ -21,7 +21,6 @@ import { FileUploadingDialogComponent } from './file-uploading-dialog.component'
 import { FileModel } from '../models/file.model';
 import { AlfrescoTranslationService, AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
 import { TranslationMock } from '../assets/translation.service.mock';
-import { UploadServiceMock } from '../assets/upload.service.mock';
 import { UploadService } from '../services/upload.service';
 import { Observable } from 'rxjs/Observable';
 import { HTTP_PROVIDERS } from '@angular/http';
@@ -34,10 +33,10 @@ describe('FileUploadDialog', () => {
     beforeEachProviders(() => {
         return [
             HTTP_PROVIDERS,
-            { provide: AlfrescoSettingsService, useClass: AlfrescoSettingsService },
+            AlfrescoSettingsService,
-            { provide: AlfrescoAuthenticationService, useClass: AlfrescoAuthenticationService },
+            AlfrescoAuthenticationService,
             { provide: AlfrescoTranslationService, useClass: TranslationMock },
-            { provide: UploadService, useClass: UploadServiceMock }
+            UploadService
         ];
     });
 
@@ -86,11 +85,9 @@ describe('FileUploadDialog', () => {
         let file = new FileModel(fileFake);
         file.progress = {'percent': 50};
 
-        uploadService.addToQueue([file]);
-
-
         let component = componentFixture.componentInstance;
         componentFixture.detectChanges();
+        uploadService.addToQueue([file]);
         component.filesUploadingList = [file];
 
         let compiled = componentFixture.debugElement.nativeElement;

ng2-components/ng2-alfresco-upload/src/components/file-uploading-list.component.ts

@@ -57,7 +57,7 @@ export class FileUploadingListComponent {
         let file = this.filesUploadingList.filter((uploadingFileModel) => {
             return uploadingFileModel.id === id;
         });
-        file[0].setAbort();
+        file[0].emitAbort();
     }
 
     /**
@@ -68,7 +68,7 @@ export class FileUploadingListComponent {
             $event.preventDefault();
         }
         this.filesUploadingList.forEach((uploadingFileModel: FileModel) => {
-            uploadingFileModel.setAbort();
+            uploadingFileModel.emitAbort();
         });
     }
 

ng2-components/ng2-alfresco-upload/src/components/upload-button.component.spec.ts

@@ -20,20 +20,49 @@ import { TestComponentBuilder } from '@angular/compiler/testing';
 import { UploadButtonComponent } from './upload-button.component';
 import { AlfrescoTranslationService, AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
 import { TranslationMock } from '../assets/translation.service.mock';
-import { UploadServiceMock } from '../assets/upload.service.mock';
 import { UploadService } from '../services/upload.service';
-import { AlfrescoApiMock } from '../assets/AlfrescoApi.mock';
 import { AlfrescoSettingsServiceMock } from '../assets/AlfrescoSettingsService.service.mock';
 import { HTTP_PROVIDERS } from '@angular/http';
-
 declare var AlfrescoApi: any;
 
 describe('AlfrescoUploadButton', () => {
 
     let uploadButtonFixture;
 
+    let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
+    let fakeEvent = {
+        currentTarget: {
+            files: [file]
+        },
+        target: {value: 'fake-name-1'}
+    };
+
+    let fakeResolveRest = {
+        entry: {
+            isFile: false,
+            isFolder: true,
+            name: 'fake-folder1'
+        }
+    };
+    let fakeResolvePromise = new Promise(function (resolve, reject) {
+        resolve(fakeResolveRest);
+    });
+
+    let fakeRejectRest = {
+        response: {
+            body: {
+                error: {
+                    statusCode: 409
+                }
+            }
+        }
+    };
+
+    let fakeRejectPromise = new Promise(function (resolve, reject) {
+        reject(fakeRejectRest);
+    });
+
     beforeEach( () => {
-        window['AlfrescoApi'] = AlfrescoApiMock;
         window['componentHandler'] = null;
     });
 
@@ -41,9 +70,9 @@ describe('AlfrescoUploadButton', () => {
         return [
             HTTP_PROVIDERS,
             { provide: AlfrescoSettingsService, useClass: AlfrescoSettingsServiceMock },
-            { provide: AlfrescoAuthenticationService, useClass: AlfrescoAuthenticationService },
+            AlfrescoAuthenticationService,
             { provide: AlfrescoTranslationService, useClass: TranslationMock },
-            { provide: UploadService, useClass: UploadServiceMock }
+            UploadService
         ];
     });
 
@@ -84,55 +113,42 @@ describe('AlfrescoUploadButton', () => {
         component._uploaderService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
 
         uploadButtonFixture.detectChanges();
-        let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
-
-        let fakeEvent = {
-            currentTarget: {
-                files: [file]
-            },
-            target: {value: 'fake-value'}
-        };
 
         component.onFilesAdded(fakeEvent);
         expect(component._uploaderService.uploadFilesInTheQueue).toHaveBeenCalledWith('/root-fake-/sites-fake/folder-fake', null);
     });
 
-    it('should create a folder and call upload file', () => {
+    it('should create a folder and emit an File uploaded event', (done) => {
         let component = uploadButtonFixture.componentInstance;
-
+        component.currentFolderPath = '/fake-root-path';
-        component.uploadFiles = jasmine.createSpy('uploadFiles');
-        let doneFn = jasmine.createSpy('success');
-
         uploadButtonFixture.detectChanges();
 
-        let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
+        spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakeResolvePromise);
 
-        let fakeEvent = {
+        component.onSuccess.subscribe(e => {
-            currentTarget: {
+            expect(e.value).toEqual('File uploaded');
-                files: [file]
+            done();
-            },
-            target: {value: 'fake-value'}
-        };
-        component.onDirectoryAdded(fakeEvent);
-        expect(doneFn).not.toHaveBeenCalledWith(fakeEvent);
         });
 
-    it('should throws an exception when the folder already exist', () => {
+        spyOn(component, 'uploadFiles').and.callFake(() => {
+            component.onSuccess.emit({
+                    value: 'File uploaded'
+                }
+            );
+        });
+        component.onDirectoryAdded(fakeEvent);
+    });
+
+    it('should emit an onError event when the folder already exist', (done) => {
         let component = uploadButtonFixture.componentInstance;
-
-        component.uploadFiles = jasmine.createSpy('uploadFiles');
-
         uploadButtonFixture.detectChanges();
 
-        let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'folder-duplicate-fake/fake-name-1.json'};
+        spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakeRejectPromise);
+        component.onError.subscribe(e => {
+            expect(e.value).toEqual('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
+            done();
+        });
 
-        let fakeEvent = {
-            currentTarget: {
-                files: [file]
-            },
-            target: {value: 'fake-value'}
-        };
         component.onDirectoryAdded(fakeEvent);
-        expect(component.uploadFiles).not.toHaveBeenCalledWith(fakeEvent);
     });
 });

ng2-components/ng2-alfresco-upload/src/components/upload-button.component.ts

@@ -76,6 +76,12 @@ export class UploadButtonComponent {
     @Output()
     onSuccess = new EventEmitter();
 
+    @Output()
+    onError = new EventEmitter();
+
+    @Output()
+    createFolder = new EventEmitter();
+
     translate: AlfrescoTranslationService;
 
 
@@ -125,6 +131,7 @@ export class UploadButtonComponent {
                     error => {
                     let errorMessagePlaceholder = this.getErrorMessage(error.response);
                     if (errorMessagePlaceholder) {
+                        this.onError.emit({value: errorMessagePlaceholder});
                         let errorMessage = this.formatString(errorMessagePlaceholder, [directoryName]);
                         if (errorMessage) {
                             this._showErrorNotificationBar(errorMessage);

ng2-components/ng2-alfresco-upload/src/components/upload-drag-area.component.spec.ts

@@ -21,9 +21,7 @@ import { UploadDragAreaComponent } from './upload-drag-area.component';
 import { AlfrescoTranslationService, AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
 import { AlfrescoSettingsServiceMock } from '../assets/AlfrescoSettingsService.service.mock';
 import { TranslationMock } from '../assets/translation.service.mock';
-import { UploadServiceMock } from '../assets/upload.service.mock';
 import { UploadService } from '../services/upload.service';
-import { AlfrescoApiMock } from '../assets/AlfrescoApi.mock';
 import { HTTP_PROVIDERS } from '@angular/http';
 
 declare var AlfrescoApi: any;
@@ -33,16 +31,16 @@ describe('AlfrescoUploadDragArea', () => {
     let componentFixture;
 
     beforeEach( () => {
-        window['AlfrescoApi'] = AlfrescoApiMock;
+
     });
 
     beforeEachProviders(() => {
         return [
             HTTP_PROVIDERS,
             { provide: AlfrescoSettingsService, useClass: AlfrescoSettingsServiceMock },
-            { provide: AlfrescoAuthenticationService, useClass: AlfrescoAuthenticationService },
+            AlfrescoAuthenticationService,
             { provide: AlfrescoTranslationService, useClass: TranslationMock },
-            { provide: UploadService, useClass: UploadServiceMock }
+            UploadService
         ];
     });
 
@@ -142,6 +140,19 @@ describe('AlfrescoUploadDragArea', () => {
         component.showUdoNotificationBar = true;
 
         componentFixture.detectChanges();
+        let fakeRest = {
+            response: {
+                body: {
+                    error: {
+                        statusCode: 409
+                    }
+                }
+            }
+        };
+        let fakePromise = new Promise(function (resolve, reject) {
+            reject(fakeRest);
+        });
+        spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakePromise);
         spyOn(component, '_showErrorNotificationBar').and.callFake( () => {
             expect(component._showErrorNotificationBar).toHaveBeenCalledWith('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
             done();
@@ -175,6 +186,17 @@ describe('AlfrescoUploadDragArea', () => {
             }
         };
 
+        let fakeRest = {
+            entry: {
+                isFile: false,
+                isFolder: true,
+                name: 'folder-fake'
+            }
+        };
+        let fakePromise = new Promise(function (resolve, reject) {
+            resolve(fakeRest);
+        });
+        spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakePromise);
         spyOn(component, 'onFilesEntityDropped').and.callFake( () => {
             expect(component.onFilesEntityDropped).toHaveBeenCalledWith(itemEntity);
             done();

ng2-components/ng2-alfresco-upload/src/models/file.model.ts

@@ -35,7 +35,7 @@ export class FileModel {
     abort: boolean = false;
     uploading: boolean = false;
     file: any;
-    _xmlHttpRequest: XMLHttpRequest;
+    promiseUpload: any;
 
     constructor(file: any) {
         this.file = file;
@@ -53,16 +53,32 @@ export class FileModel {
         this.progress = progress;
     }
 
+    /**
+     * Emit an event progress on the promise
+     */
+    emitProgres(progress: any): void {
+        this.setProgres(progress);
+        this.promiseUpload.emit('progress', progress);
+    }
+
     setError(): void {
         this.error = true;
     }
 
+    /**
+     * Emit an event progress on the promise
+     */
+    emitError(): void {
+        this.setError();
+        this.promiseUpload.emit('error');
+    }
+
     setUploading() {
         this.uploading = true;
     }
 
-    setXMLHttpRequest(xmlHttpRequest: XMLHttpRequest) {
+    setPromiseUpload(promiseUpload: any) {
-        this._xmlHttpRequest = xmlHttpRequest;
+        this.promiseUpload = promiseUpload;
     }
 
     /**
@@ -72,10 +88,17 @@ export class FileModel {
         if (!this.done && !this.error) {
             this.abort = true;
             this.uploading = false;
-            this._xmlHttpRequest.abort();
         }
     }
 
+    /**
+     * Emit an event abort on the promise
+     */
+    emitAbort(): void {
+        this.setAbort();
+        this.promiseUpload.abort();
+    }
+
     /**
      * Update status of the file when upload finish or is ended.
      */

ng2-components/ng2-alfresco-upload/src/services/upload.service.spec.ts

@@ -17,38 +17,14 @@
 
 import { it, describe, inject, beforeEach, beforeEachProviders } from '@angular/core/testing';
 import { UploadService } from './upload.service';
-import { FileModel } from './../models/file.model';
 import { AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
 import { AlfrescoSettingsServiceMock } from '../assets/AlfrescoSettingsService.service.mock';
-import { AlfrescoApiMock } from '../assets/AlfrescoApi.mock';
 import { HTTP_PROVIDERS } from '@angular/http';
+import { EventEmitter } from '@angular/core';
 
-declare var AlfrescoApi: any;
+declare let AlfrescoApi: any;
 declare let jasmine: any;
 
-let doneFn = jasmine.createSpy('success');
-let errorFn = jasmine.createSpy('error');
-
-class MockUploadService extends UploadService {
-
-    constructor(settings: AlfrescoSettingsService, authService: AlfrescoAuthenticationService) {
-        super(settings, authService);
-    }
-
-    createXMLHttpRequestInstance() {
-        let xhr = new XMLHttpRequest();
-        xhr.onreadystatechange = function () {
-            if (this.readyState === this.DONE && this.status === 200) {
-                doneFn(this.responseText);
-            } else if (this.readyState === this.DONE && this.status === 404) {
-                errorFn(this.responseText);
-            }
-        };
-        xhr.abort = jasmine.createSpy('abort');
-        return xhr;
-    }
-}
-
 describe('AlfrescoUploadService', () => {
     let service, options: any;
 
@@ -62,14 +38,12 @@ describe('AlfrescoUploadService', () => {
         }
     };
 
-    window['AlfrescoApi'] = AlfrescoApiMock;
-
     beforeEachProviders(() => {
         return [
             HTTP_PROVIDERS,
             { provide: AlfrescoSettingsService, useClass: AlfrescoSettingsServiceMock },
             { provide: AlfrescoAuthenticationService, useClass: AlfrescoAuthenticationService },
-            { provide: UploadService, useClass: MockUploadService }
+            UploadService
         ];
     });
 
@@ -82,23 +56,6 @@ describe('AlfrescoUploadService', () => {
         jasmine.Ajax.uninstall();
     });
 
-    it('should show the default option if no method setOption is called', () => {
-        let empty = {};
-        service.setOptions(empty);
-        expect(service.getUrl()).toEqual('/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children');
-        let formFields: Object = {};
-        expect(service.getFormFields()).toEqual(formFields);
-    });
-
-    it('should show the option passed as input', () => {
-        service.setOptions(options);
-        expect(service.getUrl()).toEqual('/some/cool/url');
-        expect(service.getFormFields()).toEqual({
-            siteid: 'fakeSite',
-            containerid: 'fakeFolder'
-        });
-    });
-
     it('should return an empty queue if no elements are added', () => {
         service.setOptions(options);
         expect(service.getQueue().length).toEqual(0);
@@ -118,73 +75,115 @@ describe('AlfrescoUploadService', () => {
         expect(service.getQueue().length).toEqual(2);
     });
 
-    it('should make XHR done request after the file is added in the queue', () => {
+    it('should make XHR done request after the file is added in the queue', (done) => {
+        let emitter = new EventEmitter();
+
+        emitter.subscribe(e => {
+            expect(e.value).toBe('File uploaded');
+            done();
+        });
         service.setOptions(options);
         let filesFake = [{name: 'fake-name', size: 10}];
         service.addToQueue(filesFake);
-        service.uploadFilesInTheQueue('', null);
+        service.uploadFilesInTheQueue('fake-dir', emitter);
 
         let request = jasmine.Ajax.requests.mostRecent();
-        expect(request.url).toBe('fakehost/some/cool/url');
+        expect(request.url).toBe('fakehost/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children');
         expect(request.method).toBe('POST');
-        // expect(request.data()).toEqual({fileName: 'fake-name.png'});
 
-        expect(doneFn).not.toHaveBeenCalled();
         jasmine.Ajax.requests.mostRecent().respondWith({
             'status': 200,
             contentType: 'text/plain',
             responseText: 'File uploaded'
         });
-        expect(doneFn).toHaveBeenCalledWith('File uploaded');
     });
 
-    it('should make XHR error request after an error occur', () => {
+    it('should make XHR error request after an error occur', (done) => {
+        let emitter = new EventEmitter();
+
+        emitter.subscribe(e => {
+            expect(e.value).toBe('Error file uploaded');
+            done();
+        });
         service.setOptions(options);
         let filesFake = [{name: 'fake-name', size: 10}];
         service.addToQueue(filesFake);
-        service.uploadFilesInTheQueue('', null);
+        service.uploadFilesInTheQueue('', emitter);
-        expect(jasmine.Ajax.requests.mostRecent().url).toBe('fakehost/some/cool/url');
+        expect(jasmine.Ajax.requests.mostRecent().url)
+            .toBe('fakehost/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children');
         jasmine.Ajax.requests.mostRecent().respondWith({
             'status': 404,
             contentType: 'text/plain',
             responseText: 'Error file uploaded'
         });
-        expect(errorFn).toHaveBeenCalledWith('Error file uploaded');
     });
 
-    it('should make XHR abort request after the xhr abort is called', () => {
+    it('should make XHR abort request after the xhr abort is called', (done) => {
+        let emitter = new EventEmitter();
+
+        emitter.subscribe(e => {
+            expect(e.value).toEqual('File aborted');
+            done();
+        });
         service.setOptions(options);
         let filesFake = [{name: 'fake-name', size: 10}];
         service.addToQueue(filesFake);
-        service.uploadFilesInTheQueue('', null);
+        service.uploadFilesInTheQueue('', emitter);
+
         let file = service.getQueue();
-        file[0].setAbort();
+        file[0].emitAbort();
-        expect(file[0]._xmlHttpRequest.abort).toHaveBeenCalled();
     });
 
-    it('should make XHR done request after the file is upload', () => {
+    it('should make XHR error request after the xhr error is called', (done) => {
+        let emitter = new EventEmitter();
+
+        emitter.subscribe(e => {
+            expect(e.value).toBe('Error file uploaded');
+            done();
+        });
         service.setOptions(options);
-        let filesFake = {name: 'fake-name', size: 10};
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        service.uploadFilesInTheQueue('', emitter);
 
-        let uploadingFileModel = new FileModel(filesFake);
+        let file = service.getQueue();
-        service.uploadFile(uploadingFileModel, '', null);
+        file[0].emitError();
-
-        expect(jasmine.Ajax.requests.mostRecent().url).toBe('fakehost/some/cool/url');
-        jasmine.Ajax.requests.mostRecent().respondWith({
-            'status': 200,
-            contentType: 'text/plain',
-            responseText: 'Single File uploaded'
     });
-        expect(doneFn).toHaveBeenCalledWith('Single File uploaded');
+
+    it('should make XHR progress request after the onprogress is called', (done) => {
+        service.setOptions(options);
+        let fakeProgress = {
+            loaded: 500,
+            total: 1234,
+            percent: 44
+        };
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        service.filesUpload$.subscribe( (file) => {
+            expect(file).toBeDefined();
+            expect(file[0]).toBeDefined();
+            expect(file[0].progress).toEqual(fakeProgress);
+            done();
+        });
+        service.uploadFilesInTheQueue('', null);
+
+        let file = service.getQueue();
+
+        file[0].emitProgres(fakeProgress);
     });
 
     it('should make XHR done request after the folder is created', (done)  => {
         let fakeRest = {
             entry: {
                 isFile: false,
-                isFolder: true
+                isFolder: true,
+                name: 'fake-folder'
             }
         };
+        let fakePromise = new Promise(function (resolve, reject) {
+            resolve(fakeRest);
+        });
+        spyOn(service, 'callApiCreateFolder').and.returnValue(fakePromise);
         service.setOptions(options);
         let defaultPath = '';
         let folderName = 'fake-folder';
@@ -204,6 +203,10 @@ describe('AlfrescoUploadService', () => {
                 }
             }
         };
+        let fakePromise = new Promise(function (resolve, reject) {
+            reject(fakeRest);
+        });
+        spyOn(service, 'callApiCreateFolder').and.returnValue(fakePromise);
         service.setOptions(options);
         let defaultPath = '';
         let folderName = 'folder-duplicate-fake';

ng2-components/ng2-alfresco-upload/src/services/upload.service.ts

@@ -56,15 +56,6 @@ export class UploadService {
         this.formFields = options.formFields != null ? options.formFields : this.formFields;
     }
 
-
-    /**
-     * Get the form fields
-     * @returns {Object}
-     */
-    public getFormFields(): Object {
-        return this.formFields;
-    }
-
     /**
      * Add files to the uploading queue to be uploaded.
      *
@@ -96,13 +87,13 @@ export class UploadService {
             return !uploadingFileModel.uploading && !uploadingFileModel.done && !uploadingFileModel.abort && !uploadingFileModel.error;
         });
 
-        filesToUpload.forEach((uploadingFileModel) => {
+        filesToUpload.forEach((uploadingFileModel: FileModel) => {
             uploadingFileModel.setUploading();
 
             let _filesUploadObserverProgressBar = this.filesUploadObserverProgressBar;
             let _queue = this.queue;
 
-            this.authService.getAlfrescoApi().
+            let promiseUpload = this.authService.getAlfrescoApi().
                 upload.uploadFile(uploadingFileModel.file, directory)
                 .on('progress', (progress: any) => {
                     uploadingFileModel.setProgres(progress);
@@ -112,9 +103,15 @@ export class UploadService {
                 })
                 .on('abort', () => {
                     uploadingFileModel.setAbort();
+                    elementEmit.emit({
+                        value: 'File aborted'
+                    });
                 })
                 .on('error', () => {
                     uploadingFileModel.setError();
+                    elementEmit.emit({
+                        value: 'Error file uploaded'
+                    });
                 })
                 .on('success', (data: any) => {
                     elementEmit.emit({
@@ -133,6 +130,8 @@ export class UploadService {
                         }
                     }
                 });
+
+            uploadingFileModel.setPromiseUpload(promiseUpload);
         });
     }
 
@@ -159,7 +158,7 @@ export class UploadService {
      * @param name - the folder name
      */
     createFolder(relativePath: string, name: string) {
-        return Observable.fromPromise(this.authService.getAlfrescoApi().node.createFolder(name, relativePath))
+        return Observable.fromPromise(this.callApiCreateFolder(relativePath, name))
             .map(res => {
                 return res;
             })
@@ -167,6 +166,10 @@ export class UploadService {
             .catch(this.handleError);
     }
 
+    private callApiCreateFolder(relativePath: string, name: string) {
+        return this.authService.getAlfrescoApi().node.createFolder(name, relativePath);
+    }
+
     /**
      * Throw the error
      * @param error