How to use this.sandbox.getFakes method in sinon

Best JavaScript code snippet using sinon

sandbox-test.js

Source:sandbox-test.js

...66 assert.equals(typeof actual.verify, "function");67 assert.equals(typeof object.method.restore, "function");68 });69 it("adds mock to fake array", function() {70 var fakes = this.sandbox.getFakes();71 var object = {72 method: function() {73 return;74 }75 };76 var expected = this.sandbox.mock(object);77 assert(fakes.indexOf(expected) !== -1);78 });79 it("appends mocks to fake array", function() {80 var fakes = this.sandbox.getFakes();81 this.sandbox.mock({});82 this.sandbox.mock({});83 assert.equals(fakes.length, 2);84 });85 });86 describe("stub and mock test", function() {87 beforeEach(function() {88 this.sandbox = createSandbox();89 });90 it("appends mocks and stubs to fake array", function() {91 var fakes = this.sandbox.getFakes();92 this.sandbox.mock(93 {94 method: function() {95 return;96 }97 },98 "method"99 );100 this.sandbox.stub(101 {102 method: function() {103 return;104 }105 },106 "method"107 );108 assert.equals(fakes.length, 2);109 });110 });111 describe(".spy", function() {112 it("should return a spy", function() {113 var sandbox = createSandbox();114 var spy = sandbox.spy();115 assert.isFunction(spy);116 assert.equals(spy.displayName, "spy");117 });118 it("should add a spy to the internal collection", function() {119 var sandbox = createSandbox();120 var fakes = sandbox.getFakes();121 var expected;122 expected = sandbox.spy();123 assert.isTrue(fakes.indexOf(expected) !== -1);124 });125 });126 describe(".createStubInstance", function() {127 beforeEach(function() {128 this.sandbox = createSandbox();129 });130 it("stubs existing methods", function() {131 var Class = function() {132 return;133 };134 Class.prototype.method = function() {135 return;136 };137 var stub = this.sandbox.createStubInstance(Class);138 stub.method.returns(3);139 assert.equals(3, stub.method());140 });141 it("should require a function", function() {142 var sandbox = this.sandbox;143 assert.exception(144 function() {145 sandbox.createStubInstance("not a function");146 },147 {148 name: "TypeError",149 message: "The constructor should be a function."150 }151 );152 });153 it("resets all stub methods on reset()", function() {154 var Class = function() {155 return;156 };157 Class.prototype.method1 = function() {158 return;159 };160 Class.prototype.method2 = function() {161 return;162 };163 Class.prototype.method3 = function() {164 return;165 };166 var stub = this.sandbox.createStubInstance(Class);167 stub.method1.returns(1);168 stub.method2.returns(2);169 stub.method3.returns(3);170 assert.equals(3, stub.method3());171 this.sandbox.reset();172 assert.isUndefined(stub.method1());173 assert.isUndefined(stub.method2());174 assert.isUndefined(stub.method3());175 });176 it("doesn't stub fake methods", function() {177 var Class = function() {178 return;179 };180 Class.prototype.noop = noop;181 var stub = this.sandbox.createStubInstance(Class);182 assert.exception(function() {183 stub.method.returns(3);184 });185 });186 it("doesn't call the constructor", function() {187 var Class = function(a, b) {188 var c = a + b;189 throw c;190 };191 Class.prototype.method = function() {192 return;193 };194 var stub = this.sandbox.createStubInstance(Class);195 refute.exception(function() {196 stub.method(3);197 });198 });199 it("retains non function values", function() {200 var TYPE = "some-value";201 var Class = function() {202 return;203 };204 Class.prototype.noop = noop;205 Class.prototype.type = TYPE;206 var stub = this.sandbox.createStubInstance(Class);207 assert.equals(TYPE, stub.type);208 });209 it("has no side effects on the prototype", function() {210 var proto = {211 method: function() {212 throw new Error("error");213 }214 };215 var Class = function() {216 return;217 };218 Class.prototype = proto;219 var stub = this.sandbox.createStubInstance(Class);220 refute.exception(stub.method);221 assert.exception(proto.method);222 });223 it("throws exception for non function params", function() {224 var types = [{}, 3, "hi!"];225 for (var i = 0; i < types.length; i++) {226 /​/​ yes, it's silly to create functions in a loop, it's also a test227 /​* eslint-disable-next-line ie11/​no-loop-func, no-loop-func */​228 assert.exception(function() {229 this.sandbox.createStubInstance(types[i]);230 });231 }232 });233 it("allows providing optional overrides", function() {234 var Class = function() {235 return;236 };237 Class.prototype.method = function() {238 return;239 };240 var stub = this.sandbox.createStubInstance(Class, {241 method: sinonStub().returns(3)242 });243 assert.equals(3, stub.method());244 });245 it("allows providing optional returned values", function() {246 var Class = function() {247 return;248 };249 Class.prototype.method = function() {250 return;251 };252 var stub = this.sandbox.createStubInstance(Class, {253 method: 3254 });255 assert.equals(3, stub.method());256 });257 it("allows providing null as a return value", function() {258 var Class = function() {259 return;260 };261 Class.prototype.method = function() {262 return;263 };264 var stub = this.sandbox.createStubInstance(Class, {265 method: null266 });267 assert.equals(null, stub.method());268 });269 it("throws an exception when trying to override non-existing property", function() {270 var Class = function() {271 return;272 };273 Class.prototype.method = function() {274 return;275 };276 var sandbox = this.sandbox;277 assert.exception(278 function() {279 sandbox.createStubInstance(Class, {280 foo: sinonStub().returns(3)281 });282 },283 { message: "Cannot stub foo. Property does not exist!" }284 );285 });286 });287 describe(".stub", function() {288 beforeEach(function() {289 this.sandbox = createSandbox();290 });291 it("fails if stubbing property on null", function() {292 var sandbox = this.sandbox;293 assert.exception(294 function() {295 sandbox.stub(null, "prop");296 },297 {298 message: "Trying to stub property 'prop' of null"299 }300 );301 });302 it("fails if stubbing symbol on null", function() {303 if (typeof Symbol === "function") {304 var sandbox = this.sandbox;305 assert.exception(306 function() {307 sandbox.stub(null, Symbol());308 },309 {310 message: "Trying to stub property 'Symbol()' of null"311 }312 );313 }314 });315 it("creates a stub", function() {316 var object = {317 method: function() {318 return;319 }320 };321 this.sandbox.stub(object, "method");322 assert.equals(typeof object.method.restore, "function");323 });324 it("adds stub to fake array", function() {325 var fakes = this.sandbox.getFakes();326 var object = {327 method: function() {328 return;329 }330 };331 var stub = this.sandbox.stub(object, "method");332 assert.isTrue(fakes.indexOf(stub) !== -1);333 });334 it("appends stubs to fake array", function() {335 var fakes = this.sandbox.getFakes();336 this.sandbox.stub(337 {338 method: function() {339 return;340 }341 },342 "method"343 );344 this.sandbox.stub(345 {346 method: function() {347 return;348 }349 },350 "method"351 );352 assert.equals(fakes.length, 2);353 });354 it("adds all object methods to fake array", function() {355 var fakes = this.sandbox.getFakes();356 var object = {357 method: function() {358 return;359 },360 method2: function() {361 return;362 },363 method3: function() {364 return;365 }366 };367 Object.defineProperty(object, "method3", {368 enumerable: false369 });370 this.sandbox.stub(object);371 assert.isTrue(fakes.indexOf(object.method) !== -1);372 assert.isTrue(fakes.indexOf(object.method2) !== -2);373 assert.isTrue(fakes.indexOf(object.method3) !== -3);374 assert.equals(fakes.length, 3);375 });376 it("returns a stubbed object", function() {377 var object = {378 method: function() {379 return;380 }381 };382 assert.equals(this.sandbox.stub(object), object);383 });384 it("returns a stubbed method", function() {385 var object = {386 method: function() {387 return;388 }389 };390 assert.equals(this.sandbox.stub(object, "method"), object.method);391 });392 describe("on node", function() {393 before(function() {394 if (typeof process === "undefined" || !process.env) {395 this.skip();396 }397 });398 beforeEach(function() {399 process.env.HELL = "Ain't too bad";400 });401 it("stubs environment property", function() {402 var originalPrintWarning = deprecated.printWarning;403 deprecated.printWarning = function() {404 return;405 };406 this.sandbox.stub(process.env, "HELL").value("froze over");407 assert.equals(process.env.HELL, "froze over");408 deprecated.printWarning = originalPrintWarning;409 });410 });411 });412 describe("stub anything", function() {413 beforeEach(function() {414 this.object = { property: 42 };415 this.sandbox = new Sandbox();416 });417 it("stubs number property", function() {418 var originalPrintWarning = deprecated.printWarning;419 deprecated.printWarning = function() {420 return;421 };422 this.sandbox.stub(this.object, "property").value(1);423 assert.equals(this.object.property, 1);424 deprecated.printWarning = originalPrintWarning;425 });426 it("restores number property", function() {427 var originalPrintWarning = deprecated.printWarning;428 deprecated.printWarning = function() {429 return;430 };431 this.sandbox.stub(this.object, "property").value(1);432 this.sandbox.restore();433 assert.equals(this.object.property, 42);434 deprecated.printWarning = originalPrintWarning;435 });436 it("fails if property does not exist", function() {437 var originalPrintWarning = deprecated.printWarning;438 deprecated.printWarning = function() {439 return;440 };441 var sandbox = this.sandbox;442 var object = {};443 assert.exception(function() {444 sandbox.stub(object, "prop", 1);445 });446 deprecated.printWarning = originalPrintWarning;447 });448 it("fails if Symbol does not exist", function() {449 if (typeof Symbol === "function") {450 var sandbox = this.sandbox;451 var object = {};452 var originalPrintWarning = deprecated.printWarning;453 deprecated.printWarning = function() {454 return;455 };456 assert.exception(457 function() {458 sandbox.stub(object, Symbol());459 },460 { message: "Cannot stub non-existent property Symbol()" },461 TypeError462 );463 deprecated.printWarning = originalPrintWarning;464 }465 });466 });467 describe(".fake", function() {468 it("should return a fake", function() {469 var sandbox = createSandbox();470 var fake = sandbox.fake();471 assert.isFunction(fake);472 assert.equals(fake.displayName, "fake");473 });474 it("should add a fake to the internal collection", function() {475 var sandbox = createSandbox();476 var fakes = sandbox.getFakes();477 var expected;478 expected = sandbox.fake();479 assert.isTrue(fakes.indexOf(expected) !== -1);480 });481 describe(".returns", function() {482 it("should return a fake behavior", function() {483 var sandbox = createSandbox();484 var fake = sandbox.fake.returns();485 assert.isFunction(fake);486 assert.equals(fake.displayName, "fake");487 });488 it("should add a fake behavior to the internal collection", function() {489 var sandbox = createSandbox();490 var fakes = sandbox.getFakes();491 var expected;492 expected = sandbox.fake.returns();493 assert.isTrue(fakes.indexOf(expected) !== -1);494 });495 });496 describe(".throws", function() {497 it("should return a fake behavior", function() {498 var sandbox = createSandbox();499 var fake = sandbox.fake.throws();500 assert.isFunction(fake);501 assert.equals(fake.displayName, "fake");502 });503 it("should add a fake behavior to the internal collection", function() {504 var sandbox = createSandbox();505 var fakes = sandbox.getFakes();506 var expected;507 expected = sandbox.fake.throws();508 assert.isTrue(fakes.indexOf(expected) !== -1);509 });510 });511 describe(".resolves", function() {512 it("should return a fake behavior", function() {513 var sandbox = createSandbox();514 var fake = sandbox.fake.resolves();515 assert.isFunction(fake);516 assert.equals(fake.displayName, "fake");517 });518 it("should add a fake behavior to the internal collection", function() {519 var sandbox = createSandbox();520 var fakes = sandbox.getFakes();521 var expected;522 expected = sandbox.fake.resolves();523 assert.isTrue(fakes.indexOf(expected) !== -1);524 });525 });526 describe(".rejects", function() {527 it("should return a fake behavior", function() {528 var sandbox = createSandbox();529 var fake = sandbox.fake.rejects();530 assert.isFunction(fake);531 assert.equals(fake.displayName, "fake");532 });533 it("should add a fake behavior to the internal collection", function() {534 var sandbox = createSandbox();535 var fakes = sandbox.getFakes();536 var expected;537 expected = sandbox.fake.rejects();538 assert.isTrue(fakes.indexOf(expected) !== -1);539 });540 });541 describe(".yields", function() {542 it("should return a fake behavior", function() {543 var sandbox = createSandbox();544 var fake = sandbox.fake.yields();545 assert.isFunction(fake);546 assert.equals(fake.displayName, "fake");547 });548 it("should add a fake behavior to the internal collection", function() {549 var sandbox = createSandbox();550 var fakes = sandbox.getFakes();551 var expected;552 expected = sandbox.fake.yields();553 assert.isTrue(fakes.indexOf(expected) !== -1);554 });555 });556 describe(".yieldsAsync", function() {557 it("should return a fake behavior", function() {558 var sandbox = createSandbox();559 var fake = sandbox.fake.yieldsAsync();560 assert.isFunction(fake);561 assert.equals(fake.displayName, "fake");562 });563 it("should add a fake behavior to the internal collection", function() {564 var sandbox = createSandbox();565 var fakes = sandbox.getFakes();566 var expected;567 expected = sandbox.fake.yieldsAsync();568 assert.isTrue(fakes.indexOf(expected) !== -1);569 });570 });571 });572 describe(".verifyAndRestore", function() {573 beforeEach(function() {574 this.sandbox = createSandbox();575 });576 it("calls verify and restore", function() {577 this.sandbox.verify = sinonSpy();578 this.sandbox.restore = sinonSpy();579 this.sandbox.verifyAndRestore();580 assert(this.sandbox.verify.called);581 assert(this.sandbox.restore.called);582 });583 it("throws when restore throws", function() {584 this.sandbox.verify = sinonSpy();585 this.sandbox.restore = sinonStub().throws();586 assert.exception(function() {587 this.sandbox.verifyAndRestore();588 });589 });590 it("calls restore when restore throws", function() {591 var sandbox = this.sandbox;592 sandbox.verify = sinonSpy();593 sandbox.restore = sinonStub().throws();594 assert.exception(function() {595 sandbox.verifyAndRestore();596 });597 assert(sandbox.restore.called);598 });599 });600 describe(".replace", function() {601 beforeEach(function() {602 this.sandbox = createSandbox();603 });604 it("should replace a function property", function() {605 var replacement = function replacement() {606 return;607 };608 var existing = function existing() {609 return;610 };611 var object = {612 property: existing613 };614 this.sandbox.replace(object, "property", replacement);615 assert.equals(object.property, replacement);616 this.sandbox.restore();617 assert.equals(object.property, existing);618 });619 it("should replace a non-function property", function() {620 var replacement = "replacement";621 var existing = "existing";622 var object = {623 property: existing624 };625 this.sandbox.replace(object, "property", replacement);626 assert.equals(object.property, replacement);627 this.sandbox.restore();628 assert.equals(object.property, existing);629 });630 it("should replace an inherited property", function() {631 var replacement = "replacement";632 var existing = "existing";633 var object = Object.create({634 property: existing635 });636 this.sandbox.replace(object, "property", replacement);637 assert.equals(object.property, replacement);638 this.sandbox.restore();639 assert.equals(object.property, existing);640 });641 it("should error on missing descriptor", function() {642 var sandbox = this.sandbox;643 assert.exception(644 function() {645 sandbox.replace({}, "i-dont-exist");646 },647 {648 message: "Cannot replace non-existent property i-dont-exist",649 name: "TypeError"650 }651 );652 });653 it("should error on missing replacement", function() {654 var sandbox = this.sandbox;655 var object = Object.create({656 property: "catpants"657 });658 assert.exception(659 function() {660 sandbox.replace(object, "property");661 },662 {663 message: "Expected replacement argument to be defined",664 name: "TypeError"665 }666 );667 });668 it("should refuse to replace a non-function with a function", function() {669 var sandbox = this.sandbox;670 var replacement = function() {671 return "replacement";672 };673 var existing = "existing";674 var object = {675 property: existing676 };677 assert.exception(678 function() {679 sandbox.replace(object, "property", replacement);680 },681 { message: "Cannot replace string with function" }682 );683 });684 it("should refuse to replace a function with a non-function", function() {685 var sandbox = this.sandbox;686 var replacement = "replacement";687 var object = {688 property: function() {689 return "apple pie";690 }691 };692 assert.exception(693 function() {694 sandbox.replace(object, "property", replacement);695 },696 { message: "Cannot replace function with string" }697 );698 });699 it("should refuse to replace a fake twice", function() {700 var sandbox = this.sandbox;701 var object = {702 property: function() {703 return "apple pie";704 }705 };706 sandbox.replace(object, "property", sinonFake());707 assert.exception(708 function() {709 sandbox.replace(object, "property", sinonFake());710 },711 { message: "Attempted to replace property which is already replaced" }712 );713 });714 it("should refuse to replace a string twice", function() {715 var sandbox = this.sandbox;716 var object = {717 property: "original"718 };719 sandbox.replace(object, "property", "first");720 assert.exception(721 function() {722 sandbox.replace(object, "property", "second");723 },724 { message: "Attempted to replace property which is already replaced" }725 );726 });727 it("should return the replacement argument", function() {728 var replacement = "replacement";729 var existing = "existing";730 var object = {731 property: existing732 };733 var actual = this.sandbox.replace(object, "property", replacement);734 assert.equals(actual, replacement);735 });736 describe("when asked to replace a getter", function() {737 it("should throw an Error", function() {738 var sandbox = this.sandbox;739 var object = {740 get foo() {741 return "bar";742 }743 };744 assert.exception(745 function() {746 sandbox.replace(object, "foo", sinonFake());747 },748 { message: "Use sandbox.replaceGetter for replacing getters" }749 );750 });751 });752 describe("when asked to replace a setter", function() {753 it("should throw an Error", function() {754 var sandbox = this.sandbox;755 var object = {756 /​/​ eslint-disable-next-line accessor-pairs757 set foo(value) {758 this.prop = value;759 }760 };761 assert.exception(762 function() {763 sandbox.replace(object, "foo", sinonFake());764 },765 { message: "Use sandbox.replaceSetter for replacing setters" }766 );767 });768 });769 });770 describe(".replaceGetter", function() {771 beforeEach(function() {772 this.sandbox = createSandbox();773 });774 it("should replace getters", function() {775 var expected = "baz";776 var object = {777 get foo() {778 return "bar";779 }780 };781 this.sandbox.replaceGetter(object, "foo", sinonFake.returns(expected));782 assert.equals(object.foo, expected);783 });784 it("should return replacement", function() {785 var replacement = sinonFake.returns("baz");786 var object = {787 get foo() {788 return "bar";789 }790 };791 var actual = this.sandbox.replaceGetter(object, "foo", replacement);792 assert.equals(actual, replacement);793 });794 it("should replace an inherited property", function() {795 var expected = "baz";796 var replacement = sinonFake.returns(expected);797 var existing = "existing";798 var object = Object.create({799 get foo() {800 return existing;801 }802 });803 this.sandbox.replaceGetter(object, "foo", replacement);804 assert.equals(object.foo, expected);805 this.sandbox.restore();806 assert.equals(object.foo, existing);807 });808 it("should error on missing descriptor", function() {809 var sandbox = this.sandbox;810 assert.exception(811 function() {812 sandbox.replaceGetter({}, "i-dont-exist");813 },814 {815 message: "Cannot replace non-existent property i-dont-exist",816 name: "TypeError"817 }818 );819 });820 it("should error when descriptor has no getter", function() {821 var sandbox = this.sandbox;822 var object = {823 /​/​ eslint-disable-next-line accessor-pairs824 set catpants(_) {825 return;826 }827 };828 assert.exception(829 function() {830 sandbox.replaceGetter(object, "catpants", noop);831 },832 {833 message: "`object.property` is not a getter",834 name: "Error"835 }836 );837 });838 describe("when called with a non-function replacement argument", function() {839 it("should throw a TypeError", function() {840 var sandbox = this.sandbox;841 var expected = "baz";842 var object = {843 get foo() {844 return "bar";845 }846 };847 assert.exception(848 function() {849 sandbox.replaceGetter(object, "foo", expected);850 },851 { message: "Expected replacement argument to be a function" }852 );853 });854 });855 it("allows restoring getters", function() {856 var expected = "baz";857 var object = {858 get foo() {859 return "bar";860 }861 };862 this.sandbox.replaceGetter(object, "foo", sinonFake.returns(expected));863 this.sandbox.restore();864 assert.equals(object.foo, "bar");865 });866 it("should refuse to replace a getter twice", function() {867 var sandbox = this.sandbox;868 var object = {869 get foo() {870 return "bar";871 }872 };873 sandbox.replaceGetter(object, "foo", sinonFake.returns("one"));874 assert.exception(875 function() {876 sandbox.replaceGetter(object, "foo", sinonFake.returns("two"));877 },878 { message: "Attempted to replace foo which is already replaced" }879 );880 });881 });882 describe(".replaceSetter", function() {883 beforeEach(function() {884 this.sandbox = createSandbox();885 });886 it("should replace setter", function() {887 var object = {888 /​/​ eslint-disable-next-line accessor-pairs889 set foo(value) {890 this.prop = value;891 },892 prop: "bar"893 };894 this.sandbox.replaceSetter(object, "foo", function(val) {895 this.prop = val + "bla";896 });897 object.foo = "bla";898 assert.equals(object.prop, "blabla");899 });900 it("should return replacement", function() {901 var object = {902 /​/​ eslint-disable-next-line accessor-pairs903 set foo(value) {904 this.prop = value;905 },906 prop: "bar"907 };908 var replacement = function(val) {909 this.prop = val + "bla";910 };911 var actual = this.sandbox.replaceSetter(object, "foo", replacement);912 assert.equals(actual, replacement);913 });914 it("should replace an inherited property", function() {915 var object = Object.create({916 /​/​ eslint-disable-next-line accessor-pairs917 set foo(value) {918 this.prop = value;919 },920 prop: "bar"921 });922 var replacement = function(value) {923 this.prop = value + "blabla";924 };925 this.sandbox.replaceSetter(object, "foo", replacement);926 object.foo = "doodle";927 assert.equals(object.prop, "doodleblabla");928 this.sandbox.restore();929 object.foo = "doodle";930 assert.equals(object.prop, "doodle");931 });932 it("should error on missing descriptor", function() {933 var sandbox = this.sandbox;934 assert.exception(935 function() {936 sandbox.replaceSetter({}, "i-dont-exist");937 },938 {939 message: "Cannot replace non-existent property i-dont-exist",940 name: "TypeError"941 }942 );943 });944 it("should error when descriptor has no setter", function() {945 var sandbox = this.sandbox;946 var object = {947 get catpants() {948 return;949 }950 };951 assert.exception(952 function() {953 sandbox.replaceSetter(object, "catpants", noop);954 },955 {956 message: "`object.property` is not a setter",957 name: "Error"958 }959 );960 });961 describe("when called with a non-function replacement argument", function() {962 it("should throw a TypeError", function() {963 var sandbox = this.sandbox;964 var object = {965 /​/​ eslint-disable-next-line accessor-pairs966 set foo(value) {967 this.prop = value;968 },969 prop: "bar"970 };971 assert.exception(972 function() {973 sandbox.replaceSetter(object, "foo", "bla");974 },975 { message: "Expected replacement argument to be a function" }976 );977 });978 });979 it("allows restoring setters", function() {980 var object = {981 /​/​ eslint-disable-next-line accessor-pairs982 set foo(value) {983 this.prop = value;984 },985 prop: "bar"986 };987 this.sandbox.replaceSetter(object, "foo", function(val) {988 this.prop = val + "bla";989 });990 this.sandbox.restore();991 object.prop = "bla";992 assert.equals(object.prop, "bla");993 });994 it("should refuse to replace a setter twice", function() {995 var sandbox = this.sandbox;996 var object = {997 /​/​ eslint-disable-next-line accessor-pairs998 set foo(value) {999 return;1000 }1001 };1002 sandbox.replaceSetter(object, "foo", sinonFake());1003 assert.exception(1004 function() {1005 sandbox.replaceSetter(object, "foo", sinonFake.returns("two"));1006 },1007 { message: "Attempted to replace foo which is already replaced" }1008 );1009 });1010 });1011 describe(".reset", function() {1012 beforeEach(function() {1013 var sandbox = (this.sandbox = createSandbox());1014 var fakes = sandbox.getFakes();1015 fakes.push({1016 reset: sinonSpy(),1017 resetHistory: sinonSpy()1018 });1019 fakes.push({1020 reset: sinonSpy(),1021 resetHistory: sinonSpy()1022 });1023 });1024 it("calls reset on all fakes", function() {1025 var fake0 = this.sandbox.getFakes()[0];1026 var fake1 = this.sandbox.getFakes()[1];1027 this.sandbox.reset();1028 assert(fake0.reset.called);1029 assert(fake1.reset.called);1030 });1031 it("calls resetHistory on all fakes", function() {1032 var fake0 = this.sandbox.getFakes()[0];1033 var fake1 = this.sandbox.getFakes()[1];1034 this.sandbox.reset();1035 assert(fake0.resetHistory.called);1036 assert(fake1.resetHistory.called);1037 });1038 it("resets fake behaviours", function() {1039 var fake = this.sandbox.fake();1040 fake(1234);1041 this.sandbox.reset();1042 assert.equals(fake.getCalls(), []);1043 });1044 });1045 describe(".resetBehavior", function() {1046 beforeEach(function() {1047 var sandbox = (this.sandbox = createSandbox());1048 var fakes = sandbox.getFakes();1049 fakes.push({ resetBehavior: sinonSpy() });1050 fakes.push({ resetBehavior: sinonSpy() });1051 });1052 it("calls resetBehavior on all fakes", function() {1053 var fake0 = this.sandbox.getFakes()[0];1054 var fake1 = this.sandbox.getFakes()[1];1055 this.sandbox.resetBehavior();1056 assert(fake0.resetBehavior.called);1057 assert(fake1.resetBehavior.called);1058 });1059 });1060 describe(".resetHistory", function() {1061 beforeEach(function() {1062 var sandbox = (this.sandbox = createSandbox());1063 var fakes = (this.fakes = sandbox.getFakes());1064 var spy1 = sinonSpy();1065 spy1();1066 fakes.push(spy1);1067 var spy2 = sinonSpy();1068 spy2();...

60sandbox-test.js

Source:60sandbox-test.js

...69 assert.equals(typeof actual.verify, "function");70 assert.equals(typeof object.method.restore, "function");71 });72 it("adds mock to fake array", function() {73 var fakes = this.sandbox.getFakes();74 var object = {75 method: function() {76 return;77 }78 };79 var expected = this.sandbox.mock(object);80 assert(fakes.indexOf(expected) !== -1);81 });82 it("appends mocks to fake array", function() {83 var fakes = this.sandbox.getFakes();84 this.sandbox.mock({});85 this.sandbox.mock({});86 assert.equals(fakes.length, 2);87 });88 });89 describe("stub and mock test", function() {90 beforeEach(function() {91 this.sandbox = createSandbox();92 });93 it("appends mocks and stubs to fake array", function() {94 var fakes = this.sandbox.getFakes();95 this.sandbox.mock(96 {97 method: function() {98 return;99 }100 },101 "method"102 );103 this.sandbox.stub(104 {105 method: function() {106 return;107 }108 },109 "method"110 );111 assert.equals(fakes.length, 2);112 });113 });114 describe(".spy", function() {115 it("should return a spy", function() {116 var sandbox = createSandbox();117 var spy = sandbox.spy();118 assert.isFunction(spy);119 assert.equals(spy.displayName, "spy");120 });121 it("should add a spy to the internal collection", function() {122 var sandbox = createSandbox();123 var fakes = sandbox.getFakes();124 var expected;125 expected = sandbox.spy();126 assert.isTrue(fakes.indexOf(expected) !== -1);127 });128 });129 describe(".createStubInstance", function() {130 beforeEach(function() {131 this.sandbox = createSandbox();132 });133 it("stubs existing methods", function() {134 var Class = function() {135 return;136 };137 Class.prototype.method = function() {138 return;139 };140 var stub = this.sandbox.createStubInstance(Class);141 stub.method.returns(3);142 assert.equals(3, stub.method());143 });144 it("should require a function", function() {145 var sandbox = this.sandbox;146 assert.exception(147 function() {148 sandbox.createStubInstance("not a function");149 },150 {151 name: "TypeError",152 message: "The constructor should be a function."153 }154 );155 });156 it("resets all stub methods on reset()", function() {157 var Class = function() {158 return;159 };160 Class.prototype.method1 = function() {161 return;162 };163 Class.prototype.method2 = function() {164 return;165 };166 Class.prototype.method3 = function() {167 return;168 };169 var stub = this.sandbox.createStubInstance(Class);170 stub.method1.returns(1);171 stub.method2.returns(2);172 stub.method3.returns(3);173 assert.equals(3, stub.method3());174 this.sandbox.reset();175 assert.equals(undefined, stub.method1());176 assert.equals(undefined, stub.method2());177 assert.equals(undefined, stub.method3());178 });179 it("doesn't stub fake methods", function() {180 var Class = function() {181 return;182 };183 var stub = this.sandbox.createStubInstance(Class);184 assert.exception(function() {185 stub.method.returns(3);186 });187 });188 it("doesn't call the constructor", function() {189 var Class = function(a, b) {190 var c = a + b;191 throw c;192 };193 Class.prototype.method = function() {194 return;195 };196 var stub = this.sandbox.createStubInstance(Class);197 refute.exception(function() {198 stub.method(3);199 });200 });201 it("retains non function values", function() {202 var TYPE = "some-value";203 var Class = function() {204 return;205 };206 Class.prototype.type = TYPE;207 var stub = this.sandbox.createStubInstance(Class);208 assert.equals(TYPE, stub.type);209 });210 it("has no side effects on the prototype", function() {211 var proto = {212 method: function() {213 throw new Error("error");214 }215 };216 var Class = function() {217 return;218 };219 Class.prototype = proto;220 var stub = this.sandbox.createStubInstance(Class);221 refute.exception(stub.method);222 assert.exception(proto.method);223 });224 it("throws exception for non function params", function() {225 var types = [{}, 3, "hi!"];226 for (var i = 0; i < types.length; i++) {227 /​/​ yes, it's silly to create functions in a loop, it's also a test228 /​* eslint-disable-next-line ie11/​no-loop-func, no-loop-func */​229 assert.exception(function() {230 this.sandbox.createStubInstance(types[i]);231 });232 }233 });234 });235 describe(".stub", function() {236 beforeEach(function() {237 this.sandbox = createSandbox();238 });239 it("fails if stubbing property on null", function() {240 var sandbox = this.sandbox;241 assert.exception(242 function() {243 sandbox.stub(null, "prop");244 },245 {246 message: "Trying to stub property 'prop' of null"247 }248 );249 });250 it("fails if stubbing symbol on null", function() {251 if (typeof Symbol === "function") {252 var sandbox = this.sandbox;253 assert.exception(254 function() {255 sandbox.stub(null, Symbol());256 },257 {258 message: "Trying to stub property 'Symbol()' of null"259 }260 );261 }262 });263 it("creates a stub", function() {264 var object = {265 method: function() {266 return;267 }268 };269 this.sandbox.stub(object, "method");270 assert.equals(typeof object.method.restore, "function");271 });272 it("adds stub to fake array", function() {273 var fakes = this.sandbox.getFakes();274 var object = {275 method: function() {276 return;277 }278 };279 var stub = this.sandbox.stub(object, "method");280 assert.isTrue(fakes.indexOf(stub) !== -1);281 });282 it("appends stubs to fake array", function() {283 var fakes = this.sandbox.getFakes();284 this.sandbox.stub(285 {286 method: function() {287 return;288 }289 },290 "method"291 );292 this.sandbox.stub(293 {294 method: function() {295 return;296 }297 },298 "method"299 );300 assert.equals(fakes.length, 2);301 });302 it("adds all object methods to fake array", function() {303 var fakes = this.sandbox.getFakes();304 var object = {305 method: function() {306 return;307 },308 method2: function() {309 return;310 },311 method3: function() {312 return;313 }314 };315 Object.defineProperty(object, "method3", {316 enumerable: false317 });318 this.sandbox.stub(object);319 assert.isTrue(fakes.indexOf(object.method) !== -1);320 assert.isTrue(fakes.indexOf(object.method2) !== -2);321 assert.isTrue(fakes.indexOf(object.method3) !== -3);322 assert.equals(fakes.length, 3);323 });324 it("returns a stubbed object", function() {325 var object = {326 method: function() {327 return;328 }329 };330 assert.equals(this.sandbox.stub(object), object);331 });332 it("returns a stubbed method", function() {333 var object = {334 method: function() {335 return;336 }337 };338 assert.equals(this.sandbox.stub(object, "method"), object.method);339 });340 if (typeof process !== "undefined") {341 describe("on node", function() {342 beforeEach(function() {343 process.env.HELL = "Ain't too bad";344 });345 it("stubs environment property", function() {346 var originalPrintWarning = deprecated.printWarning;347 deprecated.printWarning = function() {348 return;349 };350 this.sandbox.stub(process.env, "HELL").value("froze over");351 assert.equals(process.env.HELL, "froze over");352 deprecated.printWarning = originalPrintWarning;353 });354 });355 }356 });357 describe("stub anything", function() {358 beforeEach(function() {359 this.object = { property: 42 };360 this.sandbox = new Sandbox();361 });362 it("stubs number property", function() {363 var originalPrintWarning = deprecated.printWarning;364 deprecated.printWarning = function() {365 return;366 };367 this.sandbox.stub(this.object, "property").value(1);368 assert.equals(this.object.property, 1);369 deprecated.printWarning = originalPrintWarning;370 });371 it("restores number property", function() {372 var originalPrintWarning = deprecated.printWarning;373 deprecated.printWarning = function() {374 return;375 };376 this.sandbox.stub(this.object, "property").value(1);377 this.sandbox.restore();378 assert.equals(this.object.property, 42);379 deprecated.printWarning = originalPrintWarning;380 });381 it("fails if property does not exist", function() {382 var originalPrintWarning = deprecated.printWarning;383 deprecated.printWarning = function() {384 return;385 };386 var sandbox = this.sandbox;387 var object = {};388 assert.exception(function() {389 sandbox.stub(object, "prop", 1);390 });391 deprecated.printWarning = originalPrintWarning;392 });393 it("fails if Symbol does not exist", function() {394 if (typeof Symbol === "function") {395 var sandbox = this.sandbox;396 var object = {};397 var originalPrintWarning = deprecated.printWarning;398 deprecated.printWarning = function() {399 return;400 };401 assert.exception(402 function() {403 sandbox.stub(object, Symbol());404 },405 { message: "Cannot stub non-existent own property Symbol()" },406 TypeError407 );408 deprecated.printWarning = originalPrintWarning;409 }410 });411 });412 describe(".fake", function() {413 it("should return a fake", function() {414 var sandbox = createSandbox();415 var fake = sandbox.fake();416 assert.isFunction(fake);417 assert.equals(fake.displayName, "fake");418 });419 it("should add a fake to the internal collection", function() {420 var sandbox = createSandbox();421 var fakes = sandbox.getFakes();422 var expected;423 expected = sandbox.fake();424 assert.isTrue(fakes.indexOf(expected) !== -1);425 });426 describe(".returns", function() {427 it("should return a fake behavior", function() {428 var sandbox = createSandbox();429 var fake = sandbox.fake.returns();430 assert.isFunction(fake);431 assert.equals(fake.displayName, "fake");432 });433 it("should add a fake behavior to the internal collection", function() {434 var sandbox = createSandbox();435 var fakes = sandbox.getFakes();436 var expected;437 expected = sandbox.fake.returns();438 assert.isTrue(fakes.indexOf(expected) !== -1);439 });440 });441 describe(".throws", function() {442 it("should return a fake behavior", function() {443 var sandbox = createSandbox();444 var fake = sandbox.fake.throws();445 assert.isFunction(fake);446 assert.equals(fake.displayName, "fake");447 });448 it("should add a fake behavior to the internal collection", function() {449 var sandbox = createSandbox();450 var fakes = sandbox.getFakes();451 var expected;452 expected = sandbox.fake.throws();453 assert.isTrue(fakes.indexOf(expected) !== -1);454 });455 });456 describe(".resolves", function() {457 it("should return a fake behavior", function() {458 var sandbox = createSandbox();459 var fake = sandbox.fake.resolves();460 assert.isFunction(fake);461 assert.equals(fake.displayName, "fake");462 });463 it("should add a fake behavior to the internal collection", function() {464 var sandbox = createSandbox();465 var fakes = sandbox.getFakes();466 var expected;467 expected = sandbox.fake.resolves();468 assert.isTrue(fakes.indexOf(expected) !== -1);469 });470 });471 describe(".rejects", function() {472 it("should return a fake behavior", function() {473 var sandbox = createSandbox();474 var fake = sandbox.fake.rejects();475 assert.isFunction(fake);476 assert.equals(fake.displayName, "fake");477 });478 it("should add a fake behavior to the internal collection", function() {479 var sandbox = createSandbox();480 var fakes = sandbox.getFakes();481 var expected;482 expected = sandbox.fake.rejects();483 assert.isTrue(fakes.indexOf(expected) !== -1);484 });485 });486 describe(".yields", function() {487 it("should return a fake behavior", function() {488 var sandbox = createSandbox();489 var fake = sandbox.fake.yields();490 assert.isFunction(fake);491 assert.equals(fake.displayName, "fake");492 });493 it("should add a fake behavior to the internal collection", function() {494 var sandbox = createSandbox();495 var fakes = sandbox.getFakes();496 var expected;497 expected = sandbox.fake.yields();498 assert.isTrue(fakes.indexOf(expected) !== -1);499 });500 });501 describe(".yieldsAsync", function() {502 it("should return a fake behavior", function() {503 var sandbox = createSandbox();504 var fake = sandbox.fake.yieldsAsync();505 assert.isFunction(fake);506 assert.equals(fake.displayName, "fake");507 });508 it("should add a fake behavior to the internal collection", function() {509 var sandbox = createSandbox();510 var fakes = sandbox.getFakes();511 var expected;512 expected = sandbox.fake.yieldsAsync();513 assert.isTrue(fakes.indexOf(expected) !== -1);514 });515 });516 });517 describe(".verifyAndRestore", function() {518 beforeEach(function() {519 this.sandbox = createSandbox();520 });521 it("calls verify and restore", function() {522 this.sandbox.verify = sinonSpy();523 this.sandbox.restore = sinonSpy();524 this.sandbox.verifyAndRestore();525 assert(this.sandbox.verify.called);526 assert(this.sandbox.restore.called);527 });528 it("throws when restore throws", function() {529 this.sandbox.verify = sinonSpy();530 this.sandbox.restore = sinonStub().throws();531 assert.exception(function() {532 this.sandbox.verifyAndRestore();533 });534 });535 it("calls restore when restore throws", function() {536 var sandbox = this.sandbox;537 sandbox.verify = sinonSpy();538 sandbox.restore = sinonStub().throws();539 assert.exception(function() {540 sandbox.verifyAndRestore();541 });542 assert(sandbox.restore.called);543 });544 });545 describe(".replace", function() {546 beforeEach(function() {547 this.sandbox = createSandbox();548 });549 it("should replace a function property", function() {550 var replacement = function replacement() {551 return;552 };553 var existing = function existing() {554 return;555 };556 var object = {557 property: existing558 };559 this.sandbox.replace(object, "property", replacement);560 assert.equals(object.property, replacement);561 this.sandbox.restore();562 assert.equals(object.property, existing);563 });564 it("should replace a non-function property", function() {565 var replacement = "replacement";566 var existing = "existing";567 var object = {568 property: existing569 };570 this.sandbox.replace(object, "property", replacement);571 assert.equals(object.property, replacement);572 this.sandbox.restore();573 assert.equals(object.property, existing);574 });575 it("should replace an inherited property", function() {576 var replacement = "replacement";577 var existing = "existing";578 var object = Object.create({579 property: existing580 });581 this.sandbox.replace(object, "property", replacement);582 assert.equals(object.property, replacement);583 this.sandbox.restore();584 assert.equals(object.property, existing);585 });586 it("should error on missing descriptor", function() {587 var sandbox = this.sandbox;588 assert.exception(589 function() {590 sandbox.replace({}, "i-dont-exist");591 },592 {593 message: "Cannot replace non-existent own property i-dont-exist",594 name: "TypeError"595 }596 );597 });598 it("should error on missing replacement", function() {599 var sandbox = this.sandbox;600 var object = Object.create({601 property: "catpants"602 });603 assert.exception(604 function() {605 sandbox.replace(object, "property");606 },607 {608 message: "Expected replacement argument to be defined",609 name: "TypeError"610 }611 );612 });613 it("should refuse to replace a non-function with a function", function() {614 var sandbox = this.sandbox;615 var replacement = function() {616 return "replacement";617 };618 var existing = "existing";619 var object = {620 property: existing621 };622 assert.exception(623 function() {624 sandbox.replace(object, "property", replacement);625 },626 { message: "Cannot replace string with function" }627 );628 });629 it("should refuse to replace a function with a non-function", function() {630 var sandbox = this.sandbox;631 var replacement = "replacement";632 var object = {633 property: function() {634 return "apple pie";635 }636 };637 assert.exception(638 function() {639 sandbox.replace(object, "property", replacement);640 },641 { message: "Cannot replace function with string" }642 );643 });644 it("should refuse to replace a fake twice", function() {645 var sandbox = this.sandbox;646 var object = {647 property: function() {648 return "apple pie";649 }650 };651 sandbox.replace(object, "property", sinonFake());652 assert.exception(653 function() {654 sandbox.replace(object, "property", sinonFake());655 },656 { message: "Attempted to replace property which is already replaced" }657 );658 });659 it("should refuse to replace a string twice", function() {660 var sandbox = this.sandbox;661 var object = {662 property: "original"663 };664 sandbox.replace(object, "property", "first");665 assert.exception(666 function() {667 sandbox.replace(object, "property", "second");668 },669 { message: "Attempted to replace property which is already replaced" }670 );671 });672 it("should return the replacement argument", function() {673 var replacement = "replacement";674 var existing = "existing";675 var object = {676 property: existing677 };678 var actual = this.sandbox.replace(object, "property", replacement);679 assert.equals(actual, replacement);680 });681 describe("when asked to replace a getter", function() {682 it("should throw an Error", function() {683 var sandbox = this.sandbox;684 var object = {685 get foo() {686 return "bar";687 }688 };689 assert.exception(690 function() {691 sandbox.replace(object, "foo", sinonFake());692 },693 { message: "Use sandbox.replaceGetter for replacing getters" }694 );695 });696 });697 describe("when asked to replace a setter", function() {698 it("should throw an Error", function() {699 var sandbox = this.sandbox;700 /​/​ eslint-disable-next-line accessor-pairs701 var object = {702 set foo(value) {703 this.prop = value;704 }705 };706 assert.exception(707 function() {708 sandbox.replace(object, "foo", sinonFake());709 },710 { message: "Use sandbox.replaceSetter for replacing setters" }711 );712 });713 });714 });715 describe(".replaceGetter", function() {716 beforeEach(function() {717 this.sandbox = createSandbox();718 });719 it("should replace getters", function() {720 var expected = "baz";721 var object = {722 get foo() {723 return "bar";724 }725 };726 this.sandbox.replaceGetter(object, "foo", sinonFake.returns(expected));727 assert.equals(object.foo, expected);728 });729 it("should return replacement", function() {730 var replacement = sinonFake.returns("baz");731 var object = {732 get foo() {733 return "bar";734 }735 };736 var actual = this.sandbox.replaceGetter(object, "foo", replacement);737 assert.equals(actual, replacement);738 });739 it("should replace an inherited property", function() {740 var expected = "baz";741 var replacement = sinonFake.returns(expected);742 var existing = "existing";743 var object = Object.create({744 get foo() {745 return existing;746 }747 });748 this.sandbox.replaceGetter(object, "foo", replacement);749 assert.equals(object.foo, expected);750 this.sandbox.restore();751 assert.equals(object.foo, existing);752 });753 it("should error on missing descriptor", function() {754 var sandbox = this.sandbox;755 assert.exception(756 function() {757 sandbox.replaceGetter({}, "i-dont-exist");758 },759 {760 message: "Cannot replace non-existent own property i-dont-exist",761 name: "TypeError"762 }763 );764 });765 it("should error when descriptor has no getter", function() {766 var sandbox = this.sandbox;767 /​/​ eslint-disable-next-line accessor-pairs768 var object = {769 set catpants(_) {770 return;771 }772 };773 assert.exception(774 function() {775 sandbox.replaceGetter(object, "catpants", noop);776 },777 {778 message: "`object.property` is not a getter",779 name: "Error"780 }781 );782 });783 describe("when called with a non-function replacement argument", function() {784 it("should throw a TypeError", function() {785 var sandbox = this.sandbox;786 var expected = "baz";787 var object = {788 get foo() {789 return "bar";790 }791 };792 assert.exception(793 function() {794 sandbox.replaceGetter(object, "foo", expected);795 },796 { message: "Expected replacement argument to be a function" }797 );798 });799 });800 it("allows restoring getters", function() {801 var expected = "baz";802 var object = {803 get foo() {804 return "bar";805 }806 };807 this.sandbox.replaceGetter(object, "foo", sinonFake.returns(expected));808 this.sandbox.restore();809 assert.equals(object.foo, "bar");810 });811 it("should refuse to replace a getter twice", function() {812 var sandbox = this.sandbox;813 var object = {814 get foo() {815 return "bar";816 }817 };818 sandbox.replaceGetter(object, "foo", sinonFake.returns("one"));819 assert.exception(820 function() {821 sandbox.replaceGetter(object, "foo", sinonFake.returns("two"));822 },823 { message: "Attempted to replace foo which is already replaced" }824 );825 });826 });827 describe(".replaceSetter", function() {828 beforeEach(function() {829 this.sandbox = createSandbox();830 });831 it("should replace setter", function() {832 /​/​ eslint-disable-next-line accessor-pairs833 var object = {834 set foo(value) {835 this.prop = value;836 },837 prop: "bar"838 };839 this.sandbox.replaceSetter(object, "foo", function(val) {840 this.prop = val + "bla";841 });842 object.foo = "bla";843 assert.equals(object.prop, "blabla");844 });845 it("should return replacement", function() {846 /​/​ eslint-disable-next-line accessor-pairs847 var object = {848 set foo(value) {849 this.prop = value;850 },851 prop: "bar"852 };853 var replacement = function(val) {854 this.prop = val + "bla";855 };856 var actual = this.sandbox.replaceSetter(object, "foo", replacement);857 assert.equals(actual, replacement);858 });859 it("should replace an inherited property", function() {860 /​/​ eslint-disable-next-line accessor-pairs861 var object = Object.create({862 set foo(value) {863 this.prop = value;864 },865 prop: "bar"866 });867 var replacement = function(value) {868 this.prop = value + "blabla";869 };870 this.sandbox.replaceSetter(object, "foo", replacement);871 object.foo = "doodle";872 assert.equals(object.prop, "doodleblabla");873 this.sandbox.restore();874 object.foo = "doodle";875 assert.equals(object.prop, "doodle");876 });877 it("should error on missing descriptor", function() {878 var sandbox = this.sandbox;879 assert.exception(880 function() {881 sandbox.replaceSetter({}, "i-dont-exist");882 },883 {884 message: "Cannot replace non-existent own property i-dont-exist",885 name: "TypeError"886 }887 );888 });889 it("should error when descriptor has no setter", function() {890 var sandbox = this.sandbox;891 var object = {892 get catpants() {893 return;894 }895 };896 assert.exception(897 function() {898 sandbox.replaceSetter(object, "catpants", noop);899 },900 {901 message: "`object.property` is not a setter",902 name: "Error"903 }904 );905 });906 describe("when called with a non-function replacement argument", function() {907 it("should throw a TypeError", function() {908 var sandbox = this.sandbox;909 /​/​ eslint-disable-next-line accessor-pairs910 var object = {911 set foo(value) {912 this.prop = value;913 },914 prop: "bar"915 };916 assert.exception(917 function() {918 sandbox.replaceSetter(object, "foo", "bla");919 },920 { message: "Expected replacement argument to be a function" }921 );922 });923 });924 it("allows restoring setters", function() {925 /​/​ eslint-disable-next-line accessor-pairs926 var object = {927 set foo(value) {928 this.prop = value;929 },930 prop: "bar"931 };932 this.sandbox.replaceSetter(object, "foo", function(val) {933 this.prop = val + "bla";934 });935 this.sandbox.restore();936 object.prop = "bla";937 assert.equals(object.prop, "bla");938 });939 it("should refuse to replace a setter twice", function() {940 var sandbox = this.sandbox;941 /​/​ eslint-disable-next-line accessor-pairs942 var object = {943 set foo(value) {944 return;945 }946 };947 sandbox.replaceSetter(object, "foo", sinonFake());948 assert.exception(949 function() {950 sandbox.replaceSetter(object, "foo", sinonFake.returns("two"));951 },952 { message: "Attempted to replace foo which is already replaced" }953 );954 });955 });956 describe(".reset", function() {957 beforeEach(function() {958 var sandbox = (this.sandbox = createSandbox());959 var fakes = sandbox.getFakes();960 fakes.push({961 reset: sinonSpy(),962 resetHistory: sinonSpy()963 });964 fakes.push({965 reset: sinonSpy(),966 resetHistory: sinonSpy()967 });968 });969 it("calls reset on all fakes", function() {970 var fake0 = this.sandbox.getFakes()[0];971 var fake1 = this.sandbox.getFakes()[1];972 this.sandbox.reset();973 assert(fake0.reset.called);974 assert(fake1.reset.called);975 });976 it("calls resetHistory on all fakes", function() {977 var fake0 = this.sandbox.getFakes()[0];978 var fake1 = this.sandbox.getFakes()[1];979 this.sandbox.reset();980 assert(fake0.resetHistory.called);981 assert(fake1.resetHistory.called);982 });983 it("resets fake behaviours", function() {984 var fake = this.sandbox.fake();985 fake(1234);986 this.sandbox.reset();987 assert.equals(fake.getCalls(), []);988 });989 });990 describe(".resetBehavior", function() {991 beforeEach(function() {992 var sandbox = (this.sandbox = createSandbox());993 var fakes = sandbox.getFakes();994 fakes.push({ resetBehavior: sinonSpy() });995 fakes.push({ resetBehavior: sinonSpy() });996 });997 it("calls resetBehavior on all fakes", function() {998 var fake0 = this.sandbox.getFakes()[0];999 var fake1 = this.sandbox.getFakes()[1];1000 this.sandbox.resetBehavior();1001 assert(fake0.resetBehavior.called);1002 assert(fake1.resetBehavior.called);1003 });1004 });1005 describe(".resetHistory", function() {1006 beforeEach(function() {1007 var sandbox = (this.sandbox = createSandbox());1008 var fakes = (this.fakes = sandbox.getFakes());1009 var spy1 = sinonSpy();1010 spy1();1011 fakes.push(spy1);1012 var spy2 = sinonSpy();1013 spy2();...

Using AI Code Generation

1var sinon = require('sinon');2var chai = require('chai');3var assert = chai.assert;4var expect = chai.expect;5var should = chai.should();6var sinonChai = require('sinon-chai');7chai.use(sinonChai);8describe('sinon sandbox', function () {9 it('should return an array of all the fakes created', function () {10 var sandbox = sinon.sandbox.create();11 var fake = sandbox.stub();12 var fake2 = sandbox.stub();13 var fakes = sandbox.getFakes();14 expect(fakes).to.be.an('array');15 expect(fakes).to.have.length(2);16 expect(fakes).to.contain(fake);17 expect(fakes).to.contain(fake2);18 });19});

Using AI Code Generation

1var sinon = require('sinon');2var assert = require('assert');3describe('sinon', function() {4 var sandbox;5 beforeEach(function() {6 sandbox = sinon.sandbox.create();7 });8 afterEach(function() {9 sandbox.restore();10 });11 it('should create a sandbox', function() {12 var spy = sandbox.spy();13 spy();14 assert(spy.called);15 });16 it('should get all the fakes', function() {17 var spy = sandbox.spy();18 var stub = sandbox.stub();19 var mock = sandbox.mock();20 var clock = sandbox.useFakeTimers();21 var server = sandbox.useFakeServer();22 var request = sandbox.useFakeXMLHttpRequest();23 var fakes = sandbox.getFakes();24 assert.equal(fakes.length, 5);25 });26});

Using AI Code Generation

1var sinon = require('sinon');2describe('test', function() {3 var clock;4 beforeEach(function() {5 clock = sinon.useFakeTimers();6 });7 afterEach(function() {8 clock.restore();9 });10 it('test', function() {11 assert.equal(this.sandbox.getFakes().length, 1);12 });13});

Using AI Code Generation

1describe('Test', function () {2 beforeEach(function () {3 this.sandbox = sinon.sandbox.create();4 });5 afterEach(function () {6 this.sandbox.restore();7 });8 it('should return a fake', function () {9 var fake = this.sandbox.getFakes()[0];10 assert(fake);11 });12});

Using AI Code Generation

1var sinon = require('sinon');2var assert = require('chai').assert;3describe('sinon sandbox', function () {4 var sandbox;5 beforeEach(function () {6 sandbox = sinon.sandbox.create();7 });8 afterEach(function () {9 sandbox.restore();10 });11 it('should call callback', function () {12 var callback = sandbox.spy();13 callback();14 assert(callback.calledOnce);15 });16 it('should call callback', function () {17 var callback = sandbox.spy();18 callback();19 assert(callback.calledOnce);20 });21 it('should call callback', function () {22 var callback = sandbox.spy();23 callback();24 assert(callback.calledOnce);25 });26 it('should call callback', function () {27 var callback = sandbox.spy();28 callback();29 assert(callback.calledOnce);30 });31 it('should call callback', function () {32 var callback = sandbox.spy();33 callback();34 assert(callback.calledOnce);35 });36});

Using AI Code Generation

1describe('test', function() {2 var sandbox;3 beforeEach(function() {4 sandbox = sinon.sandbox.create();5 });6 afterEach(function() {7 sandbox.restore();8 });9 it('should call the callback with the correct value', function() {10 var callback = sandbox.spy();11 callback(42);12 assert(callback.calledWith(42));13 });14});

Using AI Code Generation

1var sinon = require('sinon');2var assert = require('assert');3var myModule = require('./​myModule.js');4var myModule = require('./​myModule.js');5var myModule = require('./​myModule.js');6describe('myModule', function () {7 beforeEach(function () {8 this.sandbox = sinon.sandbox.create();9 });10 afterEach(function () {11 this.sandbox.restore();12 });13 it('should call the callback', function () {14 var callback = this.sandbox.spy();15 myModule(callback);16 assert(callback.called);17 });18});

Using AI Code Generation

1var sinon = require('sinon');2var sandbox = sinon.sandbox.create();3var fake = sandbox.fake();4var stub = sandbox.stub();5var spy = sandbox.spy();6var mock = sandbox.mock();7var obj = sandbox.mock();8var obj2 = sandbox.mock();9var obj3 = sandbox.mock();10var obj4 = sandbox.mock();11var obj5 = sandbox.mock();12var obj6 = sandbox.mock();13var obj7 = sandbox.mock();14var obj8 = sandbox.mock();15var obj9 = sandbox.mock();16var obj10 = sandbox.mock();17var obj11 = sandbox.mock();18var obj12 = sandbox.mock();19var obj13 = sandbox.mock();20var obj14 = sandbox.mock();21var obj15 = sandbox.mock();22var obj16 = sandbox.mock();23var obj17 = sandbox.mock();24var obj18 = sandbox.mock();25var obj19 = sandbox.mock();26var obj20 = sandbox.mock();27var obj21 = sandbox.mock();28var obj22 = sandbox.mock();29var obj23 = sandbox.mock();30var obj24 = sandbox.mock();31var obj25 = sandbox.mock();32var obj26 = sandbox.mock();33var obj27 = sandbox.mock();34var obj28 = sandbox.mock();35var obj29 = sandbox.mock();36var obj30 = sandbox.mock();37var obj31 = sandbox.mock();38var obj32 = sandbox.mock();39var obj33 = sandbox.mock();40var obj34 = sandbox.mock();41var obj35 = sandbox.mock();42var obj36 = sandbox.mock();43var obj37 = sandbox.mock();44var obj38 = sandbox.mock();45var obj39 = sandbox.mock();46var obj40 = sandbox.mock();47var obj41 = sandbox.mock();48var obj42 = sandbox.mock();49var obj43 = sandbox.mock();50var obj44 = sandbox.mock();51var obj45 = sandbox.mock();52var obj46 = sandbox.mock();53var obj47 = sandbox.mock();54var obj48 = sandbox.mock();55var obj49 = sandbox.mock();56var obj50 = sandbox.mock();57var obj51 = sandbox.mock();58var obj52 = sandbox.mock();59var obj53 = sandbox.mock();60var obj54 = sandbox.mock();61var obj55 = sandbox.mock();62var obj56 = sandbox.mock();63var obj57 = sandbox.mock();64var obj58 = sandbox.mock();65var obj59 = sandbox.mock();66var obj60 = sandbox.mock();67var obj61 = sandbox.mock();68var obj62 = sandbox.mock();69var obj63 = sandbox.mock();70var obj64 = sandbox.mock();

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

• JUnit Tutorial
• TestNG Tutorial
• Webdriver Tutorial
• WebDriverIO Tutorial
• Protractor Tutorial
• Selenium 4 Tutorial
• Jenkins Tutorial
• NUnit Tutorial
• Jest Tutorial
• Playwright Tutorial
• Cypress Tutorial
• PyTest Tutorial

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run sinon automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

View sample repo View DocumentationSign up Free

›

_