From 71733c8dad414c08efd57821b896bfc1d6868e22 Mon Sep 17 00:00:00 2001 From: Johannes Ewald Date: Tue, 8 Jul 2014 01:16:29 +0200 Subject: Move __with__-function into own module --- test/__set__.test.js | 89 +++++---------------------------------------------- test/__with__.test.js | 89 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 97 insertions(+), 81 deletions(-) create mode 100644 test/__with__.test.js (limited to 'test') diff --git a/test/__set__.test.js b/test/__set__.test.js index fe6f529..c883c27 100644 --- a/test/__set__.test.js +++ b/test/__set__.test.js @@ -1,7 +1,5 @@ var expect = require("expect.js"), - setModule = require("../lib/__set__.js") - __set__ = setModule["__set__"], - __with__ = setModule["__with__"], + __set__ = require("../lib/__set__.js"), vm = require("vm"), expectReferenceError = expectError(ReferenceError), @@ -18,12 +16,15 @@ describe("__set__", function () { beforeEach(function () { moduleFake = { + module: { + exports: {} + }, myValue: 0, // copy by value myReference: {} // copy by reference }; vm.runInNewContext( - "__set__ = " + __set__.toString() + "; " + + "__set__ = module.exports.__set__ = " + __set__.toString() + "; " + "getValue = function () { return myValue; }; " + "getReference = function () { return myReference; }; ", moduleFake @@ -72,10 +73,10 @@ describe("__set__", function () { expect(moduleFake.getReference()).to.be(newObj); }); it("should return a function that when invoked reverts to the values before set was called", function () { - undo = moduleFake.__set__("myValue", 4) + undo = moduleFake.__set__("myValue", 4); expect(typeof undo).to.be("function"); expect(moduleFake.getValue()).to.be(4); - undo() + undo(); expect(moduleFake.getValue()).to.be(0); }); it("should be able to revert when calling with an env-obj", function () { @@ -126,78 +127,4 @@ describe("__set__", function () { moduleFake.__set__("someVar"); // misfitting number of params }).to.throwException(expectTypeError); }); -}); - -describe("__with__", function() { - var moduleFake; - - beforeEach(function () { - moduleFake = { - myValue: 0, // copy by value - myReference: {} // copy by reference - }; - - //__with__ requires __set__ to be in scope - vm.runInNewContext( - "__set__ = " + __set__.toString() + "; " + - "__with__ = " + __with__.toString() + "; " + - "getValue = function () { return myValue; }; " + - "getReference = function () { return myReference; }; ", - moduleFake - ); - }); - - it("should return a function that can be invoked with a callback which guarantees __sets__ undo function is called for you at the end", function () { - var newObj = { hello: "hello" }; - - expect(moduleFake.getValue()).to.be(0); - expect(moduleFake.getReference()).to.eql({}); - - moduleFake.__with__({ - myValue: 2, - myReference: newObj - })(function() { - //changes will be visible from within this callback function - expect(moduleFake.getValue()).to.be(2); - expect(moduleFake.getReference()).to.be(newObj); - }) - - //undo will automatically get called for you after returning from your callback function - expect(moduleFake.getValue()).to.be(0); - expect(moduleFake.getReference()).to.eql({}); - }); - - it("should still revert values if the callback throws an exception", function(){ - var newObj = { hello: "hello" }; - function withError(){ - moduleFake.__with__({ - myValue: 2, - myReference: newObj - })(function() { - throw new Error("something went wrong..."); - }) - } - expect(withError).to.throwError(); - expect(moduleFake.getValue()).to.be(0); - expect(moduleFake.getReference()).to.eql({}); - }); - - it("should throw an error if something other than a function is passed as the callback", function() { - var newObj = { hello: "hello" }, - withFunction = moduleFake.__with__({ - myValue: 2, - myReference: newObj - }) - callWithFunction = function(){ - var args = arguments; - return function() { - withFunction.apply(null, args); - }; - }; - - expect(callWithFunction(1)).to.throwError(); - expect(callWithFunction("a string")).to.throwError(); - expect(callWithFunction({})).to.throwError(); - expect(callWithFunction(function(){})).to.not.throwError(); - }); -}); +}); \ No newline at end of file diff --git a/test/__with__.test.js b/test/__with__.test.js new file mode 100644 index 0000000..247838a --- /dev/null +++ b/test/__with__.test.js @@ -0,0 +1,89 @@ +var expect = require("expect.js"), + __with__ = require("../lib/__with__.js"), + __set__ = require("../lib/__set__.js"), + vm = require("vm"), + expectReferenceError = expectError(ReferenceError), + expectTypeError = expectError(TypeError); + +function expectError(ErrConstructor) { + return function expectReferenceError(err) { + expect(err.constructor.name).to.be(ErrConstructor.name); + }; +} + +describe("__with__", function() { + var moduleFake; + + beforeEach(function () { + moduleFake = { + module: { + exports: {} + }, + myValue: 0, // copy by value + myReference: {} // copy by reference + }; + + //__with__ requires __set__ to be in scope + vm.runInNewContext( + "module.exports.__set__ = " + __set__.toString() + "; " + + "__with__ = " + __with__.toString() + "; " + + "getValue = function () { return myValue; }; " + + "getReference = function () { return myReference; }; ", + moduleFake + ); + }); + + it("should return a function that can be invoked with a callback which guarantees __sets__ undo function is called for you at the end", function () { + var newObj = { hello: "hello" }; + + expect(moduleFake.getValue()).to.be(0); + expect(moduleFake.getReference()).to.eql({}); + + moduleFake.__with__({ + myValue: 2, + myReference: newObj + })(function() { + //changes will be visible from within this callback function + expect(moduleFake.getValue()).to.be(2); + expect(moduleFake.getReference()).to.be(newObj); + }); + + //undo will automatically get called for you after returning from your callback function + expect(moduleFake.getValue()).to.be(0); + expect(moduleFake.getReference()).to.eql({}); + }); + + it("should still revert values if the callback throws an exception", function(){ + var newObj = { hello: "hello" }; + function withError(){ + moduleFake.__with__({ + myValue: 2, + myReference: newObj + })(function() { + throw new Error("something went wrong..."); + }); + } + expect(withError).to.throwError(); + expect(moduleFake.getValue()).to.be(0); + expect(moduleFake.getReference()).to.eql({}); + }); + + it("should throw an error if something other than a function is passed as the callback", function() { + var newObj = { hello: "hello" }, + withFunction = moduleFake.__with__({ + myValue: 2, + myReference: newObj + }); + callWithFunction = function(){ + var args = arguments; + return function() { + withFunction.apply(null, args); + }; + }; + + expect(callWithFunction(1)).to.throwError(); + expect(callWithFunction("a string")).to.throwError(); + expect(callWithFunction({})).to.throwError(); + expect(callWithFunction(function(){})).to.not.throwError(); + }); +}); -- cgit v1.2.3