chore(typings): add publish type tests

spec/operators/multicast-spec.ts

@@ -644,7 +644,7 @@ describe('Observable.prototype.multicast', () => {
     type('should infer the type', () => {
       /* tslint:disable:no-unused-variable */
       const source = Rx.Observable.of<number>(1, 2, 3);
-      const result: Rx.Observable<number> = source.multicast(() => new Subject<number>());
+      const result: Rx.ConnectableObservable<number> = source.multicast(() => new Subject<number>());
       /* tslint:enable:no-unused-variable */
     });
 
@@ -661,5 +661,26 @@ describe('Observable.prototype.multicast', () => {
       const result: Rx.Observable<string> = source.multicast(() => new Subject<number>(), s => s.map(x => x + '!'));
       /* tslint:enable:no-unused-variable */
     });
+
+    type('should infer the type for the pipeable operator', () => {
+      /* tslint:disable:no-unused-variable */
+      const source = Rx.Observable.of<number>(1, 2, 3);
+      const result: Rx.ConnectableObservable<number> = Rx.operators.multicast(() => new Subject<number>())(source);
+      /* tslint:enable:no-unused-variable */
+    });
+
+    type('should infer the type for the pipeable operator with a selector', () => {
+      /* tslint:disable:no-unused-variable */
+      const source = Rx.Observable.of<number>(1, 2, 3);
+      const result: Rx.Observable<number> = Rx.operators.multicast(() => new Subject<number>(), s => s.map(x => x))(source);
+      /* tslint:enable:no-unused-variable */
+    });
+
+    type('should infer the type for the pipeable operator with a type-changing selector', () => {
+      /* tslint:disable:no-unused-variable */
+      const source = Rx.Observable.of<number>(1, 2, 3);
+      const result: Rx.Observable<string> = Rx.operators.multicast(() => new Subject<number>(), s => s.map(x => x + '!'))(source);
+      /* tslint:enable:no-unused-variable */
+    });
   });
 });

spec/operators/publish-spec.ts

@@ -337,7 +337,7 @@ describe('Observable.prototype.publish', () => {
   type('should infer the type', () => {
     /* tslint:disable:no-unused-variable */
     const source = Rx.Observable.of<number>(1, 2, 3);
-    const result: Rx.Observable<number> = source.publish();
+    const result: Rx.ConnectableObservable<number> = source.publish();
     /* tslint:enable:no-unused-variable */
   });
 
@@ -354,4 +354,25 @@ describe('Observable.prototype.publish', () => {
     const result: Rx.Observable<string> = source.publish(s => s.map(x => x + '!'));
     /* tslint:enable:no-unused-variable */
   });
+
+  type('should infer the type for the pipeable operator', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.ConnectableObservable<number> = Rx.operators.publish()(source);
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type for the pipeable operator with a selector', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.Observable<number> = Rx.operators.publish(s => s.map(x => x))(source);
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type for the pipeable operator with a type-changing selector', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.Observable<string> = Rx.operators.publish(s => s.map(x => x + '!'))(source);
+    /* tslint:enable:no-unused-variable */
+  });
 });

spec/operators/publishBehavior-spec.ts

@@ -3,6 +3,7 @@ import * as Rx from '../../dist/package/Rx';
 import marbleTestingSignature = require('../helpers/marble-testing'); // tslint:disable-line:no-require-imports
 
 declare const { asDiagram };
+declare const type;
 declare const hot: typeof marbleTestingSignature.hot;
 declare const cold: typeof marbleTestingSignature.cold;
 declare const expectObservable: typeof marbleTestingSignature.expectObservable;
@@ -336,4 +337,18 @@ describe('Observable.prototype.publishBehavior', () => {
     expect(results).to.deep.equal([]);
     done();
   });
+
+  type('should infer the type', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.ConnectableObservable<number> = source.publishBehavior(0);
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type for the pipeable operator', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.ConnectableObservable<number> = Rx.operators.publishBehavior(0)(source);
+    /* tslint:enable:no-unused-variable */
+  });
 });

spec/operators/publishLast-spec.ts

@@ -3,6 +3,7 @@ import * as Rx from '../../dist/package/Rx';
 import marbleTestingSignature = require('../helpers/marble-testing'); // tslint:disable-line:no-require-imports
 
 declare const { asDiagram };
+declare const type;
 declare const hot: typeof marbleTestingSignature.hot;
 declare const cold: typeof marbleTestingSignature.cold;
 declare const expectObservable: typeof marbleTestingSignature.expectObservable;
@@ -257,4 +258,18 @@ describe('Observable.prototype.publishLast', () => {
     expect(subscriptions).to.equal(1);
     done();
   });
+
+  type('should infer the type', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.ConnectableObservable<number> = source.publishLast();
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type for the pipeable operator', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.ConnectableObservable<number> = Rx.operators.publishLast()(source);
+    /* tslint:enable:no-unused-variable */
+  });
 });

spec/operators/publishReplay-spec.ts

@@ -3,6 +3,7 @@ import * as Rx from '../../dist/package/Rx';
 import marbleTestingSignature = require('../helpers/marble-testing'); // tslint:disable-line:no-require-imports
 
 declare const { asDiagram };
+declare const type;
 declare const hot: typeof marbleTestingSignature.hot;
 declare const cold: typeof marbleTestingSignature.cold;
 declare const expectObservable: typeof marbleTestingSignature.expectObservable;
@@ -480,4 +481,46 @@ describe('Observable.prototype.publishReplay', () => {
     expectObservable(published).toBe(expected, undefined, error);
     expectSubscriptions(source.subscriptions).toBe(sourceSubs);
   });
+
+  type('should infer the type', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.ConnectableObservable<number> = source.publishReplay(1);
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type with a selector', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.Observable<number> = source.publishReplay(1, undefined, s => s.map(x => x));
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type with a type-changing selector', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.Observable<string> = source.publishReplay(1, undefined, s => s.map(x => x + '!'));
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type for the pipeable operator', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.ConnectableObservable<number> = Rx.operators.publishReplay(1)(source);
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type for the pipeable operator with a selector', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.Observable<number> = Rx.operators.publishReplay(1, undefined, s => s.map(x => x))(source);
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should infer the type for the pipeable operator with a type-changing selector', () => {
+    /* tslint:disable:no-unused-variable */
+    const source = Rx.Observable.of<number>(1, 2, 3);
+    const result: Rx.Observable<string> = Rx.operators.publishReplay(1, undefined, s => s.map(x => x + '!'))(source);
+    /* tslint:enable:no-unused-variable */
+  });
 });