Antes de ler este tópico, você também pode querer ler o anterior: HTML5 Websocket com AngularJS

Este tópico fala sobre o módulo ngWebsocket

Desenvolvendo com ngWebsocket

Trabalhar com HTML5 Websocket precisa ter um back-end de escuta que aceite uma conexão e responda com alguns dados.
Mas e se pudermos desenvolver e testar nosso aplicativo de websocket sem um back-end real?
Quero dizer, com AngularJS você pode usar o serviço $ httpBackend para simular um servidor da web http e isso é realmente útil para teste.
Então, acho que podemos fazer a mesma coisa (não, espere, melhor ainda!) Com o ngWebsocket.

Como? Com um recurso intrigante chamado mock .

Zombar

Mock é uma propriedade que pode ser passada para o construtor ngWebsocket da seguinte maneira:

angular.controller('MyCtrl', function ($websocket) {
    var ws = $websocket.$new({
        url: 'ws://localhost:12345',
        mock: true
    });
});

Por padrão, mock é definido como false.
No entanto, se você passar um booleano verdadeiro para ele, ele será habilitado e um servidor parrot do websocket será simulado.
Isso significa que cada evento que sua instância ngWebsocket irá emitir será interceptado pelo
servidor interno do websocket e obterá uma resposta no mesmo evento com os mesmos dados. Como um papagaio, certo?

Vamos ver em ação:

angular.controller('MyCtrl', function ($websocket) {
    var ws = $websocket.$new({
        url: 'ws://localhost:12345',
        mock: true
    });

    ws.$on('$open', function () {
        ws.$emit('a test', 'hello world');
        ws.$emit('another test', {
            my: 'awesome data'
        });
    });

    ws.$on('a test', function (message) {
        console.log(message); // 'hello world'
    });

    ws.$on('another test', function (message) {
        console.log(message.my); // 'awesome data'
    });
});

Como você pode ver, isso é muito útil!
Por quê? Porque você pode desenvolver seu aplicativo sem um back-end real.

Portanto, sua equipe de back-end e você podem configurar um protocolo de comunicação (talvez em JSON) que permite compartilhar dados entre
o aplicativo de front-end e o back-end.
Enquanto isso, o desenvolvimento de seu aplicativo pode ser feito em paralelo com o back-end, mesmo que eles não se comuniquem.
Quando o back-end estiver pronto, basta remover a propriedade mock do construtor e seu aplicativo enviará e
receberá dados de e para o servidor. Se o protocolo foi seguido corretamente, você nunca notará nenhuma mudança.

Testando

Tudo o que você disse é ótimo, sério cara, estou falando sério!
Mas e quanto aos testes ?

Bem, cara, você entendeu!
Como podemos fazer um teste de unidade para aproveitar o recurso de simulação ?

Sem problemas!
Vamos pegar o exemplo acima e transformá-lo em um teste de unidade útil!

var $websocket;

describe('My awesome websocket unit test', function () {
    beforeEach(module('ngWebsocket')); // require the ngWebsocket module
    beforeEach(inject(function (_$websocket_) {
        $websocket = _$websocket_; // inject the $websocket service
    }));

    describe('Testing the websocket', function () {
        var ws;

        beforeEach(function (done) {
            ws = $websocket.$new({
                url: 'ws://localhost:12345',
                mock: true
            });

            ws.$on('$open', function () {
                done(); // enable all tests after the websocket connection is established
            });
        });

        it('should receive the same data on the same emitted event', function (done) {
            expect(ws.$status()).toEqual(ws.$OPEN);
            expect(ws.$ready()).toBeTruthy();

            ws.$emit('a test', 'hello world');
            ws.$emit('another test', {
                my: 'awesome data'
            });

            ws.$on('a test', function (message) {
                expect(message).toEqual('hello world');
            });

            ws.$on('another test', function (message) {
                expect(message.my).toEqual('awesome data');

                done(); // it works sequentially because the internal websocket server uses a queue to enqueues messages
            });
        });

        afterEach(function () {
            ws.$close(); // close the connection
        });
    });
});

Você pode ver a luz? normalmente disse um grande homem!

Sim! Nós fazemos!
Este é um exemplo de teste de unidade real e realmente funciona, mesmo se não houver uma linha de código de back-end!

Vou mostrar a você como usar fixtures para simular um servidor de websocket personalizado muito em breve, portanto, fique ligado;)