source: trip-planner-front/node_modules/retry/test/integration/test-retry-operation.js@ e29cc2e

Last change on this file since e29cc2e was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 6.3 KB
Line 
1var common = require('../common');
2var assert = common.assert;
3var fake = common.fake.create();
4var retry = require(common.dir.lib + '/retry');
5
6(function testReset() {
7 var error = new Error('some error');
8 var operation = retry.operation([1, 2, 3]);
9 var attempts = 0;
10
11 var finalCallback = fake.callback('finalCallback');
12 fake.expectAnytime(finalCallback);
13
14 var expectedFinishes = 1;
15 var finishes = 0;
16
17 var fn = function() {
18 operation.attempt(function(currentAttempt) {
19 attempts++;
20 assert.equal(currentAttempt, attempts);
21 if (operation.retry(error)) {
22 return;
23 }
24
25 finishes++
26 assert.equal(expectedFinishes, finishes);
27 assert.strictEqual(attempts, 4);
28 assert.strictEqual(operation.attempts(), attempts);
29 assert.strictEqual(operation.mainError(), error);
30
31 if (finishes < 2) {
32 attempts = 0;
33 expectedFinishes++;
34 operation.reset();
35 fn()
36 } else {
37 finalCallback();
38 }
39 });
40 };
41
42 fn();
43})();
44
45(function testErrors() {
46 var operation = retry.operation();
47
48 var error = new Error('some error');
49 var error2 = new Error('some other error');
50 operation._errors.push(error);
51 operation._errors.push(error2);
52
53 assert.deepEqual(operation.errors(), [error, error2]);
54})();
55
56(function testMainErrorReturnsMostFrequentError() {
57 var operation = retry.operation();
58 var error = new Error('some error');
59 var error2 = new Error('some other error');
60
61 operation._errors.push(error);
62 operation._errors.push(error2);
63 operation._errors.push(error);
64
65 assert.strictEqual(operation.mainError(), error);
66})();
67
68(function testMainErrorReturnsLastErrorOnEqualCount() {
69 var operation = retry.operation();
70 var error = new Error('some error');
71 var error2 = new Error('some other error');
72
73 operation._errors.push(error);
74 operation._errors.push(error2);
75
76 assert.strictEqual(operation.mainError(), error2);
77})();
78
79(function testAttempt() {
80 var operation = retry.operation();
81 var fn = new Function();
82
83 var timeoutOpts = {
84 timeout: 1,
85 cb: function() {}
86 };
87 operation.attempt(fn, timeoutOpts);
88
89 assert.strictEqual(fn, operation._fn);
90 assert.strictEqual(timeoutOpts.timeout, operation._operationTimeout);
91 assert.strictEqual(timeoutOpts.cb, operation._operationTimeoutCb);
92})();
93
94(function testRetry() {
95 var error = new Error('some error');
96 var operation = retry.operation([1, 2, 3]);
97 var attempts = 0;
98
99 var finalCallback = fake.callback('finalCallback');
100 fake.expectAnytime(finalCallback);
101
102 var fn = function() {
103 operation.attempt(function(currentAttempt) {
104 attempts++;
105 assert.equal(currentAttempt, attempts);
106 if (operation.retry(error)) {
107 return;
108 }
109
110 assert.strictEqual(attempts, 4);
111 assert.strictEqual(operation.attempts(), attempts);
112 assert.strictEqual(operation.mainError(), error);
113 finalCallback();
114 });
115 };
116
117 fn();
118})();
119
120(function testRetryForever() {
121 var error = new Error('some error');
122 var operation = retry.operation({ retries: 3, forever: true });
123 var attempts = 0;
124
125 var finalCallback = fake.callback('finalCallback');
126 fake.expectAnytime(finalCallback);
127
128 var fn = function() {
129 operation.attempt(function(currentAttempt) {
130 attempts++;
131 assert.equal(currentAttempt, attempts);
132 if (attempts !== 6 && operation.retry(error)) {
133 return;
134 }
135
136 assert.strictEqual(attempts, 6);
137 assert.strictEqual(operation.attempts(), attempts);
138 assert.strictEqual(operation.mainError(), error);
139 finalCallback();
140 });
141 };
142
143 fn();
144})();
145
146(function testRetryForeverNoRetries() {
147 var error = new Error('some error');
148 var delay = 50
149 var operation = retry.operation({
150 retries: null,
151 forever: true,
152 minTimeout: delay,
153 maxTimeout: delay
154 });
155
156 var attempts = 0;
157 var startTime = new Date().getTime();
158
159 var finalCallback = fake.callback('finalCallback');
160 fake.expectAnytime(finalCallback);
161
162 var fn = function() {
163 operation.attempt(function(currentAttempt) {
164 attempts++;
165 assert.equal(currentAttempt, attempts);
166 if (attempts !== 4 && operation.retry(error)) {
167 return;
168 }
169
170 var endTime = new Date().getTime();
171 var minTime = startTime + (delay * 3);
172 var maxTime = minTime + 20 // add a little headroom for code execution time
173 assert(endTime >= minTime)
174 assert(endTime < maxTime)
175 assert.strictEqual(attempts, 4);
176 assert.strictEqual(operation.attempts(), attempts);
177 assert.strictEqual(operation.mainError(), error);
178 finalCallback();
179 });
180 };
181
182 fn();
183})();
184
185(function testStop() {
186 var error = new Error('some error');
187 var operation = retry.operation([1, 2, 3]);
188 var attempts = 0;
189
190 var finalCallback = fake.callback('finalCallback');
191 fake.expectAnytime(finalCallback);
192
193 var fn = function() {
194 operation.attempt(function(currentAttempt) {
195 attempts++;
196 assert.equal(currentAttempt, attempts);
197
198 if (attempts === 2) {
199 operation.stop();
200
201 assert.strictEqual(attempts, 2);
202 assert.strictEqual(operation.attempts(), attempts);
203 assert.strictEqual(operation.mainError(), error);
204 finalCallback();
205 }
206
207 if (operation.retry(error)) {
208 return;
209 }
210 });
211 };
212
213 fn();
214})();
215
216(function testMaxRetryTime() {
217 var error = new Error('some error');
218 var maxRetryTime = 30;
219 var operation = retry.operation({
220 minTimeout: 1,
221 maxRetryTime: maxRetryTime
222 });
223 var attempts = 0;
224
225 var finalCallback = fake.callback('finalCallback');
226 fake.expectAnytime(finalCallback);
227
228 var longAsyncFunction = function (wait, callback){
229 setTimeout(callback, wait);
230 };
231
232 var fn = function() {
233 var startTime = new Date().getTime();
234 operation.attempt(function(currentAttempt) {
235 attempts++;
236 assert.equal(currentAttempt, attempts);
237
238 if (attempts !== 2) {
239 if (operation.retry(error)) {
240 return;
241 }
242 } else {
243 var curTime = new Date().getTime();
244 longAsyncFunction(maxRetryTime - (curTime - startTime - 1), function(){
245 if (operation.retry(error)) {
246 assert.fail('timeout should be occurred');
247 return;
248 }
249
250 assert.strictEqual(operation.mainError(), error);
251 finalCallback();
252 });
253 }
254 });
255 };
256
257 fn();
258})();
Note: See TracBrowser for help on using the repository browser.