Gist for blog at ifedapo.com

ClassUsingSocketIO.java

package org.my.package;

import io.socket.client.IO;
import io.socket.client.Socket;
import io.socket.emitter.Emitter;
import io.socket.engineio.client.transports.WebSocket;

import java.net.URISyntaxException;

public class ClassUsingSocketIO {
    static final String MY_EVENT_TO_SERVER = "event_to_server";
    static final String MY_EVENT_FROM_SERVER = "event_from_server";
    
    public void useTheSocket() {
        final Socket socket = getSocket("https://my.websocket.url");
        Emitter.Listener onConnect = new Emitter.Listener() {
            @Override
            public void call(Object... args) {
                System.out.println("connection completet");
                socket.emit(MY_EVENT_TO_SERVER, "hey there server, here's a message to you");
            }
        };

        socket
                .on(Socket.EVENT_CONNECT, onConnect)
                .on(MY_EVENT_FROM_SERVER, onEventFromServer())
        socket.connect();
    }
    
    protected Emitter.Listener onEventFromServer() {
        return new Emitter.Listener() {
            @Override
            public void call(Object... args) {
                System.out.println("all is complete now, so I'll disconnect");
                socket.disconnect();
            }
        };
    }
    
    protected Socket getSocket(String socketUrl) throws URISyntaxException {
        return IO.socket(socketUrl);
    }
}

MockSocketIO.java

package org.my.package;

import io.socket.client.Manager;
import io.socket.client.Socket;
import io.socket.emitter.Emitter;

class MockSocket extends Socket {
    public final Map<String, Object> emitted;
    private Emitter fakeSocket;
    private boolean connected = false;

    public MockSocket() {
        super(new Manager(), "", new Manager.Options());
        fakeSocket = new Emitter();
        emitted = new HashMap<String, Object>();
    }

    @Override
    public Socket on(String event, Listener fn) {
        fakeSocket.on(event, fn);
        return this;
    }

    @Override
    public Socket emit(final String event, final Object... args) {
        fakeSocket.emit(event, args);
        emitted.put(event, args);
        return this;
    }

    @Override
    public Socket connect() {
        connected = true;
        fakeSocket.emit(Socket.EVENT_CONNECT);
        return this;
    }

    @Override
    public boolean connected() {
        return connected;
    }

    @Override
    public Socket disconnect() {
        connected = false;
        fakeSocket.emit(Socket.EVENT_DISCONNECT);
        return this;
    }
}

TestClassUsingSocketIO.java

package org.my.package;

import org.junit.Test;

import static junit.framework.TestCase.assertFalse;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class TestClassUsingSocketIO {
    @Test
    public void saveWithTusTillSocketComplete() throws Exception {
        MockClassUsingSocketIO socketUser = new ClassUsingSocketIO();
        socketUser.useTheSocket();
        // assert that the client emitted an event
        assertTrue(((MockSocket)socketUser.getSocket()).emitted.containsKey(ClassUsingSocketIO.MY_EVENT_TO_SERVER));
        // assert that socket is still connected
        assertTrue(socketUser.getSocket().connected());
        // manually emit event that ought to be sent from the server
        socketUser.getSocket().emit(ClassUsingSocketIO.MY_EVENT_FROM_SERVER);
        // assert that socket disconnection has been triggered
        assertFalse(socketUser.getSocket().connected());
    }
    
    public class MockClassUsingSocketIO extends ClassUsingSocketIO {
        @Override
        Socket getSocket(String url) {
            if (socket == null) {
                socket = new MockSocket();
            }
            return socket;
        }
        
        Socket getSocket() {
            return getSocket("");
        }
    }
}