UNPKG

6.46 kBJavaScriptView Raw
1"use strict";
2
3import 'source-map-support/register';
4const callbacks = require("../../lib/realtime-callbacks");
5const testUtils = require("../test-utils.js");
6
7import expect from 'expect';
8import lolex from 'lolex';
9
10describe("realtime-callbacks", function() {
11 let clock;
12
13 function tick(millis) {
14 clock.tick(millis);
15 }
16
17 beforeEach(function() {
18 testUtils.beforeEach(this); // eslint-disable-line babel/no-invalid-this
19 clock = lolex.install();
20 const fakeDate = clock.Date;
21 callbacks.setNow(fakeDate.now.bind(fakeDate));
22 });
23
24 afterEach(function() {
25 callbacks.setNow();
26 clock.uninstall();
27 });
28
29 describe("setTimeout", function() {
30 it("should call the callback after the timeout", function() {
31 const callback = expect.createSpy();
32 callbacks.setTimeout(callback, 100);
33
34 expect(callback).toNotHaveBeenCalled();
35 tick(100);
36 expect(callback).toHaveBeenCalled();
37 });
38
39
40 it("should default to a zero timeout", function() {
41 const callback = expect.createSpy();
42 callbacks.setTimeout(callback);
43
44 expect(callback).toNotHaveBeenCalled();
45 tick(0);
46 expect(callback).toHaveBeenCalled();
47 });
48
49 it("should pass any parameters to the callback", function() {
50 const callback = expect.createSpy();
51 callbacks.setTimeout(callback, 0, "a", "b", "c");
52 tick(0);
53 expect(callback).toHaveBeenCalledWith("a", "b", "c");
54 });
55
56 it("should set 'this' to the global object", function() {
57 let passed = false;
58 const callback = function() {
59 expect(this).toBe(global); // eslint-disable-line babel/no-invalid-this
60 expect(this.console).toBeTruthy(); // eslint-disable-line babel/no-invalid-this
61 passed = true;
62 };
63 callbacks.setTimeout(callback);
64 tick(0);
65 expect(passed).toBe(true);
66 });
67
68 it("should handle timeouts of several seconds", function() {
69 const callback = expect.createSpy();
70 callbacks.setTimeout(callback, 2000);
71
72 expect(callback).toNotHaveBeenCalled();
73 for (let i = 0; i < 4; i++) {
74 tick(500);
75 }
76 expect(callback).toHaveBeenCalled();
77 });
78
79 it("should call multiple callbacks in the right order", function() {
80 const callback1 = expect.createSpy();
81 const callback2 = expect.createSpy();
82 const callback3 = expect.createSpy();
83 callbacks.setTimeout(callback2, 200);
84 callbacks.setTimeout(callback1, 100);
85 callbacks.setTimeout(callback3, 300);
86
87 expect(callback1).toNotHaveBeenCalled();
88 expect(callback2).toNotHaveBeenCalled();
89 expect(callback3).toNotHaveBeenCalled();
90 tick(100);
91 expect(callback1).toHaveBeenCalled();
92 expect(callback2).toNotHaveBeenCalled();
93 expect(callback3).toNotHaveBeenCalled();
94 tick(100);
95 expect(callback1).toHaveBeenCalled();
96 expect(callback2).toHaveBeenCalled();
97 expect(callback3).toNotHaveBeenCalled();
98 tick(100);
99 expect(callback1).toHaveBeenCalled();
100 expect(callback2).toHaveBeenCalled();
101 expect(callback3).toHaveBeenCalled();
102 });
103
104 it("should treat -ve timeouts the same as a zero timeout", function() {
105 const callback1 = expect.createSpy();
106 const callback2 = expect.createSpy();
107
108 // check that cb1 is called before cb2
109 callback1.andCall(function() {
110 expect(callback2).toNotHaveBeenCalled();
111 });
112
113 callbacks.setTimeout(callback1);
114 callbacks.setTimeout(callback2, -100);
115
116 expect(callback1).toNotHaveBeenCalled();
117 expect(callback2).toNotHaveBeenCalled();
118 tick(0);
119 expect(callback1).toHaveBeenCalled();
120 expect(callback2).toHaveBeenCalled();
121 });
122
123 it("should not get confused by chained calls", function() {
124 const callback2 = expect.createSpy();
125 const callback1 = expect.createSpy();
126 callback1.andCall(function() {
127 callbacks.setTimeout(callback2, 0);
128 expect(callback2).toNotHaveBeenCalled();
129 });
130
131 callbacks.setTimeout(callback1);
132 expect(callback1).toNotHaveBeenCalled();
133 expect(callback2).toNotHaveBeenCalled();
134 tick(0);
135 expect(callback1).toHaveBeenCalled();
136 // the fake timer won't actually run callbacks registered during
137 // one tick until the next tick.
138 tick(1);
139 expect(callback2).toHaveBeenCalled();
140 });
141
142 it("should be immune to exceptions", function() {
143 const callback1 = expect.createSpy();
144 callback1.andCall(function() {
145 throw new Error("prepare to die");
146 });
147 const callback2 = expect.createSpy();
148 callbacks.setTimeout(callback1, 0);
149 callbacks.setTimeout(callback2, 0);
150
151 expect(callback1).toNotHaveBeenCalled();
152 expect(callback2).toNotHaveBeenCalled();
153 tick(0);
154 expect(callback1).toHaveBeenCalled();
155 expect(callback2).toHaveBeenCalled();
156 });
157 });
158
159 describe("cancelTimeout", function() {
160 it("should cancel a pending timeout", function() {
161 const callback = expect.createSpy();
162 const k = callbacks.setTimeout(callback);
163 callbacks.clearTimeout(k);
164 tick(0);
165 expect(callback).toNotHaveBeenCalled();
166 });
167
168 it("should not affect sooner timeouts", function() {
169 const callback1 = expect.createSpy();
170 const callback2 = expect.createSpy();
171
172 callbacks.setTimeout(callback1, 100);
173 const k = callbacks.setTimeout(callback2, 200);
174 callbacks.clearTimeout(k);
175
176 tick(100);
177 expect(callback1).toHaveBeenCalled();
178 expect(callback2).toNotHaveBeenCalled();
179
180 tick(150);
181 expect(callback2).toNotHaveBeenCalled();
182 });
183 });
184});