a_mock 1.0.4 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (130) hide show
  1. package/AUTHORS +1 -1
  2. package/and/newBinaryAnd.js +19 -19
  3. package/and/newBinaryAndSpec/test.js +67 -67
  4. package/and/newMonadicAnd.js +19 -19
  5. package/and/newMonadicAndSpec/test.js +45 -45
  6. package/and.js +11 -11
  7. package/andSpec/test.js +35 -35
  8. package/andSpec/testIntegration.js +24 -24
  9. package/eventEmitter/add.js +5 -5
  10. package/eventEmitter/addSpec/test.js +22 -22
  11. package/eventEmitter/emitterContext.js +7 -7
  12. package/eventEmitter/emitterContextSpec/test.js +12 -12
  13. package/eventEmitter/remove.js +11 -11
  14. package/eventEmitter/removeSpec/test.js +27 -27
  15. package/eventEmitter/tryAdd.js +7 -7
  16. package/eventEmitter/tryAddSpec/test.js +43 -43
  17. package/eventEmitter/tryRemove.js +7 -7
  18. package/eventEmitter/tryRemoveSpec/test.js +43 -43
  19. package/eventEmitter.js +42 -42
  20. package/eventEmitterSpec/test.js +142 -142
  21. package/expectRequire.js +20 -20
  22. package/expectRequireSpec/test.js +67 -67
  23. package/index.js +9 -10
  24. package/mock/mockContext.js +9 -9
  25. package/mock/mockContextSpec/test.js +30 -30
  26. package/mock/mockFuncProperties.js +16 -16
  27. package/mock/mockFuncPropertiesSpec/test.js +67 -67
  28. package/mock/objectMock.js +23 -23
  29. package/mock/objectMockSpec/test.js +123 -123
  30. package/mock/propertyMock.js +13 -13
  31. package/mock/propertyMockSpec/test.js +36 -36
  32. package/mock/throwUnexpectedArguments.js +13 -13
  33. package/mock/throwUnexpectedArgumentsSpec/test.js +35 -35
  34. package/mock.js +19 -19
  35. package/mockSpec/test.js +65 -65
  36. package/mockSpec/testIntegration.js +102 -102
  37. package/newMutableAnd.js +18 -18
  38. package/newMutableAndSpec/test.js +48 -48
  39. package/newObject.js +4 -4
  40. package/newThen.js +111 -111
  41. package/newThenSpec/test.js +11 -11
  42. package/newThenSpec/testExecute.js +80 -80
  43. package/newThenSpec/testNoCallback.js +57 -57
  44. package/newThenSpec/testPreReject.js +51 -51
  45. package/newThenSpec/testPreRejectAndThrow.js +50 -50
  46. package/newThenSpec/testPreResolve.js +49 -49
  47. package/newThenSpec/testPreResolveAndThrow.js +48 -48
  48. package/newThenSpec/testReject.js +56 -56
  49. package/newThenSpec/testRejectAndThrow.js +56 -56
  50. package/newThenSpec/testResolve.js +56 -56
  51. package/newThenSpec/testResolveAndThrow.js +54 -54
  52. package/newThenSpec/testResolveWithFailingPromise.js +65 -65
  53. package/newThenSpec/testResolveWithPromise.js +65 -65
  54. package/newTrueNTimesThenFalse.js +29 -29
  55. package/newTrueNTimesThenFalseSpec/test.js +59 -59
  56. package/newTrueOnceThenFalse.js +21 -21
  57. package/newTrueOnceThenFalseSpec/test.js +25 -25
  58. package/package.json +13 -13
  59. package/partialMock/execute.js +18 -18
  60. package/partialMock/executeSpec/test.js +84 -84
  61. package/partialMock/expect.js +13 -13
  62. package/partialMock/expectAnything.js +51 -51
  63. package/partialMock/expectAnythingSpec/test.js +167 -167
  64. package/partialMock/expectArray.js +11 -11
  65. package/partialMock/expectArraySpec/test.js +36 -36
  66. package/partialMock/expectCore.js +70 -59
  67. package/partialMock/expectCoreSpec/test.js +241 -209
  68. package/partialMock/expectEmpty.js +47 -36
  69. package/partialMock/expectEmptySpec/test.js +194 -165
  70. package/partialMock/expectSpec/test.js +45 -45
  71. package/partialMock/fallbackWrapper/getStackTrace.js +13 -13
  72. package/partialMock/hasSameArgument/isEqualArg.js +68 -68
  73. package/partialMock/hasSameArgument/isEqualArgSpec/test.js +283 -283
  74. package/partialMock/ignore.js +7 -7
  75. package/partialMock/ignoreSpec/test.js +30 -30
  76. package/partialMock/mockContext/reset.js +14 -14
  77. package/partialMock/mockContext/resetSpec/test.js +42 -42
  78. package/partialMock/negotiateDecrementExpectCount.js +5 -5
  79. package/partialMock/negotiateDecrementExpectCountSpec/test.js +31 -31
  80. package/partialMock/negotiateEnd.js +10 -10
  81. package/partialMock/negotiateEndSpec/test.js +64 -64
  82. package/partialMock/negotiateIncrementExpectCount.js +5 -5
  83. package/partialMock/negotiateIncrementExpectCountSpec/test.js +31 -31
  84. package/partialMock/newExecute.js +21 -21
  85. package/partialMock/newExecuteSpec/test.js +61 -61
  86. package/partialMock/newFallbackWrapper.js +30 -30
  87. package/partialMock/newFallbackWrapperSpec/test.js +70 -70
  88. package/partialMock/newFallbackWrapperSpec/testWithMockError.js +59 -59
  89. package/partialMock/newFallbackWrapperSpec/testWithOtherError.js +48 -48
  90. package/partialMock/newHasArgument.js +9 -9
  91. package/partialMock/newHasArgumentSpec/test.js +36 -36
  92. package/partialMock/newHasEqualArgumentArray.js +23 -23
  93. package/partialMock/newHasEqualArgumentArraySpec/test.js +59 -59
  94. package/partialMock/newHasNoMoreArguments.js +15 -15
  95. package/partialMock/newHasNoMoreArgumentsSpec/test.js +64 -64
  96. package/partialMock/newHasSameArgument.js +11 -11
  97. package/partialMock/newHasSameArgumentSpec/test.js +80 -80
  98. package/partialMock/newMockContext.js +12 -12
  99. package/partialMock/newMockContextSpec/test.js +36 -36
  100. package/partialMock/newThrow.js +6 -6
  101. package/partialMock/newThrowSpec/test.js +20 -20
  102. package/partialMock/return.js +24 -24
  103. package/partialMock/returnSpec/test.js +106 -106
  104. package/partialMock/setExecute.js +15 -15
  105. package/partialMock/setExecuteSpec/test.js +87 -87
  106. package/partialMock/simple/expectRequire.js +12 -12
  107. package/partialMock/simple/expectRequireSpec/test.js +41 -41
  108. package/partialMock/simple/newMock/throwUnexpectedArguments.js +9 -9
  109. package/partialMock/simple/newMock/throwUnexpectedArgumentsSpec/test.js +23 -23
  110. package/partialMock/simple/newMock.js +10 -10
  111. package/partialMock/simple/newMockSpec/test.js +28 -28
  112. package/partialMock/simple/newPartialMock.js +124 -124
  113. package/partialMock/simple/newPartialMockSpec/test.js +141 -141
  114. package/partialMock/simple/newPartialMockSpec/testRepeat.js +63 -63
  115. package/partialMock/simple/newPartialMockSpec/testWithMultiArgs.js +54 -54
  116. package/partialMock/simple/newPartialMockSpec/testWithSingleArg.js +116 -116
  117. package/partialMock/simple/newRequireMock.js +12 -12
  118. package/partialMock/simple/newRequireMockSpec/test.js +39 -39
  119. package/partialMock/verify.js +7 -7
  120. package/partialMock/verifySpec/test.js +37 -37
  121. package/partialMock.js +70 -70
  122. package/partialMockSpec/test.js +235 -235
  123. package/partialMockSpec/testIntegration.js +568 -485
  124. package/promise.js +10 -10
  125. package/requireMock.js +14 -14
  126. package/requireMockSpec/test.js +45 -45
  127. package/strictMock.js +10 -10
  128. package/strictMockSpec/test.js +28 -28
  129. package/test.js +16 -16
  130. package/.npmignore +0 -1
