Initial import from local backup (Documents-Playground/pakerpale)

node_modules/mockery/test/1-general.js

@@ -0,0 +1,41 @@
+/*
+This file named 1-general.js for a reason, it is so this
+test is executed first so we can catch the "warmup" of the
+module and test the dead code cases.
+*/
+var vows = require('vows'),
+    assert = require('assert'),
+    m = require('module'),
+    mockery = require('../mockery');
+
+var tests = {
+    'disable before enable': {
+        topic: function() {
+            mockery.disable();
+            return null;
+        },
+        'should not throw and this passes': function() {
+            assert.ok(true);
+        },
+        'and without a module loader': {
+            topic: function() {
+                m.__load = m._load;
+                m._load = null;
+                return m;
+            },
+            'should throw on enable': function(m) {
+                assert.throws(function() {
+                    mockery.enable();
+                    mockery.registerMock('fs', {});
+                    require('fs');
+                }, /Loader has not been hooked/);
+            },
+            teardown: function() {
+                m._load = m.__load;
+                delete m.__load;
+            }
+        }
+    }
+};
+
+vows.describe('mockery').addBatch(tests).export(module);

node_modules/mockery/test/allowable-unhook.js

@@ -0,0 +1,71 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery'),
+    sinon = require('sinon'),
+    m = require('module');
+
+function isCached(name) {
+    var id;
+    // Super-simplistic, but good enough for the tests
+    for (id in m._cache) {
+        if (m._cache.hasOwnProperty(id) && id.indexOf(name) !== -1) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+var tests = {
+    "when an allowable is registered for unhooking": {
+        topic: function () {
+            mockery.registerAllowable('./fixtures/fake_module', true);
+            return null;
+        },
+        "and mockery is enabled": {
+            setup: function () {
+                if (!this.originalCache) {
+                    // Initialise a clean cache
+                    this.originalCache = m._cache;
+                    m._cache = {};
+                }
+                mockery.enable();
+            },
+            teardown: function () {
+                if (this.originalCache) {
+                    // Restore the original cache
+                    m._cache = this.originalCache;
+                    this.originalCache = null;
+                }
+            },
+            "the module is not cached": function () {
+                assert.ok(!isCached('fixtures/fake_module'));
+            },
+
+            "and the module is required": {
+                topic: function () {
+                    require('./fixtures/fake_module');
+                    return null;
+                },
+
+                "the module is cached": function () {
+                    assert.ok(isCached('fixtures/fake_module'));
+                },
+
+                "and the module is deregistered": {
+                    topic: function () {
+                        mockery.deregisterAllowable('not-allowed-already');
+                        mockery.deregisterAllowable('./fixtures/fake_module');
+                        return null;
+                    },
+
+                    "the module is not cached": function () {
+                        assert.ok(!isCached('fixtures/fake_module'));
+                    }
+                }
+            }
+        }
+    }
+};
+
+vows.describe('allowable-unhook').addBatch(tests).export(module);

node_modules/mockery/test/fixtures/fake_module.js

@@ -0,0 +1,5 @@
+var foo = function() {
+    return 'real foo';
+};
+
+exports.foo = foo;

node_modules/mockery/test/fixtures/fake_module_2.js

@@ -0,0 +1,5 @@
+var bar = function() {
+    return 'real bar';
+};
+
+exports.bar = bar;

node_modules/mockery/test/fixtures/intermediary.js

@@ -0,0 +1,7 @@
+var fake_module = require('./fake_module');
+
+var bar = function () {
+    return fake_module.foo();
+};
+
+exports.bar = bar;

node_modules/mockery/test/fixtures/substitute_fake_module.js

@@ -0,0 +1,5 @@
+var foo = function() {
+    return 'substitute foo';
+};
+
+exports.foo = foo;

node_modules/mockery/test/intermediary.js

@@ -0,0 +1,61 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery'),
+    sinon = require('sinon');
+
+var mock_fake_module = {
+    foo: function () {
+        return 'mocked foo';
+    }
+};
+
+var tests = {
+    "when an intermediary module is involved": {
+        topic: function() {
+            return null;
+        },
+        "and mockery is not enabled requiring the intermediary causes the original to be used": function () {
+            var intermediary = require('./fixtures/intermediary');
+            assert.equal(intermediary.bar(), 'real foo');
+        },
+        "and mockery is enabled without the clean cache option": {
+            topic: function () {
+                mockery.registerMock('./fake_module', mock_fake_module);
+                mockery.registerAllowable('./fixtures/intermediary');
+                mockery.enable({ useCleanCache: false });
+                var i = require('./fixtures/intermediary');
+                mockery.resetCache();
+                mockery.disable();
+                return i;
+            },
+            "requiring the intermediary causes the original to be used": function (intermediary) {
+                assert.equal(intermediary.bar(), 'real foo');
+            },
+            "then mockery is enabled with the clean cache option": {
+                topic: function () {
+                    mockery.registerMock('./fake_module', mock_fake_module);
+                    mockery.registerAllowable('./fixtures/intermediary');
+                    mockery.enable({ useCleanCache: true });
+                    var i = require('./fixtures/intermediary');
+                    mockery.resetCache();
+                    return i;
+                },
+                "requiring the intermediary causes the mock to be used": function (intermediary) {
+                    assert.equal(intermediary.bar(), 'mocked foo');
+                },
+                "then mockery is disabled": {
+                    topic: function() {
+                        mockery.disable();
+                        return require('./fixtures/intermediary');
+                    },
+                    "requiring the intermediary causes the original to be used": function (intermediary) {
+                        assert.equal(intermediary.bar(), 'real foo');
+                    }
+                }
+            }
+        }
+    }
+};
+
+vows.describe('intermediary').addBatch(tests).export(module);
+

node_modules/mockery/test/logging-allow-array.js

@@ -0,0 +1,61 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery'),
+    sinon = require('sinon');
+
+var tests = {
+    "when an array of allowables is registered": {
+        setup: function () {
+            mockery.registerAllowables(
+                ['./fixtures/fake_module', './fixtures/fake_module_2']
+            );
+        },
+        "and mockery is enabled": {
+            topic: function () {
+                mockery.enable();
+                return null;
+            },
+            "requiring the modules causes no warning to be logged": function () {
+                var mock_console, fake_module, fake_module_2;
+
+                mock_console = sinon.mock(console);
+                mock_console.expects('warn').never();
+
+                fake_module = require('./fixtures/fake_module');
+                assert.equal(fake_module.foo(), 'real foo');
+
+                fake_module_2 = require('./fixtures/fake_module_2');
+                assert.equal(fake_module_2.bar(), 'real bar');
+
+                mock_console.verify();
+                mock_console.restore();
+            },
+            "and the allowables are deregistered": {
+                topic: function () {
+                    mockery.deregisterAllowables(
+                        ['./fixtures/fake_module', './fixtures/fake_module_2']
+                    );
+                    return null;
+                },
+                "requiring the modules causes warnings to be logged": function () {
+                    var mock_console, fake_module, fake_module_2;
+
+                    mock_console = sinon.mock(console);
+                    mock_console.expects('warn').twice();
+
+                    fake_module = require('./fixtures/fake_module');
+                    assert.equal(fake_module.foo(), 'real foo');
+
+                    fake_module_2 = require('./fixtures/fake_module_2');
+                    assert.equal(fake_module_2.bar(), 'real bar');
+
+                    mock_console.verify();
+                    mock_console.restore();
+                }
+            }
+        }
+    }
+};
+
+vows.describe('logging-allowable-array').addBatch(tests).export(module);
+

node_modules/mockery/test/logging-allowable.js

@@ -0,0 +1,52 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery'),
+    sinon = require('sinon');
+
+var tests = {
+    "when an allowable is registered": {
+        setup: function () {
+            mockery.registerAllowable('./fixtures/fake_module');
+        },
+
+        "and mockery is enabled": {
+            topic: function () {
+                mockery.enable();
+                return null;
+            },
+
+            "requiring the module causes no warning to be logged": function () {
+                var mock_console, fake_module;
+
+                mock_console = sinon.mock(console);
+                mock_console.expects('warn').never();
+
+                fake_module = require('./fixtures/fake_module');
+                assert.equal(fake_module.foo(), 'real foo');
+
+                mock_console.verify();
+                mock_console.restore();
+            },
+            "and the allowable is deregistered": {
+                topic: function () {
+                    mockery.deregisterAllowable('./fixtures/fake_module');
+                    return null;
+                },
+                "requiring the module causes a warning to be logged": function () {
+                    var mock_console, fake_module;
+
+                    mock_console = sinon.mock(console);
+                    mock_console.expects('warn').once();
+
+                    fake_module = require('./fixtures/fake_module');
+                    assert.equal(fake_module.foo(), 'real foo');
+
+                    mock_console.verify();
+                    mock_console.restore();
+                }
+            }
+        }
+    }
+};
+
+vows.describe('logging-allowable').addBatch(tests).export(module);

node_modules/mockery/test/logging.js

@@ -0,0 +1,71 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery'),
+    sinon = require('sinon');
+
+var tests = {
+    teardown: function () {
+        mockery.disable();
+        mockery.deregisterAll();
+    },
+    "when nothing is registered": {
+        topic: function () {
+            mockery.enable();
+            mockery.registerAllowable('../package.json', true);
+            require('../package.json');
+            return null;
+        },
+        "requiring a module causes a warning to be logged": function () {
+            var mock_console, fake_module;
+
+            mock_console = sinon.mock(console);
+            mock_console.expects('warn').once();
+
+            fake_module = require('./fixtures/fake_module');
+            assert.equal(fake_module.foo(), 'real foo');
+
+            mock_console.verify();
+            mock_console.restore();
+        },
+        "and warnings are disabled": {
+            topic: function () {
+                mockery.warnOnUnregistered(false);
+                return null;
+            },
+
+            "requiring a module causes no warning to be logged": function (test) {
+                var mock_console, fake_module;
+
+                mock_console = sinon.mock(console);
+                mock_console.expects('warn').never();
+
+                fake_module = require('./fixtures/fake_module');
+                assert.equal(fake_module.foo(), 'real foo');
+
+                mock_console.verify();
+                mock_console.restore();
+            },
+            "and warnings are reenabled": {
+                topic: function (callback) {
+                    mockery.warnOnUnregistered(true);
+                    return null;
+                },
+
+                "requiring a module causes a warning to be logged": function () {
+                    var mock_console, fake_module;
+
+                    mock_console = sinon.mock(console);
+                    mock_console.expects('warn').once();
+
+                    fake_module = require('./fixtures/fake_module');
+                    assert.equal(fake_module.foo(), 'real foo');
+
+                    mock_console.verify();
+                    mock_console.restore();
+                }
+            }
+        }
+    }
+};
+
+vows.describe('logging').addBatch(tests).export(module);

node_modules/mockery/test/registered.js

@@ -0,0 +1,39 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery'),
+    sinon = require('sinon');
+
+var mock_fake_module = {
+    foo: function () {
+        return 'mocked foo';
+    }
+};
+
+
+var tests = {
+    "when a mock is registered": {
+        topic: function () {
+            mockery.registerMock('./fixtures/fake_module', mock_fake_module);
+            mockery.enable();
+            return null;
+        },
+        "requiring the module returns the mock instead": function () {
+            var fake_module = require('./fixtures/fake_module');
+            assert.equal(fake_module.foo(), 'mocked foo');
+        },
+        "requiring the module returns the original module": function () {
+            mockery.deregisterMock('not-a-mock', mock_fake_module);
+            mockery.deregisterMock('./fixtures/fake_module', mock_fake_module);
+            mockery.registerAllowable('./fixtures/fake_module');
+            var fake_module = require('./fixtures/fake_module');
+            assert.equal(fake_module.foo(), 'real foo');
+        },
+        "and mockery is then disabled requiring the module returns the original module": function () {
+            mockery.disable();
+            var fake_module = require('./fixtures/fake_module');
+            assert.equal(fake_module.foo(), 'real foo');
+        }
+    }
+};
+
+vows.describe('registered').addBatch(tests).export(module);

node_modules/mockery/test/self-register.js

@@ -0,0 +1,36 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery');
+ 
+var registerBin = function () {
+    var error = 0;
+    mockery.enable({
+        warnOnUnregistered: false,
+        useCleanCache: true
+    });
+    try {
+        require('unix-dgram'); //or some other binary module
+    } catch (err) {
+        error = 1;
+    }
+    mockery.deregisterAll();
+    mockery.disable();
+    return error;
+};
+
+var tests = {
+    "register bin": {
+        topic: function () {
+            var errors = 0;
+            for (var i = 0; i < 10; i++) {
+                errors += registerBin();
+            }
+            return errors;
+        },
+        "should be able to register a bin module multiple times": function(topic) {
+            assert.equal(topic, 0);
+        }
+    }
+};
+
+vows.describe('module-failed-to-self-register').addBatch(tests).export(module);

node_modules/mockery/test/substitute.js

@@ -0,0 +1,96 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery'),
+    sinon = require('sinon');
+
+var mock_fake_module = {
+    foo: function () {
+        return 'mocked foo';
+    }
+};
+
+var tests = {
+    "when a substitute is registered": {
+        setup: function () {
+            mockery.registerSubstitute('./fixtures/fake_module',
+                './fixtures/substitute_fake_module');
+        },
+        teardown: function () {
+            mockery.deregisterSubstitute('not-registered-mock');
+            mockery.deregisterSubstitute('./fixtures/fake_module');
+        },
+        "and mockery is enabled": {
+            topic: function () {
+                mockery.enable();
+                return null;
+            },
+            "requiring the module returns the substitute instead": function () {
+                var fake_module = require('./fixtures/fake_module');
+                assert.equal(fake_module.foo(), 'substitute foo');
+            },
+            "throws on an invalid module": function() {
+                assert.throws(function() {
+                    mockery.registerSubstitute('fs', 'does-not-exist-fs');
+                    require('fs');
+                }, /Cannot find module/);
+            },
+            "throws on an invalid substitute module": function() {
+                assert.throws(function() {
+                    mockery.registerSubstitute('fs');
+                    require('fs');
+                }, /Misconfigured substitute for/);
+            },
+            "registering a replacement causes a warning to be logged": function () {
+                var mock_console;
+
+                mock_console = sinon.mock(console);
+                mock_console.expects('warn').once();
+
+                mockery.registerSubstitute('./fixtures/fake_module',
+                    './fixtures/substitute_fake_module');
+
+                mock_console.verify();
+                mock_console.restore();
+            },
+            "and warnings are disabled": {
+                topic: function () {
+                    mockery.warnOnReplace(false);
+                    return null;
+                },
+                "registering a replacement causes no warning to be logged": function () {
+                    var mock_console;
+
+                    mock_console = sinon.mock(console);
+                    mock_console.expects('warn').never();
+
+                    mockery.registerSubstitute('./fixtures/fake_module',
+                        './fixtures/substitute_fake_module');
+
+                    mock_console.verify();
+                    mock_console.restore();
+                },
+                "and warnings are reenabled": {
+                    topic: function () {
+                        mockery.warnOnReplace(true);
+                        return null;
+                    },
+                    "registering a replacement causes a warning to be logged": function () {
+                        var mock_console;
+
+                        mock_console = sinon.mock(console);
+                        mock_console.expects('warn').once();
+
+                        mockery.registerSubstitute('./fixtures/fake_module',
+                            './fixtures/substitute_fake_module');
+
+                        mock_console.verify();
+                        mock_console.restore();
+                    }
+                }
+            }
+        }
+    }
+};
+
+vows.describe('substitute').addBatch(tests).export(module);
+

node_modules/mockery/test/warn-replace.js

@@ -0,0 +1,52 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    mockery = require('../mockery'),
+    sinon = require('sinon');
+
+var mock_fake_module = {
+    foo: function () {
+        return 'mocked foo';
+    }
+};
+
+
+var tests = {
+    "warnings are disabled": {
+        topic: function () {
+            mockery.enable();
+            mockery.warnOnReplace(false);
+            return null;
+        },
+        "registering a replacement causes no warning to be logged": function() {
+            var mock_console;
+
+            mock_console = sinon.mock(console);
+            mock_console.expects('warn').never();
+
+            mockery.registerMock('./fixtures/fake_module', mock_fake_module);
+
+            mock_console.verify();
+            mock_console.restore();
+        },
+        "and warnings are reenabled": {
+            topic: function () {
+                mockery.warnOnReplace(true);
+                return null;
+            },
+            "registering a replacement causes a warning to be logged": function () {
+                var mock_console;
+
+                mock_console = sinon.mock(console);
+                mock_console.expects('warn').once();
+
+                mockery.registerMock('./fixtures/fake_module', mock_fake_module);
+
+                mock_console.verify();
+                mock_console.restore();
+            }
+        }
+    }
+};
+
+vows.describe('warn-replace').addBatch(tests).export(module);
+