📦 socketio / engine.io-parser

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63import {
  decodePacket,
  decodePayload,
  encodePacket,
  encodePayload,
  Packet
} from "..";
import * as expect from "expect.js";
import "./node"; // replaced by "./browser" for the tests in the browser (see "browser" field in the package.json file)

describe("engine.io-parser", () => {
  describe("single packet", () => {
    it("should encode/decode a string", done => {
      const packet: Packet = { type: "message", data: "test" };
      encodePacket(packet, true, encodedPacket => {
        expect(encodedPacket).to.eql("4test");
        expect(decodePacket(encodedPacket)).to.eql(packet);
        done();
      });
    });

    it("should fail to decode a malformed packet", () => {
      expect(decodePacket("")).to.eql({
        type: "error",
        data: "parser error"
      });
      expect(decodePacket("a123")).to.eql({
        type: "error",
        data: "parser error"
      });
    });
  });

  describe("payload", () => {
    it("should encode/decode all packet types", done => {
      const packets: Packet[] = [
        { type: "open" },
        { type: "close" },
        { type: "ping", data: "probe" },
        { type: "pong", data: "probe" },
        { type: "message", data: "test" }
      ];
      encodePayload(packets, payload => {
        expect(payload).to.eql("0\x1e1\x1e2probe\x1e3probe\x1e4test");
        expect(decodePayload(payload)).to.eql(packets);
        done();
      });
    });

    it("should fail to decode a malformed payload", () => {
      expect(decodePayload("{")).to.eql([
        { type: "error", data: "parser error" }
      ]);
      expect(decodePayload("{}")).to.eql([
        { type: "error", data: "parser error" }
      ]);
      expect(decodePayload('["a123", "a456"]')).to.eql([
        { type: "error", data: "parser error" }
      ]);
    });
  });
});