Fix a lot of stuff

packages/light.js/example/src/index.js

@@ -8,28 +8,10 @@ import React from 'react';
 import ReactDOM from 'react-dom';
 import 'symbol-observable'; // TODO Remove this once https://github.com/acdlite/recompose/pull/660 is merged
 
-// import App from './App';
-import light, { balanceOf$, frequency } from './light.js';
-import provider, { localProvider } from './provider';
-
-const api = new Api(localProvider);
+import App from './App';
+import light from './light.js';
+import provider from './provider';
 
 light.setProvider(provider);
-const a = balanceOf$('0x73e41c8efb30c2d18a21df05dacb8ed91d3e0bbe');
-const b = balanceOf$('0x73e41c8efb30c2d18a21df05dacb8ed91d3e0bbe');
-const c = balanceOf$(
-  '0x73e41c8efb30c2d18a21df05dacb8ed91d3e0bbe',
-  localProvider
-);
-const d = balanceOf$(
-  '0x73e41c8efb30c2d18a21df05dacb8ed91d3e0bbe',
-  localProvider
-);
-
-// a.subscribe(console.log);
-c.subscribe(console.log);
-d.subscribe(console.log);
-
-console.log('a === b', a === b, 'a === c', a === c, 'c === d', c === d);
 
-// ReactDOM.render(<App />, document.getElementById('root'));
+ReactDOM.render(<App />, document.getElementById('root'));

packages/light.js/src/api.ts

@@ -8,6 +8,8 @@ import * as debug from 'debug';
 import * as EventEmitter from 'eventemitter3';
 import * as memoizee from 'memoizee';
 
+import frequency from './frequency';
+
 // This is our global api object, to be used if no provider is passed to RpcObservables.
 let api: any; // TODO @parity/api
 
