session-desktop/test/views/network_status_view_test.js

describe('NetworkStatusView', function() {
    describe('getNetworkStatus', function() {
        var networkStatusView;
        var socketStatus = WebSocket.OPEN;

        var oldGetSocketStatus;

        /* BEGIN stubbing globals */
        before(function() {
            oldGetSocketStatus = window.getSocketStatus;
            window.getSocketStatus = function() { return socketStatus; };
        });

        after(function() {
            window.getSocketStatus = oldGetSocketStatus;

            // It turns out that continued calls to window.getSocketStatus happen
            //   because we host NetworkStatusView in three mock interfaces, and the view
            //   checks every N seconds. That results in infinite errors unless there is
            //   something to call.
            window.getSocketStatus = function() { return WebSocket.OPEN; };
        });
        /* END stubbing globals */

        beforeEach(function() {
            networkStatusView = new Whisper.NetworkStatusView();
            $('.network-status-container').append(networkStatusView.el);
        });
        afterEach(function() {
            // prevents huge number of errors on console after running tests
            clearInterval(networkStatusView.renderIntervalHandle);
            networkStatusView = null;
        });

        describe('initialization', function() {
            it('should have an empty interval', function() {
                assert.equal(networkStatusView.socketReconnectWaitDuration.asSeconds(), 0);
            });
        });
        describe('network status with no connection', function() {
            beforeEach(function() {
                networkStatusView.navigatorOnLine = function() { return false; };
            });
            it('should be interrupted', function() {
                networkStatusView.update();
                var status = networkStatusView.getNetworkStatus();
                assert(status.hasInterruption);
                assert.equal(status.instructions, "Check your network connection.");
            });
            it('should display an offline message', function() {
                networkStatusView.update();
                assert.match(networkStatusView.$el.text(), /Offline/);
            });
            it('should override socket status', function() {
                _([WebSocket.CONNECTING,
                   WebSocket.OPEN,
                   WebSocket.CLOSING,
                   WebSocket.CLOSED]).map(function(socketStatusVal) {
                    socketStatus = socketStatusVal;
                    networkStatusView.update();
                    assert.match(networkStatusView.$el.text(), /Offline/);
                });
            });
            it('should override registration status', function() {
                Whisper.Registration.remove();
                networkStatusView.update();
                assert.match(networkStatusView.$el.text(), /Offline/);
            });
        });
        describe('network status when registration is not done', function() {
            beforeEach(function() {
                Whisper.Registration.remove();
            });
            it('should display an unlinked message', function() {
                networkStatusView.update();
                assert.match(networkStatusView.$el.text(), /Relink/);
            });
            it('should override socket status', function() {
                _([WebSocket.CONNECTING,
                   WebSocket.OPEN,
                   WebSocket.CLOSING,
                   WebSocket.CLOSED]).map(function(socketStatusVal) {
                    socketStatus = socketStatusVal;
                    networkStatusView.update();
                    assert.match(networkStatusView.$el.text(), /Relink/);
                });
            });
        });
        describe('network status when registration is done', function() {
            beforeEach(function() {
                networkStatusView.navigatorOnLine = function() { return true; };
                Whisper.Registration.markDone();
                networkStatusView.update();
            });
            it('should not display an unlinked message', function() {
                networkStatusView.update();
                assert.notMatch(networkStatusView.$el.text(), /Relink/);
            });
        });
        describe('network status when socket is connecting', function() {
            beforeEach(function() {
                Whisper.Registration.markDone();
                socketStatus = WebSocket.CONNECTING;
                networkStatusView.update();
            });
            it('it should display a connecting string if connecting and not in the connecting grace period', function() {
                networkStatusView.withinConnectingGracePeriod = false;
                var status = networkStatusView.getNetworkStatus();

                assert.match(networkStatusView.$el.text(), /Connecting/);
            });
            it('it should not be interrupted if in connecting grace period', function() {
                assert(networkStatusView.withinConnectingGracePeriod);
                var status = networkStatusView.getNetworkStatus();

                assert.match(networkStatusView.$el.text(), /Connecting/);
                assert(!status.hasInterruption);
            });
            it('it should be interrupted if connecting grace period is over', function() {
                networkStatusView.withinConnectingGracePeriod = false;
                var status = networkStatusView.getNetworkStatus();

                assert(status.hasInterruption);
            });
        });
        describe('network status when socket is open', function() {
            before(function() {
                socketStatus = WebSocket.OPEN;
            });
            it('should not be interrupted', function() {
                var status = networkStatusView.getNetworkStatus();
                assert(!status.hasInterruption);
                assert.match(networkStatusView.$el.find('.network-status-message').text().trim(), /^$/);
            });
        });
        describe('network status when socket is closed or closing', function() {
            _([WebSocket.CLOSED, WebSocket.CLOSING]).map(function(socketStatusVal) {
                it('should be interrupted', function() {
                    socketStatus = socketStatusVal;
                    networkStatusView.update();
                    var status = networkStatusView.getNetworkStatus();
                    assert(status.hasInterruption);
                });

            });
        });
        describe('the socket reconnect interval', function() {
            beforeEach(function() {
                socketStatus = WebSocket.CLOSED;
                networkStatusView.setSocketReconnectInterval(61000);
                networkStatusView.update();
            });
            it('should format the message based on the socketReconnectWaitDuration property', function() {
                assert.equal(networkStatusView.socketReconnectWaitDuration.asSeconds(), 61);
                assert.match(networkStatusView.$('.network-status-message:last').text(), /Attempting reconnect/);
            });
            it('should be reset by changing the socketStatus to CONNECTING', function() {

            });
        });
    });
});