diff --git a/.github/workflows/locale-test.yml b/.github/workflows/locale-test.yml
index cb4345fa..3079ab08 100644
--- a/.github/workflows/locale-test.yml
+++ b/.github/workflows/locale-test.yml
@@ -44,3 +44,9 @@ jobs:
         sudo apt-get install xvfb
         cd ./wowup-electron 
         xvfb-run --auto-servernum ng test --watch=false --include='src/locales.spec.ts'
+
+    - name: Run Test Suite
+      run: |
+        sudo apt-get install xvfb
+        cd ./wowup-electron
+        xvfb-run --auto-servernum ng test --watch=false
diff --git a/wowup-electron/src/app/app.component.spec.ts b/wowup-electron/src/app/app.component.spec.ts
index d32749e3..fd8f075c 100644
--- a/wowup-electron/src/app/app.component.spec.ts
+++ b/wowup-electron/src/app/app.component.spec.ts
@@ -1,26 +1,100 @@
-import { TestBed, waitForAsync } from "@angular/core/testing";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { RouterTestingModule } from "@angular/router/testing";
-import { TranslateModule } from "@ngx-translate/core";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
 import { AppComponent } from "./app.component";
 import { ElectronService } from "./services";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "./app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { AddonService } from "./services/addons/addon.service";
+import { MatDialog } from "@angular/material/dialog";
+import { WowUpService } from "./services/wowup/wowup.service";
+import { SessionService } from "./services/session/session.service";
+import { FileService } from "./services/files/file.service";
+import { AnalyticsService } from "./services/analytics/analytics.service";
+import { OverlayContainer, OverlayModule } from "@angular/cdk/overlay";
+import { Subject } from "rxjs";
+import { PreferenceChange } from "./models/wowup/preference-change";
+import { MatModule } from "./mat-module";
 
 describe("AppComponent", () => {
-  beforeEach(
-    waitForAsync(() => {
-      TestBed.configureTestingModule({
-        declarations: [AppComponent],
-        providers: [ElectronService],
-        imports: [RouterTestingModule, TranslateModule.forRoot()],
-      }).compileComponents();
-    })
-  );
+  let component: AppComponent;
+  let fixture: ComponentFixture<AppComponent>;
+  let addonService: AddonService;
+  let addonServiceSpy: any;
+  let electronService: ElectronService;
+  let electronServiceSpy: any;
+  let wowUpService: WowUpService;
+  let wowUpServiceSpy: any;
+  let sessionService: SessionService;
+  let sessionServiceSpy: any;
+  let fileService: FileService;
+  let fileServiceSpy: any;
+  let analyticsService: AnalyticsService;
+  let analyticsServiceSpy: any;
 
-  it(
-    "should create the app",
-    waitForAsync(() => {
-      const fixture = TestBed.createComponent(AppComponent);
-      const app = fixture.debugElement.componentInstance;
-      expect(app).toBeTruthy();
-    })
-  );
+  beforeEach(async () => {
+    addonServiceSpy = jasmine.createSpyObj("AddonService", ["processAutoUpdates"]);
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", ["invoke"], {
+      appOptions: {quit : null},
+    });
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", [""], {
+      preferenceChange$: new Subject<PreferenceChange>().asObservable(),
+    });
+    sessionServiceSpy = jasmine.createSpyObj("SessionService", [""]);
+    fileServiceSpy = jasmine.createSpyObj("FileService", [""]);
+    analyticsServiceSpy = jasmine.createSpyObj("AnalyticsService", ["trackStartup"]);
+
+    await TestBed.configureTestingModule({
+      declarations: [AppComponent],
+      providers: [
+        MatDialog,
+        ElectronService,
+      ],
+      imports: [
+        OverlayModule,
+        RouterTestingModule,
+        HttpClientModule,
+        MatModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+    }).overrideComponent(AppComponent, {
+      set: {
+        providers: [
+          MatDialog,
+          OverlayContainer,
+          { provide: AddonService, useValue: addonServiceSpy },
+          { provide: ElectronService, useValue: electronServiceSpy },
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: SessionService, useValue: sessionServiceSpy },
+          { provide: FileService, useValue: fileServiceSpy },
+          { provide: AnalyticsService, useValue: analyticsServiceSpy },
+        ]},
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(AppComponent);
+    component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+    electronService = fixture.debugElement.injector.get(ElectronService);
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    sessionService = fixture.debugElement.injector.get(SessionService);
+    fileService = fixture.debugElement.injector.get(FileService);
+    analyticsService = fixture.debugElement.injector.get(AnalyticsService);
+
+    fixture.detectChanges();
+  });
+
+  it("should create", () => {
+    expect(component).toBeTruthy();
+  });
 });
