From 0af1dcb6b2ccbc7ec0ae757549688e666cf569a7 Mon Sep 17 00:00:00 2001 From: Johannes Date: Mon, 11 Jun 2012 23:29:10 +0200 Subject: - changed API - introduced __set__ and __get__ to rewired modules --- test/__get__.test.js | 79 +++++++++ test/__set__.test.js | 93 ++++++++++ test/debug.test.js | 8 +- test/getImportGlobalsSrc.test.js | 24 +++ test/getInjectionSrc.test.js | 24 --- test/getLeakingSrc.test.js | 16 -- test/rewire.test.js | 207 ++++++++++++---------- test/testModules/A/moduleA.js | 26 --- test/testModules/B/moduleB.js | 7 - test/testModules/C/moduleC.js | 3 - test/testModules/debuggerModule.js | 10 +- test/testModules/emptyModule.js | 1 + test/testModules/index.js | 5 - test/testModules/moduleA.js | 75 ++++++++ test/testModules/moduleB.js | 81 +++++++++ test/testModules/privateModules/privateModuleA.js | 10 -- test/testModules/privateModules/privateModuleB.js | 10 -- test/testModules/someOtherModule.js | 5 + 18 files changed, 478 insertions(+), 206 deletions(-) create mode 100644 test/__get__.test.js create mode 100644 test/__set__.test.js create mode 100644 test/getImportGlobalsSrc.test.js delete mode 100644 test/getInjectionSrc.test.js delete mode 100644 test/getLeakingSrc.test.js delete mode 100644 test/testModules/A/moduleA.js delete mode 100644 test/testModules/B/moduleB.js delete mode 100644 test/testModules/C/moduleC.js create mode 100644 test/testModules/emptyModule.js delete mode 100644 test/testModules/index.js create mode 100644 test/testModules/moduleA.js create mode 100644 test/testModules/moduleB.js delete mode 100644 test/testModules/privateModules/privateModuleA.js delete mode 100644 test/testModules/privateModules/privateModuleB.js create mode 100644 test/testModules/someOtherModule.js (limited to 'test') diff --git a/test/__get__.test.js b/test/__get__.test.js new file mode 100644 index 0000000..6506e84 --- /dev/null +++ b/test/__get__.test.js @@ -0,0 +1,79 @@ +"use strict"; // run code in ES5 strict mode + +var expect = require("expect.js"), + vm = require("vm"), + __get__ = require("../lib/__get__.js"), + + expectReferenceError = expectError(ReferenceError), + expectTypeError = expectError(TypeError); + +function expectError(ErrConstructor) { + return function expectReferenceError(err) { + expect(err.constructor.name).to.be(ErrConstructor.name); + }; +} + + +describe("__get__", function () { + var moduleFake; + + beforeEach(function () { + moduleFake = { + myNumber: 0, + myObj: {} + }; + + vm.runInNewContext( + "__get__ = " + __get__.toString() + "; " + + "setNumber = function (value) { myNumber = value; }; " + + "setObj = function (value) { myObj = value; }; ", + moduleFake + ); + }); + it("should return the initial value", function () { + expect(moduleFake.__get__("myNumber")).to.be(0); + expect(moduleFake.__get__("myObj")).to.eql({}); + }); + it("should return the changed value of the number", function () { + var newObj = { hello: "hello" }; + + moduleFake.setNumber(2); + moduleFake.setObj(newObj); + expect(moduleFake.__get__("myNumber")).to.be(2); + expect(moduleFake.__get__("myObj")).to.be(newObj); + }); + it("should throw a ReferenceError when getting not existing vars", function () { + expect(function () { + moduleFake.__get__("blabla"); + }).to.throwException(expectReferenceError); + }); + it("should throw a TypeError when passing misfitting params", function () { + expect(function () { + moduleFake.__get__(); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__get__(undefined); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__get__(null); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__get__(true); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__get__(2); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__get__(""); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__get__([]); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__get__({}); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__get__(function () {}); + }).to.throwException(expectTypeError); + }); +}); \ No newline at end of file diff --git a/test/__set__.test.js b/test/__set__.test.js new file mode 100644 index 0000000..e7950cb --- /dev/null +++ b/test/__set__.test.js @@ -0,0 +1,93 @@ +"use strict"; // run code in ES5 strict mode + +var expect = require("expect.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("__set__", function () { + var moduleFake; + + beforeEach(function () { + moduleFake = { + myNumber: 0, // copy by value + myObj: {} // copy by reference + }; + + vm.runInNewContext( + "__set__ = " + __set__.toString() + "; " + + "getNumber = function () { return myNumber; }; " + + "getObj = function () { return myObj; }; ", + moduleFake + ); + }); + it("should set the new number when calling with varName, varValue", function () { + expect(moduleFake.getNumber()).to.be(0); + moduleFake.__set__("myNumber", 2); + expect(moduleFake.getNumber()).to.be(2); + }); + it("should set the new object when calling with varName, varValue", function () { + var newObj = { hello: "hello" }; + + expect(moduleFake.getObj()).to.eql({}); + moduleFake.__set__("myObj", newObj); + expect(moduleFake.getObj()).to.be(newObj); + }); + it("should set the new number and the new obj when calling with an env-obj", function () { + var newObj = { hello: "hello" }; + + expect(moduleFake.getNumber()).to.be(0); + expect(moduleFake.getObj()).to.eql({}); + moduleFake.__set__({ + myNumber: 2, + myObj: newObj + }); + expect(moduleFake.getNumber()).to.be(2); + expect(moduleFake.getObj()).to.be(newObj); + }); + it("should return undefined", function () { + expect(moduleFake.__set__("myNumber", 4)).to.be(undefined); + }); + it("should throw a ReferenceError when trying to set non-existing vars", function () { + expect(function () { + moduleFake.__set__("notExisting", 3); + }).to.throwException(); + expect(function () { + moduleFake.__set__({ + notExisting: "bla", + notExistingAsWell: "blabla" + }); + }).to.throwException(expectReferenceError); + }); + it("should throw a TypeError when passing misfitting params", function () { + expect(function () { + moduleFake.__set__(); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__set__(undefined); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__set__(null); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__set__(true); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__set__(2); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__set__(""); + }).to.throwException(expectTypeError); + expect(function () { + moduleFake.__set__(function () {}); + }).to.throwException(expectTypeError); + }); +}); \ No newline at end of file diff --git a/test/debug.test.js b/test/debug.test.js index 4a388b6..acd16ee 100644 --- a/test/debug.test.js +++ b/test/debug.test.js @@ -4,8 +4,10 @@ var rewire = require("../lib/index.js"); // add breakpoints in testModules/debuggerModule.js and debug this file with your IDE to // check if debugging works with rewire. -var debuggerModule = rewire("./testModules/debuggerModule.js", null, { - someVar: "Look if you can see me in your IDE when holding at the breakpoints" -}); +var debuggerModule = rewire("./testModules/debuggerModule.js"); + +debugger; + +debuggerModule.__set__("myNumber", 1); debuggerModule(); \ No newline at end of file diff --git a/test/getImportGlobalsSrc.test.js b/test/getImportGlobalsSrc.test.js new file mode 100644 index 0000000..b6f8576 --- /dev/null +++ b/test/getImportGlobalsSrc.test.js @@ -0,0 +1,24 @@ +"use strict"; // run code in ES5 strict mode + +var expect = require("expect.js"), + vm = require("vm"), + getImportGlobalsSrc = require("../lib/getImportGlobalsSrc.js"); + +describe("getImportGlobalsSrc", function () { + it("should declare all globals with a var", function () { + var context = { + global: global + }, + src, + actualGlobals, + expectedGlobals = Object.keys(global); + + src = getImportGlobalsSrc(); + vm.runInNewContext(src, context); + actualGlobals = Object.keys(context); + actualGlobals.sort(); + expectedGlobals.sort(); + expect(actualGlobals).to.eql(expectedGlobals); + expect(actualGlobals.length).to.be.above(1); + }); +}); \ No newline at end of file diff --git a/test/getInjectionSrc.test.js b/test/getInjectionSrc.test.js deleted file mode 100644 index 356b00d..0000000 --- a/test/getInjectionSrc.test.js +++ /dev/null @@ -1,24 +0,0 @@ -"use strict"; // run code in ES5 strict mode - -var expect = require("expect.js"), - getInjectionSrc = require("../lib/getInjectionSrc.js"); - -describe("getMonkeyPatchSrc", function () { - it("should return ''", function () { - var expectedSrc = "", - subject = {}; - - expect(getInjectionSrc(subject)).to.be(expectedSrc); - }); - it("should return 'var process={\"argv\": [\"myArg1\", \"myArg2\"]};var console=456;'", function () { - var expectedSrc = "var process={\"argv\": [\"myArg1\", \"myArg2\"]};var console=456;", - subject = { - process: { - argv: ["myArg1", "myArg2"] - }, - console: 456 - }; - - expect(getInjectionSrc(subject)).to.be(expectedSrc); - }); -}); \ No newline at end of file diff --git a/test/getLeakingSrc.test.js b/test/getLeakingSrc.test.js deleted file mode 100644 index b1e137b..0000000 --- a/test/getLeakingSrc.test.js +++ /dev/null @@ -1,16 +0,0 @@ -"use strict"; // run code in ES5 strict mode - -var expect = require("expect.js"), - getLeakingWrapper = require("../lib/getLeakingSrc.js"); - -describe("getLeakingWrapper", function () { - it("should return 'module.exports.__ = {};'", function () { - expect(getLeakingWrapper([])).to.be("module.exports.__ = {};"); - }); - it("should return 'module.exports.__ = {somethingPrivate:somethingPrivate,somethingSecret:somethingSecret};'", function () { - var leakArr = ["somethingPrivate", "somethingSecret"]; - - expect(getLeakingWrapper(leakArr)) - .to.be("module.exports.__ = {somethingPrivate:somethingPrivate,somethingSecret:somethingSecret};"); - }); -}); \ No newline at end of file diff --git a/test/rewire.test.js b/test/rewire.test.js index 1f8ebf9..9216af6 100644 --- a/test/rewire.test.js +++ b/test/rewire.test.js @@ -4,132 +4,151 @@ var path = require("path"), expect = require("expect.js"), rewire = require("../lib/index.js"); -var testModules = [ - path.resolve(__dirname, "./testModules/index.js"), - path.resolve(__dirname, "./testModules/A/moduleA.js"), - path.resolve(__dirname, "./testModules/B/moduleB.js"), - path.resolve(__dirname, "./testModules/C/moduleC.js") - ]; +var testModules = { + A: path.resolve(__dirname, "./testModules/moduleA.js"), + B: path.resolve(__dirname, "./testModules/moduleB.js"), + someOtherModule: path.resolve(__dirname, "./testModules/someOtherModule.js"), + emptyModule: path.resolve(__dirname, "./testModules/emptyModule.js") + }; function cleanRequireCache() { - var i; - - for (i = 0; i < testModules.length; i++) { - delete require.cache[testModules[i]]; + var moduleName, + modulePath; + + for (moduleName in testModules) { + if (testModules.hasOwnProperty(moduleName)) { + modulePath = testModules[moduleName]; + delete require.cache[modulePath]; + } } } describe("rewire", function () { beforeEach(cleanRequireCache); // ensuring a clean test environment - it("should work like require() when omitting all other params", function () { - expect(rewire("./testModules/A/moduleA.js")).to.be(require("./testModules/A/moduleA.js")); + it("should work like require()", function () { + expect(rewire("./testModules/moduleA.js")).to.be(require("./testModules/moduleA.js")); + cleanRequireCache(); + expect(rewire("../test/testModules/moduleA.js")).to.be(require("../test/testModules/moduleA.js")); + cleanRequireCache(); + expect(rewire(testModules.A)).to.be(require(testModules.A)); }); - it("should require all mocks", function () { - var rewired, - fsMock = {}, - mocks = {}, - moduleBMock = {}, - moduleCMock = {}, - toSrcMock = {}, - indexMock = {}; - - mocks["fs"] = fsMock; - mocks[path.resolve(__dirname, "./testModules/B/moduleB.js")] = moduleBMock; - mocks["../C/moduleC.js"] = moduleCMock; - mocks["toSrc"] = toSrcMock; - mocks["../"] = indexMock; - - rewired = rewire("./testModules/A/moduleA.js", mocks); - expect(rewired.fs).to.be(fsMock); - expect(rewired.b).to.be(moduleBMock); - expect(rewired.c).to.be(moduleCMock); - expect(rewired.toSrc).to.be(toSrcMock); - expect(rewired.index).to.be(indexMock); + it("should modify the module so it provides a __set__ - function", function () { + expect(rewire(testModules.A).__set__).to.be.a(Function); + expect(rewire(testModules.B).__set__).to.be.a(Function); }); - it("should inject object modifications", function () { - var rewired, - injections = { - process: { - argv: ["arg1", "arg2", "arg3"] - }, - console: 123 - }; - - rewired = rewire("./testModules/A/moduleA.js", null, injections); - rewired.exportAll(); - expect(rewired.process).not.to.be(process); - expect(process.argv).not.to.eql(injections.process.argv); - expect(rewired.process).to.eql(injections.process); - expect(rewired.console).to.be(123); + it("should modify the module so it provides a __get__ - function", function () { + expect(rewire(testModules.A).__get__).to.be.a(Function); + expect(rewire(testModules.B).__get__).to.be.a(Function); }); - it("should inject custom scripts", function () { - var rewired, - script = "var console = 456;"; + it("should not influence other modules", function () { + var rewiredModuleA = rewire(testModules.A); - rewired = rewire("./testModules/A/moduleA.js", null, script); - rewired.exportAll(); - expect(rewired.console).to.be(456); + expect(require(testModules.someOtherModule).__set__).to.be(undefined); + expect(require(testModules.someOtherModule).__get__).to.be(undefined); + expect(require("fs").__set__).to.be(undefined); + expect(require("fs").__get__).to.be(undefined); }); - it("should leak private variables with both exports-styles (exports.bla = bla and module.exports = bla)", function () { - var rewired, - leaks = ["myPrivateVar"]; - - rewired = rewire("./testModules/privateModules/privateModuleA.js", null, null, leaks); - expect(rewired.__.myPrivateVar).to.be("Hello I'm very private"); - rewired = rewire("./testModules/privateModules/privateModuleB.js", null, null, leaks); - expect(rewired.__.myPrivateVar).to.be("Hello I'm very private"); + it("should not influence global objects by default", function () { + expect(function () { + rewire(testModules.A).checkSomeGlobals(); + rewire(testModules.B).checkSomeGlobals(); + }).to.not.throwException(); + }); + it("should provide the ability to set private vars", function () { + var rewiredModuleA = rewire(testModules.A), + newObj = {}; + + expect(rewiredModuleA.getMyNumber()).to.be(0); + rewiredModuleA.__set__("myNumber", 2); + expect(rewiredModuleA.getMyNumber()).to.be(2); + rewiredModuleA.__set__("myObj", newObj); + expect(rewiredModuleA.getMyObj()).to.be(newObj); }); - it("should leak private functions with both exports-styles (exports.bla = bla and module.exports = bla)", function () { - var rewired, - leaks = ["myPrivateFunction"]; + it("should provide the ability to get private vars", function () { + var rewiredModuleA = rewire(testModules.A); - rewired = rewire("./testModules/privateModules/privateModuleA.js", null, null, leaks); - expect(rewired.__.myPrivateFunction()).to.be("Hello I'm very private"); - rewired = rewire("./testModules/privateModules/privateModuleB.js", null, null, leaks); - expect(rewired.__.myPrivateFunction()).to.be("Hello I'm very private"); + expect(rewiredModuleA.__get__("myNumber")).to.be(rewiredModuleA.getMyNumber()); + expect(rewiredModuleA.__get__("myObj")).to.be(rewiredModuleA.getMyObj()); }); - it("should leak nothing on demand", function () { - var rewired; + it("should provide the ability to inject mocks", function (done) { + var rewiredModuleA = rewire(testModules.A), + mockedFs = { + readFileSync: function (file) { + expect(file).to.be("bla.txt"); + done(); + } + }; - rewired = rewire("./testModules/A/moduleA.js"); - expect(rewired.__).to.be(undefined); + rewiredModuleA.__set__("fs", mockedFs); + rewiredModuleA.readFileSync(); + }); + it("should not influence other modules when injecting mocks", function () { + var rewiredModuleA = rewire(testModules.A), + someOtherModule, + mockedFs = {}; + + rewiredModuleA.__set__("fs", mockedFs); + someOtherModule = require(testModules.someOtherModule); + expect(someOtherModule.fs).not.to.be(mockedFs); + }); + it("should provide the ability to mock global objects just within the module", function () { + var rewiredModuleA = rewire(testModules.A), + rewiredModuleB = rewire(testModules.B), + consoleMock = {}, + processMock = {}, + newFilename = "myFile.js"; + + rewiredModuleA.__set__({ + console: consoleMock, + process: processMock + }); + rewiredModuleA.__set__("__filename", newFilename); + rewiredModuleB.__set__({ + console: consoleMock, + process: processMock + }); + rewiredModuleB.__set__("__filename", newFilename); + expect(rewiredModuleA.getConsole()).to.be(consoleMock); + expect(rewiredModuleB.getConsole()).to.be(consoleMock); + expect(console).not.to.be(consoleMock); + expect(rewiredModuleA.getProcess()).to.be(processMock); + expect(rewiredModuleB.getProcess()).to.be(processMock); + expect(process).not.to.be(processMock); + expect(rewiredModuleA.getFilename()).to.be(newFilename); + expect(rewiredModuleB.getFilename()).to.be(newFilename); }); it("should cache the rewired module", function () { var rewired; - rewired = rewire("./testModules/B/moduleB.js"); - rewired.requireIndex(); - expect(rewired.index.b).to.be(rewired); + rewired = rewire(testModules.someOtherModule); + expect(require(testModules.A).someOtherModule).to.be(rewired); cleanRequireCache(); - rewired = rewire("./testModules/B/moduleB.js", null, null, null, true); - rewired.requireIndex(); - expect(rewired.index.b).to.be(rewired); + rewired = rewire(testModules.someOtherModule, true); + expect(require(testModules.A).someOtherModule).to.be(rewired); }); it("should not cache the rewired module on demand", function () { var rewired; - rewired = rewire("./testModules/B/moduleB.js", null, null, null, false); - rewired.requireIndex(); - expect(rewired.index.b).not.to.be(rewired); + rewired = rewire(testModules.someOtherModule, false); + expect(require(testModules.A).someOtherModule).not.to.be(rewired); }); it("should not influence the original node require if nothing has been required within the rewired module", function () { - var moduleCMock = {}, - moduleB, - mocks = { - "../C/moduleC.js": moduleCMock - }; - - rewire("./testModules/C/moduleC.js", mocks); // nothing happens here because moduleC doesn't require anything - moduleB = require("./testModules/A/moduleA.js"); // if restoring the original node require didn't worked, the mock would be applied now - expect(moduleB.c).not.to.be(moduleCMock); + rewire(testModules.emptyModule); // nothing happens here because emptyModule doesn't require anything + expect(require(testModules.A).__set__).to.be(undefined); // if restoring the original node require didn't worked, the module would have a setter + }); + it("subsequent calls of rewire should always return a new instance", function () { + expect(rewire(testModules.A)).not.to.be(rewire(testModules.A)); }); describe("#reset", function () { it("should remove all rewired modules from cache", function () { - var rewired = rewire("./testModules/B/moduleB.js"); + var rewiredModuleA = rewire(testModules.A), + rewiredModuleB = rewire(testModules.B); - expect(require("./testModules/B/moduleB.js")).to.be(rewired); + expect(require(testModules.A)).to.be(rewiredModuleA); + expect(require(testModules.B)).to.be(rewiredModuleB); rewire.reset(); - expect(require("./testModules/B/moduleB.js")).not.to.be(rewired); + expect(require(testModules.A)).not.to.be(rewiredModuleA); + expect(require(testModules.B)).not.to.be(rewiredModuleB); }); }); }); \ No newline at end of file diff --git a/test/testModules/A/moduleA.js b/test/testModules/A/moduleA.js deleted file mode 100644 index b8671cf..0000000 --- a/test/testModules/A/moduleA.js +++ /dev/null @@ -1,26 +0,0 @@ -"use strict"; // run code in ES5 strict mode - -var path = require("path"), - - // different ways to require a module - fs = require("fs"), // native module - c = require("../C/moduleC.js"), // relative path - b = require(path.resolve(__dirname, "../B/moduleB.js")), // absolute path - toSrc = require("toSrc"), // node_modules path - index = require("../"); // index.js path - -function exportAll() { - // expose all required modules to test for mocks - exports.fs = fs; - exports.b = b; - exports.c = c; - exports.toSrc = toSrc; - exports.index = index; - exports.process = process; - exports.console = console; -} - -exportAll(); -exports.exportAll = exportAll; - - diff --git a/test/testModules/B/moduleB.js b/test/testModules/B/moduleB.js deleted file mode 100644 index 7b7b32c..0000000 --- a/test/testModules/B/moduleB.js +++ /dev/null @@ -1,7 +0,0 @@ -"use strict"; // run code in ES5 strict mode - -var c = require("../C/moduleC.js"); - -exports.requireIndex = function () { // necessary to avoid circular dependency - exports.index = require("../index.js"); -}; \ No newline at end of file diff --git a/test/testModules/C/moduleC.js b/test/testModules/C/moduleC.js deleted file mode 100644 index b7245de..0000000 --- a/test/testModules/C/moduleC.js +++ /dev/null @@ -1,3 +0,0 @@ -"use strict"; // run code in ES5 strict mode - -module.exports = "c"; \ No newline at end of file diff --git a/test/testModules/debuggerModule.js b/test/testModules/debuggerModule.js index 926c607..5a79b53 100644 --- a/test/testModules/debuggerModule.js +++ b/test/testModules/debuggerModule.js @@ -1,13 +1,7 @@ "use strict"; // run code in ES5 strict mode -// Add a breakpoint on line 6 and on line 11 and debug "debug.test.js" to test if the IDE stops at these points. -// Watch also the variable someVar that is injected by rewire. It will be undefined at this point because -// all injections are executed at the end of the module. -// It's already visible because of hoisting: http://net.tutsplus.com/tutorials/javascript-ajax/quick-tip-javascript-hoisting-explained/) -var someNumber = 0; +var myNumber = 0; module.exports = function () { - // In this line someVar will be defined. - someNumber++; - someVar; + myNumber = 1; }; \ No newline at end of file diff --git a/test/testModules/emptyModule.js b/test/testModules/emptyModule.js new file mode 100644 index 0000000..7c9ad5d --- /dev/null +++ b/test/testModules/emptyModule.js @@ -0,0 +1 @@ +"use strict"; // run code in ES5 strict mode diff --git a/test/testModules/index.js b/test/testModules/index.js deleted file mode 100644 index fa07160..0000000 --- a/test/testModules/index.js +++ /dev/null @@ -1,5 +0,0 @@ -"use strict"; // run code in ES5 strict mode - -exports.a = require("./A/moduleA.js"); -exports.b = require("./B/moduleB.js"); -exports.c = require("./C/moduleC.js"); \ No newline at end of file diff --git a/test/testModules/moduleA.js b/test/testModules/moduleA.js new file mode 100644 index 0000000..6cc63b2 --- /dev/null +++ b/test/testModules/moduleA.js @@ -0,0 +1,75 @@ +"use strict"; // run code in ES5 strict mode + +var someOtherModule = require("./someOtherModule.js"), + myNumber = 0, // copy by value + myObj = {}, // copy by reference + fs = require("fs"); + +// We need getters and setters for private vars to check if our injected setters and getters actual work +function setMyNumber(newNumber) { + myNumber = newNumber; +} + +function getMyNumber() { + return myNumber; +} + +function setMyObj(newObj) { + myObj = newObj; +} + +function getMyObj() { + return myObj; +} + +function readFileSync() { + fs.readFileSync("bla.txt", "utf8"); +} + +function checkSomeGlobals() { + if (typeof global === "undefined") { + //throw new ReferenceError("global is undefined"); + } + if (typeof process === "undefined") { + throw new ReferenceError("process is undefined"); + } + if (typeof console === "undefined") { + throw new ReferenceError("console is undefined"); + } + if (typeof Buffer === "undefined") { + throw new ReferenceError("Buffer is undefined"); + } + if (typeof __filename === "undefined") { + throw new ReferenceError("__filename is undefined"); + } + if (typeof __dirname === "undefined") { + throw new ReferenceError("__dirname is undefined"); + } + if (typeof setTimeout === "undefined") { + throw new ReferenceError("setTimeout is undefined"); + } +} + +function getConsole() { + return console; +} + +function getProcess() { + return process; +} + +function getFilename() { + return __filename; +} + +// different styles of exports in moduleA.js and moduleB.js +exports.setMyNumber = setMyNumber; +exports.getMyNumber = getMyNumber; +exports.setMyObj = setMyObj; +exports.getMyObj = getMyObj; +exports.readFileSync = readFileSync; +exports.checkSomeGlobals = checkSomeGlobals; +exports.getConsole = getConsole; +exports.getProcess = getProcess; +exports.getFilename = getFilename; +exports.someOtherModule = someOtherModule; \ No newline at end of file diff --git a/test/testModules/moduleB.js b/test/testModules/moduleB.js new file mode 100644 index 0000000..c9fec13 --- /dev/null +++ b/test/testModules/moduleB.js @@ -0,0 +1,81 @@ +"use strict"; // run code in ES5 strict mode + +var someOtherModule = require("./someOtherModule.js"), + myNumber = 0, // copy by value + myObj = {}, // copy by reference + fs = require("fs"); + +// We need getters and setters for private vars to check if our injected setters and getters actual work +function setMyNumber(newNumber) { + myNumber = newNumber; +} + +function getMyNumber() { + return myNumber; +} + +function setMyObj(newObj) { + myObj = newObj; +} + +function getMyObj() { + return myObj; +} + +function readFileSync() { + fs.readFileSync("bla.txt", "utf8"); +} + +function checkSomeGlobals() { + if (typeof global === "undefined") { + throw new ReferenceError("global is undefined"); + } + if (typeof process === "undefined") { + throw new ReferenceError("process is undefined"); + } + if (typeof console === "undefined") { + throw new ReferenceError("console is undefined"); + } + if (typeof Buffer === "undefined") { + throw new ReferenceError("Buffer is undefined"); + } + if (typeof __filename === "undefined") { + throw new ReferenceError("__filename is undefined"); + } + if (typeof __dirname === "undefined") { + throw new ReferenceError("__dirname is undefined"); + } + if (typeof setTimeout === "undefined") { + throw new ReferenceError("setTimeout is undefined"); + } +} + +function getConsole() { + return console; +} + +function getProcess() { + return process; +} + +function getFilename() { + return __filename; +} + +function main() { + +} + +main.setMyNumber = setMyNumber; +main.getMyNumber = getMyNumber; +main.setMyObj = setMyObj; +main.getMyObj = getMyObj; +main.readFileSync = readFileSync; +main.checkSomeGlobals = checkSomeGlobals; +main.getConsole = getConsole; +main.getProcess = getProcess; +main.getFilename = getFilename; +main.someOtherModule = someOtherModule; + +// different styles of exports in moduleA.js and moduleB.js +module.exports = main; diff --git a/test/testModules/privateModules/privateModuleA.js b/test/testModules/privateModules/privateModuleA.js deleted file mode 100644 index 757df3e..0000000 --- a/test/testModules/privateModules/privateModuleA.js +++ /dev/null @@ -1,10 +0,0 @@ -"use strict"; // run code in ES5 strict mode - -var myPrivateVar = "Hello I'm very private"; - -function myPrivateFunction() { - return "Hello I'm very private"; -} - -// privateModuleA and privateModuleB use different styles of exports -exports.bla = "somevalue"; \ No newline at end of file diff --git a/test/testModules/privateModules/privateModuleB.js b/test/testModules/privateModules/privateModuleB.js deleted file mode 100644 index c9e5bc7..0000000 --- a/test/testModules/privateModules/privateModuleB.js +++ /dev/null @@ -1,10 +0,0 @@ -"use strict"; // run code in ES5 strict mode - -var myPrivateVar = "Hello I'm very private"; - -function myPrivateFunction() { - return "Hello I'm very private"; -} - -// privateModuleA and privateModuleB use different styles of exports -module.exports = function bla() {}; \ No newline at end of file diff --git a/test/testModules/someOtherModule.js b/test/testModules/someOtherModule.js new file mode 100644 index 0000000..02287d1 --- /dev/null +++ b/test/testModules/someOtherModule.js @@ -0,0 +1,5 @@ +"use strict"; // run code in ES5 strict mode + +var fs = require("fs"); + +exports.fs = fs; \ No newline at end of file -- cgit v1.2.3