Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

chore(typings): unwrap it-wrapped type tests #2877

Merged
merged 3 commits into from
Nov 6, 2017
Merged

chore(typings): unwrap it-wrapped type tests #2877

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
d5efe12
chore(typings): move test descriptions
cartant Sep 28, 2017
de795c2
chore(typings): remove type it wrappers
cartant Sep 28, 2017
c4ce8e9
chore(typings): fix test indentation
cartant Sep 28, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
136 changes: 61 additions & 75 deletions spec/observables/combineLatest-spec.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -480,80 +480,66 @@ describe('Observable.combineLatest', () => {
expectSubscriptions(e2.subscriptions).toBe(e2subs);
});

it('should support promises', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let b: Promise<string>;
let c: Promise<boolean>;
let o1: Rx.Observable<[number, string, boolean]> = Observable.combineLatest(a, b, c);
let o2: Rx.Observable<boolean> = Observable.combineLatest(a, b, c, (aa, bb, cc) => !!aa && !!bb && cc);
/* tslint:enable:no-unused-variable */
});
});

it('should support observables', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>;
let b: Rx.Observable<string>;
let c: Rx.Observable<boolean>;
let o1: Rx.Observable<[number, string, boolean]> = Observable.combineLatest(a, b, c);
let o2: Rx.Observable<boolean> = Observable.combineLatest(a, b, c, (aa, bb, cc) => !!aa && !!bb && cc);
/* tslint:enable:no-unused-variable */
});
});

it('should support mixed observables and promises', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let b: Rx.Observable<string>;
let c: Promise<boolean>;
let d: Rx.Observable<string[]>;
let o1: Rx.Observable<[number, string, boolean, string[]]> = Observable.combineLatest(a, b, c, d);
let o2: Rx.Observable<boolean> = Observable.combineLatest(a, b, c, d, (aa, bb, cc, dd) => !!aa && !!bb && cc && !!dd.length);
/* tslint:enable:no-unused-variable */
});
});

it('should support arrays of promises', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>[];
let o1: Rx.Observable<number[]> = Observable.combineLatest(a);
let o2: Rx.Observable<number[]> = Observable.combineLatest(...a);
let o3: Rx.Observable<number> = Observable.combineLatest(a, (...x) => x.length);
/* tslint:enable:no-unused-variable */
});
});

it('should support arrays of observables', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>[];
let o1: Rx.Observable<number[]> = Observable.combineLatest(a);
let o2: Rx.Observable<number[]> = Observable.combineLatest(...a);
let o3: Rx.Observable<number> = Observable.combineLatest(a, (...x) => x.length);
/* tslint:enable:no-unused-variable */
});
});

it('should return Array<T> when given a single promise', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let o1: Rx.Observable<number[]> = Observable.combineLatest(a);
/* tslint:enable:no-unused-variable */
});
});

it('should return Array<T> when given a single observable', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>;
let o1: Rx.Observable<number[]> = Observable.combineLatest(a);
/* tslint:enable:no-unused-variable */
});
type('should support promises', () => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let b: Promise<string>;
let c: Promise<boolean>;
let o1: Rx.Observable<[number, string, boolean]> = Observable.combineLatest(a, b, c);
let o2: Rx.Observable<boolean> = Observable.combineLatest(a, b, c, (aa, bb, cc) => !!aa && !!bb && cc);
/* tslint:enable:no-unused-variable */
});

type('should support observables', () => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>;
let b: Rx.Observable<string>;
let c: Rx.Observable<boolean>;
let o1: Rx.Observable<[number, string, boolean]> = Observable.combineLatest(a, b, c);
let o2: Rx.Observable<boolean> = Observable.combineLatest(a, b, c, (aa, bb, cc) => !!aa && !!bb && cc);
/* tslint:enable:no-unused-variable */
});

