Update dependencies (#243)

Notably updates resolve, improving perf

README.md

@@ -44,16 +44,16 @@ var proxyquire =  require('proxyquire')
 
 // when no overrides are specified, path.extname behaves normally
 var foo = proxyquire('./foo', { 'path': pathStub });
-assert.equal(foo.extnameAllCaps('file.txt'), '.TXT');
+assert.strictEqual(foo.extnameAllCaps('file.txt'), '.TXT');
 
 // override path.extname
 pathStub.extname = function (file) { return 'Exterminate, exterminate the ' + file; };
 
 // path.extname now behaves as we told it to
-assert.equal(foo.extnameAllCaps('file.txt'), 'EXTERMINATE, EXTERMINATE THE FILE.TXT');
+assert.strictEqual(foo.extnameAllCaps('file.txt'), 'EXTERMINATE, EXTERMINATE THE FILE.TXT');
 
 // path.basename and all other path module methods still function as before
-assert.equal(foo.basenameAllCaps('/a/b/file.txt'), 'FILE.TXT');
+assert.strictEqual(foo.basenameAllCaps('/a/b/file.txt'), 'FILE.TXT');
 ```
 
 You can also replace functions directly:
@@ -248,8 +248,8 @@ var foo2 = proxyquire('./foo', stubs);
 var foo3 = require('./foo');
 
 // foo1, foo2 and foo3 are different instances of the same module
-assert.notEqual(foo1, foo2);
-assert.notEqual(foo1, foo3);
+assert.notStrictEqual(foo1, foo2);
+assert.notStrictEqual(foo1, foo3);
 ```
 
 `proxyquire.preserveCache` allows you to restore the behavior to match nodejs's `require` again.
@@ -262,8 +262,8 @@ var foo2 = proxyquire('./foo', stubs);
 var foo3 = require('./foo');
 
 // foo1, foo2 and foo3 are the same instance
-assert.equal(foo1, foo2);
-assert.equal(foo1, foo3);
+assert.strictEqual(foo1, foo2);
+assert.strictEqual(foo1, foo3);
 ```
 
 

examples/api/api-test.js

@@ -14,34 +14,34 @@ foo = proxyquire('./samples/foo', { })
 fooCut = proxyquire('./samples/foo', { './bar': cutBarStub })
 fooWild = proxyquire('./samples/foo', { './bar': wildBarStub })
 
-assert.equal(stats.fooRequires(), 3)
+assert.strictEqual(stats.fooRequires(), 3)
 
-assert.equal(foo.bigBar(), 'BAR')
-assert.equal(fooCut.bigBar(), 'BARBER')
-assert.equal(fooWild.bigBar(), 'BARBAR')
+assert.strictEqual(foo.bigBar(), 'BAR')
+assert.strictEqual(fooCut.bigBar(), 'BARBER')
+assert.strictEqual(fooWild.bigBar(), 'BARBAR')
 
 // non overriden keys call thru by default
-assert.equal(foo.bigRab(), 'RAB')
-assert.equal(fooCut.bigRab(), 'RAB')
+assert.strictEqual(foo.bigRab(), 'RAB')
+assert.strictEqual(fooCut.bigRab(), 'RAB')
 
 // non overridden module path untouched
-assert.equal(foo.bigExt(file), '.EXT')
-assert.equal(fooCut.bigExt(file), '.EXT')
-assert.equal(fooWild.bigExt(file), '.EXT')
-assert.equal(foo.bigBas(file), 'TEST.EXT')
-assert.equal(fooCut.bigBas(file), 'TEST.EXT')
-assert.equal(fooWild.bigBas(file), 'TEST.EXT')
+assert.strictEqual(foo.bigExt(file), '.EXT')
+assert.strictEqual(fooCut.bigExt(file), '.EXT')
+assert.strictEqual(fooWild.bigExt(file), '.EXT')
+assert.strictEqual(foo.bigBas(file), 'TEST.EXT')
+assert.strictEqual(fooCut.bigBas(file), 'TEST.EXT')
+assert.strictEqual(fooWild.bigBas(file), 'TEST.EXT')
 
 // overriding keys after require works for both inline and non inline requires
 cutBarStub.bar = function () { return 'friseur' }
 cutBarStub.rab = function () { return 'rabarber' }
 
-assert.equal(fooCut.bigBar(), 'FRISEUR')
-assert.equal(fooCut.bigRab(), 'RABARBER')
+assert.strictEqual(fooCut.bigBar(), 'FRISEUR')
+assert.strictEqual(fooCut.bigRab(), 'RABARBER')
 
 // autofilling keys on delete only works for inline requires
 cutBarStub.bar = undefined
-assert.equal(fooCut.bigBar(), 'BAR')
+assert.strictEqual(fooCut.bigBar(), 'BAR')
 
 cutBarStub.rab = undefined
 assert.throws(fooCut.bigRab)
@@ -54,8 +54,8 @@ foo = proxyquire('./samples/foo', {
   }
 })
 
-assert.equal(foo.bigExt(file), 'EXTERMINATE, EXTERMINATE THE /SOME/PATH/TEST.EXT')
-assert.equal(foo.bigBas(file), 'TEST.EXT')
+assert.strictEqual(foo.bigExt(file), 'EXTERMINATE, EXTERMINATE THE /SOME/PATH/TEST.EXT')
+assert.strictEqual(foo.bigBas(file), 'TEST.EXT')
 
 // turned off
 foo = proxyquire('./samples/foo', {
@@ -65,7 +65,7 @@ foo = proxyquire('./samples/foo', {
   }
 })
 
-assert.equal(foo.bigExt(file), 'EXTERMINATE, EXTERMINATE THE /SOME/PATH/TEST.EXT')
+assert.strictEqual(foo.bigExt(file), 'EXTERMINATE, EXTERMINATE THE /SOME/PATH/TEST.EXT')
 assert.throws(foo.bigBas)
 
 // turned off globally
@@ -92,7 +92,7 @@ foo = proxyquire
     }
   })
 
-assert.equal(foo.bigBas(file), 'TEST.EXT')
+assert.strictEqual(foo.bigBas(file), 'TEST.EXT')
 
 // turned back on globally
 
@@ -104,7 +104,7 @@ foo = proxyquire
     }
   })
 
-assert.equal(foo.bigBas(file), 'TEST.EXT')
+assert.strictEqual(foo.bigBas(file), 'TEST.EXT')
 
 // turned back off per module
 

examples/async/foo-tests.js

@@ -18,13 +18,13 @@ var foo = proxyquire('./foo', { fs: fsStub })
 /*
 * Test caps locking of returned files
 */
-fsStub.readdir = function (dir, cb) { cb(null, [ 'file1', 'file2' ]) }
+fsStub.readdir = function (dir, cb) { cb(null, ['file1', 'file2']) }
 
 calledBack = false
 foo.filesAllCaps('./somedir', function (err, files) {
-  assert.equal(err, null)
-  assert.equal(files[0], 'FILE1')
-  assert.equal(files[1], 'FILE2')
+  assert.strictEqual(err, null)
+  assert.strictEqual(files[0], 'FILE1')
+  assert.strictEqual(files[1], 'FILE2')
 
   calledBack = true
 })
@@ -38,7 +38,7 @@ assert(calledBack)
 fsStub.readdir = function (dir, cb) { cb(readdirError) }
 
 foo.filesAllCaps('./somedir', function (err, files) {
-  assert.equal(err, readdirError)
+  assert.strictEqual(err, readdirError)
 })
 
 console.log('*** All asserts passed ***')

examples/simple/foo.inlineoverride.test.js

@@ -10,17 +10,17 @@ var foo
 
 // no overrides yet, so path.extname behaves normally
 foo = proxyquire('./foo', {})
-assert.equal(foo.extnameAllCaps('file.txt'), '.TXT')
+assert.strictEqual(foo.extnameAllCaps('file.txt'), '.TXT')
 
 // override path.extname
 foo = proxyquire('./foo', {
   path: { extname: function (file) { return 'Exterminate, exterminate the ' + file } }
 })
 
 // path.extname now behaves as we told it to
-assert.equal(foo.extnameAllCaps('file.txt'), 'EXTERMINATE, EXTERMINATE THE FILE.TXT')
+assert.strictEqual(foo.extnameAllCaps('file.txt'), 'EXTERMINATE, EXTERMINATE THE FILE.TXT')
 
 // path.basename on the other hand still functions as before
-assert.equal(foo.basenameAllCaps('/a/b/file.txt'), 'FILE.TXT')
+assert.strictEqual(foo.basenameAllCaps('/a/b/file.txt'), 'FILE.TXT')
 
 console.log('*** All asserts passed ***')

examples/simple/foo.test.js

@@ -9,16 +9,16 @@ var assert = require('assert')
 var pathStub = { }
 
 // when not overridden, path.extname behaves normally
-var foo = proxyquire('./foo', { 'path': pathStub })
-assert.equal(foo.extnameAllCaps('file.txt'), '.TXT')
+var foo = proxyquire('./foo', { path: pathStub })
+assert.strictEqual(foo.extnameAllCaps('file.txt'), '.TXT')
 
 // override path.extname
 pathStub.extname = function (file) { return 'Exterminate, exterminate the ' + file }
 
 // path.extname now behaves as we told it to
-assert.equal(foo.extnameAllCaps('file.txt'), 'EXTERMINATE, EXTERMINATE THE FILE.TXT')
+assert.strictEqual(foo.extnameAllCaps('file.txt'), 'EXTERMINATE, EXTERMINATE THE FILE.TXT')
 
 // path.basename and all other path module methods still function as before
-assert.equal(foo.basenameAllCaps('/a/b/file.txt'), 'FILE.TXT')
+assert.strictEqual(foo.basenameAllCaps('/a/b/file.txt'), 'FILE.TXT')
 
 console.log('*** All asserts passed ***')

examples/sinon/foo-tests.js

@@ -30,7 +30,7 @@ describe('when path.extname(file) returns ".markdown"', function () {
   })
 
   it('extnameAllCaps returns ".MARKDOWN"', function () {
-    assert.equal(foo.extnameAllCaps(file), '.MARKDOWN')
+    assert.strictEqual(foo.extnameAllCaps(file), '.MARKDOWN')
   })
 })
 
@@ -42,7 +42,7 @@ describe('when fs.readdir calls back with ["file1", "file2"]', function () {
     readdirStub = sinon.stub(fs, 'readdir')
     foo = proxyquire('./foo', { fs: { readdir: readdirStub } })
 
-    readdirStub.withArgs('../simple').yields(null, [ 'file1', 'file2' ])
+    readdirStub.withArgs('../simple').yields(null, ['file1', 'file2'])
   })
 
   after(function () {
@@ -51,9 +51,9 @@ describe('when fs.readdir calls back with ["file1", "file2"]', function () {
 
   it('filesAllCaps calls back with ["FILE1", "FILE2"]', function (done) {
     foo.filesAllCaps('../simple', function (err, files) {
-      assert.equal(err, null)
-      assert.equal(files[0], 'FILE1')
-      assert.equal(files[1], 'FILE2')
+      assert.strictEqual(err, null)
+      assert.strictEqual(files[0], 'FILE1')
+      assert.strictEqual(files[1], 'FILE2')
       done()
     })
   })
@@ -77,8 +77,8 @@ describe('when fs.readdir returns an error', function () {
 
   it('filesAllCaps calls back with that error', function (done) {
     foo.filesAllCaps('../simple', function (err, files) {
-      assert.equal(err, readdirError)
-      assert.equal(files, null)
+      assert.strictEqual(err, readdirError)
+      assert.strictEqual(files, null)
       done()
     })
   })
@@ -101,7 +101,7 @@ describe('when calling filesAllCaps with "../simple"', function () {
     foo.filesAllCaps('../simple', function (err, files) {
       assert.ifError(err)
       assert(fs.readdir.calledOnce)
-      assert.equal(fs.readdir.getCall(0).args[0], '../simple')
+      assert.strictEqual(fs.readdir.getCall(0).args[0], '../simple')
       done()
     })
   })

package.json

@@ -26,14 +26,14 @@
   "devDependencies": {
     "mocha": "^5.2.0",
     "native-hello-world": "^1.0.0",
-    "should": "~13.2",
-    "sinon": "~6.1",
-    "standard": "^11.0.0"
+    "should": "^13.2.3",
+    "sinon": "^7.3.2",
+    "standard": "^13.0.1"
   },
   "dependencies": {
     "fill-keys": "^1.0.2",
-    "module-not-found-error": "^1.0.0",
-    "resolve": "~1.8.1"
+    "module-not-found-error": "^1.0.1",
+    "resolve": "^1.11.1"
   },
   "standard": {
     "env": [

test/proxyquire-api.js

@@ -17,21 +17,21 @@ describe('api', function () {
     it('proxyquire can load', function () {
       var proxiedFoo = proxyquire.load('./samples/foo', stubs)
 
-      assert.equal(typeof proxiedFoo, 'object')
+      assert.strictEqual(typeof proxiedFoo, 'object')
       assert.notStrictEqual(realFoo, proxiedFoo)
     })
 
     it('proxyquire can callThru and then load', function () {
       var proxiedFoo = proxyquire.callThru().load('./samples/foo', stubs)
 
-      assert.equal(typeof proxiedFoo, 'object')
+      assert.strictEqual(typeof proxiedFoo, 'object')
       assert.notStrictEqual(realFoo, proxiedFoo)
     })
 
     it('proxyquire can noCallThru and then load', function () {
       var proxiedFoo = proxyquire.noCallThru().load('./samples/foo', stubs)
 
-      assert.equal(typeof proxiedFoo, 'object')
+      assert.strictEqual(typeof proxiedFoo, 'object')
       assert.notStrictEqual(realFoo, proxiedFoo)
     })
   })