How can you mock external dependencies?

I am trying to test a logger-service, which uses imports from the node_modules winston and fs, and I would like to mock these imports, but I don’t know how. With nest it’s really easy to mock the injected dependencies, but these dependencies are imported, not injected. For normal Node.js modules I use proxyquire to proxy my required node_modules, but that’s not possible with Nest, because the dependencies are imported, not required, and they are imported very early in the process (before the constructor of the service is called).

Here is my logger-service:

import {Component} from '@nestjs/common';
import {Logger, transports} from 'winston';
import * as path from 'path';
import * as fs from 'fs';

import { ConfigService } from '../config/config.service';

require('winston-daily-rotate-file');

@Component()
export class LoggerService {
    logger:any;
    logFolders:any;

    constructor(private config:ConfigService) {
        this.logFolders = {base: path.join(__dirname, '..', '..', '..', 'logs')};
        this.logFolders.debug = path.join(this.logFolders.base, 'debug');
        this.logFolders.exception = path.join(this.logFolders.base, 'debug');

        this._createLogFolders();

        this.logger = new Logger({
            transports: [
                new transports.Console({
                    json: false,
                    timestamp: true,
                    level: config.get('debug') ? 'debug' : 'info'
                }),
                new transports.DailyRotateFile({
                    filename: path.join(this.logFolders.debug, 'debug.log'),
                    json: false,
                    level: 'error',
                    datePattern: 'yyyy-MM-dd-',
                    prepend: true
                })
            ],
            exceptionHandlers: [
                new transports.Console({
                    json: false,
                    timestamp: true,
                    level: config.get('debug') ? 'debug' : 'info'
                }),
                new transports.DailyRotateFile({
                    filename: path.join(this.logFolders.exception, 'execeptions.log'),
                    json: false,
                    level: 'error',
                    datePattern: 'yyyy-MM-dd-',
                    prepend: true
                })
            ],
            exitOnError: false
        });
    }

    private _createLogFolders() {
        const createDir = dir => {
            if (!fs.existsSync(dir)) {
                fs.mkdirSync(dir);
            }
        };

        createDir(this.logFolders.base);
        createDir(this.logFolders.debug);
        createDir(this.logFolders.exception);
    }

    debug(message:string) {
        this.logger.debug(message);
    }

    info(message:string) {
        this.logger.info(message);
    }

    warn(message:string) {
        this.logger.warn(message);
    }

    error(message:string) {
        this.logger.error(message);
    }
}

And this is my test:

import {Test} from '@nestjs/testing';
import {TestingModule} from '@nestjs/testing/testing-module';
import {LoggerService, ConfigService} from '../';
import {expect} from 'chai';
import * as sinon from 'sinon';

describe ('LoggerService', () => {
    let module: TestingModule;
    let service: LoggerService;
    let sandbox;
    let logStub;

    beforeEach(async () => {
        sandbox = sinon.sandbox.create();

        module = await Test.createTestingModule({
            components: [
                LoggerService,
                ConfigService
            ]
        }).compile();

        service = module.get(LoggerService);
    });

    it('should exist', () => {
        expect(service).to.exist;
    });

    it('should log a debug message', () => {
         logStub = sandbox.stub(service.logger, 'debug');
         service.debug('someMessage');
         expect(logStub).to.have.been.calledWith('someMessage');
    });

    it('should log a info message', () => {
        logStub = sandbox.stub(service.logger, 'info');
        service.info('someMessage');
        expect(logStub).to.have.been.calledWith('someMessage');
    });

    it('should log a debug message', () => {
        logStub = sandbox.stub(service.logger, 'warn');
        service.warn('someMessage');
        expect(logStub).to.have.been.calledWith('someMessage');
    });

    it('should log a debug message', () => {
        logStub = sandbox.stub(service.logger, 'error');
        service.error('someMessage');
        expect(logStub).to.have.been.calledWith('someMessage');
    });

});

I am not able to mock winston or fs, so I cannot test the constructor or prevent the creation of the logFolders.

Can anyone help me to mock imports?

[unlight]

You are not following IoC You must create injectable component from logger package and inject to constructor.

{
  provide: 'Logger',
  useFactory: () => require('winston')
};

constructor(
    private config:ConfigService,
   @Inject('Logger) private logger,
) {}

[unlight]

@mslourens You can create new type by using typeof (it behaves differently in TypeScript):

import * as fs from 'fs';

export class AppModule {

    constructor(
       @Inject('fs') private _fs: typeof fs
    ) { }
}

or

import * as fs from 'fs';
type FsType = typeof fs;

export class AppModule {

    constructor(
       @Inject('fs') private fs: FsType
    ) { }
}