it('file replacements work with forked type checker on watch mode', async () => {
host.writeMultipleFiles({
'src/file-replaced.ts': 'export var obj = { one: 1, two: 2 };',
'src/file.ts': `export var obj = { one: 1 };`,
'src/main.ts': `
import { obj } from './file';
console.log(obj.two);
`,
});
const overrides = {
fileReplacements: [{
replace: normalize('/src/file.ts'),
with: normalize('/src/file-replaced.ts'),
}],
watch: true,
};
const unexpectedError = `Property 'two' does not exist on type '{ one: number; }'`;
const expectedError = `Property 'prop' does not exist on type '{}'`;
const logger = new TestLogger('rebuild-type-errors');
// Race between a timeout and the expected log entry.
const stop$ = race<null | string>(
of(null).pipe(delay(45000 * 2 / 3)),
logger.pipe(
filter(entry => entry.message.includes(expectedError)),
map(entry => entry.message),
take(1),
),
);
let errorAdded = false;
const run = await architect.scheduleTarget(target, overrides, { logger });
run.output.pipe(
tap((buildEvent) => expect(buildEvent.success).toBe(true, 'build should succeed')),
tap(() => {
// Introduce a known type error to detect in the logger filter.
if (!errorAdded) {
host.appendToFile('src/main.ts', 'console.log({}.prop);');
errorAdded = true;
}
}),
takeUntil(stop$),
).subscribe();
const res = await stop$.toPromise();
expect(res).not.toBe(null, 'Test timed out.');
expect(res).not.toContain(unexpectedError);
await run.stop();
});
it ('Minimal (implied defaults)', () => {
const newSetting: UserSettingState = UserSettingUtil.updateUserSettingState(userSettingState, mutable => {
mutable.boardCode = 'TEST&=123';
});
userSettingSubject.next(newSetting);
urlObservable
.pipe(
take(1)
)
.subscribe(s => {
const parsedState = userSettingStateFromQueryString(s);
expect(parsedState).toEqual(newSetting);
})
});
resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<Hero> {
let id = +route.paramMap.get('id')
return this.heroService.getHero(id).pipe(
take(1),
map(hero => {
if (hero) {
return hero;
} else {
this.router.navigate(['heroes']);
return null;
}
})
)
}
it('should update streaming translations on language change', (done: Function) => {
translations = {"TEST": "This is a test"};
translate.use('en');
translate.stream('TEST').pipe(take(3), toArray()).subscribe((res: string[]) => {
const expected = ['This is a test', 'Dit is een test', 'This is a test'];
expect(res).toEqual(expected);
done();
});
translate.setTranslation('nl', {"TEST": "Dit is een test"});
translate.use('nl');
translate.use('en');
});
it(`handles function selection on a base path that doesn't exist yet`, () => {
const nonExistentSubStore = ngRedux.configureSubStore(
['sure', 'whatever'],
(state: any, action: any) => ({ ...state, value: action.newValue })
);
nonExistentSubStore
.select(s => (s ? s.value : s))
.pipe(take(2), toArray())
.subscribe(v => expect(v).toEqual([undefined, 'now I exist']));
nonExistentSubStore.dispatch<AnyAction>({
type: 'nvm',
newValue: 'now I exist',
});
});
test('Receive correct message type', t => {
const service = new MqttService(t.context.mqtt);
const observer = service.observe('/test/hallo2').pipe(take(1));
observer.subscribe(value => {
t.is(value.topic, 'test/hallo2');
t.is(value.val, 'world');
t.is(value.retain, false);
});
t.context.mqtt.publish('test/hallo2', 'world', { retain: false, qos: 0 });
return observer;
});
mergeMap((aObject: Ha4usObject) => {
return this.$states.observe(aObject.topic).pipe(
timeoutWith(100, of({})),
take(1),
map((state: Ha4usMessage) => {
delete state.topic
delete state.match
return {
object: aObject,
state: state,
}
})
)
}),
resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<Prestation> {
const id = route.paramMap.get('id');
return this.prestationService.getPrestation(id).pipe(
take(1),
tap((data) => {
if (data) {
return data;
} else {
this.router.navigate(['prestations/chart']);
return null;
}
})
);
}
/**
* Get Filters
*
* @returns {Observable<any>}
*/
getFilters(): any
{
return this._store.pipe(
select(getFiltersLoaded),
tap(loaded => {
if ( !loaded )
{
this._store.dispatch(new fromStore.GetFilters([]));
}
}),
filter(loaded => loaded),
take(1)
);
}
onSubmit() {
const fullPath = `${this.rootFolder}/${this.form.get("folderName").value}`;
this.dataGateway.createLocalFolder(fullPath).pipe(
take(1)
).subscribeTracked(this, () => {
this.localFileRepository.reloadPath(this.rootFolder);
this.modal.close();
}, err => {
this.form.setErrors({
creationFailure: err.message
})
});
}