diff --git a/wowup-electron/src/app/components/addon-detail/addon-detail.component.spec.ts b/wowup-electron/src/app/components/addon-detail/addon-detail.component.spec.ts
index 68ad2ab1..dbc286e3 100644
--- a/wowup-electron/src/app/components/addon-detail/addon-detail.component.spec.ts
+++ b/wowup-electron/src/app/components/addon-detail/addon-detail.component.spec.ts
@@ -1,19 +1,73 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
-import { AddonDetailComponent } from "./addon-detail.component";
+import { AddonDetailComponent, AddonDetailModel } from "./addon-detail.component";
+import { CUSTOM_ELEMENTS_SCHEMA } from "@angular/core";
+import { MAT_DIALOG_DATA } from "@angular/material/dialog";
+import { AddonService } from "../../services/addons/addon.service";
+import {
+  TranslateCompiler,
+  TranslateLoader,
+  TranslateModule,
+} from "@ngx-translate/core";
+import { Subject} from "rxjs";
+import { AddonUpdateEvent } from "../../models/wowup/addon-update-event";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { AddonViewModel } from "../../business-objects/my-addon-list-item";
+import { Addon } from "../../entities/addon";
+import { MatModule } from "../../mat-module";
 
 describe("AddonDetailComponent", () => {
   let component: AddonDetailComponent;
   let fixture: ComponentFixture<AddonDetailComponent>;
+  let addonService: AddonService;
+  let dialogModel: AddonDetailModel;
+  let addonServiceSpy: any;
 
   beforeEach(async () => {
+    addonServiceSpy = jasmine.createSpyObj("AddonService", ["logDebugData"], {
+      addonInstalled$ : new Subject<AddonUpdateEvent>().asObservable(),
+    });
+
+    const viewModel = new AddonViewModel({
+      installedVersion: "1.0.0",
+      externalId: '52001',
+    } as Addon);
+
+    dialogModel = {listItem: viewModel} as AddonDetailModel;
+
     await TestBed.configureTestingModule({
       declarations: [AddonDetailComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+      providers: [
+        { provide: MAT_DIALOG_DATA, useValue: dialogModel },
+      ]
+    }).overrideComponent(AddonDetailComponent, {
+      set: {
+        providers: [
+          { provide: AddonService, useValue: addonServiceSpy },
+        ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(AddonDetailComponent);
     component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+
     fixture.detectChanges();
   });
 
diff --git a/wowup-electron/src/app/components/addon-install-button/addon-install-button.component.spec.ts b/wowup-electron/src/app/components/addon-install-button/addon-install-button.component.spec.ts
index c824ae89..55873419 100644
--- a/wowup-electron/src/app/components/addon-install-button/addon-install-button.component.spec.ts
+++ b/wowup-electron/src/app/components/addon-install-button/addon-install-button.component.spec.ts
@@ -1,19 +1,67 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
 import { AddonInstallButtonComponent } from "./addon-install-button.component";
+import { AddonService } from "../../services/addons/addon.service";
+import { SessionService } from "../../services/session/session.service";
+import { httpLoaderFactory } from "../../app.module";
+import { AddonSearchResult } from "../../models/wowup/addon-search-result";
+import { WowClientType } from "../../models/warcraft/wow-client-type";
+import { Subject } from "rxjs";
+import { AddonUpdateEvent } from "../../models/wowup/addon-update-event";
 
 describe("AddonInstallButtonComponent", () => {
   let component: AddonInstallButtonComponent;
   let fixture: ComponentFixture<AddonInstallButtonComponent>;
+  let addonService: AddonService;
+  let addonServiceSpy: any;
+  let sessionService: SessionService;
+  let sessionServiceSpy: any;
 
   beforeEach(async () => {
+    addonServiceSpy = jasmine.createSpyObj("AddonService", {
+      isInstalled: () => false,
+    }, {
+      addonInstalled$ : new Subject<AddonUpdateEvent>().asObservable(),
+    });
+    sessionServiceSpy = jasmine.createSpyObj("SessionService", [""], {
+      selectedClientType: WowClientType.Retail,
+    });
+
     await TestBed.configureTestingModule({
       declarations: [AddonInstallButtonComponent],
+      imports: [
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+    }).overrideComponent(AddonInstallButtonComponent, {
+      set: {
+        providers: [
+          { provide: AddonService, useValue: addonServiceSpy },
+          { provide: SessionService, useValue: sessionServiceSpy },
+        ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(AddonInstallButtonComponent);
     component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+    sessionService = fixture.debugElement.injector.get(SessionService);
+
+    component.addonSearchResult = {
+      externalId: "123123",
+    } as AddonSearchResult;
+
     fixture.detectChanges();
   });
 
diff --git a/wowup-electron/src/app/components/addon-update-button/addon-update-button.component.spec.ts b/wowup-electron/src/app/components/addon-update-button/addon-update-button.component.spec.ts
index aa5ada4a..be5b8ac0 100644
--- a/wowup-electron/src/app/components/addon-update-button/addon-update-button.component.spec.ts
+++ b/wowup-electron/src/app/components/addon-update-button/addon-update-button.component.spec.ts
@@ -1,17 +1,70 @@
-import { inject } from "@angular/core/testing";
-import { TranslateService } from "@ngx-translate/core";
-import { AddonService } from "../../services/addons/addon.service";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { MatDialog } from "@angular/material/dialog";
 import { AnalyticsService } from "../../services/analytics/analytics.service";
+import { AddonService } from "../../services/addons/addon.service";
+import { ElectronService } from "../../services";
+import { httpLoaderFactory } from "../../app.module";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
 import { AddonUpdateButtonComponent } from "./addon-update-button.component";
-
+import { Subject } from "rxjs";
+import { AddonUpdateEvent } from "../../models/wowup/addon-update-event";
+import { MatModule } from "../../mat-module";
 describe("AddonUpdateButtonComponent", () => {
+  let component: AddonUpdateButtonComponent;
+  let fixture: ComponentFixture<AddonUpdateButtonComponent>;
+  let addonService: AddonService;
+  let addonServiceSpy: any;
+  let analyticsService: AnalyticsService;
+  let analyticsServiceSpy: any;
+
+  beforeEach(async () => {
+    addonServiceSpy = jasmine.createSpyObj("AddonService", [""], {
+      addonInstalled$: new Subject<AddonUpdateEvent>().asObservable(),
+    })
+
+    await TestBed.configureTestingModule({
+      declarations: [AddonUpdateButtonComponent],
+      providers: [
+        MatDialog,
+        ElectronService,
+      ],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        BrowserAnimationsModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+    }).overrideComponent(AddonUpdateButtonComponent, {
+      set: {
+        providers: [
+          MatDialog,
+          { provide: AddonService, useValue: addonServiceSpy },
+          { provide: AnalyticsService, useValue: analyticsServiceSpy },
+        ]},
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(AddonUpdateButtonComponent);
+    component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+    analyticsService = fixture.debugElement.injector.get(AnalyticsService);
+
+    fixture.detectChanges();
+  });
+
   it("should create", () => {
-    inject(
-      [AddonService, AnalyticsService, TranslateService],
-      (addonService: AddonService, analyticsService: AnalyticsService, translateService: TranslateService) => {
-        const instance = new AddonUpdateButtonComponent(addonService, analyticsService, translateService);
-        expect(instance).toBeTruthy();
-      }
-    );
+    expect(component).toBeTruthy();
   });
 });
diff --git a/wowup-electron/src/app/components/alert-dialog/alert-dialog.component.spec.ts b/wowup-electron/src/app/components/alert-dialog/alert-dialog.component.spec.ts
index 003d4939..eb696bdd 100644
--- a/wowup-electron/src/app/components/alert-dialog/alert-dialog.component.spec.ts
+++ b/wowup-electron/src/app/components/alert-dialog/alert-dialog.component.spec.ts
@@ -1,5 +1,11 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { AlertDialogComponent } from "./alert-dialog.component";
+import { MAT_DIALOG_DATA, MatDialogRef } from "@angular/material/dialog";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { MatModule } from "../../mat-module";
 
 describe("AlertDialogComponent", () => {
   let component: AlertDialogComponent;
@@ -8,10 +14,27 @@ describe("AlertDialogComponent", () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [AlertDialogComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      providers: [
+        { provide: MAT_DIALOG_DATA, useValue: {} },
+        { provide: MatDialogRef, useValue: {} },
+      ]
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(AlertDialogComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
diff --git a/wowup-electron/src/app/components/confirm-dialog/confirm-dialog.component.spec.ts b/wowup-electron/src/app/components/confirm-dialog/confirm-dialog.component.spec.ts
index ca99957e..14ba1285 100644
--- a/wowup-electron/src/app/components/confirm-dialog/confirm-dialog.component.spec.ts
+++ b/wowup-electron/src/app/components/confirm-dialog/confirm-dialog.component.spec.ts
@@ -1,5 +1,11 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { ConfirmDialogComponent } from "./confirm-dialog.component";
+import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from "@angular/material/dialog";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { MatModule } from "../../mat-module";
 
 describe("ConfirmDialogComponent", () => {
   let component: ConfirmDialogComponent;
@@ -8,10 +14,27 @@ describe("ConfirmDialogComponent", () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [ConfirmDialogComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      providers: [
+        { provide: MAT_DIALOG_DATA, useValue: {} },
+        { provide: MatDialogRef, useValue: {} },
+      ]
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(ConfirmDialogComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
diff --git a/wowup-electron/src/app/components/footer/footer.component.spec.ts b/wowup-electron/src/app/components/footer/footer.component.spec.ts
index 28ae6738..30450d82 100644
--- a/wowup-electron/src/app/components/footer/footer.component.spec.ts
+++ b/wowup-electron/src/app/components/footer/footer.component.spec.ts
@@ -1,19 +1,73 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { FooterComponent } from "./footer.component";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { WowUpService } from "../../services/wowup/wowup.service";
+import { ElectronService } from "../../services";
+import { SessionService } from "../../services/session/session.service";
+import { OverlayModule } from "@angular/cdk/overlay";
+import { BehaviorSubject, Subject } from "rxjs";
+import { UpdateCheckResult } from "electron-updater";
+import { MatModule } from "../../mat-module";
 
 describe("FooterComponent", () => {
   let component: FooterComponent;
   let fixture: ComponentFixture<FooterComponent>;
+  let electronService: ElectronService;
+  let wowUpService: WowUpService;
+  let sessionService: SessionService;
+  let electronServiceSpy: any;
+  let wowUpServiceSpy: any;
+  let sessionServiceSpy: any;
 
   beforeEach(async () => {
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", [""], {
+      wowupUpdateCheck$: new Subject<UpdateCheckResult>().asObservable(),
+      wowupUpdateDownloaded$: new Subject<any>().asObservable(),
+      wowupUpdateCheckInProgress$: new Subject<boolean>().asObservable(),
+      wowupUpdateDownloadInProgress$: new Subject<boolean>().asObservable(),
+    });
+
+    sessionServiceSpy = jasmine.createSpyObj("SessionService", [""], {
+      statusText$: new BehaviorSubject(""),
+      pageContextText$: new BehaviorSubject(""),
+    });
+
     await TestBed.configureTestingModule({
       declarations: [FooterComponent],
+      imports: [
+        MatModule,
+        OverlayModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+    }).overrideComponent(FooterComponent, {
+      set: {
+        providers: [
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: ElectronService, useValue: electronServiceSpy },
+          { provide: SessionService, useValue: sessionServiceSpy },
+        ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(FooterComponent);
     component = fixture.componentInstance;
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    electronService = fixture.debugElement.injector.get(ElectronService);
+    sessionService = fixture.debugElement.injector.get(SessionService);
+
     fixture.detectChanges();
   });
 
diff --git a/wowup-electron/src/app/components/get-addon-status-column/get-addon-status-column.component.spec.ts b/wowup-electron/src/app/components/get-addon-status-column/get-addon-status-column.component.spec.ts
index 954f71c4..75118c66 100644
--- a/wowup-electron/src/app/components/get-addon-status-column/get-addon-status-column.component.spec.ts
+++ b/wowup-electron/src/app/components/get-addon-status-column/get-addon-status-column.component.spec.ts
@@ -1,5 +1,6 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { GetAddonStatusColumnComponent } from "./get-addon-status-column.component";
+import { CUSTOM_ELEMENTS_SCHEMA } from "@angular/core";
 
 describe("GetAddonStatusColumnComponent", () => {
   let component: GetAddonStatusColumnComponent;
@@ -8,10 +9,9 @@ describe("GetAddonStatusColumnComponent", () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [GetAddonStatusColumnComponent],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(GetAddonStatusColumnComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
diff --git a/wowup-electron/src/app/components/install-from-url-dialog/install-from-url-dialog.component.spec.ts b/wowup-electron/src/app/components/install-from-url-dialog/install-from-url-dialog.component.spec.ts
index b7ceeb85..dd20bd08 100644
--- a/wowup-electron/src/app/components/install-from-url-dialog/install-from-url-dialog.component.spec.ts
+++ b/wowup-electron/src/app/components/install-from-url-dialog/install-from-url-dialog.component.spec.ts
@@ -1,19 +1,58 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { AddonService, } from "../../services/addons/addon.service";
+import { SessionService } from "../../services/session/session.service";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
 import { InstallFromUrlDialogComponent } from "./install-from-url-dialog.component";
+import { MatDialogRef } from "@angular/material/dialog";
+import { DownloadCountPipe } from "../../pipes/download-count.pipe";
+import { MatModule } from "../../mat-module";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
 
 describe("InstallFromUrlDialogComponent", () => {
   let component: InstallFromUrlDialogComponent;
   let fixture: ComponentFixture<InstallFromUrlDialogComponent>;
+  let sessionService: SessionService;
+  let sessionServiceSpy: any;
+  let addonService: AddonService;
+  let addonServiceSpy: any;
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [InstallFromUrlDialogComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        BrowserAnimationsModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+    }).overrideComponent(InstallFromUrlDialogComponent, {
+      set: {
+        providers: [
+          DownloadCountPipe,
+          { provide: MatDialogRef, useValue: {} },
+          { provide: AddonService, useValue: addonServiceSpy },
+          { provide: SessionService, useValue: sessionServiceSpy },
+        ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(InstallFromUrlDialogComponent);
     component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+    sessionService = fixture.debugElement.injector.get(SessionService);
+
     fixture.detectChanges();
   });
 
diff --git a/wowup-electron/src/app/components/my-addon-status-column/my-addon-status-column.component.spec.ts b/wowup-electron/src/app/components/my-addon-status-column/my-addon-status-column.component.spec.ts
index 15989d6b..4a8a1f5d 100644
--- a/wowup-electron/src/app/components/my-addon-status-column/my-addon-status-column.component.spec.ts
+++ b/wowup-electron/src/app/components/my-addon-status-column/my-addon-status-column.component.spec.ts
@@ -1,5 +1,9 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { MyAddonStatusColumnComponent } from "./my-addon-status-column.component";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
 
 describe("MyAddonStatusColumnComponent", () => {
   let component: MyAddonStatusColumnComponent;
@@ -8,6 +12,17 @@ describe("MyAddonStatusColumnComponent", () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [MyAddonStatusColumnComponent],
+      imports: [HttpClientModule, TranslateModule.forRoot({
+        loader: {
+          provide: TranslateLoader,
+          useFactory: httpLoaderFactory,
+          deps: [HttpClient],
+        },
+        compiler: {
+          provide: TranslateCompiler,
+          useClass: TranslateMessageFormatCompiler,
+        },
+      })],
     }).compileComponents();
   });
 
diff --git a/wowup-electron/src/app/components/my-addons-addon-cell/my-addons-addon-cell.component.spec.ts b/wowup-electron/src/app/components/my-addons-addon-cell/my-addons-addon-cell.component.spec.ts
index 7830b182..b5014357 100644
--- a/wowup-electron/src/app/components/my-addons-addon-cell/my-addons-addon-cell.component.spec.ts
+++ b/wowup-electron/src/app/components/my-addons-addon-cell/my-addons-addon-cell.component.spec.ts
@@ -1,8 +1,49 @@
+import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
 import { MyAddonsAddonCellComponent } from "./my-addons-addon-cell.component";
+import { AddonViewModel } from "../../business-objects/my-addon-list-item";
+import { Addon } from "../../entities/addon";
+import { MatModule } from "../../mat-module";
 
 describe("MyAddonsAddonCellComponent", () => {
+  let component: MyAddonsAddonCellComponent;
+  let fixture: ComponentFixture<MyAddonsAddonCellComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [MyAddonsAddonCellComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(MyAddonsAddonCellComponent);
+    component = fixture.componentInstance;
+
+    component.listItem = new AddonViewModel({
+      name: "Teelo's Test Tool",
+      dependencies: [],
+    } as Addon);
+
+    fixture.detectChanges();
+  });
+
   it("should create", () => {
-    const instance = new MyAddonsAddonCellComponent();
-    expect(instance).toBeTruthy();
+    expect(component).toBeTruthy();
   });
 });
diff --git a/wowup-electron/src/app/components/options-app-section/options-app-section.component.spec.ts b/wowup-electron/src/app/components/options-app-section/options-app-section.component.spec.ts
index f29179e4..d6803b16 100644
--- a/wowup-electron/src/app/components/options-app-section/options-app-section.component.spec.ts
+++ b/wowup-electron/src/app/components/options-app-section/options-app-section.component.spec.ts
@@ -1,20 +1,92 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
-
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { MatDialog } from "@angular/material/dialog";
+import { AnalyticsService } from "../../services/analytics/analytics.service";
+import { FileService } from "../../services/files/file.service";
+import { SessionService } from "../../services/session/session.service";
+import { WowUpService } from "../../services/wowup/wowup.service";
+import { ElectronService } from "../../services";
 import { OptionsAppSectionComponent } from "./options-app-section.component";
+import { httpLoaderFactory } from "../../app.module";
+import { BehaviorSubject } from "rxjs";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
+import { MatModule } from "../../mat-module";
 
 describe("OptionsAppSectionComponent", () => {
   let component: OptionsAppSectionComponent;
   let fixture: ComponentFixture<OptionsAppSectionComponent>;
+  let electronService: ElectronService;
+  let electronServiceSpy: any;
+  let wowUpService: WowUpService;
+  let wowUpServiceSpy: any;
+  let sessionService: SessionService;
+  let sessionServiceSpy: any;
+  let fileService: FileService;
+  let fileServiceSpy: any;
+  let analyticsService: AnalyticsService;
+  let analyticsServiceSpy: any;
 
   beforeEach(async () => {
+    analyticsServiceSpy = jasmine.createSpyObj("AnalyticsService", [""], {
+      telemetryEnabled$: new BehaviorSubject(false).asObservable()
+    });
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", [""], {
+      isWin : false,
+      isLinux : true,
+      isMac: false,
+    });
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", [""], {
+      collapseToTray: false,
+      useHardwareAcceleration: false,
+      startWithSystem: false,
+      startMinimized: false,
+      currentLanguage: false,
+    });
+
     await TestBed.configureTestingModule({
       declarations: [OptionsAppSectionComponent],
+      providers: [
+        MatDialog,
+        ElectronService,
+      ],
+      imports: [
+        HttpClientModule,
+        MatModule,
+        BrowserAnimationsModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+    }).overrideComponent(OptionsAppSectionComponent, {
+      set: {
+        providers: [
+          MatDialog,
+          { provide: ElectronService, useValue: electronServiceSpy },
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: SessionService, useValue: sessionServiceSpy },
+          { provide: FileService, useValue: fileServiceSpy },
+          { provide: AnalyticsService, useValue: analyticsServiceSpy },
+        ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(OptionsAppSectionComponent);
     component = fixture.componentInstance;
+    electronService = fixture.debugElement.injector.get(ElectronService);
+    sessionService = fixture.debugElement.injector.get(SessionService);
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    fileService = fixture.debugElement.injector.get(FileService);
+    analyticsService = fixture.debugElement.injector.get(AnalyticsService);
+
     fixture.detectChanges();
   });
 
diff --git a/wowup-electron/src/app/components/options-debug-section/options-debug-section.component.spec.ts b/wowup-electron/src/app/components/options-debug-section/options-debug-section.component.spec.ts
index 94c73b29..55e54278 100644
--- a/wowup-electron/src/app/components/options-debug-section/options-debug-section.component.spec.ts
+++ b/wowup-electron/src/app/components/options-debug-section/options-debug-section.component.spec.ts
@@ -1,29 +1,68 @@
-import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { ComponentFixture, fakeAsync, TestBed, tick } from "@angular/core/testing";
 import { OptionsDebugSectionComponent } from "./options-debug-section.component";
 import { AddonService } from "../../services/addons/addon.service";
 import { WowUpService } from "../../services/wowup/wowup.service";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { httpLoaderFactory } from "../../app.module";
 
 describe("OptionsDebugSectionComponent", () => {
   let component: OptionsDebugSectionComponent;
   let fixture: ComponentFixture<OptionsDebugSectionComponent>;
+  let addonService: AddonService;
+  let wowUpService: WowUpService;
+  let addonServiceSpy: any;
+  let wowUpServiceSpy: any;
 
   beforeEach(async () => {
+    addonServiceSpy = jasmine.createSpyObj(AddonService, ["logDebugData"]);
+    wowUpServiceSpy = jasmine.createSpyObj(WowUpService, ["showLogsFolder"]);
+
     await TestBed.configureTestingModule({
       declarations: [OptionsDebugSectionComponent],
+      imports: [HttpClientModule, TranslateModule.forRoot({
+        loader: {
+          provide: TranslateLoader,
+          useFactory: httpLoaderFactory,
+          deps: [HttpClient],
+        },
+        compiler: {
+          provide: TranslateCompiler,
+          useClass: TranslateMessageFormatCompiler,
+        },
+      })],
+    }).overrideComponent(OptionsDebugSectionComponent, {
+      set: {
       providers: [
-        { provider: AddonService, useValue: jasmine.createSpyObj(AddonService, ['logDebugData']) },
-        { provider: WowUpService, useValue: jasmine.createSpyObj(WowUpService, ['showLogsFolder']) },
-      ],
+          { provide: AddonService, useValue: addonServiceSpy },
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+      ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(OptionsDebugSectionComponent);
     component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+
     fixture.detectChanges();
   });
 
   it("should create", () => {
     expect(component).toBeTruthy();
   });
+
+  it("Should call logDebugData", fakeAsync(() => {
+    const button = fixture.debugElement.nativeElement.querySelector("button[action='LogDebugData']");
+    button.click();
+    tick();
+    expect(addonServiceSpy.logDebugData).toHaveBeenCalled();
+  }));
+
+  it("Should call showLogFiles", fakeAsync(() => {
+    const button = fixture.debugElement.nativeElement.querySelector("button[action='ShowLogFiles']");
+    button.click();
+    tick();
+    expect(wowUpServiceSpy.showLogsFolder).toHaveBeenCalled();
+  }));
 });
diff --git a/wowup-electron/src/app/components/options-wow-section/options-wow-section.component.spec.ts b/wowup-electron/src/app/components/options-wow-section/options-wow-section.component.spec.ts
index a33949b0..1deb1ebb 100644
--- a/wowup-electron/src/app/components/options-wow-section/options-wow-section.component.spec.ts
+++ b/wowup-electron/src/app/components/options-wow-section/options-wow-section.component.spec.ts
@@ -1,20 +1,60 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
-
+import { MatDialog, MatDialogModule } from "@angular/material/dialog";
+import { WowUpService } from "../../services/wowup/wowup.service";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { WarcraftService } from "../../services/warcraft/warcraft.service";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
 import { OptionsWowSectionComponent } from "./options-wow-section.component";
+import { WowUpReleaseChannelType } from "../../models/wowup/wowup-release-channel-type";
 
 describe("OptionsWowSectionComponent", () => {
   let component: OptionsWowSectionComponent;
   let fixture: ComponentFixture<OptionsWowSectionComponent>;
+  let wowUpService: WowUpService;
+  let wowUpServiceSpy: any;
+  let warcraftService: WarcraftService;
+  let warcraftServiceSpy: any;
 
   beforeEach(async () => {
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", [""], {
+      wowUpReleaseChannel: WowUpReleaseChannelType.Stable,
+    })
+
     await TestBed.configureTestingModule({
       declarations: [OptionsWowSectionComponent],
+      imports: [
+        HttpClientModule,
+        MatDialogModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      providers: [
+        MatDialog,
+      ]
+    }).overrideComponent(OptionsWowSectionComponent, {
+      set: {
+        providers: [
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: WarcraftService, useValue: warcraftServiceSpy },
+        ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(OptionsWowSectionComponent);
     component = fixture.componentInstance;
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    warcraftService = fixture.debugElement.injector.get(WarcraftService);
+
     fixture.detectChanges();
   });
 
diff --git a/wowup-electron/src/app/components/progress-spinner/progress-spinner.component.spec.ts b/wowup-electron/src/app/components/progress-spinner/progress-spinner.component.spec.ts
index 066b0c58..376adc9d 100644
--- a/wowup-electron/src/app/components/progress-spinner/progress-spinner.component.spec.ts
+++ b/wowup-electron/src/app/components/progress-spinner/progress-spinner.component.spec.ts
@@ -1,5 +1,11 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { ProgressSpinnerComponent } from "./progress-spinner.component";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { CUSTOM_ELEMENTS_SCHEMA } from "@angular/core";
+import { MatModule } from "../../mat-module";
 
 describe("ProgressSpinnerComponent", () => {
   let component: ProgressSpinnerComponent;
@@ -8,10 +14,24 @@ describe("ProgressSpinnerComponent", () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [ProgressSpinnerComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(ProgressSpinnerComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
diff --git a/wowup-electron/src/app/components/telemetry-dialog/telemetry-dialog.component.spec.ts b/wowup-electron/src/app/components/telemetry-dialog/telemetry-dialog.component.spec.ts
index c10c7dfc..c25ad216 100644
--- a/wowup-electron/src/app/components/telemetry-dialog/telemetry-dialog.component.spec.ts
+++ b/wowup-electron/src/app/components/telemetry-dialog/telemetry-dialog.component.spec.ts
@@ -1,5 +1,11 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { TelemetryDialogComponent } from "./telemetry-dialog.component";
+import { MatDialogRef } from "@angular/material/dialog";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { MatModule } from "../../mat-module";
 
 describe("TelemetryDialogComponent", () => {
   let component: TelemetryDialogComponent;
@@ -8,10 +14,26 @@ describe("TelemetryDialogComponent", () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [TelemetryDialogComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      providers: [
+        {provide: MatDialogRef, useValue: {} },
+      ]
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(TelemetryDialogComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
diff --git a/wowup-electron/src/app/components/titlebar/titlebar.component.html b/wowup-electron/src/app/components/titlebar/titlebar.component.html
index e97e7de2..2b6df5a1 100644
--- a/wowup-electron/src/app/components/titlebar/titlebar.component.html
+++ b/wowup-electron/src/app/components/titlebar/titlebar.component.html
@@ -13,7 +13,7 @@
   <div class="title-container">
     <div>WowUp.io</div>
   </div>
-  <!-- <div *ngIf="isMac" class="window-control-container pointer">
+  <!-- <div *ngIf="electronService.isMac" class="window-control-container pointer">
     <div class="window-control hover-primary-2" (click)="onClickDebug()">
       <mat-icon class="debug-button pointer" svgIcon="fas:bug"></mat-icon>
     </div>
@@ -37,4 +37,4 @@
       <img src="assets/chrome-close.svg" />
     </div>
   </div>
-</div>
\ No newline at end of file
+</div>
diff --git a/wowup-electron/src/app/components/titlebar/titlebar.component.spec.ts b/wowup-electron/src/app/components/titlebar/titlebar.component.spec.ts
index 1d62be52..1a05033f 100644
--- a/wowup-electron/src/app/components/titlebar/titlebar.component.spec.ts
+++ b/wowup-electron/src/app/components/titlebar/titlebar.component.spec.ts
@@ -1,19 +1,62 @@
 import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { OverlayContainer } from "@angular/cdk/overlay";
+import { httpLoaderFactory } from "../../app.module";
 import { TitlebarComponent } from "./titlebar.component";
+import { WowUpService } from "../../services/wowup/wowup.service";
+import { ElectronService } from "../../services";
+import { BehaviorSubject } from "rxjs";
 
 describe("TitlebarComponent", () => {
   let component: TitlebarComponent;
   let fixture: ComponentFixture<TitlebarComponent>;
+  let electronService: ElectronService;
+  let electronServiceSpy: any;
+  let wowUpService: WowUpService;
+  let wowUpServiceSpy: any;
 
   beforeEach(async () => {
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", [""], {
+      windowMaximized$: new BehaviorSubject(false).asObservable(),
+    });
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", {
+      getThemeLogoPath: () => "",
+    }, {
+      currentTheme: "horde ofc",
+    });
+
     await TestBed.configureTestingModule({
       declarations: [TitlebarComponent],
+      imports: [
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+    }).overrideComponent(TitlebarComponent, {
+      set: {
+        providers: [
+          OverlayContainer,
+          { provide: ElectronService, useValue: electronServiceSpy },
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+        ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(TitlebarComponent);
     component = fixture.componentInstance;
+    electronService = fixture.debugElement.injector.get(ElectronService);
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+
     fixture.detectChanges();
   });
 
diff --git a/wowup-electron/src/app/components/titlebar/titlebar.component.ts b/wowup-electron/src/app/components/titlebar/titlebar.component.ts
index 4bcb9806..62aa79ef 100644
--- a/wowup-electron/src/app/components/titlebar/titlebar.component.ts
+++ b/wowup-electron/src/app/components/titlebar/titlebar.component.ts
@@ -7,7 +7,6 @@ import {
   HORDE_LIGHT_THEME,
   HORDE_THEME,
 } from "../../../common/constants";
-import { platform } from "os";
 import { Subscription } from "rxjs";
 import { AppConfig } from "../../../environments/environment";
 import { ElectronService } from "../../services/electron/electron.service";
@@ -19,17 +18,16 @@ import { WowUpService } from "../../services/wowup/wowup.service";
   styleUrls: ["./titlebar.component.scss"],
 })
 export class TitlebarComponent implements OnInit, OnDestroy {
-  // TODO use electron service
-  public isMac = platform() === "darwin";
-  public isWindows = platform() === "win32";
-  public isLinux = platform() === "linux";
-  public userAgent = platform();
   public isProd = AppConfig.production;
   public isMaximized = false;
 
   private _subscriptions: Subscription[] = [];
 
-  constructor(public electronService: ElectronService, private _wowUpService: WowUpService, private _ngZone: NgZone) {
+  constructor(
+    public electronService: ElectronService,
+    private _wowUpService: WowUpService,
+    private _ngZone: NgZone,
+  ) {
     const windowMaximizedSubscription = this.electronService.windowMaximized$.subscribe((maximized) => {
       this._ngZone.run(() => (this.isMaximized = maximized));
     });
@@ -73,7 +71,7 @@ export class TitlebarComponent implements OnInit, OnDestroy {
   onDblClick() {
     const win = this.electronService.remote.getCurrentWindow();
 
-    if (this.isMac) {
+    if (this.electronService.isMac) {
       const action = this.electronService.remote.systemPreferences.getUserDefault("AppleActionOnDoubleClick", "string");
       if (action === "Maximize") {
         if (win.isMaximized()) {
diff --git a/wowup-electron/src/app/components/wow-client-options/wow-client-options.component.spec.ts b/wowup-electron/src/app/components/wow-client-options/wow-client-options.component.spec.ts
index 7ba0d87c..8672e95f 100644
--- a/wowup-electron/src/app/components/wow-client-options/wow-client-options.component.spec.ts
+++ b/wowup-electron/src/app/components/wow-client-options/wow-client-options.component.spec.ts
@@ -1,49 +1,83 @@
-import { ChangeDetectorRef } from "@angular/core";
-import { ComponentFixture, inject, TestBed } from "@angular/core/testing";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { MatDialog } from "@angular/material/dialog";
-import { ElectronService } from "../../services/electron/electron.service";
-import { WarcraftService } from "../../services/warcraft/warcraft.service";
 import { WowUpService } from "../../services/wowup/wowup.service";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { ElectronService } from "../../services";
+import { WarcraftService } from "../../services/warcraft/warcraft.service";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
 import { WowClientOptionsComponent } from "./wow-client-options.component";
-import { TranslateService } from "@ngx-translate/core";
+import { BehaviorSubject } from "rxjs";
+import { InstalledProduct } from "../../models/warcraft/installed-product";
+import { WowClientType } from "../../models/warcraft/wow-client-type";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
+import { MatModule } from "../../mat-module";
 
 describe("WowClientOptionsComponent", () => {
   let component: WowClientOptionsComponent;
   let fixture: ComponentFixture<WowClientOptionsComponent>;
+  let electronService: ElectronService;
+  let electronServiceSpy: any;
+  let wowUpService: WowUpService;
+  let wowUpServiceSpy: any;
+  let warcraftService: WarcraftService;
+  let warcraftServiceSpy: any;
 
   beforeEach(async () => {
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", {
+      getDefaultAddonChannel: (clientType: WowClientType) => clientType.toString(),
+      getDefaultAutoUpdate: (clientType: WowClientType) => clientType.toString(),
+    })
+    warcraftServiceSpy = jasmine.createSpyObj("WarcraftService", {
+      getClientFolderName: (clientType: WowClientType) => clientType.toString(),
+      getClientLocation: (clientType: WowClientType) => clientType.toString(),
+    }, {
+      products$: new BehaviorSubject<InstalledProduct[]>([]).asObservable(),
+    })
+
     await TestBed.configureTestingModule({
       declarations: [WowClientOptionsComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        BrowserAnimationsModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      providers: [
+        MatDialog,
+      ]
+    }).overrideComponent(WowClientOptionsComponent, {
+      set: {
+        providers: [
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: ElectronService, useValue: electronServiceSpy },
+          { provide: WarcraftService, useValue: warcraftServiceSpy },
+        ]},
     }).compileComponents();
-  });
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(WowClientOptionsComponent);
     component = fixture.componentInstance;
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    electronService = fixture.debugElement.injector.get(ElectronService);
+    warcraftService = fixture.debugElement.injector.get(WarcraftService);
+
+    component.clientType = WowClientType.Retail;
+
     fixture.detectChanges();
   });
 
   it("should create", () => {
-    inject(
-      [MatDialog, ElectronService, WarcraftService, WowUpService, ChangeDetectorRef, TranslateService],
-      (
-        matDialog: MatDialog,
-        electronService: ElectronService,
-        warcraftService: WarcraftService,
-        wowupService: WowUpService,
-        changeRef: ChangeDetectorRef,
-        translateService: TranslateService,
-      ) => {
-        const instance = new WowClientOptionsComponent(
-          matDialog,
-          electronService,
-          warcraftService,
-          wowupService,
-          changeRef,
-          translateService,
-        );
-        expect(instance).toBeTruthy();
-      }
-    );
+    expect(component).toBeTruthy();
   });
 });
diff --git a/wowup-electron/src/app/components/wow-client-options/wow-client-options.component.ts b/wowup-electron/src/app/components/wow-client-options/wow-client-options.component.ts
index 8370ee0d..c06687aa 100644
--- a/wowup-electron/src/app/components/wow-client-options/wow-client-options.component.ts
+++ b/wowup-electron/src/app/components/wow-client-options/wow-client-options.component.ts
@@ -4,10 +4,8 @@ import { MatSelectChange } from "@angular/material/select";
 import { MatSlideToggleChange } from "@angular/material/slide-toggle";
 import { TranslateService } from "@ngx-translate/core";
 import * as _ from "lodash";
-import { map } from "lodash";
 import * as path from "path";
-import { from, Subscription } from "rxjs";
-import { switchMap } from "rxjs/operators";
+import { Subscription } from "rxjs";
 import { WowClientType } from "../../models/warcraft/wow-client-type";
 import { AddonChannelType } from "../../models/wowup/addon-channel-type";
 import { ElectronService } from "../../services";
diff --git a/wowup-electron/src/app/directives/external-link.directive.spec.ts b/wowup-electron/src/app/directives/external-link.directive.spec.ts
index 4658aab3..7960018e 100644
--- a/wowup-electron/src/app/directives/external-link.directive.spec.ts
+++ b/wowup-electron/src/app/directives/external-link.directive.spec.ts
@@ -1,21 +1,49 @@
-import { ComponentFixture, TestBed, waitForAsync } from "@angular/core/testing";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { ExternalLinkDirective } from "./external-link.directive";
+import { Component } from "@angular/core";
+import { ElectronService } from "../services";
+
+@Component({
+  template: `<a appExternalLink href="http://localhost:2020/">test link</a>`,
+})
+class TestAppExternalLinkComponent {
+}
 
 describe("ExternalLinkDirective", () => {
-  let directive: ExternalLinkDirective;
-  let fixture: ComponentFixture<ExternalLinkDirective>;
+  let component: TestAppExternalLinkComponent;
+  let fixture: ComponentFixture<TestAppExternalLinkComponent>;
+  let electronService: ElectronService;
+  let electronServiceSpy: any;
+  let shellSpy: any;
 
-  beforeEach(
-    waitForAsync(() => {
-      TestBed.configureTestingModule({
-        declarations: [ExternalLinkDirective],
-      }).compileComponents();
-    })
-  );
+  beforeEach(async () => {
+    shellSpy = jasmine.createSpyObj("Shell", ["openExternal"]);
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", [], {shell: shellSpy});
 
-  it("should create an instance", () => {
-    fixture = TestBed.createComponent(ExternalLinkDirective);
-    directive = fixture.componentInstance;
-    expect(directive).toBeTruthy();
+    await TestBed.configureTestingModule({
+      declarations: [TestAppExternalLinkComponent, ExternalLinkDirective],
+    }).overrideComponent(TestAppExternalLinkComponent, {
+      set: {
+        providers: [
+          { provide: ElectronService, useValue: electronServiceSpy },
+        ]},
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(TestAppExternalLinkComponent);
+    component = fixture.componentInstance;
+    electronService = fixture.debugElement.injector.get(ElectronService);
+
+    fixture.detectChanges();
+  });
+
+  it("should create", () => {
+    expect(component).toBeTruthy();
+  });
+
+  it("should call openExternal on click", async () => {
+    let a = fixture.debugElement.nativeElement.querySelector("a");
+    a.click();
+    fixture.detectChanges();
+    expect(shellSpy.openExternal).toHaveBeenCalledWith("http://localhost:2020/");
   });
 });
diff --git a/wowup-electron/src/app/pages/about/about.component.spec.ts b/wowup-electron/src/app/pages/about/about.component.spec.ts
index 623ea854..58d3fe44 100644
--- a/wowup-electron/src/app/pages/about/about.component.spec.ts
+++ b/wowup-electron/src/app/pages/about/about.component.spec.ts
@@ -1,21 +1,54 @@
-import { ComponentFixture, TestBed, waitForAsync } from "@angular/core/testing";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { AboutComponent } from "./about.component";
+import { ElectronService } from "../../services";
+import { WowUpService } from "../../services/wowup/wowup.service";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
 
 describe("AboutComponent", () => {
   let component: AboutComponent;
   let fixture: ComponentFixture<AboutComponent>;
+  let electronService: ElectronService;
+  let wowUpService: WowUpService;
+  let electronServiceSpy: any;
+  let wowUpServiceSpy: any;
 
-  beforeEach(
-    waitForAsync(() => {
-      TestBed.configureTestingModule({
-        declarations: [AboutComponent],
-      }).compileComponents();
-    })
-  );
+  beforeEach(async () => {
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", {
+      getThemeLogoPath: () => "",
+    });
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", {
+      getVersionNumber: () => '2.0.0',
+    });
+
+    await TestBed.configureTestingModule({
+      declarations: [AboutComponent],
+      imports: [HttpClientModule, TranslateModule.forRoot({
+        loader: {
+          provide: TranslateLoader,
+          useFactory: httpLoaderFactory,
+          deps: [HttpClient],
+        },
+        compiler: {
+          provide: TranslateCompiler,
+          useClass: TranslateMessageFormatCompiler,
+        },
+      })],
+    }).overrideComponent(AboutComponent, {
+      set: {
+        providers: [
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: ElectronService, useValue: electronServiceSpy },
+        ]},
+    }).compileComponents();
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(AboutComponent);
     component = fixture.componentInstance;
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    electronService = fixture.debugElement.injector.get(ElectronService);
+
     fixture.detectChanges();
   });
 
diff --git a/wowup-electron/src/app/pages/about/about.component.ts b/wowup-electron/src/app/pages/about/about.component.ts
index 4fbb7d35..2cb6371e 100644
--- a/wowup-electron/src/app/pages/about/about.component.ts
+++ b/wowup-electron/src/app/pages/about/about.component.ts
@@ -1,5 +1,4 @@
 import { ChangeDetectionStrategy, Component, Input, OnInit } from "@angular/core";
-import { remote } from "electron";
 import * as ChangeLogJson from "../../../assets/changelog.json";
 import { ChangeLog } from "../../models/wowup/change-log";
 import { ElectronService } from "../../services";
@@ -20,7 +19,7 @@ export class AboutComponent implements OnInit {
   constructor(public wowUpService: WowUpService, public electronService: ElectronService) {}
 
   ngOnInit(): void {
-    this.version = remote.app.getVersion();
+    this.electronService.getVersionNumber()
   }
 
   formatChanges(changeLog: ChangeLog): string {
diff --git a/wowup-electron/src/app/pages/get-addons/get-addons.component.spec.ts b/wowup-electron/src/app/pages/get-addons/get-addons.component.spec.ts
index 34fd46e4..9e0b5c83 100644
--- a/wowup-electron/src/app/pages/get-addons/get-addons.component.spec.ts
+++ b/wowup-electron/src/app/pages/get-addons/get-addons.component.spec.ts
@@ -1,24 +1,102 @@
-import { ComponentFixture, TestBed, waitForAsync } from "@angular/core/testing";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { GetAddonsComponent } from "./get-addons.component";
+import { AddonService } from "../../services/addons/addon.service";
+import { SessionService } from "../../services/session/session.service";
+import { MatDialog } from "@angular/material/dialog";
+import { WowUpService } from "../../services/wowup/wowup.service";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { ElectronService } from "../../services";
+import { WarcraftService } from "../../services/warcraft/warcraft.service";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { OverlayModule } from "@angular/cdk/overlay";
+import { BehaviorSubject } from "rxjs";
+import { WowClientType } from "../../models/warcraft/wow-client-type";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
+import { MatModule } from "../../mat-module";
+import { CUSTOM_ELEMENTS_SCHEMA } from "@angular/core";
 
 describe("GetAddonsComponent", () => {
   let component: GetAddonsComponent;
   let fixture: ComponentFixture<GetAddonsComponent>;
+  let electronService: ElectronService;
+  let electronServiceSpy: any;
+  let wowUpService: WowUpService;
+  let wowUpServiceSpy: any;
+  let sessionService: SessionService;
+  let sessionServiceSpy: any;
+  let addonService: AddonService;
+  let addonServiceSpy: any;
+  let warcraftService: WarcraftService;
+  let warcraftServiceSpy: any;
 
-  beforeEach(
-    waitForAsync(() => {
-      TestBed.configureTestingModule({
-        declarations: [GetAddonsComponent],
-      }).compileComponents();
+  beforeEach(async () => {
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", [""], {
+      getAddonsHiddenColumns: [],
     })
-  );
+    sessionServiceSpy = jasmine.createSpyObj("SessionService", [""], {
+      selectedHomeTab$: new BehaviorSubject(0).asObservable(),
+    })
+    warcraftServiceSpy = jasmine.createSpyObj("WarcraftService", [""], {
+      installedClientTypesSelectItems$: new BehaviorSubject<WowClientType[] | undefined>(undefined).asObservable(),
+    })
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", [""], {
+      isWin : false,
+      isLinux : true,
+      isMac: false,
+    });
+
+    await TestBed.configureTestingModule({
+      declarations: [GetAddonsComponent],
+      imports: [
+        MatModule,
+        OverlayModule,
+        BrowserAnimationsModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      providers: [
+        MatDialog,
+      ],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+    }).overrideComponent(GetAddonsComponent, {
+      set: {
+        providers: [
+          { provide: AddonService, useValue: addonServiceSpy },
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: ElectronService, useValue: electronServiceSpy },
+          { provide: SessionService, useValue: sessionServiceSpy },
+          { provide: WarcraftService, useValue: warcraftServiceSpy },
+        ]},
+    }).compileComponents();
 
-  beforeEach(() => {
     fixture = TestBed.createComponent(GetAddonsComponent);
     component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    electronService = fixture.debugElement.injector.get(ElectronService);
+    sessionService = fixture.debugElement.injector.get(SessionService);
+    warcraftService = fixture.debugElement.injector.get(WarcraftService);
+
     fixture.detectChanges();
   });
 
+  afterEach(() => {
+    fixture.debugElement.nativeElement.remove();
+    fixture.destroy();
+  });
+
   it("should create", () => {
     expect(component).toBeTruthy();
   });
diff --git a/wowup-electron/src/app/pages/home/home.component.spec.ts b/wowup-electron/src/app/pages/home/home.component.spec.ts
index fc6a6df3..55cdb2e4 100644
--- a/wowup-electron/src/app/pages/home/home.component.spec.ts
+++ b/wowup-electron/src/app/pages/home/home.component.spec.ts
@@ -1,36 +1,101 @@
-import { ComponentFixture, TestBed, waitForAsync } from "@angular/core/testing";
-import { RouterTestingModule } from "@angular/router/testing";
-import { TranslateModule } from "@ngx-translate/core";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { AddonService, ScanUpdate, ScanUpdateType } from "../../services/addons/addon.service";
+import { SessionService } from "../../services/session/session.service";
+import { WowUpService } from "../../services/wowup/wowup.service";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { ElectronService } from "../../services";
+import { WarcraftService } from "../../services/warcraft/warcraft.service";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { BehaviorSubject } from "rxjs";
+import { WowClientType } from "../../models/warcraft/wow-client-type";
 import { HomeComponent } from "./home.component";
+import { MatSnackBar } from "@angular/material/snack-bar";
+import { CUSTOM_ELEMENTS_SCHEMA } from "@angular/core";
+import { MatModule } from "../../mat-module";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
 
 describe("HomeComponent", () => {
   let component: HomeComponent;
   let fixture: ComponentFixture<HomeComponent>;
+  let electronService: ElectronService;
+  let electronServiceSpy: any;
+  let wowUpService: WowUpService;
+  let wowUpServiceSpy: any;
+  let sessionService: SessionService;
+  let sessionServiceSpy: any;
+  let addonService: AddonService;
+  let addonServiceSpy: any;
+  let warcraftService: WarcraftService;
+  let warcraftServiceSpy: any;
 
-  beforeEach(
-    waitForAsync(() => {
-      TestBed.configureTestingModule({
-        declarations: [HomeComponent],
-        imports: [TranslateModule.forRoot(), RouterTestingModule],
-      }).compileComponents();
+  beforeEach(async () => {
+    addonServiceSpy = jasmine.createSpyObj("AddonService", [""], {
+      scanUpdate$: new BehaviorSubject<ScanUpdate>({ type: ScanUpdateType.Unknown }).asObservable(),
+    })
+    warcraftServiceSpy = jasmine.createSpyObj("WarcraftService", [""], {
+      installedClientTypes$: new BehaviorSubject<WowClientType[] | undefined>(undefined).asObservable(),
+    })
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", [""], {
+      isWin : false,
+      isLinux : true,
+      isMax: false,
+    });
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", {
+      checkForAppUpdate : async () => null,
     })
-  );
 
-  beforeEach(() => {
+    await TestBed.configureTestingModule({
+      declarations: [HomeComponent],
+      imports: [
+        MatModule,
+        HttpClientModule,
+        BrowserAnimationsModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
+      ],
+      providers: [
+        MatSnackBar,
+      ],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+    }).overrideComponent(HomeComponent, {
+      set: {
+        providers: [
+          { provide: AddonService, useValue: addonServiceSpy },
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: ElectronService, useValue: electronServiceSpy },
+          { provide: SessionService, useValue: sessionServiceSpy },
+          { provide: WarcraftService, useValue: warcraftServiceSpy },
+        ]},
+    }).compileComponents();
+
     fixture = TestBed.createComponent(HomeComponent);
     component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    electronService = fixture.debugElement.injector.get(ElectronService);
+    sessionService = fixture.debugElement.injector.get(SessionService);
+    warcraftService = fixture.debugElement.injector.get(WarcraftService);
+
     fixture.detectChanges();
   });
 
+  afterEach(() => {
+    fixture.debugElement.nativeElement.remove();
+    fixture.destroy();
+  });
+
   it("should create", () => {
     expect(component).toBeTruthy();
   });
-
-  it(
-    "should render title in a h1 tag",
-    waitForAsync(() => {
-      const compiled = fixture.debugElement.nativeElement;
-      expect(compiled.querySelector("h1").textContent).toContain("PAGES.HOME.TITLE");
-    })
-  );
 });
diff --git a/wowup-electron/src/app/pages/my-addons/my-addons.component.spec.ts b/wowup-electron/src/app/pages/my-addons/my-addons.component.spec.ts
index 049766bf..6e92c253 100644
--- a/wowup-electron/src/app/pages/my-addons/my-addons.component.spec.ts
+++ b/wowup-electron/src/app/pages/my-addons/my-addons.component.spec.ts
@@ -1,60 +1,120 @@
-import { Overlay } from "@angular/cdk/overlay";
-import { ChangeDetectorRef, NgZone } from "@angular/core";
-import { inject } from "@angular/core/testing";
-import { MatDialog } from "@angular/material/dialog";
-import { TranslateService } from "@ngx-translate/core";
-import { ElectronService } from "../../services";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { AddonService } from "../../services/addons/addon.service";
 import { SessionService } from "../../services/session/session.service";
+import { MatDialog } from "@angular/material/dialog";
+import { WowUpService } from "../../services/wowup/wowup.service";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { ElectronService } from "../../services";
 import { WarcraftService } from "../../services/warcraft/warcraft.service";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { OverlayModule } from "@angular/cdk/overlay";
 import { MyAddonsComponent } from "./my-addons.component";
 import { WowUpAddonService } from "../../services/wowup/wowup-addon.service";
-import { WowUpService } from "../../services/wowup/wowup.service";
+import { BehaviorSubject, Subject } from "rxjs";
+import { AddonUpdateEvent } from "../../models/wowup/addon-update-event";
+import { SortOrder } from "../../models/wowup/sort-order";
+import { WowClientType } from "../../models/warcraft/wow-client-type";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
+import { MatModule } from "../../mat-module";
+import { CUSTOM_ELEMENTS_SCHEMA } from "@angular/core";
 
 describe("MyAddonsComponent", () => {
-  it("should create", () => {
-    inject(
-      [
-        AddonService,
-        SessionService,
-        NgZone,
-        MatDialog,
-        ChangeDetectorRef,
-        TranslateService,
-        WowUpAddonService,
-        ElectronService,
-        Overlay,
-        WarcraftService,
-        WowUpService,
+  let component: MyAddonsComponent;
+  let fixture: ComponentFixture<MyAddonsComponent>;
+  let electronService: ElectronService;
+  let electronServiceSpy: any;
+  let wowUpService: WowUpService;
+  let wowUpServiceSpy: any;
+  let wowUpAddonService: WowUpAddonService;
+  let wowUpAddonServiceSpy: any;
+  let sessionService: SessionService;
+  let sessionServiceSpy: any;
+  let addonService: AddonService;
+  let addonServiceSpy: any;
+  let warcraftService: WarcraftService;
+  let warcraftServiceSpy: any;
+
+  beforeEach(async () => {
+    wowUpAddonServiceSpy = jasmine.createSpyObj("WowUpAddonService", {
+      persistUpdateInformationToWowUpAddon: () => {},
+    });
+    addonServiceSpy = jasmine.createSpyObj("AddonService", {
+      getAddons: Promise.resolve([]),
+    }, {
+      addonInstalled$: new Subject<AddonUpdateEvent>().asObservable(),
+      addonRemoved$: new Subject<string>().asObservable(),
+    })
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", [""], {
+      myAddonsSortOrder: {name: "test sort", direction: "asc"} as SortOrder,
+    })
+    sessionServiceSpy = jasmine.createSpyObj("SessionService", [""], {
+      selectedHomeTab$: new BehaviorSubject(0).asObservable(),
+      autoUpdateComplete$: new BehaviorSubject(0).asObservable(),
+    })
+    warcraftServiceSpy = jasmine.createSpyObj("WarcraftService", [""], {
+      installedClientTypesSelectItems$: new BehaviorSubject<WowClientType[] | undefined>(undefined).asObservable(),
+    })
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", [""], {
+      isWin : false,
+      isLinux : true,
+      isMac: false,
+    });
+
+    await TestBed.configureTestingModule({
+      declarations: [MyAddonsComponent],
+      imports: [
+        MatModule,
+        OverlayModule,
+        HttpClientModule,
+        BrowserAnimationsModule,
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useFactory: httpLoaderFactory,
+            deps: [HttpClient],
+          },
+          compiler: {
+            provide: TranslateCompiler,
+            useClass: TranslateMessageFormatCompiler,
+          },
+        })
       ],
-      (
-        addonService: AddonService,
-        sessionService: SessionService,
-        ngZone: NgZone,
-        dialog: MatDialog,
-        cdRef: ChangeDetectorRef,
-        wowUpAddonService: WowUpAddonService,
-        translateService: TranslateService,
-        electronService: ElectronService,
-        overlay: Overlay,
-        warcraftService: WarcraftService,
-        wowUpService: WowUpService,
-      ) => {
-        const instance = new MyAddonsComponent(
-          addonService,
-          sessionService,
-          ngZone,
-          dialog,
-          cdRef,
-          wowUpAddonService,
-          translateService,
-          electronService,
-          overlay,
-          warcraftService,
-          wowUpService,
-        );
-        expect(instance).toBeTruthy();
-      }
-    );
+      providers: [
+        MatDialog,
+      ],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+    }).overrideComponent(MyAddonsComponent, {
+      set: {
+        providers: [
+          { provide: AddonService, useValue: addonServiceSpy },
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: WowUpAddonService, useValue: wowUpAddonServiceSpy },
+          { provide: ElectronService, useValue: electronServiceSpy },
+          { provide: SessionService, useValue: sessionServiceSpy },
+          { provide: WarcraftService, useValue: warcraftServiceSpy },
+        ]},
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(MyAddonsComponent);
+    component = fixture.componentInstance;
+    addonService = fixture.debugElement.injector.get(AddonService);
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    wowUpAddonService = fixture.debugElement.injector.get(WowUpAddonService);
+    electronService = fixture.debugElement.injector.get(ElectronService);
+    sessionService = fixture.debugElement.injector.get(SessionService);
+    warcraftService = fixture.debugElement.injector.get(WarcraftService);
+
+    fixture.detectChanges();
+  });
+
+  afterEach(() => {
+    fixture.debugElement.nativeElement.remove();
+    fixture.destroy();
+  });
+
+  it("should create", () => {
+    expect(component).toBeTruthy();
   });
 });
diff --git a/wowup-electron/src/app/pages/my-addons/my-addons.component.ts b/wowup-electron/src/app/pages/my-addons/my-addons.component.ts
index 7c9144c2..1b3fdb00 100644
--- a/wowup-electron/src/app/pages/my-addons/my-addons.component.ts
+++ b/wowup-electron/src/app/pages/my-addons/my-addons.component.ts
@@ -693,7 +693,7 @@ export class MyAddonsComponent implements OnInit, OnDestroy, AfterViewInit {
       this._displayAddonsSrc.next(this.formatAddons(addons));
       this.setPageContextText();
       this._cdRef.detectChanges();
-      this._wowUpAddonService.persistUpdateInformationToWowUpAddon(addons);
+      await this._wowUpAddonService.persistUpdateInformationToWowUpAddon(addons);
     } catch (e) {
       console.error(e);
       this.isBusy = false;
diff --git a/wowup-electron/src/app/pages/options/options.component.spec.ts b/wowup-electron/src/app/pages/options/options.component.spec.ts
index 89b4e434..31cda192 100644
--- a/wowup-electron/src/app/pages/options/options.component.spec.ts
+++ b/wowup-electron/src/app/pages/options/options.component.spec.ts
@@ -1,25 +1,64 @@
-import { inject } from "@angular/core/testing";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { ElectronService } from "../../services/electron/electron.service";
 import { WowUpService } from "../../services/wowup/wowup.service";
 import { OptionsComponent } from "./options.component";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { CUSTOM_ELEMENTS_SCHEMA } from "@angular/core";
 
 describe("OptionsComponent", () => {
+  let component: OptionsComponent;
+  let fixture: ComponentFixture<OptionsComponent>;
+  let electronService: ElectronService;
+  let wowUpService: WowUpService;
+  let electronServiceSpy: any;
+  let wowUpServiceSpy: any;
+
+  beforeEach(async () => {
+    wowUpServiceSpy = jasmine.createSpyObj("WowUpService", {
+      getThemeLogoPath: () => "",
+    }, {
+      currentTheme: "horde ofc",
+    });
+    electronServiceSpy = jasmine.createSpyObj("ElectronService", [""], {
+      isWin : false,
+      isLinux : true,
+      isMac: false,
+    });
+
+    await TestBed.configureTestingModule({
+      declarations: [OptionsComponent],
+      imports: [HttpClientModule, TranslateModule.forRoot({
+        loader: {
+          provide: TranslateLoader,
+          useFactory: httpLoaderFactory,
+          deps: [HttpClient],
+        },
+        compiler: {
+          provide: TranslateCompiler,
+          useClass: TranslateMessageFormatCompiler,
+        },
+      })],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+    }).overrideComponent(OptionsComponent, {
+      set: {
+        providers: [
+          { provide: WowUpService, useValue: wowUpServiceSpy },
+          { provide: ElectronService, useValue: electronServiceSpy },
+        ]},
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(OptionsComponent);
+    component = fixture.componentInstance;
+    wowUpService = fixture.debugElement.injector.get(WowUpService);
+    electronService = fixture.debugElement.injector.get(ElectronService);
+
+    fixture.detectChanges();
+  });
+
   it("should create", () => {
-    inject(
-      [
-        WowUpService,
-        ElectronService,
-      ],
-      (
-        wowupService: WowUpService,
-        electronService: ElectronService,
-      ) => {
-        const instance = new OptionsComponent(
-          wowupService,
-          electronService,
-        );
-        expect(instance).toBeTruthy();
-      }
-    );
+    expect(component).toBeTruthy();
   });
 });
diff --git a/wowup-electron/src/app/pipes/download-count.pipe.spec.ts b/wowup-electron/src/app/pipes/download-count.pipe.spec.ts
index 5ce1c232..52de0ca5 100644
--- a/wowup-electron/src/app/pipes/download-count.pipe.spec.ts
+++ b/wowup-electron/src/app/pipes/download-count.pipe.spec.ts
@@ -1,21 +1,67 @@
-import { ComponentFixture, TestBed, waitForAsync } from "@angular/core/testing";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { DownloadCountPipe } from "./download-count.pipe";
+import { Component } from "@angular/core";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+
+@Component({
+  template: `<p>{{ number | downloadCount }}</p>`,
+})
+class TestDownloadCountComponent {
+  public number: number = 0;
+}
 
 describe("DownloadCountPipe", () => {
-  let directive: DownloadCountPipe;
-  let fixture: ComponentFixture<DownloadCountPipe>;
+  let component: TestDownloadCountComponent;
+  let fixture: ComponentFixture<TestDownloadCountComponent>;
 
-  beforeEach(
-    waitForAsync(() => {
-      TestBed.configureTestingModule({
-        declarations: [DownloadCountPipe],
-      }).compileComponents();
-    })
-  );
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [TestDownloadCountComponent, DownloadCountPipe],
+      imports: [HttpClientModule, TranslateModule.forRoot({
+        loader: {
+          provide: TranslateLoader,
+          useFactory: httpLoaderFactory,
+          deps: [HttpClient],
+        },
+        compiler: {
+          provide: TranslateCompiler,
+          useClass: TranslateMessageFormatCompiler,
+        },
+      })],
+    }).compileComponents();
 
-  it("should create an instance", () => {
-    fixture = TestBed.createComponent(DownloadCountPipe);
-    directive = fixture.componentInstance;
-    expect(directive).toBeTruthy();
+    fixture = TestBed.createComponent(TestDownloadCountComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
   });
+
+  it("should create", () => {
+    expect(component).toBeTruthy();
+  });
+
+  const inputs = {
+    "e+0": 1,
+    "e+1": 10,
+    "e+2": 100,
+    "e+3": 1000,
+    "e+4": 10000,
+    "e+5": 100000,
+    "e+6": 1000000,
+    "e+7": 10000000,
+    "e+8": 100000000,
+    "e+9": 1000000000,
+  };
+
+  for (let index in inputs) {
+    let number = inputs[index];
+    it(`should transform the number ${number} to ${index}`, () => {
+      component.number = number;
+      fixture.detectChanges();
+      let p = fixture.debugElement.nativeElement.querySelector("p");
+      expect(p.innerHTML).toBe(`COMMON.DOWNLOAD_COUNT.${index}`);
+    });
+  }
 });
diff --git a/wowup-electron/src/app/pipes/get-addon-list-item-file-prop.pipe.spec.ts b/wowup-electron/src/app/pipes/get-addon-list-item-file-prop.pipe.spec.ts
index 109731d0..51e3e970 100644
--- a/wowup-electron/src/app/pipes/get-addon-list-item-file-prop.pipe.spec.ts
+++ b/wowup-electron/src/app/pipes/get-addon-list-item-file-prop.pipe.spec.ts
@@ -1,21 +1,51 @@
 import { ComponentFixture, TestBed, waitForAsync } from "@angular/core/testing";
 import { GetAddonListItemFilePropPipe } from "./get-addon-list-item-file-prop.pipe";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { httpLoaderFactory } from "../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
+import { Component } from "@angular/core";
+import { GetAddonListItem } from "../business-objects/get-addon-list-item";
+import { AddonChannelType } from "../models/wowup/addon-channel-type";
+
+@Component({
+  template: `<p>{{ item | getAddonListItemFileProp: "version": channel }}</p>`,
+})
+class TestAddonListItemFilePropComponent {
+  public item: GetAddonListItem = {
+    searchResult: {
+      files: [],
+    },
+  } as GetAddonListItem;
+  public channel: AddonChannelType = AddonChannelType.Stable;
+}
 
 describe("GetAddonListItemFilePropPipe", () => {
-  let directive: GetAddonListItemFilePropPipe;
-  let fixture: ComponentFixture<GetAddonListItemFilePropPipe>;
+  let component: TestAddonListItemFilePropComponent;
+  let fixture: ComponentFixture<TestAddonListItemFilePropComponent>;
 
-  beforeEach(
-    waitForAsync(() => {
-      TestBed.configureTestingModule({
-        declarations: [GetAddonListItemFilePropPipe],
-      }).compileComponents();
-    })
-  );
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [TestAddonListItemFilePropComponent, GetAddonListItemFilePropPipe],
+      imports: [HttpClientModule, TranslateModule.forRoot({
+        loader: {
+          provide: TranslateLoader,
+          useFactory: httpLoaderFactory,
+          deps: [HttpClient],
+        },
+        compiler: {
+          provide: TranslateCompiler,
+          useClass: TranslateMessageFormatCompiler,
+        },
+      })],
+    }).compileComponents();
 
-  it("should create an instance", () => {
-    fixture = TestBed.createComponent(GetAddonListItemFilePropPipe);
-    directive = fixture.componentInstance;
-    expect(directive).toBeTruthy();
+    fixture = TestBed.createComponent(TestAddonListItemFilePropComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it("should create", () => {
+    expect(component).toBeTruthy();
   });
 });
diff --git a/wowup-electron/src/app/pipes/interface-format.pipe.spec.ts b/wowup-electron/src/app/pipes/interface-format.pipe.spec.ts
index 354c0050..271176ad 100644
--- a/wowup-electron/src/app/pipes/interface-format.pipe.spec.ts
+++ b/wowup-electron/src/app/pipes/interface-format.pipe.spec.ts
@@ -1,21 +1,50 @@
-import { ComponentFixture, TestBed, waitForAsync } from "@angular/core/testing";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
 import { InterfaceFormatPipe } from "./interface-format.pipe";
+import { Component } from "@angular/core";
+
+@Component({
+  template: `<p>{{ version | interfaceFormat }}</p>`,
+})
+class TestInterfaceFormatComponent {
+  public version: string = "";
+}
 
 describe("InterfaceFormatPipe", () => {
-  let directive: InterfaceFormatPipe;
-  let fixture: ComponentFixture<InterfaceFormatPipe>;
+  let component: TestInterfaceFormatComponent;
+  let fixture: ComponentFixture<TestInterfaceFormatComponent>;
 
-  beforeEach(
-    waitForAsync(() => {
-      TestBed.configureTestingModule({
-        declarations: [InterfaceFormatPipe],
-      }).compileComponents();
-    })
-  );
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [TestInterfaceFormatComponent, InterfaceFormatPipe],
+    }).compileComponents();
 
-  it("should create an instance", () => {
-    fixture = TestBed.createComponent(InterfaceFormatPipe);
-    directive = fixture.componentInstance;
-    expect(directive).toBeTruthy();
+    fixture = TestBed.createComponent(TestInterfaceFormatComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it("should create", () => {
+    expect(component).toBeTruthy();
+  });
+
+  it("should transform .toc format to semver", () => {
+    component.version = "90002";
+    fixture.detectChanges();
+    let p = fixture.debugElement.nativeElement.querySelector("p");
+    expect(p.innerHTML).toBe("9.0.2");
+  });
+
+  it("should leave any dot version alone", () => {
+    let p: HTMLElement;
+
+    component.version = "0.1";
+    fixture.detectChanges();
+    p = fixture.debugElement.nativeElement.querySelector("p");
+    expect(p.innerHTML).toBe("0.1");
+
+    component.version = "8.3.1";
+    fixture.detectChanges();
+    p = fixture.debugElement.nativeElement.querySelector("p");
+    expect(p.innerHTML).toBe("8.3.1");
   });
 });
diff --git a/wowup-electron/src/app/pipes/relative-duration-pipe.spec.ts b/wowup-electron/src/app/pipes/relative-duration-pipe.spec.ts
index 3a9baf7a..b00deaea 100644
--- a/wowup-electron/src/app/pipes/relative-duration-pipe.spec.ts
+++ b/wowup-electron/src/app/pipes/relative-duration-pipe.spec.ts
@@ -1,13 +1,44 @@
-import { DatePipe } from "@angular/common";
-import { inject } from "@angular/core/testing";
-import { TranslateService } from "@ngx-translate/core";
+import { ComponentFixture, TestBed } from "@angular/core/testing";
+import { Component } from "@angular/core";
+import { TranslateCompiler, TranslateLoader, TranslateModule } from "@ngx-translate/core";
+import { HttpClient, HttpClientModule } from "@angular/common/http";
+import { httpLoaderFactory } from "../app.module";
+import { TranslateMessageFormatCompiler } from "ngx-translate-messageformat-compiler";
 import { RelativeDurationPipe } from "./relative-duration-pipe";
 
+@Component({
+  template: `<p>{{ date | relativeDuration }}</p>`,
+})
+class TestRelativeDurationComponent {
+  public date = new Date().toString();
+}
+
 describe("RelativeDurationPipe", () => {
-  it("create an instance", () => {
-    inject([DatePipe, TranslateService], (datePipe: DatePipe, translateService: TranslateService) => {
-      const pipe = new RelativeDurationPipe(translateService);
-      expect(pipe).toBeTruthy();
-    });
+  let component: TestRelativeDurationComponent;
+  let fixture: ComponentFixture<TestRelativeDurationComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [TestRelativeDurationComponent, RelativeDurationPipe],
+      imports: [HttpClientModule, TranslateModule.forRoot({
+        loader: {
+          provide: TranslateLoader,
+          useFactory: httpLoaderFactory,
+          deps: [HttpClient],
+        },
+        compiler: {
+          provide: TranslateCompiler,
+          useClass: TranslateMessageFormatCompiler,
+        },
+      })],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(TestRelativeDurationComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it("should create", () => {
+    expect(component).toBeTruthy();
   });
 });
diff --git a/wowup-electron/src/app/services/electron/electron.service.spec.ts b/wowup-electron/src/app/services/electron/electron.service.spec.ts
index 268db7cd..b630924b 100644
--- a/wowup-electron/src/app/services/electron/electron.service.spec.ts
+++ b/wowup-electron/src/app/services/electron/electron.service.spec.ts
@@ -1,11 +1,14 @@
-import { TestBed } from "@angular/core/testing";
 import { ElectronService } from "./electron.service";
 
-describe("ElectronService", () => {
-  beforeEach(() => TestBed.configureTestingModule({}));
+class StubbedElectronService extends ElectronService {
+  public get isElectron(): boolean {
+    return false;
+  }
+}
 
+describe("ElectronService", () => {
   it("should be created", () => {
-    const service: ElectronService = new ElectronService();
+    const service: ElectronService = new StubbedElectronService();
     expect(service).toBeTruthy();
   });
 });
diff --git a/wowup-electron/src/app/services/icons/icon.service.ts b/wowup-electron/src/app/services/icons/icon.service.ts
index d827368e..a0fa0c47 100644
--- a/wowup-electron/src/app/services/icons/icon.service.ts
+++ b/wowup-electron/src/app/services/icons/icon.service.ts
@@ -2,7 +2,6 @@ import { Injectable } from "@angular/core";
 import { MatIconRegistry } from "@angular/material/icon";
 import { IconDefinition } from "@fortawesome/fontawesome-svg-core";
 import { DomSanitizer } from "@angular/platform-browser";
-
 import {
   faAngleDoubleDown,
   faArrowUp,
diff --git a/wowup-electron/src/app/utils/addon.utils.ts b/wowup-electron/src/app/utils/addon.utils.ts
index c5f12f1a..4eddcf67 100644
--- a/wowup-electron/src/app/utils/addon.utils.ts
+++ b/wowup-electron/src/app/utils/addon.utils.ts
@@ -31,7 +31,7 @@ export function getGameVersion(gameVersion: string): string {
     return gameVersion;
   }
 
-  if (gameVersion.indexOf(".") !== -1) {
+  if (gameVersion.toString().indexOf(".") !== -1) {
     return gameVersion;
   }