@i implementou o criador de logs para o nó js usando winston, morgan e winston-daily-rotate-file, express-http-context. Portanto, todos os dias, um novo arquivo de log será gravado quando qualquer solicitação de http (morgan) ou desenvolvedor definiu mensagens do registrador no arquivo. do nó js. Abaixo do formato como será registrado

timestamp || Nível || filename || traceId || statusCode || logMessage

Tudo está funcionando bem, mas quando escrevi os casos de teste usando o gracejo, (iniciante ao gracejo). Não consigo cobrir duas linhas. Aqui está o código inteiro e a estrutura da past

Para cada solicitação, estou definindo um traceId, que extrairei no método customFormat e depois retorno a mensagem customFormat, essas são as duas linhas que não consigo cobrir em tom de brincadeir

//index.js

const app = require('express')();
const cors = require('cors')
const morgan = require('morgan') // HTTP request logger middleware 
const logger = require('./lib/logger')(module) //Logger
const uuid = require('uuid')
const httpContext = require('express-http-context')
const config = require('./config').get(process.env.APP_ENV)


// Use any third party middleware that does not need access to the context here
// app.use(some3rdParty.middleware);

app.use(httpContext.middleware);
// all code from here on has access to the same context for each request

// Run the context for each request.
// Assigning a unique identifier to each request
app.use((req, res, next) => {
  httpContext.set('traceId', uuid.v1());
  next();
});

// using morgan with winston(logger)
app.use(morgan('combined', {
  stream: {
    write: (message) => logger[config.logLevel](message)
  }
}))

app.use(cors());

app.listen(4000, () => {
  console.log('Server running on port 4000');
});



// lib/logger/index.js

const appRoot = require('app-root-path');
const {
  createLogger,
  format,
  transports
} = require('winston');
require('winston-daily-rotate-file');
const {
  combine,
  label,
} = format;
const config = require('../../config').get(process.env.APP_ENV);
const loggerHelper = require('./helpers')



// Custom settings for each transport
const options = {
  dailyRotateFile: {
    filename: `${appRoot}/logs/TPS-UI-%DATE%.log`,
    datePattern: 'YYYY-MM-DD',
    prepend: true,
    level: config.logLevel,
    timestamp: new Date(),
    localTime: true,
  }
}

// Instantiate a Winston Logger with the settings
const logger = moduleObj => createLogger({
  format: combine(
    label({
      label: loggerHelper.getFileName(moduleObj)
    }),
    format.timestamp(),
    loggerHelper.customFormat()
  ),
  transports: [
    new transports.DailyRotateFile(options.dailyRotateFile),
  ],
  exitOnError: false, // do not exit on handled exceptions
});


module.exports = logger


// lib/logger/helpers/index.js

const loggerHelper = require('../../../helper');
const httpContext = require('express-http-context');
const {
  format: {
    printf
  }
} = require('winston')

/**
 * @method checkMessageProp
 * @param {message} can be object if developer defined, else it will be string
 *                  if its a network request (morgan requests)
 * @returns a fixed format how the status code and message should show
 */
const returnLogMessage = (message) => {
  const {
    statusCode,
    logMsg,
    maskedData
  } = message;
  switch (typeof message) {
    case 'object':
      let statusCodeToBeLogged = statusCode ? statusCode : "Status code not defined",
        logMessageToBeLogged = logMsg ? logMsg : "Log message not defined",
        return `${statusCodeToBeLogged} || ${logMessageToBeLogged}`
    case 'string':
      if (message) {
        const messageSplit = message.split('"');
        let statusCodeToBeLogged = messageSplit[2].trim().split(" ")[0],
          logMessageToBeLogged = messageSplit[1]
        return `${statusCodeToBeLogged} || ${logMessageToBeLogged}`;
      }
      return 'Status Code Not Defined || Log Message Not Defined';
    default:
      return message;
  }
};

/**
 * @method getFileName
 * @param {moduleObj} the module realted object passed from the require of logger file
 * @returns the file name where the logger was invoked
 */
const getFileName = (moduleObj) => {
  if (Object.keys(moduleObj).length > 0) {
    const tempFileNameParts = moduleObj.filename.split("/");
    const fileName = tempFileNameParts.slice(Math.max(tempFileNameParts.length - 2, 1)).join('/');
    return fileName;
  }
  return 'Module not passed while requiring the logger';
};

/**
 * @method customFormat
 * @param {log} the log passed by the developer or based on network requests
 * @returns a customFormat how it should be logged to the log files
 */

const customFormat = () => {
  return printf((log) => {
    const traceId = httpContext.get('traceId');
    return `${new Date(log.timestamp)} || ${log.level.toUpperCase()} || ${log.label} || ${traceId} || ${returnLogMessage(log.message)} `;
  })
}



module.exports = {
  returnLogMessage,
  getFileName,
  customFormat
}

// lib/logger/__test__/logger.test.js

jest.mock('winston');

const logger = require('..');
const winston = require('winston');

describe('Given the logger method is called', () => {
  let loggerObject;
  const mockModuleObject = {
    filename: 'server/index.js'
  };
  beforeEach(() => {
    loggerObject = logger(mockModuleObject);
  });
  test('it should return a object returned by createLogger', () => {
    expect(loggerObject).toEqual(winston.mockLoggerObject);
  });
  test('it should call combine, format, printf and timestamp method of winston', () => {
    expect(winston.mockPrintf).toHaveBeenCalled();
    expect(winston.mockLabel).toHaveBeenCalled();
    expect(winston.mockCombine).toHaveBeenCalled();
  });
  test('expect Dailytransports to be called', () => {
    // how to check the daily transport has been called
    expect(winston.mockDailyTransport).toHaveBeenCalled();
  });
});


