-
Notifications
You must be signed in to change notification settings - Fork 0
/
index.js
163 lines (145 loc) · 6.27 KB
/
index.js
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
(function (sinomocha) {
"use strict";
function findNodeJSMocha(moduleToTest, suffix) {
if (moduleToTest.id.indexOf(suffix, moduleToTest.id.length - suffix.length) !== -1 && moduleToTest.exports) {
return moduleToTest.exports;
}
for (var i = 0; i < moduleToTest.children.length; ++i) {
var found = findNodeJSMocha(moduleToTest.children[i], suffix);
if (found) {
return found;
}
}
}
// Module systems magic dance.
if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
// Node.js: plug in automatically, if no argument is provided. This is a good idea since one can run Mocha tests
// using the Mocha test runner from either a locally-installed package, or from a globally-installed one.
// In the latter case, naively plugging in `require("mocha")` would end up duck-punching the wrong instance,
// so we provide this shortcut to auto-detect which Mocha package needs to be duck-punched.
module.exports = function (mocha) {
if (!mocha) {
if (typeof process === "object" && Object.prototype.toString.call(process) === "[object process]") {
// We're in *real* Node.js, not in a browserify-like environment. Do automatic detection logic.
// Funky syntax prevents Browserify from detecting the require, since it's needed for Node.js-only stuff.
var path = (require)("path");
var suffix = path.join("mocha", "lib", "mocha.js");
mocha = findNodeJSMocha(require.main, suffix);
if (mocha === undefined) {
throw new Error("Attempted to automatically plug in to Mocha, but could not detect a " +
"running Mocha module.");
}
} else if (typeof Mocha !== "undefined") {
// We're in a browserify-like emulation environment. Try the `Mocha` global.
mocha = Mocha;
} else {
throw new Error("Attempted to automatically plug in to Mocha, but could not detect the " +
"environment. Plug in manually by passing the running Mocha module.");
}
}
sinomocha(mocha);
};
} else if (typeof define === "function" && define.amd) {
// AMD
define(function () {
return sinomocha;
});
} else {
// Other environment (usually <script> tag): plug in global `Mocha` directly and automatically.
sinomocha(Mocha);
}
}((function () {
'use strict';
var duckPunchedAlready = false,
nop = function () {},
sinon;
if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
sinon = require('sinon');
} else {
sinon = (typeof window === 'undefined' ? global : window).sinon;
}
function setupSandbox(context) {
return function setupSandbox() {
var oldSandbox = context._sandbox;
context._sandbox = sinon.sandbox.create({
properties: ['spy', 'stub', 'mock', 'clock', 'server', 'requests'],
useFakeTimers: false,
useFakeServer: false
});
context._sandbox.inject(context);
context.useFakeServer = function () {
context._sandbox.useFakeServer();
context._sandbox.inject(context);
}
context.useFakeTimers = function () {
context._sandbox.useFakeTimers();
context._sandbox.inject(context);
}
context.useFakeXMLHttpRequest = function () {
context._sandbox.useFakeXMLHttpRequest();
context._sandbox.inject(context);
}
if (oldSandbox) {
context._sandbox.parent = oldSandbox;
}
}
}
function teardownSandbox(context) {
return function teardownSandbox() {
if (!context._sandbox) return;
context._sandbox.restore();
delete context.spy;
delete context.stub;
delete context.mock;
delete context.clock;
delete context.server;
delete context.requests;
delete context.useFakeServer;
delete context.useFakeTimers;
delete context.useFakeXMLHttpRequest;
if (context._sandbox.parent) {
context._sandbox = context._sandbox.parent;
context._sandbox.inject(context);
}
}
}
return function sinomocha(mocha) {
if (duckPunchedAlready) {
return;
}
duckPunchedAlready = true;
var oldBeforeEach = mocha.Suite.prototype.beforeEach,
oldBeforeAll = mocha.Suite.prototype.beforeAll,
oldRun = mocha.Test.prototype.run;
mocha.Suite.prototype.beforeEach = function beforeEach(beforeFunction) {
if (!this._sandboxedEach) {
this._sandboxedEach = true;
oldBeforeEach.call(this, setupSandbox(this.ctx));
this.afterEach(teardownSandbox(this.ctx));
}
return oldBeforeEach.call(this, beforeFunction);
};
mocha.Suite.prototype.beforeAll = function beforeAll(beforeFunction) {
if (!this._sandboxedAll) {
this._sandboxedAll = true;
oldBeforeAll.call(this, setupSandbox(this.ctx));
this.afterAll(teardownSandbox(this.ctx));
}
return oldBeforeAll.call(this, beforeFunction);
};
mocha.Test.prototype.run = function (callback) {
var fn = this.fn, context = this.ctx;
this.fn = function (done) {
setupSandbox(context)();
return fn.call(context, done);
};
this.fn.toString = function () {
return fn.toString();
}
return oldRun.call(this, function (err) {
teardownSandbox(context)();
return callback.call(context, err || null);
});
}
};
}())));