package/partialMockSpec/testIntegration.js CHANGED
@@ -1,485 +1,568 @@
1
- var assert = require('assert');
2
- var test = require('../test');
3
- var newMock = require('../partialMock/simple/newMock');
4
- var newSut = require('../partialMock');
5
-
6
- var fallbackValue = 'fallbackValue';
7
-
8
-
9
- function fallback(arg,arg2)
10
- {
11
- return fallbackValue;
12
- }
13
-
14
- (function(){
15
- console.log('partialMock');
16
-
17
- test('it should return expected given stubbed twice with repeat',function() {
18
- var arg = 'a';
19
- var arg2 = 'b';
20
- var expected = {};
21
- var expected2 = expected;
22
- var expected3 = {};
23
- var sut = newSut(fallback);
24
- sut.expect(arg).return(expected).repeat(2);
25
- sut.expect(arg2).return(expected3);
26
-
27
- var returned = sut(arg);
28
- var returned2 = sut(arg);
29
- var returned3 = sut(arg2);
30
- var returned4 = sut(arg);
31
-
32
- assert.equal(returned,expected);
33
- assert.equal(returned2,expected2);
34
- assert.equal(returned3,expected3);
35
- assert.equal(returned4,fallbackValue);
36
- });
37
-
38
-
39
- test('it should return expected given stubbed twice',function() {
40
- var arg = 'a';
41
- var arg2 = 'b';
42
- var expected = {};
43
- var expected2 = {};
44
- var sut = newSut(fallback);
45
- sut.expect(arg).return(expected);
46
- sut.expect(arg2).return(expected2);
47
- var returned = sut(arg);
48
- var returned2 = sut(arg2);
49
- assert.equal(returned,expected);
50
- assert.equal(returned2,expected2);
51
- });
52
-
53
- test('it should return expected given stubbed twice and called unordered',function() {
54
- var arg = 'a';
55
- var arg2 = 'b';
56
- var expected = {};
57
- var expected2 = {};
58
- var sut = newSut(fallback);
59
- sut.expect(arg).return(expected);
60
- sut.expect(arg2).return(expected2);
61
- var returned2 = sut(arg2);
62
- var returned = sut(arg);
63
- assert.equal(returned,expected);
64
- assert.equal(returned2,expected2);
65
- });
66
-
67
-
68
- test('it should return expected for correct arg',function() {
69
- var arg = 'a';
70
- var expected = {};
71
- var sut = newSut(fallback);
72
- sut.expect(arg).return(expected);
73
- var returned = sut(arg);
74
- var returned2 = sut(arg);
75
- assert.equal(returned,expected);
76
- assert.equal(returned2,fallbackValue);
77
- });
78
-
79
- test('it should return correct after expect, reset, expect',function() {
80
- var arg = 'a';
81
- var expected = {};
82
- var sut = newSut(fallback);
83
- sut.expect(arg).return(expected);
84
- sut.reset();
85
- var returned = sut(arg);
86
- sut.expect(arg).return(expected);
87
- var returned2 = sut(arg);
88
- var returned3 = sut(arg);
89
- assert.equal(returned,fallbackValue);
90
- assert.equal(returned2,expected);
91
- assert.equal(returned3,fallbackValue);
92
- });
93
-
94
- test('it should throw for correct arg',function() {
95
- var arg = 'a';
96
- var error = {};
97
- var expected = {};
98
- var sut = newSut();
99
- sut.expect(arg).throw(error);
100
- sut.expect(arg).return(expected);
101
- try {
102
- sut(arg);
103
- }
104
- catch (e) {
105
- thrown = e;
106
- }
107
-
108
- var returned2 = sut(arg);
109
- assert.equal(error,thrown);
110
- assert.equal(returned2,expected);
111
- });
112
-
113
- test('it should throw for void arg',function() {
114
- var error = {};
115
- var expected = {};
116
- var sut = newSut();
117
- sut.expect().throw(error);
118
- sut.expect().return(expected);
119
- try {
120
- sut();
121
- }
122
- catch (e) {
123
- thrown = e;
124
- }
125
-
126
- var returned2 = sut();
127
- assert.equal(error,thrown);
128
- assert.equal(returned2,expected);
129
- });
130
-
131
- test('it should return expected for expected array',function() {
132
- var element1 = 'a';
133
- var element2 = 'b';
134
- var expected = {};
135
- var sut = newSut(fallback);
136
- sut.expect([element1,element2]).return(expected);
137
- var returned = sut([element1,element2]);
138
- var returned2 = sut([element1,element2]);
139
- assert.equal(returned,expected);
140
- assert.equal(returned2,fallbackValue);
141
- });
142
-
143
-
144
- test('it should return expected for correct arg,arg2',function() {
145
- var arg = 'a';
146
- var arg2 = 'b';
147
- var expected = {};
148
- var sut = newSut(fallback);
149
- sut.expect(arg).expect(arg2).return(expected);
150
- var returned = sut(arg,arg2);
151
- var returned2 = sut(arg,arg2);
152
-
153
- assert.equal(returned,expected);
154
- assert.equal(returned2,fallbackValue);
155
- assert.ok(sut.verify());
156
- });
157
-
158
- test('it should return expected for correct arg,arg2.repeat twice',function() {
159
- var arg = 'a';
160
- var arg2 = 'b';
161
- var expected = {};
162
- var repeats = 2;
163
- var sut = newSut(fallback);
164
-
165
- sut.expect(arg).expect(arg2).return(expected).repeat(repeats);
166
- var returned = sut(arg,arg2);
167
- var returned2 = sut(arg,arg2);
168
- var returned3 = sut(arg,arg2);
169
-
170
- assert.equal(returned,expected);
171
- assert.equal(returned2,expected);
172
- assert.equal(returned3,fallbackValue);
173
- assert.ok(sut.verify());
174
- });
175
-
176
- test('it should return expected for correct arg,arg2.repeat any',function() {
177
- var arg = 'a';
178
- var arg2 = 'b';
179
- var expected = {};
180
- var sut = newSut(fallback);
181
-
182
- sut.expect(arg).expect(arg2).return(expected).repeatAny();
183
- var returned = sut(arg,arg2);
184
- var returned2 = sut(arg,arg2);
185
- var returned3 = sut(arg,arg2);
186
-
187
- assert.equal(returned,expected);
188
- assert.equal(returned2,expected);
189
- assert.equal(returned3,expected);
190
- assert.ok(sut.verify());
191
- });
192
-
193
- test('it should invoke whenCalled for correct arg,arg2.repeat twice',function() {
194
- var arg = 'a';
195
- var arg2 = 'b';
196
- var expected = {};
197
- var onWhenCalled = newMock();
198
- var numberOfInvokes = 0;
199
- onWhenCalled.expect(arg).expect(arg2).whenCalled(onDidInvoke).return();
200
- onWhenCalled.expect(arg).expect(arg2).whenCalled(onDidInvoke).return();
201
-
202
- function onDidInvoke() {
203
- numberOfInvokes++;
204
- }
205
-
206
- var sut = newSut(fallback);
207
-
208
- sut.expect(arg).expect(arg2).whenCalled(onWhenCalled).return(expected).repeat(2);
209
- var returned = sut(arg,arg2);
210
- var returned2 = sut(arg,arg2);
211
- var returned3 = sut(arg,arg2);
212
-
213
- assert.equal(numberOfInvokes,2);
214
- });
215
-
216
- test('it should return expected for multiExpect arg,arg2',function() {
217
- var arg = 'a';
218
- var arg2 = 'b';
219
- var arg3 = '3';
220
- var expected = {};
221
- var sut = newSut(fallback);
222
-
223
- sut.expect(arg,arg2).expect(arg3).return(expected).repeat(2);
224
- var returned = sut(arg,arg2,arg3);
225
- var returned2 = sut(arg,arg2,arg3);
226
- var returned3 = sut(arg,arg2,arg3);
227
-
228
- assert.equal(returned,expected);
229
- assert.equal(returned2,expected);
230
- assert.equal(returned3,fallbackValue);
231
- assert.ok(sut.verify());
232
- });
233
-
234
- test('it should return expected for arg, anything twice',function() {
235
- var arg = 'a';
236
- var arg2 = 'b';
237
- var arg3;
238
- var expected = {};
239
- var sut = newSut(fallback);
240
-
241
-
242
- sut.expect(arg).expectAnything().return(expected).repeat(2);
243
- var returned = sut(arg,arg2,arg3);
244
- var returned2 = sut(arg,arg2);
245
- var returned3 = sut('foo',arg2);
246
-
247
- assert.equal(returned,expected);
248
- assert.equal(returned2,expected);
249
- assert.equal(returned3,fallbackValue);
250
- assert.ok(sut.verify());
251
- });
252
-
253
- test('it should return expected for arg, ignore twice',function() {
254
- var arg = 'a';
255
- var arg2 = 'b';
256
- var expected = {};
257
- var sut = newSut(fallback);
258
-
259
- sut.expect(arg).ignore().expect(arg2).return(expected).repeat(2);
260
- var returned = sut(arg,'foo',arg2);
261
- var returned2 = sut(arg,'bar',arg2, 'a');
262
- var returned3 = sut(arg,{},arg2);
263
-
264
- assert.equal(returned,expected);
265
- assert.equal(returned2,fallbackValue);
266
- assert.equal(returned3,expected);
267
- assert.ok(sut.verify());
268
- });
269
-
270
-
271
- test('it should return expected for void',function() {
272
- var expected = {};
273
- var sut = newSut(fallback);
274
-
275
- function fallback() {
276
- if (arguments.length != 0)
277
- throw 'expected no args';
278
- return fallbackValue;
279
- }
280
-
281
- sut.expect().return(expected);
282
- var returned = sut();
283
- var returned2 = sut();
284
-
285
- assert.equal(returned,expected);
286
- assert.equal(returned2,fallbackValue);
287
- assert.ok(sut.verify());
288
- });
289
-
290
- test('it should return expected for undefined',function() {
291
- var expected = {};
292
- var sut = newSut(fallback);
293
-
294
- function fallback() {
295
- if (arguments.length != 1)
296
- throw 'expected no args';
297
- return fallbackValue;
298
- }
299
-
300
- sut.expect(undefined).return(expected);
301
- var returned = sut(undefined);
302
- var returned2 = sut(undefined);
303
-
304
- assert.equal(returned,expected);
305
- assert.equal(returned2,fallbackValue);
306
- assert.ok(sut.verify());
307
- });
308
-
309
- test('it should return void for unspecified return',function() {
310
- var sut = newSut(fallback);
311
-
312
- function fallback() {
313
- if (arguments.length != 0)
314
- throw 'expected no args';
315
- return fallbackValue;
316
- }
317
-
318
- sut.expect();
319
- var returned = sut();
320
- var returned2 = sut();
321
-
322
- assert.deepEqual(returned,undefined);
323
- assert.equal(returned2,fallbackValue);
324
- assert.ok(sut.verify());
325
- });
326
-
327
- test('it should return void with multiple args for unspecified return',function() {
328
- var sut = newSut(fallback);
329
- var arg = 'a';
330
- function fallback() {
331
- if (arguments.length != 0)
332
- throw 'expected no args';
333
- return fallbackValue;
334
- }
335
-
336
- sut.expect(arg);
337
- var returned = sut();
338
- var returned2 = sut(arg);
339
-
340
- assert.equal(returned,fallbackValue);
341
- assert.deepEqual(returned2,undefined);
342
- assert.ok(sut.verify());
343
- });
344
-
345
- test('it should return void for unspecified return, expectAnything',function() {
346
- var sut = newSut(fallback);
347
-
348
- function fallback() {
349
- if (arguments.length != 0)
350
- throw 'expected no args';
351
- return fallbackValue;
352
- }
353
-
354
- sut.expectAnything();
355
- var returned = sut('foo');
356
- var returned2 = sut();
357
-
358
- assert.deepEqual(returned,undefined);
359
- assert.equal(returned2,fallbackValue);
360
- assert.ok(sut.verify());
361
- });
362
-
363
- test('it should return void for unspecified return, expectArray',function() {
364
- var sut = newSut(fallback);
365
- var a = {}, b = {};
366
- function fallback() {
367
- if (arguments.length != 0)
368
- throw 'expected no args';
369
- return fallbackValue;
370
- }
371
-
372
- sut.expect([a,b]);
373
- var returned = sut([a,b]);
374
- var returned2 = sut();
375
-
376
- assert.deepEqual(returned,undefined);
377
- assert.equal(returned2,fallbackValue);
378
- assert.ok(sut.verify());
379
- });
380
-
381
- test('it should return void for unspecified return, expect, repeat twice',function() {
382
- var sut = newSut(fallback);
383
-
384
- function fallback() {
385
- if (arguments.length != 1)
386
- throw 'expected one arg';
387
- return fallbackValue;
388
- }
389
-
390
- sut.expect().repeat(2);
391
- var returned = sut('foo');
392
- var returned2 = sut();
393
- var returned3 = sut();
394
-
395
- assert.equal(returned,fallbackValue);
396
- assert.deepEqual(returned2,undefined);
397
- assert.deepEqual(returned3,undefined);
398
- assert.ok(sut.verify());
399
- });
400
-
401
- test('it should return void for unspecified return, expect, repeat any',function() {
402
- var sut = newSut(fallback);
403
-
404
- function fallback() {
405
- if (arguments.length != 1)
406
- throw 'expected one arg';
407
- return fallbackValue;
408
- }
409
-
410
- sut.expect().repeatAny();
411
- var returned = sut('foo');
412
- var returned2 = sut();
413
-
414
- assert.deepEqual(returned2,undefined);
415
- assert.equal(returned,fallbackValue);
416
- assert.ok(sut.verify());
417
- });
418
-
419
- test('it should return void for unspecified return, expect one arg, repeat twice',function() {
420
- var sut = newSut(fallback);
421
- var arg = {};
422
-
423
- function fallback() {
424
- if (arguments.length != 1)
425
- throw 'expected one arg';
426
- return fallbackValue;
427
- }
428
-
429
- sut.expect(arg).repeat(2);
430
- var returned = sut(arg);
431
- var returned2 = sut(arg);
432
- var returned3 = sut(arg);
433
-
434
- assert.deepEqual(returned,undefined);
435
- assert.deepEqual(returned2,undefined);
436
- assert.equal(returned3,fallbackValue);
437
- assert.ok(sut.verify());
438
- });
439
-
440
- test('it should return void for unspecified return, expect one arg, repeat any',function() {
441
- var sut = newSut(fallback);
442
- var arg = {};
443
-
444
- function fallback() {
445
- }
446
-
447
- sut.expect(arg).repeatAny();
448
- var returned = sut(arg);
449
- var returned2 = sut(arg);
450
-
451
- assert.deepEqual(returned,undefined);
452
- assert.deepEqual(returned2,undefined);
453
- assert.ok(sut.verify());
454
- });
455
-
456
- test('it should return void for unspecified return, expect one arg, whenCalled ',function() {
457
- var sut = newSut(fallback);
458
- var arg = {};
459
- var didInvoke;
460
- var fallbackValue = {};
461
-
462
- function fallback(theArg) {
463
- if (theArg !== arg)
464
- throw new Error('unexpected argument');
465
- return fallbackValue;
466
- }
467
-
468
- sut.expect(arg).whenCalled(onCalled);
469
-
470
- function onCalled(theArg) {
471
- if (theArg !== arg)
472
- throw new Error('unexpected argument');
473
- didInvoke = true;
474
- }
475
-
476
- var returned = sut(arg);
477
- var returned2 = sut(arg);
478
-
479
- assert.deepEqual(returned,undefined);
480
- assert.deepEqual(returned2,fallbackValue);
481
- assert.ok(didInvoke);
482
- assert.ok(sut.verify());
483
- });
484
-
485
- })();
1
+ var assert = require('assert');
2
+ var test = require('../test');
3
+ var newMock = require('../partialMock/simple/newMock');
4
+ var newSut = require('../partialMock');
5
+
6
+ var fallbackValue = 'fallbackValue';
7
+
8
+
9
+ function fallback(arg, arg2) {
10
+ return fallbackValue;
11
+ }
12
+
13
+ (function() {
14
+ console.log('partialMock');
15
+
16
+ test('it should return expected given stubbed twice with repeat', function() {
17
+ var arg = 'a';
18
+ var arg2 = 'b';
19
+ var expected = {};
20
+ var expected2 = expected;
21
+ var expected3 = {};
22
+ var sut = newSut(fallback);
23
+ sut.expect(arg).return(expected).repeat(2);
24
+ sut.expect(arg2).return(expected3);
25
+
26
+ var returned = sut(arg);
27
+ var returned2 = sut(arg);
28
+ var returned3 = sut(arg2);
29
+ var returned4 = sut(arg);
30
+
31
+ assert.equal(returned, expected);
32
+ assert.equal(returned2, expected2);
33
+ assert.equal(returned3, expected3);
34
+ assert.equal(returned4, fallbackValue);
35
+ });
36
+
37
+
38
+ test('it should return expected given stubbed twice', function() {
39
+ var arg = 'a';
40
+ var arg2 = 'b';
41
+ var expected = {};
42
+ var expected2 = {};
43
+ var sut = newSut(fallback);
44
+ sut.expect(arg).return(expected);
45
+ sut.expect(arg2).return(expected2);
46
+ var returned = sut(arg);
47
+ var returned2 = sut(arg2);
48
+ assert.equal(returned, expected);
49
+ assert.equal(returned2, expected2);
50
+ });
51
+
52
+ test('it should return resolved given expect empty', function() {
53
+ var expected = {};
54
+ var sut = newSut(fallback);
55
+ sut.expect().resolve(expected);
56
+
57
+ sut().then(function(returned) {
58
+ assert.equal(returned, expected);
59
+
60
+ });
61
+
62
+ });
63
+
64
+ test('it should return expected resolved given stubbed twice', function() {
65
+ var arg = 'a';
66
+ var arg2 = 'b';
67
+ var expected = {};
68
+ var expected2 = {};
69
+ var sut = newSut(fallback);
70
+ sut.expect(arg).resolve(expected);
71
+ sut.expect(arg2).resolve(expected2);
72
+
73
+ sut(arg).then(function(returned) {
74
+ assert.equal(returned, expected);
75
+
76
+ });
77
+
78
+ sut(arg2).then(function(returned) {
79
+ assert.equal(returned, expected2);
80
+
81
+ });
82
+ });
83
+ test('it should return resolved given expect empty', function() {
84
+ var expected = {};
85
+ var sut = newSut(fallback);
86
+ sut.expect().resolve(expected);
87
+
88
+ sut().then(function(returned) {
89
+ assert.equal(returned, expected);
90
+
91
+ });
92
+
93
+ });
94
+
95
+ test('it should return expected resolved given stubbed twice', function() {
96
+ var arg = 'a';
97
+ var arg2 = 'b';
98
+ var expected = {};
99
+ var expected2 = {};
100
+ var sut = newSut(fallback);
101
+ sut.expect(arg).resolve(expected);
102
+ sut.expect(arg2).resolve(expected2);
103
+
104
+ sut(arg).then(function(returned) {
105
+ assert.equal(returned, expected);
106
+
107
+ });
108
+
109
+ sut(arg2).then(function(returned) {
110
+ assert.equal(returned, expected2);
111
+
112
+ });
113
+ });
114
+
115
+ test('it should return expected rejected given stubbed twice', function() {
116
+ var arg = 'a';
117
+ var arg2 = 'b';
118
+ var expected = {};
119
+ var expected2 = {};
120
+ var sut = newSut(fallback);
121
+ sut.expect(arg).reject(expected);
122
+ sut.expect(arg2).reject(expected2);
123
+
124
+ sut(arg).then(null, function(returned) {
125
+ assert.equal(returned, expected);
126
+
127
+ });
128
+
129
+ sut(arg2).then(null, function(returned) {
130
+ assert.equal(returned, expected2);
131
+
132
+ });
133
+ });
134
+
135
+
136
+ test('it should return expected given stubbed twice and called unordered', function() {
137
+ var arg = 'a';
138
+ var arg2 = 'b';
139
+ var expected = {};
140
+ var expected2 = {};
141
+ var sut = newSut(fallback);
142
+ sut.expect(arg).return(expected);
143
+ sut.expect(arg2).return(expected2);
144
+ var returned2 = sut(arg2);
145
+ var returned = sut(arg);
146
+ assert.equal(returned, expected);
147
+ assert.equal(returned2, expected2);
148
+ });
149
+
150
+
151
+ test('it should return expected for correct arg', function() {
152
+ var arg = 'a';
153
+ var expected = {};
154
+ var sut = newSut(fallback);
155
+ sut.expect(arg).return(expected);
156
+ var returned = sut(arg);
157
+ var returned2 = sut(arg);
158
+ assert.equal(returned, expected);
159
+ assert.equal(returned2, fallbackValue);
160
+ });
161
+
162
+ test('it should return correct after expect, reset, expect', function() {
163
+ var arg = 'a';
164
+ var expected = {};
165
+ var sut = newSut(fallback);
166
+ sut.expect(arg).return(expected);
167
+ sut.reset();
168
+ var returned = sut(arg);
169
+ sut.expect(arg).return(expected);
170
+ var returned2 = sut(arg);
171
+ var returned3 = sut(arg);
172
+ assert.equal(returned, fallbackValue);
173
+ assert.equal(returned2, expected);
174
+ assert.equal(returned3, fallbackValue);
175
+ });
176
+
177
+ test('it should throw for correct arg', function() {
178
+ var arg = 'a';
179
+ var error = {};
180
+ var expected = {};
181
+ var sut = newSut();
182
+ sut.expect(arg).throw(error);
183
+ sut.expect(arg).return(expected);
184
+ try {
185
+ sut(arg);
186
+ } catch (e) {
187
+ thrown = e;
188
+ }
189
+
190
+ var returned2 = sut(arg);
191
+ assert.equal(error, thrown);
192
+ assert.equal(returned2, expected);
193
+ });
194
+
195
+ test('it should throw for void arg', function() {
196
+ var error = {};
197
+ var expected = {};
198
+ var sut = newSut();
199
+ sut.expect().throw(error);
200
+ sut.expect().return(expected);
201
+ try {
202
+ sut();
203
+ } catch (e) {
204
+ thrown = e;
205
+ }
206
+
207
+ var returned2 = sut();
208
+ assert.equal(error, thrown);
209
+ assert.equal(returned2, expected);
210
+ });
211
+
212
+ test('it should return expected for expected array', function() {
213
+ var element1 = 'a';
214
+ var element2 = 'b';
215
+ var expected = {};
216
+ var sut = newSut(fallback);
217
+ sut.expect([element1, element2]).return(expected);
218
+ var returned = sut([element1, element2]);
219
+ var returned2 = sut([element1, element2]);
220
+ assert.equal(returned, expected);
221
+ assert.equal(returned2, fallbackValue);
222
+ });
223
+
224
+
225
+ test('it should return expected for correct arg,arg2', function() {
226
+ var arg = 'a';
227
+ var arg2 = 'b';
228
+ var expected = {};
229
+ var sut = newSut(fallback);
230
+ sut.expect(arg).expect(arg2).return(expected);
231
+ var returned = sut(arg, arg2);
232
+ var returned2 = sut(arg, arg2);
233
+
234
+ assert.equal(returned, expected);
235
+ assert.equal(returned2, fallbackValue);
236
+ assert.ok(sut.verify());
237
+ });
238
+
239
+ test('it should return expected for correct arg,arg2.repeat twice', function() {
240
+ var arg = 'a';
241
+ var arg2 = 'b';
242
+ var expected = {};
243
+ var repeats = 2;
244
+ var sut = newSut(fallback);
245
+
246
+ sut.expect(arg).expect(arg2).return(expected).repeat(repeats);
247
+ var returned = sut(arg, arg2);
248
+ var returned2 = sut(arg, arg2);
249
+ var returned3 = sut(arg, arg2);
250
+
251
+ assert.equal(returned, expected);
252
+ assert.equal(returned2, expected);
253
+ assert.equal(returned3, fallbackValue);
254
+ assert.ok(sut.verify());
255
+ });
256
+
257
+ test('it should return expected for correct arg,arg2.repeat any', function() {
258
+ var arg = 'a';
259
+ var arg2 = 'b';
260
+ var expected = {};
261
+ var sut = newSut(fallback);
262
+
263
+ sut.expect(arg).expect(arg2).return(expected).repeatAny();
264
+ var returned = sut(arg, arg2);
265
+ var returned2 = sut(arg, arg2);
266
+ var returned3 = sut(arg, arg2);
267
+
268
+ assert.equal(returned, expected);
269
+ assert.equal(returned2, expected);
270
+ assert.equal(returned3, expected);
271
+ assert.ok(sut.verify());
272
+ });
273
+
274
+ test('it should invoke whenCalled for correct arg,arg2.repeat twice', function() {
275
+ var arg = 'a';
276
+ var arg2 = 'b';
277
+ var expected = {};
278
+ var onWhenCalled = newMock();
279
+ var numberOfInvokes = 0;
280
+ onWhenCalled.expect(arg).expect(arg2).whenCalled(onDidInvoke).return();
281
+ onWhenCalled.expect(arg).expect(arg2).whenCalled(onDidInvoke).return();
282
+
283
+ function onDidInvoke() {
284
+ numberOfInvokes++;
285
+ }
286
+
287
+ var sut = newSut(fallback);
288
+
289
+ sut.expect(arg).expect(arg2).whenCalled(onWhenCalled).return(expected).repeat(2);
290
+ var returned = sut(arg, arg2);
291
+ var returned2 = sut(arg, arg2);
292
+ var returned3 = sut(arg, arg2);
293
+
294
+ assert.equal(numberOfInvokes, 2);
295
+ });
296
+
297
+ test('it should return expected for multiExpect arg,arg2', function() {
298
+ var arg = 'a';
299
+ var arg2 = 'b';
300
+ var arg3 = '3';
301
+ var expected = {};
302
+ var sut = newSut(fallback);
303
+
304
+ sut.expect(arg, arg2).expect(arg3).return(expected).repeat(2);
305
+ var returned = sut(arg, arg2, arg3);
306
+ var returned2 = sut(arg, arg2, arg3);
307
+ var returned3 = sut(arg, arg2, arg3);
308
+
309
+ assert.equal(returned, expected);
310
+ assert.equal(returned2, expected);
311
+ assert.equal(returned3, fallbackValue);
312
+ assert.ok(sut.verify());
313
+ });
314
+
315
+ test('it should return expected for arg, anything twice', function() {
316
+ var arg = 'a';
317
+ var arg2 = 'b';
318
+ var arg3;
319
+ var expected = {};
320
+ var sut = newSut(fallback);
321
+
322
+
323
+ sut.expect(arg).expectAnything().return(expected).repeat(2);
324
+ var returned = sut(arg, arg2, arg3);
325
+ var returned2 = sut(arg, arg2);
326
+ var returned3 = sut('foo', arg2);
327
+
328
+ assert.equal(returned, expected);
329
+ assert.equal(returned2, expected);
330
+ assert.equal(returned3, fallbackValue);
331
+ assert.ok(sut.verify());
332
+ });
333
+
334
+ test('it should return expected for arg, ignore twice', function() {
335
+ var arg = 'a';
336
+ var arg2 = 'b';
337
+ var expected = {};
338
+ var sut = newSut(fallback);
339
+
340
+ sut.expect(arg).ignore().expect(arg2).return(expected).repeat(2);
341
+ var returned = sut(arg, 'foo', arg2);
342
+ var returned2 = sut(arg, 'bar', arg2, 'a');
343
+ var returned3 = sut(arg, {}, arg2);
344
+
345
+ assert.equal(returned, expected);
346
+ assert.equal(returned2, fallbackValue);
347
+ assert.equal(returned3, expected);
348
+ assert.ok(sut.verify());
349
+ });
350
+
351
+
352
+ test('it should return expected for void', function() {
353
+ var expected = {};
354
+ var sut = newSut(fallback);
355
+
356
+ function fallback() {
357
+ if (arguments.length != 0)
358
+ throw 'expected no args';
359
+ return fallbackValue;
360
+ }
361
+
362
+ sut.expect().return(expected);
363
+ var returned = sut();
364
+ var returned2 = sut();
365
+
366
+ assert.equal(returned, expected);
367
+ assert.equal(returned2, fallbackValue);
368
+ assert.ok(sut.verify());
369
+ });
370
+
371
+ test('it should return expected for undefined', function() {
372
+ var expected = {};
373
+ var sut = newSut(fallback);
374
+
375
+ function fallback() {
376
+ if (arguments.length != 1)
377
+ throw 'expected no args';
378
+ return fallbackValue;
379
+ }
380
+
381
+ sut.expect(undefined).return(expected);
382
+ var returned = sut(undefined);
383
+ var returned2 = sut(undefined);
384
+
385
+ assert.equal(returned, expected);
386
+ assert.equal(returned2, fallbackValue);
387
+ assert.ok(sut.verify());
388
+ });
389
+
390
+ test('it should return void for unspecified return', function() {
391
+ var sut = newSut(fallback);
392
+
393
+ function fallback() {
394
+ if (arguments.length != 0)
395
+ throw 'expected no args';
396
+ return fallbackValue;
397
+ }
398
+
399
+ sut.expect();
400
+ var returned = sut();
401
+ var returned2 = sut();
402
+
403
+ assert.deepEqual(returned, undefined);
404
+ assert.equal(returned2, fallbackValue);
405
+ assert.ok(sut.verify());
406
+ });
407
+
408
+ test('it should return void with multiple args for unspecified return', function() {
409
+ var sut = newSut(fallback);
410
+ var arg = 'a';
411
+
412
+ function fallback() {
413
+ if (arguments.length != 0)
414
+ throw 'expected no args';
415
+ return fallbackValue;
416
+ }
417
+
418
+ sut.expect(arg);
419
+ var returned = sut();
420
+ var returned2 = sut(arg);
421
+
422
+ assert.equal(returned, fallbackValue);
423
+ assert.deepEqual(returned2, undefined);
424
+ assert.ok(sut.verify());
425
+ });
426
+
427
+ test('it should return void for unspecified return, expectAnything', function() {
428
+ var sut = newSut(fallback);
429
+
430
+ function fallback() {
431
+ if (arguments.length != 0)
432
+ throw 'expected no args';
433
+ return fallbackValue;
434
+ }
435
+
436
+ sut.expectAnything();
437
+ var returned = sut('foo');
438
+ var returned2 = sut();
439
+
440
+ assert.deepEqual(returned, undefined);
441
+ assert.equal(returned2, fallbackValue);
442
+ assert.ok(sut.verify());
443
+ });
444
+
445
+ test('it should return void for unspecified return, expectArray', function() {
446
+ var sut = newSut(fallback);
447
+ var a = {},
448
+ b = {};
449
+
450
+ function fallback() {
451
+ if (arguments.length != 0)
452
+ throw 'expected no args';
453
+ return fallbackValue;
454
+ }
455
+
456
+ sut.expect([a, b]);
457
+ var returned = sut([a, b]);
458
+ var returned2 = sut();
459
+
460
+ assert.deepEqual(returned, undefined);
461
+ assert.equal(returned2, fallbackValue);
462
+ assert.ok(sut.verify());
463
+ });
464
+
465
+ test('it should return void for unspecified return, expect, repeat twice', function() {
466
+ var sut = newSut(fallback);
467
+
468
+ function fallback() {
469
+ if (arguments.length != 1)
470
+ throw 'expected one arg';
471
+ return fallbackValue;
472
+ }
473
+
474
+ sut.expect().repeat(2);
475
+ var returned = sut('foo');
476
+ var returned2 = sut();
477
+ var returned3 = sut();
478
+
479
+ assert.equal(returned, fallbackValue);
480
+ assert.deepEqual(returned2, undefined);
481
+ assert.deepEqual(returned3, undefined);
482
+ assert.ok(sut.verify());
483
+ });
484
+
485
+ test('it should return void for unspecified return, expect, repeat any', function() {
486
+ var sut = newSut(fallback);
487
+
488
+ function fallback() {
489
+ if (arguments.length != 1)
490
+ throw 'expected one arg';
491
+ return fallbackValue;
492
+ }
493
+
494
+ sut.expect().repeatAny();
495
+ var returned = sut('foo');
496
+ var returned2 = sut();
497
+
498
+ assert.deepEqual(returned2, undefined);
499
+ assert.equal(returned, fallbackValue);
500
+ assert.ok(sut.verify());
501
+ });
502
+
503
+ test('it should return void for unspecified return, expect one arg, repeat twice', function() {
504
+ var sut = newSut(fallback);
505
+ var arg = {};
506
+
507
+ function fallback() {
508
+ if (arguments.length != 1)
509
+ throw 'expected one arg';
510
+ return fallbackValue;
511
+ }
512
+
513
+ sut.expect(arg).repeat(2);
514
+ var returned = sut(arg);
515
+ var returned2 = sut(arg);
516
+ var returned3 = sut(arg);
517
+
518
+ assert.deepEqual(returned, undefined);
519
+ assert.deepEqual(returned2, undefined);
520
+ assert.equal(returned3, fallbackValue);
521
+ assert.ok(sut.verify());
522
+ });
523
+
524
+ test('it should return void for unspecified return, expect one arg, repeat any', function() {
525
+ var sut = newSut(fallback);
526
+ var arg = {};
527
+
528
+ function fallback() {}
529
+
530
+ sut.expect(arg).repeatAny();
531
+ var returned = sut(arg);
532
+ var returned2 = sut(arg);
533
+
534
+ assert.deepEqual(returned, undefined);
535
+ assert.deepEqual(returned2, undefined);
536
+ assert.ok(sut.verify());
537
+ });
538
+
539
+ test('it should return void for unspecified return, expect one arg, whenCalled ', function() {
540
+ var sut = newSut(fallback);
541
+ var arg = {};
542
+ var didInvoke;
543
+ var fallbackValue = {};
544
+
545
+ function fallback(theArg) {
546
+ if (theArg !== arg)
547
+ throw new Error('unexpected argument');
548
+ return fallbackValue;
549
+ }
550
+
551
+ sut.expect(arg).whenCalled(onCalled);
552
+
553
+ function onCalled(theArg) {
554
+ if (theArg !== arg)
555
+ throw new Error('unexpected argument');
556
+ didInvoke = true;
557
+ }
558
+
559
+ var returned = sut(arg);
560
+ var returned2 = sut(arg);
561
+
562
+ assert.deepEqual(returned, undefined);
563
+ assert.deepEqual(returned2, fallbackValue);
564
+ assert.ok(didInvoke);
565
+ assert.ok(sut.verify());
566
+ });
567
+
568
+ })();