type('should support mixed observables and promises', () => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let b: Rx.Observable<string>;
let c: Promise<boolean>;
let d: Rx.Observable<string[]>;
let o1: Rx.Observable<[number, string, boolean, string[]]> = Observable.combineLatest(a, b, c, d);
let o2: Rx.Observable<boolean> = Observable.combineLatest(a, b, c, d, (aa, bb, cc, dd) => !!aa && !!bb && cc && !!dd.length);
/* tslint:enable:no-unused-variable */
});

type('should support arrays of promises', () => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>[];
let o1: Rx.Observable<number[]> = Observable.combineLatest(a);
let o2: Rx.Observable<number[]> = Observable.combineLatest(...a);
let o3: Rx.Observable<number> = Observable.combineLatest(a, (...x) => x.length);
/* tslint:enable:no-unused-variable */
});

type('should support arrays of observables', () => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>[];
let o1: Rx.Observable<number[]> = Observable.combineLatest(a);
let o2: Rx.Observable<number[]> = Observable.combineLatest(...a);
let o3: Rx.Observable<number> = Observable.combineLatest(a, (...x) => x.length);
/* tslint:enable:no-unused-variable */
});

type('should return Array<T> when given a single promise', () => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let o1: Rx.Observable<number[]> = Observable.combineLatest(a);
/* tslint:enable:no-unused-variable */
});

type('should return Array<T> when given a single observable', () => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>;
let o1: Rx.Observable<number[]> = Observable.combineLatest(a);
/* tslint:enable:no-unused-variable */
});
});
136 changes: 61 additions & 75 deletions spec/observables/forkJoin-spec.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -360,80 +360,66 @@ describe('Observable.forkJoin', () => {
expectSubscriptions(e2.subscriptions).toBe(e2subs);
});

it('should support promises', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let b: Promise<string>;
let c: Promise<boolean>;
let o1: Rx.Observable<[number, string, boolean]> = Observable.forkJoin(a, b, c);
let o2: Rx.Observable<boolean> = Observable.forkJoin(a, b, c, (aa, bb, cc) => !!aa && !!bb && cc);
/* tslint:enable:no-unused-variable */
});
});

it('should support observables', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>;
let b: Rx.Observable<string>;
let c: Rx.Observable<boolean>;
let o1: Rx.Observable<[number, string, boolean]> = Observable.forkJoin(a, b, c);
let o2: Rx.Observable<boolean> = Observable.forkJoin(a, b, c, (aa, bb, cc) => !!aa && !!bb && cc);
/* tslint:enable:no-unused-variable */
});
});

it('should support mixed observables and promises', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let b: Rx.Observable<string>;
let c: Promise<boolean>;
let d: Rx.Observable<string[]>;
let o1: Rx.Observable<[number, string, boolean, string[]]> = Observable.forkJoin(a, b, c, d);
let o2: Rx.Observable<boolean> = Observable.forkJoin(a, b, c, d, (aa, bb, cc, dd) => !!aa && !!bb && cc && !!dd.length);
/* tslint:enable:no-unused-variable */
});
});

it('should support arrays of promises', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>[];
let o1: Rx.Observable<number[]> = Observable.forkJoin(a);
let o2: Rx.Observable<number[]> = Observable.forkJoin(...a);
let o3: Rx.Observable<number> = Observable.forkJoin(a, (...x) => x.length);
/* tslint:enable:no-unused-variable */
});
});

it('should support arrays of observables', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>[];
let o1: Rx.Observable<number[]> = Observable.forkJoin(a);
let o2: Rx.Observable<number[]> = Observable.forkJoin(...a);
let o3: Rx.Observable<number> = Observable.forkJoin(a, (...x) => x.length);
/* tslint:enable:no-unused-variable */
});
});

it('should return Array<T> when given a single promise', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let o1: Rx.Observable<number[]> = Observable.forkJoin(a);
/* tslint:enable:no-unused-variable */
});
});

