fix tests

dist/peerjs.js

@@ -8689,10 +8689,6 @@ function (_super) {
     _this.serialization = _this.options.serialization || enums_1.SerializationType.Binary;
     _this.reliable = !!_this.options.reliable;
 
-    if (_this.options._payload) {
-      _this._peerBrowser = _this.options._payload.browser;
-    }
-
     _this._encodingQueue.on('done', function (ab) {
       _this._bufferedSend(ab);
     });
@@ -8998,8 +8994,6 @@ function (_super) {
 
     switch (message.type) {
       case enums_1.ServerMessageType.Answer:
-        this._peerBrowser = payload.browser; // Forward to negotiator
-
         this._negotiator.handleSDP(message.type, payload.sdp);
 
         break;
@@ -9656,9 +9650,9 @@ function (_super) {
     switch (type) {
       case enums_1.ServerMessageType.Open:
         // The connection to the server is open.
-        this.emit(enums_1.PeerEventType.Open, this.id);
         this._lastServerId = this.id;
         this._open = true;
+        this.emit(enums_1.PeerEventType.Open, this.id);
         break;
 
       case enums_1.ServerMessageType.Error:
@@ -9950,13 +9944,16 @@ function (_super) {
 
   Peer.prototype.emitError = function (type, err) {
     logger_1.default.error("Error:", err);
+    var error;
 
     if (typeof err === "string") {
-      err = new Error(err);
+      error = new Error(err);
+    } else {
+      error = err;
     }
 
-    err.type = type;
-    this.emit(enums_1.PeerEventType.Error, err);
+    error.type = type;
+    this.emit(enums_1.PeerEventType.Error, error);
   };
   /**
    * Destroys the Peer: closes all active connections as well as the connection

lib/peer.ts

@@ -219,9 +219,9 @@ export class Peer extends EventEmitter {
 
     switch (type) {
       case ServerMessageType.Open: // The connection to the server is open.
-        this.emit(PeerEventType.Open, this.id);
         this._lastServerId = this.id;
         this._open = true;
+        this.emit(PeerEventType.Open, this.id);
         break;
       case ServerMessageType.Error: // Server error.
         this._abort(PeerErrorType.ServerError, payload.msg);

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "peerjs",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -5789,12 +5789,12 @@
       }
     },
     "mock-socket": {
-      "version": "9.0.0",
-      "resolved": "https://registry.npmjs.org/mock-socket/-/mock-socket-9.0.0.tgz",
-      "integrity": "sha512-8Q3y/chmcYRJ6oxhAO9QJwSr6ZWU2zuzD0A7tHa0HOyL83nInIqimFWuke7936IYjEuhBaOrruV+aemlB1f+aA==",
+      "version": "8.0.5",
+      "resolved": "https://registry.npmjs.org/mock-socket/-/mock-socket-8.0.5.tgz",
+      "integrity": "sha512-dE2EbcxJKQCeYLZSsI7BAiMZCe/bHbJ2LHb5aGwUuDmfoOINEJ8QI6qYJ85NHsSNkNa90F3s6onZcmt/+MppFA==",
       "dev": true,
       "requires": {
-        "url-parse": "^1.4.4"
+        "url-parse": "^1.2.0"
       }
     },
     "ms": {

package.json

@@ -27,7 +27,7 @@
     "jsdom": "^15.1.1",
     "jsdom-global": "^3.0.2",
     "mocha": "^6.2.0",
-    "mock-socket": "^9.0.0",
+    "mock-socket": "8.0.5",
     "parcel-bundler": "^1.12.3",
     "standard": "^14.1.0",
     "ts-node": "^8.3.0",

test/logger.ts

@@ -2,6 +2,12 @@ import { expect } from "chai";
 import Logger, { LogLevel } from "../lib/logger";
 
 describe("Logger", function () {
+    let oldLoggerPrint;
+    before(() => {
+        //@ts-ignore
+        oldLoggerPrint = Logger._print;
+    });
+
     it("should be disabled by default", function () {
         expect(Logger.logLevel).to.eq(LogLevel.Disabled);
     });
@@ -42,4 +48,8 @@ describe("Logger", function () {
 
         expect(checkedLevels).to.deep.eq([LogLevel.All, LogLevel.Warnings, LogLevel.Errors]);
     });
+
+    after(() => {
+        Logger.setLogFunction(oldLoggerPrint);
+    })
 });

test/peer.ts

@@ -2,14 +2,30 @@ import "./setup";
 import { expect } from "chai";
 import { Peer } from "../lib/peer";
 import { Server } from 'mock-socket';
-import { ConnectionType, ServerMessageType } from "../lib/enums";
+import { ConnectionType, ServerMessageType, PeerErrorType, PeerEventType } from "../lib/enums";
 
+const createMockServer = (): Server => {
+    const fakeURL = 'ws://localhost:8080/peerjs?key=peerjs&id=1&token=testToken';
+    const mockServer = new Server(fakeURL);
+
+    mockServer.on('connection', socket => {
+        //@ts-ignore
+        socket.on('message', data => {
+            socket.send('test message from mock server');
+        });
+
+        socket.send(JSON.stringify({ type: ServerMessageType.Open }));
+    });
+
+    return mockServer;
+}
 describe("Peer", function () {
     describe("after construct without parameters", function () {
         it("shouldn't contains any connection", function () {
             const peer = new Peer();
 
-            expect(peer.connections).to.deep.eq({});
+            expect(peer.open).to.be.false;
+            expect(peer.connections).to.be.empty;
             expect(peer.id).to.be.null;
             expect(peer.disconnected).to.be.false;
             expect(peer.destroyed).to.be.false;
@@ -19,15 +35,13 @@ describe("Peer", function () {
     });
 
     describe("after construct with parameters", function () {
-        it("should contains id and key", function (done) {
+        it("should contains id and key", function () {
             const peer = new Peer('1', { key: 'anotherKey' });
 
             expect(peer.id).to.eq('1');
             expect(peer.options.key).to.eq('anotherKey');
 
             peer.destroy();
-
-            setTimeout(() => done(), 0);
         });
     });
 
@@ -35,21 +49,12 @@ describe("Peer", function () {
         let mockServer;
 
         before(function () {
-            const fakeURL = 'ws://localhost:8080/peerjs?key=peerjs&id=1&token=testToken';
-            mockServer = new Server(fakeURL);
-
-            mockServer.on('connection', socket => {
-                //@ts-ignore
-                socket.on('message', data => {
-                    socket.send('test message from mock server');
-                });
-
-                socket.send(ServerMessageType.Open);
-            });
+            mockServer = createMockServer();
         });
 
         it("Peer#1 should has id #1", function (done) {
             const peer1 = new Peer('1', { port: 8080, host: 'localhost' });
+            expect(peer1.open).to.be.false;
 
             const mediaOptions = {
                 metadata: { var: '123' },
@@ -73,13 +78,136 @@ describe("Peer", function () {
             expect(mediaConnection.metadata).to.deep.eq(mediaOptions.metadata);
             expect(mediaConnection.peerConnection.getSenders()[0].track.id).to.eq(track.id);
 
-            peer1.destroy();
+            peer1.once('open', (id) => {
+                expect(id).to.be.eq('1');
+                //@ts-ignore
+                expect(peer1._lastServerId).to.be.eq('1');
+                expect(peer1.disconnected).to.be.false;
+                expect(peer1.destroyed).to.be.false;
+                expect(peer1.open).to.be.true;
 
-            expect(peer1.disconnected).to.be.true;
-            expect(peer1.destroyed).to.be.true;
-            expect(peer1.open).to.be.false;
+                peer1.destroy();
+
+                expect(peer1.disconnected).to.be.true;
+                expect(peer1.destroyed).to.be.true;
+                expect(peer1.open).to.be.false;
+                expect(peer1.connections).to.be.empty;
+
+                done();
+            });
+        });
+
+        after(function () {
+            mockServer.stop();
+        });
+    });
+
+    describe("reconnect", function () {
+        let mockServer;
+
+        before(function () {
+            mockServer = createMockServer();
+        });
+
+        it("connect to server => disconnect => reconnect => destroy", function (done) {
+            const peer1 = new Peer('1', { port: 8080, host: 'localhost' });
 
-            done();
+            peer1.once('open', () => {
+                expect(peer1.open).to.be.true;
+
+                peer1.once('disconnected', () => {
+                    expect(peer1.disconnected).to.be.true;
+                    expect(peer1.destroyed).to.be.false;
+                    expect(peer1.open).to.be.false;
+
+                    peer1.once('open', (id) => {
+                        expect(id).to.be.eq('1');
+                        expect(peer1.disconnected).to.be.false;
+                        expect(peer1.destroyed).to.be.false;
+                        expect(peer1.open).to.be.true;
+
+                        peer1.once('disconnected', () => {
+                            expect(peer1.disconnected).to.be.true;
+                            expect(peer1.destroyed).to.be.false;
+                            expect(peer1.open).to.be.false;
+
+                            peer1.once('close', () => {
+                                expect(peer1.disconnected).to.be.true;
+                                expect(peer1.destroyed).to.be.true;
+                                expect(peer1.open).to.be.false;
+
+                                done();
+                            });
+                        });
+
+                        peer1.destroy();
+                    });
+
+                    peer1.reconnect();
+                });
+
+                peer1.disconnect();
+            });
+        });
+
+        it("disconnect => reconnect => destroy", function (done) {
+            mockServer.stop();
+
+            const peer1 = new Peer('1', { port: 8080, host: 'localhost' });
+
+            peer1.once('disconnected', (id) => {
+                expect(id).to.be.eq('1');
+                expect(peer1.disconnected).to.be.true;
+                expect(peer1.destroyed).to.be.false;
+                expect(peer1.open).to.be.false;
+
+                peer1.once('open', (id) => {
+                    expect(id).to.be.eq('1');
+                    expect(peer1.disconnected).to.be.false;
+                    expect(peer1.destroyed).to.be.false;
+                    expect(peer1.open).to.be.true;
+
+                    peer1.once('disconnected', () => {
+                        expect(peer1.disconnected).to.be.true;
+                        expect(peer1.destroyed).to.be.false;
+                        expect(peer1.open).to.be.false;
+
+                        peer1.once('close', () => {
+                            expect(peer1.disconnected).to.be.true;
+                            expect(peer1.destroyed).to.be.true;
+                            expect(peer1.open).to.be.false;
+
+                            done();
+                        });
+                    });
+
+                    peer1.destroy();
+                });
+
+                mockServer = createMockServer();
+
+                peer1.reconnect();
+            });
+        });
+
+        it("destroy peer if no id and no connection", function (done) {
+            mockServer.stop();
+
+            const peer1 = new Peer({ port: 8080, host: 'localhost' });
+
+            peer1.once(PeerEventType.Error, (error) => {
+                expect(error.type).to.be.eq(PeerErrorType.ServerError);
+
+                peer1.once(PeerEventType.Close, () => {
+                    expect(peer1.disconnected).to.be.true;
+                    expect(peer1.destroyed).to.be.true;
+                    expect(peer1.open).to.be.false;
+
+                    done();
+                });
+
+                mockServer = createMockServer();
+            });
         });
 
         after(function () {