Fix tests

packages/light.js/src/api.spec.ts

@@ -3,21 +3,21 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { getApi, NullProvider, setApi } from './api';
+import { getApi, NullProvider, setApi, setProvider } from './api';
 import { resolveApi } from './utils/testHelpers/mockApi';
 
 it('should return the Null provider', () => {
   expect(getApi().provider instanceof NullProvider).toBe(true);
 });
 
-it('should correctly set a new Api', () => {
-  const mockApi = resolveApi(undefined, false); // Pubsub
-  setApi(mockApi);
-  expect(getApi()).toBe(mockApi);
+it('should correctly set a new api', () => {
+  const api = resolveApi();
+  setApi(api);
+  expect(getApi()).toBe(api);
 });
 
-it('should correctly set a new Api', () => {
-  const mockApi = resolveApi(undefined, false); // Not pubsub
-  setApi(mockApi);
-  expect(getApi()).toBe(mockApi);
+it('should correctly set a new provider', () => {
+  const provider = new NullProvider();
+  setProvider(provider);
+  expect(getApi().provider).toBe(provider);
 });

packages/light.js/src/api.ts

@@ -8,8 +8,14 @@ import * as debug from 'debug';
 import * as EventEmitter from 'eventemitter3';
 import * as memoizee from 'memoizee';
 
+// This is our global api object, to be used if no provider is passed to RpcObservables.
 let api: any; // TODO @parity/api
 
+/**
+ * Like `return new Api(provider);`, but memoized.
+ *
+ * @ignore
+ */
 export const createApiFromProvider = memoizee(
   (provider?: any) => new Api(provider)
 );
@@ -29,6 +35,20 @@ export class NullProvider extends EventEmitter {
   }
 }
 
+/**
+ * Sets a new Api object.
+ *
+ * @param newApi - An Api object.
+ */
+export const setApi = (newApi: any) => {
+  api = newApi;
+  if (!api.isPubSub) {
+    console.warn(
+      `Current provider does not support pubsub. @parity/light.js will poll every second to listen to changes.`
+    );
+  }
+};
+
 /**
  * Sets a new Ethereum provider object.
  *

packages/light.js/src/frequency/accounts.ts

@@ -3,25 +3,30 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { AccountsInfo, Address, FrequencyObservable } from '../types';
+import {
+  AccountsInfo,
+  Address,
+  FrequencyObservable,
+  FrequencyObservableOptions
+} from '../types';
 import createPubsubObservable from './utils/createPubsubObservable';
 
 /**
  * Observable that emits each time the default account changes
  *
- * @param provider - The provider object with which to create this {@link FrequencyObservable}.
+ * @param options - Options to pass to {@link FrequencyObservable}.
  */
 export const onAccountsChanged$: FrequencyObservable<Address[]> = (
-  provider?: any
-) => createPubsubObservable('eth_accounts', provider);
+  options?: FrequencyObservableOptions
+) => createPubsubObservable('eth_accounts', options);
 onAccountsChanged$.metadata = { name: 'onAccountsChanged$' };
 
 /**
  * Observable that emits each time the default account changes
  *
- * @param provider - The provider object with which to create this {@link FrequencyObservable}.
+ * @param options - Options to pass to {@link FrequencyObservable}.
  */
 export const onAccountsInfoChanged$: FrequencyObservable<AccountsInfo> = (
-  provider?: any
-) => createPubsubObservable('parity_accountsInfo', provider);
+  options?: FrequencyObservableOptions
+) => createPubsubObservable('parity_accountsInfo', options);
 onAccountsInfoChanged$.metadata = { name: 'onAccountsInfoChanged$' };

packages/light.js/src/frequency/blocks.ts

@@ -7,39 +7,40 @@ import BigNumber from 'bignumber.js';
 import { filter } from 'rxjs/operators';
 
 import createPubsubObservable from './utils/createPubsubObservable';
-import { FrequencyObservable } from '../types';
+import { FrequencyObservable, FrequencyObservableOptions } from '../types';
 
 /**
  * Observable that emits on every new block.
  *
- * @param provider - The provider object with which to create this {@link FrequencyObservable}.
+ * @param options - Options to pass to {@link FrequencyObservable}.
  */
-export const onEveryBlock$: FrequencyObservable<BigNumber> = (provider?: any) =>
-  createPubsubObservable('eth_blockNumber', provider);
+export const onEveryBlock$: FrequencyObservable<BigNumber> = (
+  options?: FrequencyObservableOptions
+) => createPubsubObservable('eth_blockNumber', options);
 onEveryBlock$.metadata = { name: 'onEveryBlock$' };
 
 /**
  * Observable that emits on every 2nd block.
  *
- * @param provider - The provider object with which to create this {@link FrequencyObservable}.
+ * @param options - Options to pass to {@link FrequencyObservable}.
  */
 export const onEvery2Blocks$: FrequencyObservable<BigNumber> = (
-  provider?: any
+  options?: FrequencyObservableOptions
 ) =>
-  onEveryBlock$(provider).pipe(
+  onEveryBlock$(options).pipe(
     filter(n => +n % 2 === 0) // Around ~30s on mainnet // TODO Use isEqualTo and mod from bignumber.js
   );
 onEvery2Blocks$.metadata = { name: 'onEvery2Blocks$' };
 
 /**
  * Observable that emits on every 4th block.
  *
- * @param provider - The provider object with which to create this {@link FrequencyObservable}.
+ * @param options - Options to pass to {@link FrequencyObservable}.
  */
 export const onEvery4Blocks$: FrequencyObservable<BigNumber> = (
-  provider?: any
+  options?: FrequencyObservableOptions
 ) =>
-  onEveryBlock$(provider).pipe(
+  onEveryBlock$(options).pipe(
     filter(n => +n % 4 === 0) // Around ~1min on mainnet // TODO Use isEqualTo and mod from bignumber.js
   );
 onEvery4Blocks$.metadata = { name: 'onEvery4Blocks$' };

packages/light.js/src/utils/testHelpers/testFrequency.ts → packages/light.js/src/frequency/frequency.spec.ts

@@ -3,8 +3,11 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { FrequencyObservable } from '../../types';
-import isObservable from '../isObservable';
+import { createApiFromProvider } from '../api';
+import frequency from './frequency';
+import { FrequencyObservable, FrequencyKey, FrequencyMap } from '../types';
+import isObservable from '../utils/isObservable';
+import { resolveApi } from '../utils/testHelpers/mockApi';
 
 /**
  * Helper function to make basic tests for frequency$ observables.
@@ -31,4 +34,6 @@ const testFrequency = (name: string, frequency$: FrequencyObservable<any>) =>
     });
   });
 
-export default testFrequency;
+Object.keys(frequency).forEach(key =>
+  testFrequency(key, (frequency as FrequencyMap)[key as FrequencyKey])
+);

packages/light.js/src/frequency/frequency.ts

@@ -3,8 +3,19 @@
 //
 // SPDX-License-Identifier: MIT
 
-export * from './accounts';
-export * from './blocks';
-export * from './health';
-export * from './other';
-export * from './time';
+import * as accounts from './accounts';
+import * as blocks from './blocks';
+import * as health from './health';
+import { memoizeAll } from '../utils/memoizeAll';
+import * as other from './other';
+import * as time from './time';
+
+const frequency = memoizeAll({
+  ...accounts,
+  ...blocks,
+  ...health,
+  ...other,
+  ...time
+});
+
+export default frequency;

packages/light.js/src/frequency/health.ts

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT
 
 import createPubsubObservable from './utils/createPubsubObservable';
-import { FrequencyObservable } from '../types';
+import { FrequencyObservable, FrequencyObservableOptions } from '../types';
 
 /**
  * Observable that emits when syncing status changes.
@@ -14,11 +14,11 @@ import { FrequencyObservable } from '../types';
 /**
  * Observable that emits when syncing status changes.
  *
- * @param provider - The provider object with which to create this {@link FrequencyObservable}.
+ * @param options - Options to pass to {@link FrequencyObservable}.
  */
 export const onSyncingChanged$: FrequencyObservable<object | boolean> = (
-  provider?: any
-) => createPubsubObservable('eth_syncing', provider);
+  options?: FrequencyObservableOptions
+) => createPubsubObservable('eth_syncing', options);
 onSyncingChanged$.metadata = {
   calls: ['eth_syncing'],
   name: 'onSyncingChanged$'

packages/light.js/src/frequency/index.ts

@@ -3,7 +3,6 @@
 //
 // SPDX-License-Identifier: MIT
 
-import * as frequency from './frequency';
-import { memoizeAll } from '../utils/memoizeAll';
+import frequency from './frequency';
 
-export default memoizeAll(frequency);
+export default frequency;

packages/light.js/src/frequency/other.ts

@@ -5,10 +5,14 @@
 
 import { of } from 'rxjs';
 
-import { FrequencyObservable } from '../types';
+import { FrequencyObservable, FrequencyObservableOptions } from '../types';
 
 /**
  * Observable that emits only once.
+ *
+ * @param options - Options to pass to {@link FrequencyObservable}.
  */
-export const onStartup$: FrequencyObservable<number> = (_?: any) => of(0);
+export const onStartup$: FrequencyObservable<number> = (
+  _?: FrequencyObservableOptions
+) => of(0);
 onStartup$.metadata = { name: 'onStartup$' };

packages/light.js/src/frequency/time.ts

@@ -5,25 +5,28 @@
 
 import { timer } from 'rxjs';
 
-import { FrequencyObservable } from '../types';
+import { FrequencyObservable, FrequencyObservableOptions } from '../types';
 
 /**
  * Observable that emits on every second.
  */
-export const onEverySecond$: FrequencyObservable<number> = (_?: any) =>
-  timer(0, 1000);
+export const onEverySecond$: FrequencyObservable<number> = (
+  _?: FrequencyObservableOptions
+) => timer(0, 1000);
 onEverySecond$.metadata = { name: 'onEverySecond$' };
 
 /**
  * Observable that emits on every other second.
  */
-export const onEvery2Seconds$: FrequencyObservable<number> = (_?: any) =>
-  timer(0, 2000);
+export const onEvery2Seconds$: FrequencyObservable<number> = (
+  _?: FrequencyObservableOptions
+) => timer(0, 2000);
 onEvery2Seconds$.metadata = { name: 'onEvery2Seconds$' };
 
 /**
  * Observable that emits every five seconds.
  */
-export const onEvery5Seconds$: FrequencyObservable<number> = (_?: any) =>
-  timer(0, 5000);
+export const onEvery5Seconds$: FrequencyObservable<number> = (
+  _?: FrequencyObservableOptions
+) => timer(0, 5000);
 onEvery5Seconds$.metadata = { name: 'onEvery5Seconds$' };

packages/light.js/src/frequency/utils/createPubsubObservable.spec.ts

@@ -6,41 +6,40 @@
 import createPubsubObservable from './createPubsubObservable';
 import isObservable from '../../utils/isObservable';
 import { rejectApi, resolveApi } from '../../utils/testHelpers/mockApi';
+import { setApi } from '../../api';
 
 it('should return an Observable', () => {
-  expect(
-    isObservable(createPubsubObservable('fake_method', resolveApi()))
-  ).toBe(true);
+  setApi(resolveApi());
+  expect(isObservable(createPubsubObservable('fake_method'))).toBe(true);
 });
 
 it('should fire an event when pubsub publishes', done => {
-  createPubsubObservable('fake_method', resolveApi()).subscribe(data => {
+  setApi(resolveApi());
+  createPubsubObservable('fake_method').subscribe(data => {
     expect(data).toBe('foo');
     done();
   });
 });
 
 it('should fire an error when pubsub errors', done => {
-  createPubsubObservable('fake_method', rejectApi()).subscribe(null, err => {
+  setApi(rejectApi());
+  createPubsubObservable('fake_method').subscribe(null, err => {
     expect(err).toEqual(new Error('bar'));
     done();
   });
 });
 
 it('should fire an event when polling pubsub publishes', done => {
-  createPubsubObservable('fake_method', resolveApi('foo', false)).subscribe(
-    data => {
-      expect(data).toBe('foo');
-      done();
-    }
-  );
+  setApi(resolveApi('foo', false));
+  createPubsubObservable('fake_method').subscribe(data => {
+    expect(data).toBe('foo');
+    done();
+  });
 });
 
 it('should fire an error when polling pubsub errors', done => {
-  createPubsubObservable(
-    'fake_method',
-    rejectApi(new Error('bar'), false)
-  ).subscribe(null, err => {
+  setApi(rejectApi(new Error('bar'), false));
+  createPubsubObservable('fake_method').subscribe(null, err => {
     expect(err).toEqual(new Error('bar'));
     done();
   });