1  var path = require('path');
  2  var test = require('tape');
  3  var resolve = require('../');
  4  
  5  test('foo', function (t) {
  6      var dir = path.join(__dirname, 'resolver');
  7  
  8      t.equal(
  9          resolve.sync('./foo', { basedir: dir }),
 10          path.join(dir, 'foo.js')
 11      );
 12  
 13      t.equal(
 14          resolve.sync('./foo.js', { basedir: dir }),
 15          path.join(dir, 'foo.js')
 16      );
 17  
 18      t.equal(
 19          resolve.sync('./foo.js', { basedir: dir, filename: path.join(dir, 'bar.js') }),
 20          path.join(dir, 'foo.js')
 21      );
 22  
 23      t.throws(function () {
 24          resolve.sync('foo', { basedir: dir });
 25      });
 26  
 27      // Test that filename is reported as the "from" value when passed.
 28      t.throws(
 29          function () {
 30              resolve.sync('foo', { basedir: dir, filename: path.join(dir, 'bar.js') });
 31          },
 32          {
 33              name: 'Error',
 34              message: "Cannot find module 'foo' from '" + path.join(dir, 'bar.js') + "'"
 35          }
 36      );
 37  
 38      t.end();
 39  });
 40  
 41  test('bar', function (t) {
 42      var dir = path.join(__dirname, 'resolver');
 43  
 44      t.equal(
 45          resolve.sync('foo', { basedir: path.join(dir, 'bar') }),
 46          path.join(dir, 'bar/node_modules/foo/index.js')
 47      );
 48      t.end();
 49  });
 50  
 51  test('baz', function (t) {
 52      var dir = path.join(__dirname, 'resolver');
 53  
 54      t.equal(
 55          resolve.sync('./baz', { basedir: dir }),
 56          path.join(dir, 'baz/quux.js')
 57      );
 58      t.end();
 59  });
 60  
 61  test('biz', function (t) {
 62      var dir = path.join(__dirname, 'resolver/biz/node_modules');
 63      t.equal(
 64          resolve.sync('./grux', { basedir: dir }),
 65          path.join(dir, 'grux/index.js')
 66      );
 67  
 68      t.equal(
 69          resolve.sync('tiv', { basedir: path.join(dir, 'grux') }),
 70          path.join(dir, 'tiv/index.js')
 71      );
 72  
 73      t.equal(
 74          resolve.sync('grux', { basedir: path.join(dir, 'tiv') }),
 75          path.join(dir, 'grux/index.js')
 76      );
 77      t.end();
 78  });
 79  
 80  test('normalize', function (t) {
 81      var dir = path.join(__dirname, 'resolver/biz/node_modules/grux');
 82      t.equal(
 83          resolve.sync('../grux', { basedir: dir }),
 84          path.join(dir, 'index.js')
 85      );
 86      t.end();
 87  });
 88  
 89  test('cup', function (t) {
 90      var dir = path.join(__dirname, 'resolver');
 91      t.equal(
 92          resolve.sync('./cup', {
 93              basedir: dir,
 94              extensions: ['.js', '.coffee']
 95          }),
 96          path.join(dir, 'cup.coffee')
 97      );
 98  
 99      t.equal(
100          resolve.sync('./cup.coffee', { basedir: dir }),
101          path.join(dir, 'cup.coffee')
102      );
103  
104      t.throws(function () {
105          resolve.sync('./cup', {
106              basedir: dir,
107              extensions: ['.js']
108          });
109      });
110  
111      t.end();
112  });
113  
114  test('mug', function (t) {
115      var dir = path.join(__dirname, 'resolver');
116      t.equal(
117          resolve.sync('./mug', { basedir: dir }),
118          path.join(dir, 'mug.js')
119      );
120  
121      t.equal(
122          resolve.sync('./mug', {
123              basedir: dir,
124              extensions: ['.coffee', '.js']
125          }),
126          path.join(dir, 'mug.coffee')
127      );
128  
129      t.equal(
130          resolve.sync('./mug', {
131              basedir: dir,
132              extensions: ['.js', '.coffee']
133          }),
134          path.join(dir, 'mug.js')
135      );
136  
137      t.end();
138  });
139  
140  test('other path', function (t) {
141      var resolverDir = path.join(__dirname, 'resolver');
142      var dir = path.join(resolverDir, 'bar');
143      var otherDir = path.join(resolverDir, 'other_path');
144  
145      t.equal(
146          resolve.sync('root', {
147              basedir: dir,
148              paths: [otherDir]
149          }),
150          path.join(resolverDir, 'other_path/root.js')
151      );
152  
153      t.equal(
154          resolve.sync('lib/other-lib', {
155              basedir: dir,
156              paths: [otherDir]
157          }),
158          path.join(resolverDir, 'other_path/lib/other-lib.js')
159      );
160  
161      t.throws(function () {
162          resolve.sync('root', { basedir: dir });
163      });
164  
165      t.throws(function () {
166          resolve.sync('zzz', {
167              basedir: dir,
168              paths: [otherDir]
169          });
170      });
171  
172      t.end();
173  });
174  
175  test('path iterator', function (t) {
176      var resolverDir = path.join(__dirname, 'resolver');
177  
178      var exactIterator = function (x, start, getPackageCandidates, opts) {
179          return [path.join(resolverDir, x)];
180      };
181  
182      t.equal(
183          resolve.sync('baz', { packageIterator: exactIterator }),
184          path.join(resolverDir, 'baz/quux.js')
185      );
186  
187      t.end();
188  });
189  
190  test('incorrect main', function (t) {
191      var resolverDir = path.join(__dirname, 'resolver');
192      var dir = path.join(resolverDir, 'incorrect_main');
193  
194      t.equal(
195          resolve.sync('./incorrect_main', { basedir: resolverDir }),
196          path.join(dir, 'index.js')
197      );
198  
199      t.end();
200  });
201  
202  var stubStatSync = function stubStatSync(fn) {
203      var fs = require('fs');
204      var statSync = fs.statSync;
205      try {
206          fs.statSync = function () {
207              throw new EvalError('Unknown Error');
208          };
209          return fn();
210      } finally {
211          fs.statSync = statSync;
212      }
213  };
214  
215  test('#79 - re-throw non ENOENT errors from stat', function (t) {
216      var dir = path.join(__dirname, 'resolver');
217  
218      stubStatSync(function () {
219          t.throws(function () {
220              resolve.sync('foo', { basedir: dir });
221          }, /Unknown Error/);
222      });
223  
224      t.end();
225  });
226  
227  test('#52 - incorrectly resolves module-paths like "./someFolder/" when there is a file of the same name', function (t) {
228      var dir = path.join(__dirname, 'resolver');
229  
230      t.equal(
231          resolve.sync('./foo', { basedir: path.join(dir, 'same_names') }),
232          path.join(dir, 'same_names/foo.js')
233      );
234      t.equal(
235          resolve.sync('./foo/', { basedir: path.join(dir, 'same_names') }),
236          path.join(dir, 'same_names/foo/index.js')
237      );
238      t.end();
239  });
240  
241  test('#211 - incorrectly resolves module-paths like "." when from inside a folder with a sibling file of the same name', function (t) {
242      var dir = path.join(__dirname, 'resolver');
243  
244      t.equal(
245          resolve.sync('./', { basedir: path.join(dir, 'same_names/foo') }),
246          path.join(dir, 'same_names/foo/index.js')
247      );
248      t.equal(
249          resolve.sync('.', { basedir: path.join(dir, 'same_names/foo') }),
250          path.join(dir, 'same_names/foo/index.js')
251      );
252      t.end();
253  });
254  
255  test('sync: #121 - treating an existing file as a dir when no basedir', function (t) {
256      var testFile = path.basename(__filename);
257  
258      t.test('sanity check', function (st) {
259          st.equal(
260              resolve.sync('./' + testFile),
261              __filename,
262              'sanity check'
263          );
264          st.end();
265      });
266  
267      t.test('with a fake directory', function (st) {
268          function run() { return resolve.sync('./' + testFile + '/blah'); }
269  
270          st.throws(run, 'throws an error');
271  
272          try {
273              run();
274          } catch (e) {
275              st.equal(e.code, 'MODULE_NOT_FOUND', 'error code matches require.resolve');
276              st.equal(
277                  e.message,
278                  'Cannot find module \'./' + testFile + '/blah\' from \'' + __dirname + '\'',
279                  'can not find nonexistent module'
280              );
281          }
282  
283          st.end();
284      });
285  
286      t.end();
287  });
288  
289  test('sync dot main', function (t) {
290      var start = new Date();
291      t.equal(resolve.sync('./resolver/dot_main'), path.join(__dirname, 'resolver/dot_main/index.js'));
292      t.ok(new Date() - start < 50, 'resolve.sync timedout');
293      t.end();
294  });
295  
296  test('sync dot slash main', function (t) {
297      var start = new Date();
298      t.equal(resolve.sync('./resolver/dot_slash_main'), path.join(__dirname, 'resolver/dot_slash_main/index.js'));
299      t.ok(new Date() - start < 50, 'resolve.sync timedout');
300      t.end();
301  });
302  
303  test('not a directory', function (t) {
304      var path = './foo';
305      try {
306          resolve.sync(path, { basedir: __filename });
307          t.fail();
308      } catch (err) {
309          t.ok(err, 'a non-directory errors');
310          t.equal(err && err.message, 'Cannot find module \'' + path + "' from '" + __filename + "'");
311          t.equal(err && err.code, 'MODULE_NOT_FOUND');
312      }
313      t.end();
314  });
315  
316  test('non-string "main" field in package.json', function (t) {
317      var dir = path.join(__dirname, 'resolver');
318      try {
319          var result = resolve.sync('./invalid_main', { basedir: dir });
320          t.equal(result, undefined, 'result should not exist');
321          t.fail('should not get here');
322      } catch (err) {
323          t.ok(err, 'errors on non-string main');
324          t.equal(err.message, 'package “invalid main” `main` must be a string');
325          t.equal(err.code, 'INVALID_PACKAGE_MAIN');
326      }
327      t.end();
328  });
329  
330  test('non-string "main" field in package.json', function (t) {
331      var dir = path.join(__dirname, 'resolver');
332      try {
333          var result = resolve.sync('./invalid_main', { basedir: dir });
334          t.equal(result, undefined, 'result should not exist');
335          t.fail('should not get here');
336      } catch (err) {
337          t.ok(err, 'errors on non-string main');
338          t.equal(err.message, 'package “invalid main” `main` must be a string');
339          t.equal(err.code, 'INVALID_PACKAGE_MAIN');
340      }
341      t.end();
342  });
343  
344  test('browser field in package.json', function (t) {
345      var dir = path.join(__dirname, 'resolver');
346      var res = resolve.sync('./browser_field', {
347          basedir: dir,
348          packageFilter: function packageFilter(pkg) {
349              if (pkg.browser) {
350                  pkg.main = pkg.browser; // eslint-disable-line no-param-reassign
351                  delete pkg.browser; // eslint-disable-line no-param-reassign
352              }
353              return pkg;
354          }
355      });
356      t.equal(res, path.join(dir, 'browser_field', 'b.js'));
357      t.end();
358  });