Single naming convention for core services (#1363)

* remove temporary file from repo

* fix: alfresco-api.service

* new: auth.service.ts

- new auth.service.ts implementation
- deprecation warning for AlfrescoAuthenticationService
- fix ‘clean-build’ typo
- extra vscode settings for ‘.d.ts’ files

* use AuthService internally

* new: content.service.ts

- deprecation warning for AlfrescoContentService
- use new ContentService internally

* new: settings.service.ts

- new SettingsService
- deprecation warning for AlfrescoSettingsService
- using new SettingsService internally

* new: translate.service and translate-loader.service

- custom TranslateLoader becomes AlfrescoTranslateLoader
- custom TranslateService becomes AlfrescoTranslateService
- deprecation notices for old service and loader implementations

* fix: document list

* fix: search

* fix: tag

also fixes #1364

* fix: activiti form

* fix: activiti tasklist, improve unit tests

* fix: activiti processlist, unit tests improvements

* fix: diagram component

* fix: analytics component

* fix: upload component

- fix numerous issues with unit tests (hidden by ‘any’ type)
- test improvements

* fix: webscript

* fix: userinfo unit tests

* code fixes

* fix 'beforeAll' issue

* tasklist unit testing improvements

* fix: form unit tests

* fix: unit tests

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

@@ -15,42 +15,33 @@
  * limitations under the License.
  */
 
+import { DebugElement } from '@angular/core';
 import { ComponentFixture, TestBed, async } from '@angular/core/testing';
+import { CoreModule } from 'ng2-alfresco-core';
 import { FileUploadingDialogComponent } from './file-uploading-dialog.component';
 import { FileUploadingListComponent } from './file-uploading-list.component';
-import { DebugElement, ReflectiveInjector }    from '@angular/core';
-import {
-    AlfrescoAuthenticationService,
-    AlfrescoSettingsService,
-    AlfrescoApiService,
-    CoreModule
-} from 'ng2-alfresco-core';
 import { UploadService } from '../services/upload.service';
 import { FileModel } from '../models/file.model';
 
-describe('Test ng2-alfresco-upload FileUploadDialog', () => {
+describe('FileUploadingDialogComponent', () => {
 
-    let injector;
-    let component: any;
+    let component: FileUploadingDialogComponent;
     let fixture: ComponentFixture<FileUploadingDialogComponent>;
     let debug: DebugElement;
     let element: any;
     let file: FileModel;
+    let uploadService: UploadService;
 
     beforeEach(async(() => {
-        injector = ReflectiveInjector.resolveAndCreate([
-            UploadService
-        ]);
-
         TestBed.configureTestingModule({
             imports: [
-                CoreModule
+                CoreModule.forRoot()
+            ],
+            declarations: [
+                FileUploadingDialogComponent,
+                FileUploadingListComponent
             ],
-            declarations: [FileUploadingDialogComponent, FileUploadingListComponent],
             providers: [
-                AlfrescoSettingsService,
-                AlfrescoAuthenticationService,
-                AlfrescoApiService,
                 UploadService
             ]
         }).compileComponents();
@@ -66,6 +57,7 @@ describe('Test ng2-alfresco-upload FileUploadDialog', () => {
         file = new FileModel(fileFake);
 
         fixture = TestBed.createComponent(FileUploadingDialogComponent);
+        uploadService = TestBed.get(UploadService);
 
         debug = fixture.debugElement;
         element = fixture.nativeElement;
@@ -81,14 +73,14 @@ describe('Test ng2-alfresco-upload FileUploadDialog', () => {
     });
 
     it('should render completed upload 1 when an element is added to Observer', () => {
-        component._uploaderService.updateFileCounterStream(1);
+        uploadService.updateFileCounterStream(1);
         fixture.detectChanges();
 
         expect(element.querySelector('#total-upload-completed').innerText).toEqual('1');
     });
 
     it('should render dialog box with css class show when an element is added to Observer', () => {
-        component._uploaderService.addToQueue([file]);
+        uploadService.addToQueue([file]);
         component.filesUploadingList = [file];
 
         fixture.detectChanges();

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

@@ -17,7 +17,7 @@
 
 import { Component, ChangeDetectorRef, OnInit, OnDestroy } from '@angular/core';
 import { FileModel } from '../models/file.model';
-import { AlfrescoTranslationService } from 'ng2-alfresco-core';
+import { AlfrescoTranslateService } from 'ng2-alfresco-core';
 import { UploadService } from '../services/upload.service';
 
 /**
@@ -52,14 +52,16 @@ export class FileUploadingDialogComponent implements OnInit, OnDestroy {
     private counterSubscription: any;
 
     constructor(private cd: ChangeDetectorRef,
-                translate: AlfrescoTranslationService,
-                private _uploaderService: UploadService) {
-        translate.addTranslationFolder('ng2-alfresco-upload', 'node_modules/ng2-alfresco-upload/src');
+                translateService: AlfrescoTranslateService,
+                private uploadService: UploadService) {
+        if (translateService) {
+            translateService.addTranslationFolder('ng2-alfresco-upload', 'node_modules/ng2-alfresco-upload/src');
+        }
     }
 
     ngOnInit() {
-        if (this._uploaderService.filesUpload$) {
-            this.listSubscription = this._uploaderService.filesUpload$.subscribe((fileList: FileModel[]) => {
+        if (this.uploadService.filesUpload$) {
+            this.listSubscription = this.uploadService.filesUpload$.subscribe((fileList: FileModel[]) => {
                 this.filesUploadingList = fileList;
                 if (this.filesUploadingList.length > 0) {
                     this.isDialogActive = true;
@@ -67,8 +69,8 @@ export class FileUploadingDialogComponent implements OnInit, OnDestroy {
                 }
             });
         }
-        if (this._uploaderService.totalCompleted$) {
-            this.counterSubscription = this._uploaderService.totalCompleted$.subscribe((total: number) => {
+        if (this.uploadService.totalCompleted$) {
+            this.counterSubscription = this.uploadService.totalCompleted$.subscribe((total: number) => {
                 this.totalCompleted = total;
                 this.cd.detectChanges();
             });

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

@@ -40,7 +40,6 @@ export class FileUploadingListComponent {
     filesUploadingList: FileModel [];
 
     constructor(public el: ElementRef) {
-        console.log('filesUploadingList constructor', el);
     }
 
     /**

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

@@ -18,17 +18,11 @@
 import { ComponentFixture, TestBed, async } from '@angular/core/testing';
 import { UploadButtonComponent } from './upload-button.component';
 import { DebugElement }    from '@angular/core';
-import {
-    AlfrescoAuthenticationService,
-    AlfrescoSettingsService,
-    AlfrescoApiService,
-    CoreModule,
-    AlfrescoTranslationService
-} from 'ng2-alfresco-core';
+import { CoreModule, AlfrescoTranslateService } from 'ng2-alfresco-core';
 import { TranslationMock } from '../assets/translation.service.mock';
 import { UploadService } from '../services/upload.service';
 
-describe('Test ng2-alfresco-upload UploadButton', () => {
+describe('UploadButtonComponent', () => {
 
     let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
     let fakeEvent = {
@@ -63,23 +57,23 @@ describe('Test ng2-alfresco-upload UploadButton', () => {
         reject(fakeRejectRest);
     });
 
-    let component: any;
+    let component: UploadButtonComponent;
     let fixture: ComponentFixture<UploadButtonComponent>;
     let debug: DebugElement;
     let element: HTMLElement;
+    let uploadService: UploadService;
 
     beforeEach(async(() => {
         TestBed.configureTestingModule({
             imports: [
-                CoreModule
+                CoreModule.forRoot()
+            ],
+            declarations: [
+                UploadButtonComponent
             ],
-            declarations: [UploadButtonComponent],
             providers: [
-                AlfrescoSettingsService,
-                AlfrescoAuthenticationService,
-                AlfrescoApiService,
                 UploadService,
-                { provide: AlfrescoTranslationService, useClass: TranslationMock }
+                { provide: AlfrescoTranslateService, useClass: TranslationMock }
             ]
         }).compileComponents();
     }));
@@ -88,6 +82,7 @@ describe('Test ng2-alfresco-upload UploadButton', () => {
         window['componentHandler'] = null;
 
         fixture = TestBed.createComponent(UploadButtonComponent);
+        uploadService = TestBed.get(UploadService);
 
         debug = fixture.debugElement;
         element = fixture.nativeElement;
@@ -115,7 +110,7 @@ describe('Test ng2-alfresco-upload UploadButton', () => {
     });
 
     it('should render an uploadFolder button if uploadFolder is true', () => {
-        component.uploadFolder = true;
+        component.uploadFolders = true;
         let compiled = fixture.debugElement.nativeElement;
         fixture.detectChanges();
         expect(compiled.querySelector('#uploadFolder')).toBeDefined();
@@ -124,31 +119,31 @@ describe('Test ng2-alfresco-upload UploadButton', () => {
     it('should call uploadFile with the default root folder', () => {
         component.currentFolderPath = '/root-fake-/sites-fake/folder-fake';
         component.onSuccess = null;
-        component._uploaderService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
+        uploadService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
 
         fixture.detectChanges();
 
         component.onFilesAdded(fakeEvent);
-        expect(component._uploaderService.uploadFilesInTheQueue).toHaveBeenCalledWith('-root-', '/root-fake-/sites-fake/folder-fake', null);
+        expect(uploadService.uploadFilesInTheQueue).toHaveBeenCalledWith('-root-', '/root-fake-/sites-fake/folder-fake', null);
     });
 
     it('should call uploadFile with a custom root folder', () => {
         component.currentFolderPath = '/root-fake-/sites-fake/folder-fake';
         component.rootFolderId = '-my-';
         component.onSuccess = null;
-        component._uploaderService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
+        uploadService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
 
         fixture.detectChanges();
 
         component.onFilesAdded(fakeEvent);
-        expect(component._uploaderService.uploadFilesInTheQueue).toHaveBeenCalledWith('-my-', '/root-fake-/sites-fake/folder-fake', null);
+        expect(uploadService.uploadFilesInTheQueue).toHaveBeenCalledWith('-my-', '/root-fake-/sites-fake/folder-fake', null);
     });
 
     it('should create a folder and emit an File uploaded event', (done) => {
         component.currentFolderPath = '/fake-root-path';
         fixture.detectChanges();
 
-        spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakeResolvePromise);
+        spyOn(uploadService, 'callApiCreateFolder').and.returnValue(fakeResolvePromise);
 
         component.onSuccess.subscribe(e => {
             expect(e.value).toEqual('File uploaded');
@@ -165,7 +160,7 @@ describe('Test ng2-alfresco-upload UploadButton', () => {
     });
 
     it('should emit an onError event when the folder already exist', (done) => {
-        spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakeRejectPromise);
+        spyOn(uploadService, 'callApiCreateFolder').and.returnValue(fakeRejectPromise);
         component.onError.subscribe(e => {
             expect(e.value).toEqual('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
             done();

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

@@ -16,10 +16,10 @@
  */
 
 import { Component, ViewChild, ElementRef, Input, Output, EventEmitter } from '@angular/core';
+import 'rxjs/Rx';
+import { AlfrescoTranslateService } from 'ng2-alfresco-core';
 import { UploadService } from '../services/upload.service';
 import { FileModel } from '../models/file.model';
-import { AlfrescoTranslationService } from 'ng2-alfresco-core';
-import 'rxjs/Rx';
 
 declare let componentHandler: any;
 
@@ -88,16 +88,17 @@ export class UploadButtonComponent {
     @Output()
     createFolder = new EventEmitter();
 
-    translate: AlfrescoTranslationService;
-
-    constructor(public el: ElementRef, private _uploaderService: UploadService, translate: AlfrescoTranslationService) {
-        this.translate = translate;
-        translate.addTranslationFolder('ng2-alfresco-upload', 'node_modules/ng2-alfresco-upload/src');
+    constructor(public el: ElementRef,
+                private uploadService: UploadService,
+                private translateService: AlfrescoTranslateService) {
+        if (translateService) {
+            translateService.addTranslationFolder('ng2-alfresco-upload', 'node_modules/ng2-alfresco-upload/src');
+        }
     }
 
     ngOnChanges(changes) {
         let formFields = this.createFormFields();
-        this._uploaderService.setOptions(formFields, this.versioning);
+        this.uploadService.setOptions(formFields, this.versioning);
     }
 
     /**
@@ -125,7 +126,7 @@ export class UploadButtonComponent {
             let directoryName = this.getDirectoryName(directoryPath);
             let absolutePath = this.currentFolderPath + this.getDirectoryPath(directoryPath);
 
-            this._uploaderService.createFolder(absolutePath, directoryName)
+            this.uploadService.createFolder(absolutePath, directoryName)
                 .subscribe(
                     res => {
                         let relativeDir = this.currentFolderPath + '/' + directoryPath;
@@ -155,8 +156,8 @@ export class UploadButtonComponent {
      */
     private uploadFiles(path: string, files: any[]) {
         if (files.length) {
-            let latestFilesAdded = this._uploaderService.addToQueue(files);
-            this._uploaderService.uploadFilesInTheQueue(this.rootFolderId, path, this.onSuccess);
+            let latestFilesAdded = this.uploadService.addToQueue(files);
+            this.uploadService.uploadFilesInTheQueue(this.rootFolderId, path, this.onSuccess);
             if (this.showUdoNotificationBar) {
                 this._showUndoNotificationBar(latestFilesAdded);
             }
@@ -220,8 +221,8 @@ export class UploadButtonComponent {
         }
 
         let messageTranslate: any, actionTranslate: any;
-        messageTranslate = this.translate.get('FILE_UPLOAD.MESSAGES.PROGRESS');
-        actionTranslate = this.translate.get('FILE_UPLOAD.ACTION.UNDO');
+        messageTranslate = this.translateService.get('FILE_UPLOAD.MESSAGES.PROGRESS');
+        actionTranslate = this.translateService.get('FILE_UPLOAD.ACTION.UNDO');
 
         if (this.undoNotificationBar.nativeElement.MaterialSnackbar) {
             this.undoNotificationBar.nativeElement.MaterialSnackbar.showSnackbar({
@@ -245,7 +246,7 @@ export class UploadButtonComponent {
     private getErrorMessage(response: any): string {
         if (response.body && response.body.error.statusCode === ERROR_FOLDER_ALREADY_EXIST) {
             let errorMessage: any;
-            errorMessage = this.translate.get('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
+            errorMessage = this.translateService.get('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
             return errorMessage.value;
         }
     }

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

@@ -16,44 +16,40 @@
  */
 
 import { ComponentFixture, TestBed, async } from '@angular/core/testing';
-import { UploadDragAreaComponent } from './upload-drag-area.component';
+import { EventEmitter } from '@angular/core';
 import { DebugElement }    from '@angular/core';
-import {
-    AlfrescoAuthenticationService,
-    AlfrescoSettingsService,
-    AlfrescoApiService,
-    AlfrescoTranslationService,
-    CoreModule
-} from 'ng2-alfresco-core';
+import { AlfrescoTranslateService, CoreModule } from 'ng2-alfresco-core';
+
+import { UploadDragAreaComponent } from './upload-drag-area.component';
 import { TranslationMock } from '../assets/translation.service.mock';
 import { UploadService } from '../services/upload.service';
-import { EventEmitter } from '@angular/core';
 
-describe('Test ng2-alfresco-upload UploadDragArea', () => {
+describe('UploadDragAreaComponent', () => {
 
-    let component: any;
+    let component: UploadDragAreaComponent;
     let fixture: ComponentFixture<UploadDragAreaComponent>;
     let debug: DebugElement;
     let element: HTMLElement;
+    let uploadService: UploadService;
 
     beforeEach(async(() => {
         TestBed.configureTestingModule({
             imports: [
-                CoreModule
+                CoreModule.forRoot()
+            ],
+            declarations: [
+                UploadDragAreaComponent
             ],
-            declarations: [UploadDragAreaComponent],
             providers: [
-                AlfrescoSettingsService,
-                AlfrescoAuthenticationService,
-                AlfrescoApiService,
                 UploadService,
-                { provide: AlfrescoTranslationService, useClass: TranslationMock }
+                { provide: AlfrescoTranslateService, useClass: TranslationMock }
             ]
         }).compileComponents();
     }));
 
     beforeEach(() => {
         fixture = TestBed.createComponent(UploadDragAreaComponent);
+        uploadService = TestBed.get(UploadService);
 
         debug = fixture.debugElement;
         element = fixture.nativeElement;
@@ -77,45 +73,45 @@ describe('Test ng2-alfresco-upload UploadDragArea', () => {
     });
 
     it('should show an folder non supported error in the notification bar when the file type is empty', () => {
-        component._showErrorNotificationBar = jasmine.createSpy('_showErrorNotificationBar');
+        component.showErrorNotificationBar = jasmine.createSpy('_showErrorNotificationBar');
         component.showUdoNotificationBar = true;
 
         let fileFake = new File([''], 'folder-fake', {type: ''});
         component.onFilesDropped([fileFake]);
 
-        expect(component._showErrorNotificationBar).toHaveBeenCalledWith('FILE_UPLOAD.MESSAGES.FOLDER_NOT_SUPPORTED');
+        expect(component.showErrorNotificationBar).toHaveBeenCalledWith('FILE_UPLOAD.MESSAGES.FOLDER_NOT_SUPPORTED');
     });
 
     it('should upload the list of files dropped', () => {
         component.currentFolderPath = '/root-fake-/sites-fake/folder-fake';
         component.onSuccess = null;
         component.showUdoNotificationBar = false;
-        component._uploaderService.addToQueue = jasmine.createSpy('addToQueue');
-        component._uploaderService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
+        uploadService.addToQueue = jasmine.createSpy('addToQueue');
+        uploadService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
 
         fixture.detectChanges();
-        let fileFake = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
+        let fileFake = <File> {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
         let filesList = [fileFake];
 
         component.onFilesDropped(filesList);
-        expect(component._uploaderService.addToQueue).toHaveBeenCalledWith(filesList);
-        expect(component._uploaderService.uploadFilesInTheQueue).toHaveBeenCalledWith('-root-', '/root-fake-/sites-fake/folder-fake', null);
+        expect(uploadService.addToQueue).toHaveBeenCalledWith(filesList);
+        expect(uploadService.uploadFilesInTheQueue).toHaveBeenCalledWith('-root-', '/root-fake-/sites-fake/folder-fake', null);
     });
 
     it('should show the loading messages in the notification bar when the files are dropped', () => {
         component.currentFolderPath = '/root-fake-/sites-fake/folder-fake';
         component.onSuccess = null;
         component.showUdoNotificationBar = true;
-        component._uploaderService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
-        component._showUndoNotificationBar = jasmine.createSpy('_showUndoNotificationBar');
+        uploadService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
+        component.showUndoNotificationBar = jasmine.createSpy('_showUndoNotificationBar');
 
         fixture.detectChanges();
-        let fileFake = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
+        let fileFake = <File> {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
         let filesList = [fileFake];
 
         component.onFilesDropped(filesList);
-        expect(component._uploaderService.uploadFilesInTheQueue).toHaveBeenCalledWith('-root-', '/root-fake-/sites-fake/folder-fake', null);
-        expect(component._showUndoNotificationBar).toHaveBeenCalled();
+        expect(uploadService.uploadFilesInTheQueue).toHaveBeenCalledWith('-root-', '/root-fake-/sites-fake/folder-fake', null);
+        expect(component.showUndoNotificationBar).toHaveBeenCalled();
     });
 
     it('should upload a file when dropped', () => {
@@ -123,7 +119,7 @@ describe('Test ng2-alfresco-upload UploadDragArea', () => {
         component.onSuccess = null;
 
         fixture.detectChanges();
-        spyOn(component._uploaderService, 'uploadFilesInTheQueue');
+        spyOn(uploadService, 'uploadFilesInTheQueue');
 
         let itemEntity = {
             fullPath: '/folder-fake/file-fake.png',
@@ -137,7 +133,7 @@ describe('Test ng2-alfresco-upload UploadDragArea', () => {
         };
 
         component.onFilesEntityDropped(itemEntity);
-        expect(component._uploaderService.uploadFilesInTheQueue)
+        expect(uploadService.uploadFilesInTheQueue)
             .toHaveBeenCalledWith('-root-', '/root-fake-/sites-fake/document-library-fake/folder-fake/', null);
     });
 
@@ -147,7 +143,7 @@ describe('Test ng2-alfresco-upload UploadDragArea', () => {
         component.onSuccess = null;
 
         fixture.detectChanges();
-        spyOn(component._uploaderService, 'uploadFilesInTheQueue');
+        spyOn(uploadService, 'uploadFilesInTheQueue');
 
         let itemEntity = {
             fullPath: '/folder-fake/file-fake.png',
@@ -161,7 +157,7 @@ describe('Test ng2-alfresco-upload UploadDragArea', () => {
         };
 
         component.onFilesEntityDropped(itemEntity);
-        expect(component._uploaderService.uploadFilesInTheQueue)
+        expect(uploadService.uploadFilesInTheQueue)
             .toHaveBeenCalledWith('-my-', '/root-fake-/sites-fake/document-library-fake/folder-fake/', null);
     });
 
@@ -182,9 +178,9 @@ describe('Test ng2-alfresco-upload UploadDragArea', () => {
         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');
+        spyOn(uploadService, 'callApiCreateFolder').and.returnValue(fakePromise);
+        spyOn(component, 'showErrorNotificationBar').and.callFake( () => {
+            expect(component.showErrorNotificationBar).toHaveBeenCalledWith('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
             done();
         });
 
@@ -225,13 +221,13 @@ describe('Test ng2-alfresco-upload UploadDragArea', () => {
         let fakePromise = new Promise(function (resolve, reject) {
             resolve(fakeRest);
         });
-        spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakePromise);
+        spyOn(uploadService, 'callApiCreateFolder').and.returnValue(fakePromise);
         spyOn(component, 'onFilesEntityDropped').and.callFake( () => {
             expect(component.onFilesEntityDropped).toHaveBeenCalledWith(itemEntity);
         });
 
-        spyOn(component, '_showUndoNotificationBar').and.callFake( () => {
-            expect(component._showUndoNotificationBar).toHaveBeenCalled();
+        spyOn(component, 'showUndoNotificationBar').and.callFake( () => {
+            expect(component.showUndoNotificationBar).toHaveBeenCalled();
             done();
         });
 

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

@@ -17,7 +17,7 @@
 
 import { Component, ViewChild, Input, Output, EventEmitter } from '@angular/core';
 import { UploadService } from '../services/upload.service';
-import { AlfrescoTranslationService } from 'ng2-alfresco-core';
+import { AlfrescoTranslateService } from 'ng2-alfresco-core';
 import { FileModel } from '../models/file.model';
 
 declare let componentHandler: any;
@@ -61,16 +61,16 @@ export class UploadDragAreaComponent {
     @Output()
     onSuccess = new EventEmitter();
 
-    translate: AlfrescoTranslationService;
-
-    constructor(private _uploaderService: UploadService, translate: AlfrescoTranslationService) {
-        this.translate = translate;
-        translate.addTranslationFolder('ng2-alfresco-upload', 'node_modules/ng2-alfresco-upload/src');
+    constructor(private uploadService: UploadService,
+                private translateService: AlfrescoTranslateService) {
+        if (translateService) {
+            translateService.addTranslationFolder('ng2-alfresco-upload', 'node_modules/ng2-alfresco-upload/src');
+        }
     }
 
     ngOnChanges(changes) {
         let formFields = this.createFormFields();
-        this._uploaderService.setOptions(formFields, this.versioning);
+        this.uploadService.setOptions(formFields, this.versioning);
     }
 
     /**
@@ -81,17 +81,17 @@ export class UploadDragAreaComponent {
     onFilesDropped(files: File[]): void {
         if (files.length) {
             if (this.checkValidity(files)) {
-                this._uploaderService.addToQueue(files);
-                this._uploaderService.uploadFilesInTheQueue(this.rootFolderId, this.currentFolderPath, this.onSuccess);
-                let latestFilesAdded = this._uploaderService.getQueue();
+                this.uploadService.addToQueue(files);
+                this.uploadService.uploadFilesInTheQueue(this.rootFolderId, this.currentFolderPath, this.onSuccess);
+                let latestFilesAdded = this.uploadService.getQueue();
                 if (this.showUdoNotificationBar) {
-                    this._showUndoNotificationBar(latestFilesAdded);
+                    this.showUndoNotificationBar(latestFilesAdded);
                 }
             } else {
                 let errorMessage: any;
-                errorMessage = this.translate.get('FILE_UPLOAD.MESSAGES.FOLDER_NOT_SUPPORTED');
+                errorMessage = this.translateService.get('FILE_UPLOAD.MESSAGES.FOLDER_NOT_SUPPORTED');
                 if (this.showUdoNotificationBar) {
-                    this._showErrorNotificationBar(errorMessage.value);
+                    this.showErrorNotificationBar(errorMessage.value);
                 } else {
                     console.error(errorMessage.value);
                 }
@@ -117,10 +117,10 @@ export class UploadDragAreaComponent {
      */
     onFilesEntityDropped(item: any): void {
         item.file( (file: any) => {
-            this._uploaderService.addToQueue([file]);
+            this.uploadService.addToQueue([file]);
             let path = item.fullPath.replace(item.name, '');
             let filePath = this.currentFolderPath + path;
-            this._uploaderService.uploadFilesInTheQueue(this.rootFolderId, filePath, this.onSuccess);
+            this.uploadService.uploadFilesInTheQueue(this.rootFolderId, filePath, this.onSuccess);
         });
     }
 
@@ -133,7 +133,7 @@ export class UploadDragAreaComponent {
             let relativePath = folder.fullPath.replace(folder.name, '');
             relativePath = this.currentFolderPath + relativePath;
 
-            this._uploaderService.createFolder(relativePath, folder.name)
+            this.uploadService.createFolder(relativePath, folder.name)
                 .subscribe(
                     message => {
                         this.onSuccess.emit({
@@ -145,8 +145,8 @@ export class UploadDragAreaComponent {
                                 this._traverseFileTree(entries[i]);
                             }
                             if (this.showUdoNotificationBar) {
-                                let latestFilesAdded = this._uploaderService.getQueue();
-                                this._showUndoNotificationBar(latestFilesAdded);
+                                let latestFilesAdded = this.uploadService.getQueue();
+                                this.showUndoNotificationBar(latestFilesAdded);
                             }
                         });
                     },
@@ -154,7 +154,7 @@ export class UploadDragAreaComponent {
                         let errorMessagePlaceholder = this.getErrorMessage(error.response);
                         let errorMessage = this.formatString(errorMessagePlaceholder, [folder.name]);
                         if (this.showUdoNotificationBar) {
-                            this._showErrorNotificationBar(errorMessage);
+                            this.showErrorNotificationBar(errorMessage);
                         } else {
                             console.error(errorMessage);
                         }
@@ -184,14 +184,14 @@ export class UploadDragAreaComponent {
      *
      * @param {FileModel[]} latestFilesAdded - files in the upload queue enriched with status flag and xhr object.
      */
-    private _showUndoNotificationBar(latestFilesAdded: FileModel[]) {
+    showUndoNotificationBar(latestFilesAdded: FileModel[]) {
         if (componentHandler) {
             componentHandler.upgradeAllRegistered();
         }
 
         let messageTranslate: any, actionTranslate: any;
-        messageTranslate = this.translate.get('FILE_UPLOAD.MESSAGES.PROGRESS');
-        actionTranslate = this.translate.get('FILE_UPLOAD.ACTION.UNDO');
+        messageTranslate = this.translateService.get('FILE_UPLOAD.MESSAGES.PROGRESS');
+        actionTranslate = this.translateService.get('FILE_UPLOAD.ACTION.UNDO');
 
         this.undoNotificationBar.nativeElement.MaterialSnackbar.showSnackbar({
             message: messageTranslate.value,
@@ -210,7 +210,7 @@ export class UploadDragAreaComponent {
      * @param Error message
      * @private
      */
-    private _showErrorNotificationBar(errorMessage: string) {
+    showErrorNotificationBar(errorMessage: string) {
         if (componentHandler) {
             componentHandler.upgradeAllRegistered();
         }
@@ -229,7 +229,7 @@ export class UploadDragAreaComponent {
     private getErrorMessage(response: any): string {
         if (response.body.error.statusCode === ERROR_FOLDER_ALREADY_EXIST) {
             let errorMessage: any;
-            errorMessage = this.translate.get('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
+            errorMessage = this.translateService.get('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
             return errorMessage.value;
         }
     }

ng2-components/ng2-alfresco-upload/src/directives/file-draggable.directive.spec.ts

@@ -17,7 +17,7 @@
 
 import { FileDraggableDirective } from '../directives/file-draggable.directive';
 
-describe('Test ng2-alfresco-upload FileDraggableDirective', () => {
+describe('FileDraggableDirective', () => {
 
     let component;
 

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

@@ -15,22 +15,17 @@
  * limitations under the License.
  */
 
-import { ReflectiveInjector } from '@angular/core';
-import {
-    AlfrescoAuthenticationService,
-    AlfrescoSettingsService,
-    AlfrescoApiService
-} from 'ng2-alfresco-core';
-import { UploadService } from './upload.service';
 import { EventEmitter } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { CoreModule } from 'ng2-alfresco-core';
+import { UploadService } from './upload.service';
 
 declare let jasmine: any;
-declare let AlfrescoApi: any;
 
-describe('Test ng2-alfresco-upload', () => {
-    let service, injector, options;
+describe('UploadService', () => {
+    let service: UploadService;
 
-    options = {
+    let options = {
         host: 'fakehost',
         url: '/some/cool/url',
         baseUrlPath: 'fakebasepath',
@@ -41,224 +36,221 @@ describe('Test ng2-alfresco-upload', () => {
     };
 
     beforeEach(() => {
-        injector = ReflectiveInjector.resolveAndCreate([
-            AlfrescoSettingsService,
-            AlfrescoApiService,
-            AlfrescoAuthenticationService,
-            UploadService
-        ]);
+        TestBed.configureTestingModule({
+            imports: [
+                CoreModule.forRoot()
+            ],
+            providers: [
+                UploadService
+            ]
+        });
+        service = TestBed.get(UploadService);
+        jasmine.Ajax.install();
     });
-    describe('UploadService ', () => {
-        beforeEach(() => {
-            service = injector.get(UploadService);
-            service.apiService.setInstance(new AlfrescoApi({}));
-            jasmine.Ajax.install();
+
+    afterEach(() => {
+        jasmine.Ajax.uninstall();
+    });
+
+    it('should return an empty queue if no elements are added', () => {
+        service.setOptions(options, false);
+        expect(service.getQueue().length).toEqual(0);
+    });
+
+    it('should add an element in the queue and returns it', () => {
+        service.setOptions(options, false);
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        expect(service.getQueue().length).toEqual(1);
+    });
+
+    it('should add two elements in the queue and returns them', () => {
+        service.setOptions(options, false);
+        let filesFake = [{name: 'fake-name', size: 10}, {name: 'fake-name2', size: 20}];
+        service.addToQueue(filesFake);
+        expect(service.getQueue().length).toEqual(2);
+    });
+
+    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, false);
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        service.uploadFilesInTheQueue('-root-', 'fake-dir', emitter);
 
-        afterEach(() => {
-            jasmine.Ajax.uninstall();
+        let request = jasmine.Ajax.requests.mostRecent();
+        expect(request.url).toBe('http://localhost:8080/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children?autoRename=true');
+        expect(request.method).toBe('POST');
+
+        jasmine.Ajax.requests.mostRecent().respondWith({
+            'status': 200,
+            contentType: 'text/plain',
+            responseText: 'File uploaded'
         });
+    });
 
-        it('should return an empty queue if no elements are added', () => {
-            service.setOptions(options, false);
-            expect(service.getQueue().length).toEqual(0);
+    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, false);
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        service.uploadFilesInTheQueue('-root-', '', emitter);
+        expect(jasmine.Ajax.requests.mostRecent().url)
+            .toBe('http://localhost:8080/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children?autoRename=true');
 
-        it('should add an element in the queue and returns it', () => {
-            service.setOptions(options, false);
-            let filesFake = [{name: 'fake-name', size: 10}];
-            service.addToQueue(filesFake);
-            expect(service.getQueue().length).toEqual(1);
+        jasmine.Ajax.requests.mostRecent().respondWith({
+            'status': 404,
+            contentType: 'text/plain',
+            responseText: 'Error file uploaded'
         });
+    });
 
-        it('should add two elements in the queue and returns them', () => {
-            service.setOptions(options, false);
-            let filesFake = [{name: 'fake-name', size: 10}, {name: 'fake-name2', size: 20}];
-            service.addToQueue(filesFake);
-            expect(service.getQueue().length).toEqual(2);
+    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, false);
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        service.uploadFilesInTheQueue('-root-', '', emitter);
 
-        it('should make XHR done request after the file is added in the queue', (done) => {
-            let emitter = new EventEmitter();
+        let file = service.getQueue();
+        file[0].emitAbort();
+    });
 
-            emitter.subscribe(e => {
-                expect(e.value).toBe('File uploaded');
-                done();
-            });
-            service.setOptions(options, false);
-            let filesFake = [{name: 'fake-name', size: 10}];
-            service.addToQueue(filesFake);
-            service.uploadFilesInTheQueue('-root-', 'fake-dir', emitter);
+    it('should make XHR error request after the xhr error is called', (done) => {
+        let emitter = new EventEmitter();
 
-            let request = jasmine.Ajax.requests.mostRecent();
-            expect(request.url).toBe('http://127.0.0.1:8080/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children?autoRename=true');
-            expect(request.method).toBe('POST');
-
-            jasmine.Ajax.requests.mostRecent().respondWith({
-                'status': 200,
-                contentType: 'text/plain',
-                responseText: 'File uploaded'
-            });
+        emitter.subscribe(e => {
+            expect(e.value).toBe('Error file uploaded');
+            done();
         });
+        service.setOptions(options, false);
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        service.uploadFilesInTheQueue('-root-', '', emitter);
 
-        it('should make XHR error request after an error occur', (done) => {
-            let emitter = new EventEmitter();
+        let file = service.getQueue();
+        file[0].emitError();
+    });
 
-            emitter.subscribe(e => {
-                expect(e.value).toBe('Error file uploaded');
-                done();
-            });
-            service.setOptions(options, false);
-            let filesFake = [{name: 'fake-name', size: 10}];
-            service.addToQueue(filesFake);
-            service.uploadFilesInTheQueue('-root-', '', emitter);
-            expect(jasmine.Ajax.requests.mostRecent().url)
-                .toBe('http://127.0.0.1:8080/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children?autoRename=true');
-
-            jasmine.Ajax.requests.mostRecent().respondWith({
-                'status': 404,
-                contentType: 'text/plain',
-                responseText: 'Error file uploaded'
-            });
+    it('should make XHR progress request after the onprogress is called', (done) => {
+        service.setOptions(options, false);
+        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('-root-', '', null);
 
-        it('should make XHR abort request after the xhr abort is called', (done) => {
-            let emitter = new EventEmitter();
+        let file = service.getQueue();
 
-            emitter.subscribe(e => {
-                expect(e.value).toEqual('File aborted');
-                done();
-            });
-            service.setOptions(options, false);
-            let filesFake = [{name: 'fake-name', size: 10}];
-            service.addToQueue(filesFake);
-            service.uploadFilesInTheQueue('-root-', '', emitter);
+        file[0].emitProgres(fakeProgress);
+    });
 
-            let file = service.getQueue();
-            file[0].emitAbort();
+    it('should make XHR done request after the folder is created', (done) => {
+        let fakeRest = {
+            entry: {
+                isFile: false,
+                isFolder: true,
+                name: 'fake-folder'
+            }
+        };
+        let fakePromise = new Promise(function (resolve, reject) {
+            resolve(fakeRest);
         });
-
-        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, false);
-            let filesFake = [{name: 'fake-name', size: 10}];
-            service.addToQueue(filesFake);
-            service.uploadFilesInTheQueue('-root-', '', emitter);
-
-            let file = service.getQueue();
-            file[0].emitError();
+        spyOn(service, 'callApiCreateFolder').and.returnValue(fakePromise);
+        service.setOptions(options, false);
+        let defaultPath = '';
+        let folderName = 'fake-folder';
+        service.createFolder(defaultPath, folderName).subscribe(res => {
+            expect(res).toEqual(fakeRest);
+            done();
         });
+    });
 
-        it('should make XHR progress request after the onprogress is called', (done) => {
-            service.setOptions(options, false);
-            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('-root-', '', 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,
-                    name: 'fake-folder'
-                }
-            };
-            let fakePromise = new Promise(function (resolve, reject) {
-                resolve(fakeRest);
-            });
-            spyOn(service, 'callApiCreateFolder').and.returnValue(fakePromise);
-            service.setOptions(options, false);
-            let defaultPath = '';
-            let folderName = 'fake-folder';
-            service.createFolder(defaultPath, folderName).subscribe(res => {
-                expect(res).toEqual(fakeRest);
-                done();
-            });
-        });
-
-        it('should throws an exception when a folder already exist', (done) => {
-            let fakeRest = {
-                response: {
-                    body: {
-                        error: {
-                            statusCode: 409
-                        }
+    it('should throws an exception when a folder already exist', (done) => {
+        let fakeRest = {
+            response: {
+                body: {
+                    error: {
+                        statusCode: 409
                     }
                 }
-            };
-            let fakePromise = new Promise(function (resolve, reject) {
-                reject(fakeRest);
-            });
-            spyOn(service, 'callApiCreateFolder').and.returnValue(fakePromise);
-            service.setOptions(options, false);
-            let defaultPath = '';
-            let folderName = 'folder-duplicate-fake';
-            service.createFolder(defaultPath, folderName).subscribe(
-                res => {
-                },
-                error => {
-                    expect(error).toEqual(fakeRest);
-                    done();
-                }
-            );
+            }
+        };
+        let fakePromise = new Promise(function (resolve, reject) {
+            reject(fakeRest);
         });
-
-        it('If versioning is true autoRename should not be present and majorVersion should be a param', () => {
-            let emitter = new EventEmitter();
-
-            let enableVersioning = true;
-            service.setOptions(options, enableVersioning);
-            let filesFake = [{name: 'fake-name', size: 10}];
-            service.addToQueue(filesFake);
-            service.uploadFilesInTheQueue('-root-', '', emitter);
-
-            console.log(jasmine.Ajax.requests.mostRecent().url);
-            expect(jasmine.Ajax.requests.mostRecent().url.endsWith('autoRename=true')).toBe(false);
-            expect(jasmine.Ajax.requests.mostRecent().params.has('majorVersion')).toBe(true);
-        });
-
-        it('should use custom root folder ID given to the service', (done) => {
-            let emitter = new EventEmitter();
-
-            emitter.subscribe(e => {
-                expect(e.value).toBe('File uploaded');
+        spyOn(service, 'callApiCreateFolder').and.returnValue(fakePromise);
+        service.setOptions(options, false);
+        let defaultPath = '';
+        let folderName = 'folder-duplicate-fake';
+        service.createFolder(defaultPath, folderName).subscribe(
+            res => {
+            },
+            error => {
+                expect(error).toEqual(fakeRest);
                 done();
-            });
-            service.setOptions(options, false);
-            let filesFake = [{name: 'fake-name', size: 10}];
-            service.addToQueue(filesFake);
-            service.uploadFilesInTheQueue('123', 'fake-dir', emitter);
+            }
+        );
+    });
 
-            let request = jasmine.Ajax.requests.mostRecent();
-            expect(request.url).toBe('http://127.0.0.1:8080/alfresco/api/-default-/public/alfresco/versions/1/nodes/123/children?autoRename=true');
-            expect(request.method).toBe('POST');
+    it('If versioning is true autoRename should not be present and majorVersion should be a param', () => {
+        let emitter = new EventEmitter();
 
-            jasmine.Ajax.requests.mostRecent().respondWith({
-                'status': 200,
-                contentType: 'text/plain',
-                responseText: 'File uploaded'
-            });
+        let enableVersioning = true;
+        service.setOptions(options, enableVersioning);
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        service.uploadFilesInTheQueue('-root-', '', emitter);
+
+        console.log(jasmine.Ajax.requests.mostRecent().url);
+        expect(jasmine.Ajax.requests.mostRecent().url.endsWith('autoRename=true')).toBe(false);
+        expect(jasmine.Ajax.requests.mostRecent().params.has('majorVersion')).toBe(true);
+    });
+
+    it('should use custom root folder ID given to the service', (done) => {
+        let emitter = new EventEmitter();
+
+        emitter.subscribe(e => {
+            expect(e.value).toBe('File uploaded');
+            done();
+        });
+        service.setOptions(options, false);
+        let filesFake = [{name: 'fake-name', size: 10}];
+        service.addToQueue(filesFake);
+        service.uploadFilesInTheQueue('123', 'fake-dir', emitter);
+
+        let request = jasmine.Ajax.requests.mostRecent();
+        expect(request.url).toBe('http://localhost:8080/alfresco/api/-default-/public/alfresco/versions/1/nodes/123/children?autoRename=true');
+        expect(request.method).toBe('POST');
+
+        jasmine.Ajax.requests.mostRecent().respondWith({
+            'status': 200,
+            contentType: 'text/plain',
+            responseText: 'File uploaded'
         });
     });
 });

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

@@ -195,7 +195,7 @@ export class UploadService {
         }
     }
 
-    private updateFileCounterStream(total: number) {
+    updateFileCounterStream(total: number) {
         if (this.totalCompletedObserver) {
             this.totalCompletedObserver.next(total);
         }