Fixed shell-require test

js/common/test-data/modules/node_modules/TestD/lib/index.js

@@ -2,4 +2,3 @@ exports.version = "D 1.0.0";
 exports.fs = require("fs");
 exports.y = require("./y");
 exports.z = require("../common/z");
-exports.z2 = require("common/z");

js/common/tests/shell-require.js

@@ -28,26 +28,28 @@
 /// @author Copyright 2012, triAGENS GmbH, Cologne, Germany
 ////////////////////////////////////////////////////////////////////////////////
 
-var jsunity = require("jsunity");
+var jsunity = require('jsunity');
+var Module = require('module');
+var path = require('path');
 
 // -----------------------------------------------------------------------------
 // --SECTION--                                                        test suite
 // -----------------------------------------------------------------------------
 
 ////////////////////////////////////////////////////////////////////////////////
-/// @brief test suite for "require"
+/// @brief test suite for 'require'
 ////////////////////////////////////////////////////////////////////////////////
 
 function RequireTestSuite () {
   'use strict';
-  var console = require("console");
+  var console = require('console');
   function createTestPackage () {
-    var test = module.createTestEnvironment("./js/common/test-data/modules");
+    var test = new Module(Module.globalPaths[0] + '/.test');
 
-    test.exports.print = require("internal").print;
+    test.exports.print = require('internal').print;
 
     test.exports.assert = function (guard, message) {
-      console.log("running test %s", message);
+      console.log('running test %s', message);
       assertEqual(guard !== false, true);
     };
 
@@ -56,76 +58,82 @@ function RequireTestSuite () {
 
   return {
 
+    setUp() {
+      Module.globalPaths.unshift(path.resolve('./js/common/test-data/modules'));
+      Module.globalPaths.unshift(path.resolve(Module.globalPaths[0], 'node_modules'));
+    },
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief tear down
 ////////////////////////////////////////////////////////////////////////////////
 
-    tearDown : function () {
+    tearDown() {
+      Module.globalPaths.splice(0, 2);
     },
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief test requiring JSON
 ////////////////////////////////////////////////////////////////////////////////
 
-    testRequireJson : function () {
+    testRequireJson() {
       var test = createTestPackage();
-      var data = test.require("test-data");
+      var data = test.require('./test-data');
 
-      assertTrue(data.hasOwnProperty("tags"));
+      assertTrue(data.hasOwnProperty('tags'));
-      assertEqual([ "foo", "bar", "baz" ], data.tags);
+      assertEqual(['foo', 'bar', 'baz'], data.tags);
 
-      assertTrue(data.hasOwnProperty("author"));
+      assertTrue(data.hasOwnProperty('author'));
-      assertEqual({ "first" : "foo", "last" : "bar" }, data.author);
+      assertEqual({'first': 'foo', 'last': 'bar'}, data.author);
 
-      assertTrue(data.hasOwnProperty("number"));
+      assertTrue(data.hasOwnProperty('number'));
       assertEqual(42, data.number);
 
-      assertTrue(data.hasOwnProperty("sensible"));
+      assertTrue(data.hasOwnProperty('sensible'));
       assertFalse(data.sensible);
 
-      assertTrue(data.hasOwnProperty("nullValue"));
+      assertTrue(data.hasOwnProperty('nullValue'));
       assertNull(data.nullValue);
 
-      assertFalse(data.hasOwnProperty("schabernack"));
+      assertFalse(data.hasOwnProperty('schabernack'));
     },
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief test coffee script execution
 ////////////////////////////////////////////////////////////////////////////////
 
-    testRequireCoffeeScript : function () {
+    testRequireCoffeeScript() {
       var test = createTestPackage();
-      var script = test.require("coffee-test");
+      var script = test.require('./coffee-test');
 
-      assertTrue(script.hasOwnProperty("coffeeSquare"));
+      assertTrue(script.hasOwnProperty('coffeeSquare'));
-      assertEqual("function", typeof script.coffeeSquare);
+      assertEqual('function', typeof script.coffeeSquare);
       assertEqual(49, script.coffeeSquare(7));
 
-      assertTrue(script.hasOwnProperty("coffeeValue"));
+      assertTrue(script.hasOwnProperty('coffeeValue'));
-      assertEqual("string", typeof script.coffeeValue);
+      assertEqual('string', typeof script.coffeeValue);
-      assertEqual("test", script.coffeeValue);
+      assertEqual('test', script.coffeeValue);
     },
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief test package loading
 ////////////////////////////////////////////////////////////////////////////////
 
-    testPackage : function () {
+    testPackage() {
       var test = createTestPackage();
-      var m = test.require("TestA");
+      var m = test.require('./TestA');
 
-      assertEqual(m.version, "A 1.0.0");
+      assertEqual(m.version, 'A 1.0.0');
-      assertEqual(m.x.version, "x 1.0.0");
+      assertEqual(m.x.version, 'x 1.0.0');
-      assertEqual(m.B.version, "B 2.0.0");
+      assertEqual(m.B.version, 'B 2.0.0');
-      assertEqual(m.C.version, "C 1.0.0");
+      assertEqual(m.C.version, 'C 1.0.0');
-      assertEqual(m.C.B.version, "B 2.0.0");
+      assertEqual(m.C.B.version, 'B 2.0.0');
-      assertEqual(m.D.version, "D 1.0.0");
+      assertEqual(m.D.version, 'D 1.0.0');
 
       assertEqual(m.B, m.C.B);
 
-      var n = test.require("TestB");
+      var n = test.require('./TestB');
 
-      assertEqual(n.version, "B 1.0.0");
+      assertEqual(n.version, 'B 1.0.0');
       assertNotEqual(n, m.B);
     }
 
@@ -137,63 +145,71 @@ function RequireTestSuite () {
 // -----------------------------------------------------------------------------
 
 ////////////////////////////////////////////////////////////////////////////////
-/// @brief test suite for "commonjs"
+/// @brief test suite for 'commonjs'
 ////////////////////////////////////////////////////////////////////////////////
 
 function CommonJSTestSuite () {
   'use strict';
-  var fs = require("fs");
+  var console = require('console');
-  var console = require("console");
+  var basePath = path.resolve('./js/common/test-data/modules/commonjs/tests/modules/1.0/');
 
   function createTestPackage (testPath) {
-    var lib = "./" + fs.join(
-      "./js/common/test-data/modules/commonjs/tests/modules/1.0/",
-      testPath);
 
-    console.log(lib);
+    var lib = path.resolve(basePath, testPath, '.fake');
 
-    var test = module.createTestEnvironment(lib);
+    var test = new Module(lib);
 
-    test.exports.print = require("internal").print;
+    test.exports.print = require('internal').print;
 
     test.exports.assert = function (guard, message) {
-      console.log("running test %s", message);
+      console.log('running test %s', message);
       assertEqual(guard !== false, true);
     };
 
     return test;
   }
 
-  return {
+  var tests = {
+
+    setUp() {
+      Module.globalPaths.unshift('.');
+    },
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief tear down
 ////////////////////////////////////////////////////////////////////////////////
 
-    tearDown : function () {
+    tearDown() {
-    },
+      Module.globalPaths.shift();
+    }
+
+  };
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief test module loading
 ////////////////////////////////////////////////////////////////////////////////
 
-    testRequireCommonJS : function () {
+  [
-      var i;
+    'absolute',
-      var tests = [
+    'cyclic',
-        "absolute", "cyclic", "determinism", "exactExports", "hasOwnProperty",
+    'determinism',
-        "method", "missing", "monkeys", "nested", "relative", "transitive" ];
+    'exactExports',
-
+    'hasOwnProperty',
-      for (i = 0;  i < tests.length;  i++) {
+    'method',
-        var name = tests[i];
+    'missing',
-
+    'monkeys',
-        console.log("running CommonJS test '%s'", name);
+    'nested',
-
+    'relative',
+    'transitive'
+  ].forEach(function (name) {
+    tests[`testCommonJS${name.charAt(0).toUpperCase()}${name.slice(1)}`] = function () {
+      Module.globalPaths[0] = path.resolve(basePath, name);
       var test = createTestPackage(name);
-        test.require("program");
+      test.require('./program');
-      }
-    }
-
     };
+  });
+
+  return tests;
 }
 
 // -----------------------------------------------------------------------------