const dependency = require('./TestDependency');
 
module.exports = class TestModule {
 
    getDependency() {
        return dependency;
    }
 
    async callDependencyAsync() {
        return new Promise(function(resolve, reject) {
          setTimeout(function() {
            resolve(dependency);
          }, 100);
        });
    }
 
}

module.exports = {
    "dependencyType": "Real"
}

const requireIntercept = require('require-intercept');
const { module: TestModule, mockDependency, stopMocking, mockAround } = requireIntercept('./TestModule');
 
const testModule = new TestModule();
console.log("Before any mocking it calls the real TestDependency >", testModule.getDependency());
// Before any mocking it calls the real TestDependency > { "dependencyType": "Real" }
 
const mock = { "dependencyType": "Mocked" };
 
mockDependency('./TestDependency', mock);
 
console.log("Once mocked we have injected the mock without modifying the code structure >", testModule.getDependency());
// Once mocked we have injected the mock without modifying the code structure > { "dependencyType": "Mocked" }
 
stopMocking('./TestDependency');
 
console.log("Once we have stopped mocking we restore the original module >", testModule.getDependency());
// Once we have stopped mocking we restore the original module > { "dependencyType": "Real" }
 
mockAround('./TestDependency', mock, () => {
    console.log("We can inject mocks within a particular scope >", testModule.getDependency());
    // We can inject mocks within a particular scope > { "dependencyType": "Mocked" }
});
 
console.log("And they are automatically restored afterwards >", testModule.getDependency());
// And they are automatically restored afterwards > { "dependencyType": "Real" }
 
mockAround('./TestDependency', mock, async () => {
    const value = await testModule.getDependencyAsync()
    console.log("This also works with async functions >", value);
    // This also works with async functions > { "dependencyType": "Mocked" }
});