@@ -55,12 +57,7 @@ export const setApi = (newApi: any) => {
  * @param provider - An Ethereum provider object.
  */
 export const setProvider = (provider?: any) => {
-  api = createApiFromProvider(provider);
-  if (!api.isPubSub) {
-    console.warn(
-      `Current provider does not support pubsub. @parity/light.js will poll every second to listen to changes.`
-    );
-  }
+  setApi(createApiFromProvider(provider));
 };
 
 /**

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

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT
 
 import BigNumber from 'bignumber.js';
-import { filter } from 'rxjs/operators';
+import { filter, tap } from 'rxjs/operators';
 
 import createPubsubObservable from './utils/createPubsubObservable';
 import { FrequencyObservable, FrequencyObservableOptions } from '../types';

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

@@ -3,19 +3,29 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { createApiFromProvider } from '../api';
+import { take } from 'rxjs/operators';
+
 import frequency from './frequency';
 import { FrequencyObservable, FrequencyKey, FrequencyMap } from '../types';
 import isObservable from '../utils/isObservable';
 import { resolveApi } from '../utils/testHelpers/mockApi';
+import { setApi } from '@parity/light.js/src/api';
 
 /**
  * Helper function to make basic tests for frequency$ observables.
  *
  * @ignore
  */
-const testFrequency = (name: string, frequency$: FrequencyObservable<any>) =>
-  describe(`${name} rpc`, () => {
+const testFrequency = (
+  name: string,
+  frequency$: FrequencyObservable<any>,
+  resolveWith: any = 'foo'
+) =>
+  describe(`${name} frequency`, () => {
+    beforeAll(() => {
+      setApi(resolveApi(resolveWith));
+    });
+
     it('should be an Observable', () => {
       expect(isObservable(frequency$())).toBe(true);
     });
@@ -32,8 +42,26 @@ const testFrequency = (name: string, frequency$: FrequencyObservable<any>) =>
       const { metadata } = frequency$;
       expect(metadata.name).toBeTruthy();
     });
+
+    it('function should return the same Observable upon re-running (memoization)', () => {
+      const initial$ = frequency$();
+      expect(frequency$()).toBe(initial$);
+    });
+
+    it('should return values', done => {
+      frequency$()
+        .pipe(take(1))
+        .subscribe(data => {
+          expect(data).not.toBeNull();
+          done();
+        });
+    });
   });
 
 Object.keys(frequency).forEach(key =>
-  testFrequency(key, (frequency as FrequencyMap)[key as FrequencyKey])
+  testFrequency(
+    key,
+    (frequency as FrequencyMap)[key as FrequencyKey],
+    key.includes('Account') ? ['foo'] : 4 // Give string[] for accounts pubsub, or number elsewhere
+  )
 );

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

@@ -3,9 +3,6 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { memoizeAll } from '../utils/memoizeAll';
-import * as eth from './eth';
+import rpc from './rpc';
 
-const rpc = { ...eth };
-
-export default memoizeAll(rpc);
+export default rpc;

packages/light.js/src/rpc/other/makeContract.ts

@@ -11,7 +11,7 @@ import { Address } from '../../types';
 import createRpc from '../utils/createRpc';
 import { switchMapPromise } from '../../utils/operators';
 import api from '../../api';
-import { onEveryBlock$ } from '../../frequency';
+import frequency from '../../frequency';
 import { post$ } from './post';
 
 interface MakeContract {
@@ -75,7 +75,7 @@ export const makeContract = memoizee(
 
         if (method.constant) {
           return createRpc({
-            frequency: [onEveryBlock$],
+            frequency: [frequency.onEveryBlock$],
             name,
             pipes: () => [
               switchMapPromise(() =>

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

@@ -0,0 +1,63 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+//
+// SPDX-License-Identifier: MIT
+
+import isObservable from '../utils/isObservable';
+import { resolveApi } from '../utils/testHelpers/mockApi';
+import rpc from './rpc';
+import { RpcKey, RpcMap, RpcObservable } from '../types';
+import { RPC_LOADING } from '../utils/isLoading';
+import { setApi } from '../api';
+
+/**
+ * Helper function to make basic tests for RpcObservables.
+ *
+ * @ignore
+ */
+const testRpc = (name: string, rpc$: RpcObservable<any, any>) =>
+  describe(`${name} rpc`, () => {
+    beforeAll(() => {
+      setApi(resolveApi());
+    });
+
+    it('should be a function', () => {
+      expect(typeof rpc$).toBe('function');
+    });
+
+    it('function should return an Observable', () => {
+      expect(isObservable(rpc$())).toBe(true);
+    });
+
+    it('function result Observable should be subscribable', () => {
+      expect(() => rpc$().subscribe()).not.toThrow();
+    });
+
+    it('function result Observable should return values', done => {
+      rpc$().subscribe(data => {
+        // The first value is either 'foo' (defined in mockApi), or the
+        // RPC_LOADING symbole.
+        // In the case of defaultAccount$ (which is accounts$[0]), the returned
+        // value is 'f'. TODO not clean.
+        expect(['foo', 'f', RPC_LOADING]).toContain(data);
+        done();
+      });
+    });
+
+    it('function should return the same Observable upon re-running (memoization)', () => {
+      const initial$ = rpc$();
+      expect(rpc$()).toBe(initial$);
+    });
+
+    it('function should not return the same Observable if options are passed', () => {
+      const initial$ = rpc$();
+      expect(rpc$({ withoutLoading: true })).not.toBe(initial$);
+    });
+
+    it('function should return the same Observable if same options are passed', () => {
+      const initial$ = rpc$({ withoutLoading: true });
+      expect(rpc$({ withoutLoading: true })).toBe(initial$);
+    });
+  });
+
+Object.keys(rpc).forEach(key => testRpc(key, (rpc as RpcMap)[key as RpcKey]));

packages/light.js/src/rpc/rpc.ts

@@ -5,7 +5,9 @@
 
 import * as eth from './eth';
 import { memoizeAll } from '../utils/memoizeAll';
+import * as net from './net';
+import * as parity from './parity';
 
-const rpc = memoizeAll({ ...eth });
+const rpc = { ...eth, ...net, ...parity };
 
-export default rpc;
+export default memoizeAll(rpc);

packages/light.js/src/utils/memoizeAll.ts

@@ -24,7 +24,7 @@ export const memoizeAll = <T extends FunctionMap>(rpcMap: T) =>
   Object.keys(rpcMap).reduce(
     (result, key) => {
       const metadata = rpcMap[key].metadata;
-      result[key] = memoizee(rpcMap[key]); // This operation does not copy the metadata of rpcMap[key].
+      result[key] = memoizee(rpcMap[key], { primitive: true }); // This operation does not copy the metadata of rpcMap[key].
       result[key].metadata = metadata;
       return result;
     },