first commit

wangzhibo

2026-05-09 53418655c061ac26f66058253f39200aced1ab1d

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/*
 * Copyright (c) 2012 Mathieu Turcotte
 * Licensed under the MIT license.
 */
 
var sinon = require('sinon');
var util = require('util');
 
var BackoffStrategy = require('../lib/strategy/strategy');
 
function SampleBackoffStrategy(options) {
    BackoffStrategy.call(this, options);
}
util.inherits(SampleBackoffStrategy, BackoffStrategy);
 
SampleBackoffStrategy.prototype.next_ = function() {
    return this.getInitialDelay();
};
 
SampleBackoffStrategy.prototype.reset_ = function() {};
 
exports["BackoffStrategy"] = {
    setUp: function(callback) {
        this.random = sinon.stub(Math, 'random');
        callback();
    },
 
    tearDown: function(callback) {
        this.random.restore();
        callback();
    },
 
    "the randomisation factor should be between 0 and 1": function(test) {
        test.throws(function() {
            new BackoffStrategy({
                randomisationFactor: -0.1
            });
        });
 
        test.throws(function() {
            new BackoffStrategy({
                randomisationFactor: 1.1
            });
        });
 
        test.doesNotThrow(function() {
            new BackoffStrategy({
                randomisationFactor: 0.5
            });
        });
 
        test.done();
    },
 
    "the raw delay should be randomized based on the randomisation factor": function(test) {
        var strategy = new SampleBackoffStrategy({
            randomisationFactor: 0.5,
            initialDelay: 1000
        });
        this.random.returns(0.5);
 
        var backoffDelay = strategy.next();
 
        test.equals(backoffDelay, 1000 + (1000 * 0.5 * 0.5));
        test.done();
    },
 
    "the initial backoff delay should be greater than 0": function(test) {
        test.throws(function() {
            new BackoffStrategy({
                initialDelay: -1
            });
        });
 
        test.throws(function() {
            new BackoffStrategy({
                initialDelay: 0
            });
        });
 
        test.doesNotThrow(function() {
            new BackoffStrategy({
                initialDelay: 1
            });
        });
 
        test.done();
    },
 
    "the maximal backoff delay should be greater than 0": function(test) {
        test.throws(function() {
            new BackoffStrategy({
                maxDelay: -1
            });
        });
 
        test.throws(function() {
            new BackoffStrategy({
                maxDelay: 0
            });
        });
 
        test.done();
    },
 
    "the maximal backoff delay should be greater than the initial backoff delay": function(test) {
        test.throws(function() {
            new BackoffStrategy({
                initialDelay: 10,
                maxDelay: 10
            });
        });
 
        test.doesNotThrow(function() {
            new BackoffStrategy({
                initialDelay: 10,
                maxDelay: 11
            });
        });
 
        test.done();
    }
};