feat(XmppConnection): sendIQ2

A new method which not only has Promise interface,
but also allows to queue IQs regardless of the current
connection's status.

Ping and send ICE failed notification requests are changed
to use this method which makes it more reliable on XMPP
Websocket connections on mobile(which in contrary to BOSH
dies much faster there).

modules/util/TestUtils.js

+/* global process */
+/**
+ * Returns a Promise resolved after {@code process.nextTick}.
+ *
+ * @returns {Promise<void>}
+ */
+export function nextTick() {
+    return new Promise(resolve => process.nextTick(resolve));
+}

modules/xmpp/JingleSessionPC.js

                     id: this._bridgeSessionId
                 });
 
-        this.connection.sendIQ(
-            sessionInfo,
-            null,
-            this.newJingleErrorHandler(sessionInfo),
-            /*
-             * This message will be often sent when there are connectivity
-             * issues, so make it slightly longer than Prosody's default BOSH
-             * inactivity timeout of 60 seconds.
-             */ 65);
+        this.connection.sendIQ2(
+            sessionInfo, {
+                /*
+                 * This message will be often sent when there are connectivity
+                 * issues, so make it slightly longer than Prosody's default BOSH
+                 * inactivity timeout of 60 seconds.
+                 */
+                timeout: 65
+            })
+            .catch(this.newJingleErrorHandler(sessionInfo));
     }
 
     /**

modules/xmpp/XmppConnection.js

 
         this._lastSuccessTracker = new LastSuccessTracker();
         this._lastSuccessTracker.startTracking(this._stropheConn);
+
+        /**
+         * @typedef DeferredSendIQ Object
+         * @property {Element} iq - The IQ to send.
+         * @property {function} resolve - The resolve method of the deferred Promise.
+         * @property {function} reject - The reject method of the deferred Promise.
+         * @property {number} timeout - The ID of the timeout task that needs to be cleared, before sending the IQ.
+         */
+        /**
+         * Deferred IQs to be sent upon reconnect.
+         * @type {Array<DeferredSendIQ>}
+         * @private
+         */
+        this._deferredIQs = [];
     }
 
     /**
 
         let blockCallback = false;
 
-        if (status === Strophe.Status.CONNECTED) {
+        if (status === Strophe.Status.CONNECTED || status === Strophe.Status.ATTACHED) {
             this._maybeEnableStreamResume();
             this._maybeStartWSKeepAlive();
-            this._resumeRetryN = 0;
+            this._processDeferredIQs();
         } else if (status === Strophe.Status.DISCONNECTED) {
             // FIXME add RECONNECTING state instead of blocking the DISCONNECTED update
             blockCallback = this._tryResumingConnection();
         }
     }
 
+    /**
+     * Clears the list of IQs and rejects deferred Promises with an error.
+     *
+     * @private
+     */
+    _clearDeferredIQs() {
+        for (const deferred of this._deferredIQs) {
+            deferred.reject(new Error('disconnect'));
+        }
+        this._deferredIQs = [];
+    }
+
     /**
      * The method is meant to be used for testing. It's a shortcut for closing the WebSocket.
      *
     disconnect(...args) {
         clearTimeout(this._resumeTimeout);
         clearTimeout(this._wsKeepAlive);
+        this._clearDeferredIQs();
         this._stropheConn.disconnect(...args);
     }
 
         }
     }
 
+    /**
+     * Goes over the list of {@link DeferredSendIQ} tasks and sends them.
+     *
+     * @private
+     * @returns {void}
+     */
+    _processDeferredIQs() {
+        for (const deferred of this._deferredIQs) {
+            if (deferred.iq) {
+                clearTimeout(deferred.timeout);
+
+                const timeLeft = Date.now() - deferred.start;
+
+                this.sendIQ(
+                    deferred.iq,
+                    result => deferred.resolve(result),
+                    error => deferred.reject(error),
+                    timeLeft);
+            }
+        }
+
+        this._deferredIQs = [];
+    }
+
     /**
      * Send a stanza. This function is called to push data onto the send queue to go out over the wire.
      *
         return this._stropheConn.sendIQ(elem, callback, errback, timeout);
     }
 
+    /**
+     * Sends an IQ immediately if connected or puts it on the send queue otherwise(in contrary to other send methods
+     * which would fail immediately if disconnected).
+     *
+     * @param {Element} iq - The IQ to send.
+     * @param {number} timeout - How long to wait for the response. The time when the connection is reconnecting is
+     * included, which means that the IQ may never be sent and still fail with a timeout.
+     */
+    sendIQ2(iq, { timeout }) {
+        return new Promise((resolve, reject) => {
+            if (this.connected) {
+                this.sendIQ(
+                    iq,
+                    result => resolve(result),
+                    error => reject(error));
+            } else {
+                const deferred = {
+                    iq,
+                    resolve,
+                    reject,
+                    start: Date.now(),
+                    timeout: setTimeout(() => {
+                        // clears the IQ on timeout and invalidates the deferred task
+                        deferred.iq = undefined;
+
+                        // Strophe calls with undefined on timeout
+                        reject(undefined);
+                    }, timeout)
+                };
+
+                this._deferredIQs.push(deferred);
+            }
+        });
+    }
+
     /**
      *  Helper function to send presence stanzas. The main benefit is for sending presence stanzas for which you expect
      *  a responding presence stanza with the same id (for example when leaving a chat room).

modules/xmpp/XmppConnection.spec.js

+import { default as XmppConnection } from './XmppConnection';
+import { $iq, Strophe } from 'strophe.js';
+import { nextTick } from '../util/TestUtils';
+
+/**
+ * Mock Strophe connection.
+ */
+class MockStropheConnection {
+    /**
+     * XMPP service URL.
+     *
+     * @returns {string}
+     */
+    get service() {
+        return 'wss://localhost/xmpp-websocket';
+    }
+
+    /**
+     * {@see Strophe.Connection.connect}
+     */
+    connect(jid, pass, callback) {
+        this._connectCb = callback;
+    }
+
+    /**
+     * {@see Strophe.Connection.disconnect}
+     */
+    disconnect() {
+        this.simulateConnectionState(Strophe.Status.DISCONNECTING);
+        this.simulateConnectionState(Strophe.Status.DISCONNECTED);
+    }
+
+    /**
+     * Simulates transition to the new connection status.
+     *
+     * @param {Strophe.Status} newState - The new connection status to set.
+     * @returns {void}
+     */
+    simulateConnectionState(newState) {
+        this._connectCb(newState);
+    }
+
+    /**
+     * {@see Strophe.Connection.sendIQ}.
+     */
+    sendIQ(iq, resultCb) {
+        resultCb();
+    }
+}
+
+/**
+ * Creates any IQ.
+ * @returns {Element}
+ */
+function testIQ() {
+    return $iq({
+        to: 'remoteJid',
+        type: 'set'
+    })
+    .c('jingle', { xmlns: 'urn:xmpp:jingle:1',
+        action: 'session-info',
+        initiator: 'blabla',
+        sid: '1234' })
+    .up();
+}
+
+describe('XmppConnection', () => {
+    let connection;
+    let mockStropheConnection;
+    let sendIQSpy;
+
+    beforeEach(() => {
+        jasmine.clock().install();
+
+        spyOn(Strophe, 'Connection').and.callFake((...args) => {
+            mockStropheConnection = new MockStropheConnection(...args);
+
+            return mockStropheConnection;
+        });
+
+        connection = new XmppConnection({
+            serviceUrl: 'wss://localhost/xmpp-websocket'
+        });
+
+        sendIQSpy = spyOn(mockStropheConnection, 'sendIQ').and.callThrough();
+
+        // eslint-disable-next-line no-empty-function
+        connection.connect('jid', undefined, () => { });
+    });
+
+    afterEach(() => {
+        jasmine.clock().uninstall();
+    });
+    describe('sendIQ2', () => {
+        it('will send the IQ immediately if connected', () => {
+            mockStropheConnection.simulateConnectionState(Strophe.Status.CONNECTED);
+
+            return connection.sendIQ2(testIQ(), { timeout: 15000 })
+                .then(() => {
+                    expect(sendIQSpy).toHaveBeenCalled();
+                });
+        });
+        it('will send the IQ on reconnect', () => {
+            mockStropheConnection.simulateConnectionState(Strophe.Status.CONNECTING);
+
+            let resolved = false;
+
+            connection
+                .sendIQ2(testIQ(), { timeout: 15000 })
+                .then(() => {
+                    resolved = true;
+                });
+
+            jasmine.clock().tick(10000);
+
+            return nextTick()
+                .then(() => {
+                    expect(resolved).toBe(false);
+                    expect(sendIQSpy).not.toHaveBeenCalled();
+
+                    mockStropheConnection.simulateConnectionState(Strophe.Status.CONNECTED);
+
+                    return nextTick();
+                })
+                .then(() => {
+                    expect(resolved).toBe(true);
+                    expect(sendIQSpy).toHaveBeenCalled();
+                });
+        });
+        it('will timeout the operation if not connected in time', () => {
+            mockStropheConnection.simulateConnectionState(Strophe.Status.CONNECTING);
+
+            let rejected = false, resolved = false;
+
+            connection
+                .sendIQ2(testIQ(), { timeout: 15000 })
+                .then(() => {
+                    resolved = true;
+                }, () => {
+                    rejected = true;
+                });
+
+            jasmine.clock().tick(10000);
+
+            return nextTick()
+                .then(() => {
+                    expect(sendIQSpy).not.toHaveBeenCalled();
+                    expect(resolved).toBe(false);
+                    expect(rejected).toBe(false);
+
+                    jasmine.clock().tick(10000);
+
+                    return nextTick();
+                })
+                .then(() => {
+                    expect(sendIQSpy).not.toHaveBeenCalled();
+                    expect(resolved).toBe(false);
+                    expect(rejected).toBe(true);
+                });
+        });
+        it('will reject the promise on explicit disconnect', () => {
+            mockStropheConnection.simulateConnectionState(Strophe.Status.CONNECTING);
+
+            let rejected = false, resolved = false;
+
+            connection
+                .sendIQ2(testIQ(), { timeout: 15000 })
+                .then(() => {
+                    resolved = true;
+                }, error => {
+                    rejected = error;
+                });
+
+            jasmine.clock().tick(10000);
+
+            return nextTick()
+                .then(() => {
+                    expect(sendIQSpy).not.toHaveBeenCalled();
+                    expect(resolved).toBe(false);
+                    expect(rejected).toBe(false);
+
+                    connection.disconnect();
+
+                    return nextTick();
+                })
+                .then(() => {
+                    expect(sendIQSpy).not.toHaveBeenCalled();
+                    expect(resolved).toBe(false);
+                    expect(rejected).toEqual(new Error('disconnect'));
+                });
+        });
+    });
+});

modules/xmpp/strophe.ping.js

         });
 
         iq.c('ping', { xmlns: Strophe.NS.PING });
-        this.connection.sendIQ(iq, success, error, timeout);
+        this.connection.sendIQ2(iq, { timeout })
+            .then(success, error);
     }
 
     /* eslint-enable max-params */