add tests for handshake and upgrade

pom.xml

@@ -22,6 +22,12 @@
       <version>4.11</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.hamcrest</groupId>
+      <artifactId>hamcrest-library</artifactId>
+      <version>1.3</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <build>

src/main/java/com/github/nkzawa/engineio/client/Socket.java

@@ -6,9 +6,7 @@ import com.github.nkzawa.engineio.client.transports.PollingXHR;
 import com.github.nkzawa.engineio.client.transports.WebSocket;
 import com.github.nkzawa.engineio.parser.Packet;
 import com.github.nkzawa.engineio.parser.Parser;
-import com.google.gson.JsonElement;
+import com.google.gson.Gson;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
 
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -20,6 +18,8 @@ public abstract class Socket extends Emitter {
 
     private static final Logger logger = Logger.getLogger(Socket.class.getName());
 
+    private static final Gson gson = new Gson();
+
     private static final int OPENING = 0;
     private static final int OPEN = 1;
     private static final int CLOSING = 2;
@@ -244,7 +244,7 @@ public abstract class Socket extends Emitter {
 
                                     logger.fine("changing transport and sending upgrade packet");
                                     transport[0].off(Transport.EVENT_ERROR, onerror);
-                                    self.emit(EVENT_UPGRADE, transport);
+                                    self.emit(EVENT_UPGRADE, transport[0]);
                                     self.setTransport(transport[0]);
                                     Packet packet = new Packet(Packet.UPGRADE);
                                     transport[0].send(new Packet[]{packet});
@@ -316,7 +316,7 @@ public abstract class Socket extends Emitter {
             this.emit(EVENT_HEARTBEAT);
 
             if (Packet.OPEN.equals(packet.type)) {
-                this.onHandshake(new JsonParser().parse(packet.data).getAsJsonObject());
+                this.onHandshake(gson.fromJson(packet.data, HandshakeData.class));
             } else if (Packet.PONG.equals(packet.type)) {
                 this.ping();
             } else if (Packet.ERROR.equals(packet.type)) {
@@ -334,19 +334,13 @@ public abstract class Socket extends Emitter {
         }
     }
 
-    private void onHandshake(JsonObject data) {
+    private void onHandshake(HandshakeData data) {
         this.emit(EVENT_HANDSHAKE, data);
-        this.id = data.get("sid").getAsString();
+        this.id = data.sid;
-        this.transport.query.put("sid", data.get("sid").getAsString());
+        this.transport.query.put("sid", data.sid);
-
+        this.upgrades = this.filterUpgrades(data.upgrades);
-        List<String> upgrades = new ArrayList<String>();
+        this.pingInterval = data.pingInterval;
-        for (JsonElement upgrade : data.get("upgrades").getAsJsonArray()) {
+        this.pingTimeout = data.pingTimeout;
-            upgrades.add(upgrade.getAsString());
-        }
-        this.upgrades = this.filterUpgrades(upgrades);
-
-        this.pingInterval = data.get("pingInterval").getAsLong();
-        this.pingTimeout = data.get("pingTimeout").getAsLong();
         this.onOpen();
         this.ping();
 
@@ -526,6 +520,7 @@ public abstract class Socket extends Emitter {
 
     public abstract void onclose();
 
+
     public static class Options extends Transport.Options {
 
         public String host;
@@ -558,4 +553,12 @@ public abstract class Socket extends Emitter {
 
         public Emitter evs = new Emitter();
     }
+
+    public static class HandshakeData {
+
+        public String sid;
+        public List<String> upgrades;
+        public long pingInterval;
+        public long pingTimeout;
+    }
 }

src/test/java/com/github/nkzawa/engineio/client/ServerConnectionTest.java

@@ -1,5 +1,6 @@
 package com.github.nkzawa.engineio.client;
 
+import com.github.nkzawa.emitter.Emitter;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -12,11 +13,14 @@ import java.io.InputStreamReader;
 import java.net.URISyntaxException;
 import java.util.concurrent.*;
 
-import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.*;
+import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.instanceOf;
 import static org.junit.Assert.assertThat;
 
 @RunWith(JUnit4.class)
-public class ConnectionTest {
+public class ServerConnectionTest {
 
     final static int TIMEOUT = 3000;
     final static int PORT = 3000;
@@ -133,4 +137,82 @@ public class ConnectionTest {
         assertThat(events.take(), is("hi"));
         socket.close();
     }
+
+    @Test(timeout = TIMEOUT)
+    public void handshake() throws URISyntaxException, InterruptedException {
+        final BlockingQueue<Object[]> events = new LinkedBlockingQueue<Object[]>();
+
+        socket = new Socket("ws://localhost:" + PORT) {
+            @Override
+            public void onopen() {}
+            @Override
+            public void onmessage(String data) {}
+            @Override
+            public void onclose() {}
+        };
+        socket.on(Socket.EVENT_HANDSHAKE, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                System.out.println(String.format("on handshake: %s", args.length));
+                events.offer(args);
+            }
+        });
+        socket.open();
+
+        Object[] args = events.take();
+        assertThat(args.length, is(1));
+        assertThat(args[0], is(instanceOf(Socket.HandshakeData.class)));
+
+        Socket.HandshakeData data = (Socket.HandshakeData)args[0];
+        assertThat(data.sid, is(notNullValue()));
+        assertThat(data.upgrades, is(notNullValue()));
+        assertThat(data.upgrades, is(not(empty())));
+        assertThat(data.pingTimeout, is(greaterThan((long)0)));
+        assertThat(data.pingInterval, is(greaterThan((long)0)));
+
+        socket.close();
+    }
+
+    @Test(timeout = TIMEOUT)
+    public void upgrade() throws URISyntaxException, InterruptedException {
+        final BlockingQueue<Object[]> events = new LinkedBlockingQueue<Object[]>();
+
+        socket = new Socket("ws://localhost:" + PORT) {
+            @Override
+            public void onopen() {}
+            @Override
+            public void onmessage(String data) {}
+            @Override
+            public void onclose() {}
+        };
+        socket.on(Socket.EVENT_UPGRADING, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                System.out.println(String.format("on upgrading: %s", args.length));
+                events.offer(args);
+            }
+        });
+        socket.on(Socket.EVENT_UPGRADE, new Emitter.Listener() {
+            @Override
+            public void call(Object... args) {
+                System.out.println(String.format("on upgrade: %s", args.length));
+                events.offer(args);
+            }
+        });
+        socket.open();
+
+        Object[] args1 = events.take();
+        assertThat(args1.length, is(1));
+        assertThat(args1[0], is(instanceOf(Transport.class)));
+        Transport transport1 = (Transport)args1[0];
+        assertThat(transport1, is(notNullValue()));
+
+        Object[] args2 = events.take();
+        assertThat(args2.length, is(1));
+        assertThat(args2[0], is(instanceOf(Transport.class)));
+        Transport transport2 = (Transport)args2[0];
+        assertThat(transport2, is(notNullValue()));
+
+        socket.close();
+    }
 }