// lib/logger/__test__/helpers/helper.test.js

jest.mock('winston')
jest.mock('express-http-context')
const helper = require('../../helpers/')
const httpContext = require('express-http-context')
const {
  format: {
    printf
  }
} = jest.requireActual('winston')

describe('Given the helper methods for logger should call a d take different scenarios', () => {
  let mockMessageObj, mockMessageString, mockMessageStringEmpty, mockMessageNumber;
  beforeAll(() => {
    mockMessageObj = {
      statusCode: 200,
      logMsg: "Testing log"
    }
    mockMessageString = `::1 - - [31/Jan/2019:11:26:54 +0000] 
            "GET /graphql HTTP/1.1" 404 146 "-" "Mozilla/5.0 (X11; Linux x86_64)
             AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36"`
    mockMessageStringEmpty = ""
    mockMessageNumber = 12345
  })
  test('returnLogMessage and getFileName methods should exist', () => {
    expect(helper.returnLogMessage).toBeDefined()
    expect(helper.getFileName).toBeDefined()
  })
  // returnLogMessage Method Test Cases
  test('should return a string when passes object', () => {
    expect(helper.returnLogMessage(mockMessageObj)).toEqual('200 || Testing log || userId : tne:1***:***2354')
  })
  test('should return a string when passes string', () => {
    expect(helper.returnLogMessage(mockMessageString)).toEqual('404 || GET /graphql HTTP/1.1')
  })
  test('should return default string when passes string as undefined', () => {
    expect(helper.returnLogMessage(mockMessageStringEmpty)).toEqual('Status Code Not Defined || Log Message Not Defined || Mask Data Not Defined')
  })
  test('should return the actual default message if the type is nor object neither string', () => {
    expect(helper.returnLogMessage(mockMessageNumber)).toEqual(12345)
  })
  test('should return default message for status code', () => {
    let tempMockMessageObjStatusCode = { ...mockMessageObj
    }
    tempMockMessageObjStatusCode["statusCode"] = ""
    expect(helper.returnLogMessage(tempMockMessageObjStatusCode)).toEqual('Status code not defined || Testing log || userId : tne:1***:***2354')
  })
  test('should return default message for log msg', () => {
    let tempMockMessageObjLogMsg = { ...mockMessageObj
    }
    tempMockMessageObjLogMsg["logMsg"] = ""
    expect(helper.returnLogMessage(tempMockMessageObjLogMsg)).toEqual('200 || Log message not defined || userId : tne:1***:***2354')
  })
  test('should return default message for masked data for undefined', () => {
    let tempMockMessageObjMaskData = { ...mockMessageObj
    }
    tempMockMessageObjMaskData["maskedData"] = ""
    expect(helper.returnLogMessage(tempMockMessageObjMaskData)).toEqual('200 || Testing log || Masked data not defined')
  })
  test('should return default message for masked data for empty object', () => {
    let tempMockMessageObjMaskData = { ...mockMessageObj
    }
    tempMockMessageObjMaskData["maskedData"] = {}
    expect(helper.returnLogMessage(tempMockMessageObjMaskData)).toEqual('200 || Testing log || Masked data not defined')
  })
  // getFileName Method Test Cases
  test('should return default label when module is not passed', () => {
    expect(helper.getFileName({})).toEqual('Module not passed while requiring the logger')
  })
})

// this one how can i test the custom format method
describe('custom format', () => {
  test('should call the printF function inside customFormat function', () => {
    
  })
})


// __mocks/winston.js
const winston = jest.genMockFromModule('winston');


const mockLoggerObject = {
  error: jest.fn(),
  info: jest.fn(),
};

const mockLabel = jest.fn();
const mocktimestamp = jest.fn();
const mockPrintf = jest.fn();
const mockCombine = jest.fn();
const mockDailyTransport = jest.fn();
const mockTransports = {
  DailyRotateFile: mockDailyTransport
};
const mockCreateLogger = jest.fn().mockReturnValue(mockLoggerObject);
const mockFormat = {
  label: mockLabel,
  timestamp: mocktimestamp,
  printf: mockPrintf,
  combine: mockCombine,
};


winston.createLogger = mockCreateLogger;
winston.transports = mockTransports;
winston.mockLoggerObject = mockLoggerObject;
winston.format = mockFormat;
winston.mockLabel = mockLabel;
winston.mocktimestamp = mocktimestamp;
winston.mockPrintf = mockPrintf;
winston.mockDailyTransport = mockDailyTransport;
winston.mockCombine = mockCombine;


module.exports = winston;


//__mocks/express-http-context

const httpContext = jest.genMockFromModule('express-http-context');

const mockGet = jest.fn();

httpContext.get = mockGet;

module.exports = httpContext;

os dois casos de teste que não consigo verificar ou o erro de lançamento é um

// helper.test.js

describe('custom format', () => {
    test('should call the printF function inside customFormat function', () => {
        // how can i coverage the line what should be written here
    })
})

// logger.test.js

test('expect Dailytransports to be called', () => {
    expect(winston.mockDailyTransport).toHaveBeenCalled(); 
  });