it('should retrieve a type', () => {
const chargeCategoryService = TestBed.get(ChargeCategoryService);
const expectedResult: Observable<ChargeCategoryModel> = of({ id: 42, name: 'rental' });
spyOn(chargeCategoryService, 'get').and.returnValue(expectedResult);
const resolver = TestBed.get(ChargeCategoryResolverService);
const params = { id: '42' } as Params;
const paramMap = convertToParamMap(params);
const routeSnapshot = { paramMap } as ActivatedRouteSnapshot;
const result = resolver.resolve(routeSnapshot);
expect(result).toBe(expectedResult);
expect(chargeCategoryService.get).toHaveBeenCalledWith(42);
});
it('caches overlays when product unchanged', () => {
const event = new Event({
id: 'us0000test',
properties: {
products: {
origin: [
{
properties: {
latitude: '12',
longitude: '13'
}
},
{
code: 'othercode',
properties: {
latitude: '14',
longitude: '15'
},
source: 'othersource'
}
]
}
}
});
const params = convertToParamMap({});
const otherparams = convertToParamMap({
epicenter: 'false',
'origin-code': 'othercode',
'origin-source': 'othersource'
});
pipe.overlayFactories = [
{ type: 'origin', pipe: new RegionInfoOverlaysPipe() }
];
let overlays = pipe.transform(event, null);
const epicenterOverlay = overlays.filter(overlay => {
return overlay instanceof EpicenterOverlay;
})[0];
// same event, with params object that results in same product
overlays = pipe.transform(event, params);
expect(
overlays.filter(overlay => {
return overlay instanceof EpicenterOverlay;
})[0]
).toBe(epicenterOverlay);
// different params, should be different overlay
overlays = pipe.transform(event, otherparams);
const otherEpicenterOverlay = overlays.filter(overlay => {
return overlay instanceof EpicenterOverlay;
})[0];
expect(otherEpicenterOverlay).not.toBe(epicenterOverlay);
expect(otherEpicenterOverlay.enabled).toBeFalsy();
});
beforeEach(async(() => {
TestBed.configureTestingModule({
imports: [
BrowserModule,
RouterTestingModule,
DragDropModule,
MaterialModule,
FormsModule,
FormHelperModule,
LayoutModule,
ReactiveFormsModule,
HttpClientTestingModule,
NgxsModule.forRoot([AppState, SessionState]),
NgxsFormPluginModule,
NgProgressModule,
NgProgressHttpModule,
NoopAnimationsModule,
ToastrModule.forRoot(),
],
providers: [
{
provide: ActivatedRoute,
useValue: {
paramMap: of(convertToParamMap({
storageId: 'storage-id',
type: RepositoryTypeEnum.HOSTED.toLowerCase()
}))
}
}
],
declarations: [ManageRepositoryComponent]
}).compileComponents();
}));
function prepareModule(task: TaskModel, concernedPersonId: number) {
const activatedRoute = {
snapshot: {
data: {
persons,
users,
categories,
task
},
paramMap: convertToParamMap(concernedPersonId ? {'concerned-person': concernedPersonId.toString()} : {})
}
} as any;
TestBed.configureTestingModule({
imports: [
CurrentUserModule.forRoot(),
ReactiveFormsModule,
RouterTestingModule,
GlobeNgbModule.forRoot(),
HttpClientModule,
ValdemortModule
],
declarations: [TaskEditComponent, ValidationDefaultsComponent, PageTitleDirective],
providers: [{ provide: ActivatedRoute, useValue: activatedRoute }]
});
TestBed.createComponent(ValidationDefaultsComponent).detectChanges();
// different object on purpose
TestBed.get(CurrentUserService).userEvents.next({id: 3, login: '******', admin: false});
}
beforeEach(async(() => {
TestBed.configureTestingModule({
imports: [
TestsModule,
TranslateModule.forRoot(),
HeroesModule
],
providers: [
{provide: APP_CONFIG, useValue: AppConfig},
{provide: APP_BASE_HREF, useValue: '/'},
{
provide: ActivatedRoute,
useValue: {
snapshot: {
paramMap: convertToParamMap({
id: '1'
})
}
}
},
HeroService
],
}).compileComponents();
fixture = TestBed.createComponent(HeroDetailComponent);
fixture.detectChanges();
component = fixture.debugElement.componentInstance;
heroService = TestBed.get(HeroService);
}));
beforeEach(async(() => {
TestBed.configureTestingModule({
declarations: [
PlayersListComponent
],
imports: [
HttpClientTestingModule,
NgbModule.forRoot(),
ReactiveFormsModule,
RouterTestingModule
],
providers: [
{
provide: ActivatedRoute,
useValue: {
snapshot: {
paramMap: convertToParamMap({
groupName: 'Under 10',
yearOfBirth: '2008'
})
}
}
},
NgbModal,
PlayersService
]
})
.compileComponents();
}));
beforeEach(async(() => {
TestBed.configureTestingModule({
declarations: [
MockComponent,
CreatePasswordComponent
],
imports: [
HttpClientTestingModule,
ReactiveFormsModule,
RouterTestingModule.withRoutes([
{ path: "login", component: MockComponent }
])
],
providers: [
{
provide: ActivatedRoute,
useValue: {
snapshot: {
paramMap: convertToParamMap({
userToken: 'dummyToken'
})
}
}
},
UserService,
ValidationService
],
schemas: [
NO_ERRORS_SCHEMA
]
})
.compileComponents();
}));
it('should have a title', () => {
const participants = [] as Array<ParticipantModel>;
dataSubject.next({ participants });
paramMapSubject.next(convertToParamMap({ activityType : 'MEAL' }));
fixture.detectChanges();
expect(fixture.nativeElement.querySelector('h2').textContent).toBe('Participants aux activités de type Repas');
});
it('should resolve tasks when page is present', () => {
const route = routeWithType('archived');
(route as any).queryParamMap = convertToParamMap({page: '2'});
const expected = of({} as Page<TaskModel>);
spyOn(taskService, 'listArchived').and.returnValue(expected);
expect(resolver.resolve(route)).toBe(expected);
expect(taskService.listArchived).toHaveBeenCalledWith(2);
});
it('should resolve family when editing it', () => {
const route = {
paramMap: convertToParamMap({
id: 42
})
} as ActivatedRouteSnapshot;
expect(resolver.resolve(route)).toBe(family);
});
