mirror/WowUp
1
0
Fork 0
mirror of https://github.com/WowUp/WowUp.git synced 2026-04-23 15:27:03 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #509 from linaori/fix/test-completion

Browse Source 
Fixed testsuite
This commit is contained in:
jliddev
2020-11-24 07:19:59 -08:00
committed by GitHub
parent 8f6043d3a3 0d544564bf
commit 821f6eedfe
37 changed files with 1417 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
.github/workflows/locale-test.yml vendored
View File

@@ -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

112
wowup-electron/src/app/app.component.spec.ts
View File

@@ -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();
});
});

60
wowup-electron/src/app/components/addon-detail/addon-detail.component.spec.ts
View File

@@ -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();
});

52
wowup-electron/src/app/components/addon-install-button/addon-install-button.component.spec.ts
View File

@@ -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();
});

75
wowup-electron/src/app/components/addon-update-button/addon-update-button.component.spec.ts
View File

@@ -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();
});
});

27
wowup-electron/src/app/components/alert-dialog/alert-dialog.component.spec.ts
View File

@@ -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();

27
wowup-electron/src/app/components/confirm-dialog/confirm-dialog.component.spec.ts
View File

@@ -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();

58
wowup-electron/src/app/components/footer/footer.component.spec.ts
View File

@@ -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();
});

4
wowup-electron/src/app/components/get-addon-status-column/get-addon-status-column.component.spec.ts
View File

@@ -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();

43
wowup-electron/src/app/components/install-from-url-dialog/install-from-url-dialog.component.spec.ts
View File

@@ -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();
});

15
wowup-electron/src/app/components/my-addon-status-column/my-addon-status-column.component.spec.ts
View File

@@ -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();
});

45
wowup-electron/src/app/components/my-addons-addon-cell/my-addons-addon-cell.component.spec.ts
View File

@@ -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();
});
});

78
wowup-electron/src/app/components/options-app-section/options-app-section.component.spec.ts
View File

@@ -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();
});

51
wowup-electron/src/app/components/options-debug-section/options-debug-section.component.spec.ts
View File

@@ -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();
}));
});

46
wowup-electron/src/app/components/options-wow-section/options-wow-section.component.spec.ts
View File

@@ -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();
});

24
wowup-electron/src/app/components/progress-spinner/progress-spinner.component.spec.ts
View File

@@ -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();

26
wowup-electron/src/app/components/telemetry-dialog/telemetry-dialog.component.spec.ts
View File

@@ -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();

4
wowup-electron/src/app/components/titlebar/titlebar.component.html
View File

@@ -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>
</div>

47
wowup-electron/src/app/components/titlebar/titlebar.component.spec.ts
View File

@@ -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();
});

14
wowup-electron/src/app/components/titlebar/titlebar.component.ts
View File

@@ -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()) {

90
wowup-electron/src/app/components/wow-client-options/wow-client-options.component.spec.ts
View File

@@ -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();
});
});

4
wowup-electron/src/app/components/wow-client-options/wow-client-options.component.ts
View File

@@ -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";

56
wowup-electron/src/app/directives/external-link.directive.spec.ts
View File

@@ -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/");
});
});

51
wowup-electron/src/app/pages/about/about.component.spec.ts
View File

@@ -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();
});

3
wowup-electron/src/app/pages/about/about.component.ts
View File

@@ -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 {

94
wowup-electron/src/app/pages/get-addons/get-addons.component.spec.ts
View File

@@ -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();
});

103
wowup-electron/src/app/pages/home/home.component.spec.ts
View File

@@ -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");
})
);
});

160
wowup-electron/src/app/pages/my-addons/my-addons.component.spec.ts
View File

@@ -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();
});
});

2
wowup-electron/src/app/pages/my-addons/my-addons.component.ts
View File

@@ -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;

73
wowup-electron/src/app/pages/options/options.component.spec.ts
View File

@@ -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();
});
});

74
wowup-electron/src/app/pipes/download-count.pipe.spec.ts
View File

@@ -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}`);
});
}
});

56
wowup-electron/src/app/pipes/get-addon-list-item-file-prop.pipe.spec.ts
View File

@@ -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();
});
});

57
wowup-electron/src/app/pipes/interface-format.pipe.spec.ts
View File

@@ -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");
});
});

47
wowup-electron/src/app/pipes/relative-duration-pipe.spec.ts
View File

@@ -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();
});
});

11
wowup-electron/src/app/services/electron/electron.service.spec.ts
View File

@@ -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();
});
});

1
wowup-electron/src/app/services/icons/icon.service.ts
View File

@@ -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,

2
wowup-electron/src/app/utils/addon.utils.ts
View File

@@ -31,7 +31,7 @@ export function getGameVersion(gameVersion: string): string {
return gameVersion;
}
if (gameVersion.indexOf(".") !== -1) {
if (gameVersion.toString().indexOf(".") !== -1) {
return gameVersion;
}