cleanup the connection trace logic

src/api.ts

@@ -82,7 +82,6 @@ export interface APIOptions extends ConnectionOptions {
   server?: string,
   feeCushion?: number,
   maxFeeXRP?: string,
-  trace?: boolean,
   proxy?: string,
   timeout?: number
 }

src/common/connection.ts

@@ -8,7 +8,7 @@ import {RippledError, DisconnectedError, NotConnectedError,
   RippledNotInitializedError} from './errors'
 
 export interface ConnectionOptions {
-  trace?: boolean
+  trace?: boolean | ((id: string, msg: string) => void)
   proxy?: string
   proxyAuthorization?: string
   authorization?: string
@@ -23,8 +23,6 @@ export interface ConnectionOptions {
 class Connection extends EventEmitter {
 
   private _url: string
-  private _trace: boolean
-  private _console?: Console
   private _proxyURL?: string
   private _proxyAuthorization?: string
   private _authorization?: string
@@ -48,14 +46,16 @@ class Connection extends EventEmitter {
   private _fee_ref: null|number = null
   private _connectionTimeout: number
 
+  private _trace: (id: string, msg: string) => void = () => {}
+
   constructor(url, options: ConnectionOptions = {}) {
     super()
     this.setMaxListeners(Infinity)
     this._url = url
-    this._trace = options.trace || false
-    if (this._trace) {
-      // for easier unit testing
-      this._console = console
+    if (typeof options.trace === 'function') {
+      this._trace = options.trace
+    } else if (options.trace === true) {
+      this._trace = console.log
     }
     this._proxyURL = options.proxy
     this._proxyAuthorization = options.proxyAuthorization
@@ -106,9 +106,7 @@ class Connection extends EventEmitter {
   }
 
   _onMessage(message) {
-    if (this._trace) {
-      this._console!.log(message)
-    }
+    this._trace('receive', message)
     let parameters
     try {
       parameters = this._parseMessage(message)
@@ -445,9 +443,7 @@ class Connection extends EventEmitter {
   }
 
   _send(message: string): Promise<void> {
-    if (this._trace) {
-      this._console.log(message)
-    }
+    this._trace('send', message)
     return new Promise((resolve, reject) => {
       this._ws.send(message, undefined, error => {
         if (error) {

test/connection-test.ts

@@ -35,23 +35,46 @@ describe('Connection', function() {
     assert(_.isUndefined(connection._authorization));
   });
 
-  it('trace', function() {
-    const connection: any = new utils.common.Connection('url', {trace: true});
+  describe('trace', () => {
     const message1 = '{"type": "transaction"}';
     const message2 = '{"type": "path_find"}';
-    const messages = [];
-    connection._console = {
-      log: function(message) {
-        messages.push(message);
-      }
-    };
-    connection._ws = {
-      send: function() {}
-    };
-    connection._onMessage(message1);
-    connection._send(message2);
+    const expectedMessages = [['send', message1], ['receive', message2]];
+    const originalConsoleLog = console.log;
 
-    assert.deepEqual(messages, [message1, message2]);
+    afterEach(() => {
+      console.log = originalConsoleLog;
+    });
+
+    it('as false', function() {
+      const messages = [];
+      console.log = (id, msg) => messages.push([id, msg]);
+      const connection: any = new utils.common.Connection('url', {trace: false});
+      connection._ws = {send: function() {}};
+      connection._send(message1);
+      connection._onMessage(message2);
+      assert.deepEqual(messages, []);
+    });
+
+    it('as true', function() {
+      const messages = [];
+      console.log = (id, msg) => messages.push([id, msg]);
+      const connection: any = new utils.common.Connection('url', {trace: true});
+      connection._ws = {send: function() {}};
+      connection._send(message1);
+      connection._onMessage(message2);
+      assert.deepEqual(messages, expectedMessages);
+    });
+
+    it('as a function', function() {
+      const messages = [];
+      const connection: any = new utils.common.Connection('url', {
+        trace: (id, msg) => messages.push([id, msg])
+      });
+      connection._ws = {send: function() {}};
+      connection._send(message1);
+      connection._onMessage(message2);
+      assert.deepEqual(messages, expectedMessages);
+    });
   });
 
   it('with proxy', function(done) {