it('should return Array<T> when given a single observable', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>;
let o1: Rx.Observable<number[]> = Observable.forkJoin(a);
/* tslint:enable:no-unused-variable */
});
type('should support promises', () => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let b: Promise<string>;
let c: Promise<boolean>;
let o1: Rx.Observable<[number, string, boolean]> = Observable.forkJoin(a, b, c);
let o2: Rx.Observable<boolean> = Observable.forkJoin(a, b, c, (aa, bb, cc) => !!aa && !!bb && cc);
/* tslint:enable:no-unused-variable */
});

type('should support observables', () => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>;
let b: Rx.Observable<string>;
let c: Rx.Observable<boolean>;
let o1: Rx.Observable<[number, string, boolean]> = Observable.forkJoin(a, b, c);
let o2: Rx.Observable<boolean> = Observable.forkJoin(a, b, c, (aa, bb, cc) => !!aa && !!bb && cc);
/* tslint:enable:no-unused-variable */
});

type('should support mixed observables and promises', () => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let b: Rx.Observable<string>;
let c: Promise<boolean>;
let d: Rx.Observable<string[]>;
let o1: Rx.Observable<[number, string, boolean, string[]]> = Observable.forkJoin(a, b, c, d);
let o2: Rx.Observable<boolean> = Observable.forkJoin(a, b, c, d, (aa, bb, cc, dd) => !!aa && !!bb && cc && !!dd.length);
/* tslint:enable:no-unused-variable */
});

type('should support arrays of promises', () => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>[];
let o1: Rx.Observable<number[]> = Observable.forkJoin(a);
let o2: Rx.Observable<number[]> = Observable.forkJoin(...a);
let o3: Rx.Observable<number> = Observable.forkJoin(a, (...x) => x.length);
/* tslint:enable:no-unused-variable */
});

type('should support arrays of observables', () => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>[];
let o1: Rx.Observable<number[]> = Observable.forkJoin(a);
let o2: Rx.Observable<number[]> = Observable.forkJoin(...a);
let o3: Rx.Observable<number> = Observable.forkJoin(a, (...x) => x.length);
/* tslint:enable:no-unused-variable */
});

type('should return Array<T> when given a single promise', () => {
/* tslint:disable:no-unused-variable */
let a: Promise<number>;
let o1: Rx.Observable<number[]> = Observable.forkJoin(a);
/* tslint:enable:no-unused-variable */
});

type('should return Array<T> when given a single observable', () => {
/* tslint:disable:no-unused-variable */
let a: Rx.Observable<number>;
let o1: Rx.Observable<number[]> = Observable.forkJoin(a);
/* tslint:enable:no-unused-variable */
});
});
24 changes: 10 additions & 14 deletions spec/observables/from-spec.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,22 +24,18 @@ describe('Observable.from', () => {
expect(r).to.throw();
});

it('should return T for ObservableLike objects', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let o1: Rx.Observable<number> = Observable.from(<number[]>[], Rx.Scheduler.asap);
let o2: Rx.Observable<{ a: string }> = Observable.from(Observable.empty<{ a: string }>());
let o3: Rx.Observable<{ b: number }> = Observable.from(new Promise<{b: number}>(resolve => resolve()));
/* tslint:enable:no-unused-variable */
});
type('should return T for ObservableLike objects', () => {
/* tslint:disable:no-unused-variable */
let o1: Rx.Observable<number> = Observable.from(<number[]>[], Rx.Scheduler.asap);
let o2: Rx.Observable<{ a: string }> = Observable.from(Observable.empty<{ a: string }>());
let o3: Rx.Observable<{ b: number }> = Observable.from(new Promise<{b: number}>(resolve => resolve()));
/* tslint:enable:no-unused-variable */
});

it('should return T for arrays', () => {
type(() => {
/* tslint:disable:no-unused-variable */
let o1: Rx.Observable<number> = Observable.from(<number[]>[], Rx.Scheduler.asap);
/* tslint:enable:no-unused-variable */
});
type('should return T for arrays', () => {
/* tslint:disable:no-unused-variable */
let o1: Rx.Observable<number> = Observable.from(<number[]>[], Rx.Scheduler.asap);
/* tslint:enable:no-unused-variable */
});

const fakervable = (...values) => ({
Expand Down