Javascript 单元测试得到客户端时出现预期错误

我需要你的帮助来解决这个问题，我在对一个GET客户机钩子进行单元测试时遇到了这个问题 我在这里记录HTTP请求。我在开玩笑。 我得到一个预期错误，该错误将参数视为.toBeCalledWith作为对象，而当我控制台记录它时，它是一个字符串。也许我做错了什么。请让我知道

下面是got-client.js

下面是got-client.spec.js

下面的测试失败错误

错误：expect（jest.fn（））.toBeCalledWith（…expected）
应为：ObjectContaining{“message”：StringContaining“请求错误获取”https://subdomain.domain.com/path/error"}
通话次数：0
反对。（/Users/user/Documents/company/teams/team/project/test/unit/lib/got clients.spec.js:62:26）
在处理和拒绝时（内部/process/task_queues.js:97:5）

我真的很感激你的帮助。事先非常感谢

正在使用got-client.spec.js

正在使用got-client.spec.js

---

只是想确认一下，当您在Jest之外运行日志钩子而不使用Nock时，是否会按照预期记录错误？你在这里发布了很多代码，不清楚我们是在调试GET客户机还是在调试单元测试。Matt，谢谢你的帮助。我想这个问题已经解决了。Got客户机运行良好，但必须稍微进行调整才能成功测试错误并重试挂钩。我将努力在这里发布一点解决方案。再次感谢。请确认一下，当您在Jest之外运行日志钩子时，没有Nock，错误是否会按预期记录？你在这里发布了很多代码，不清楚我们是在调试GET客户机还是在调试单元测试。Matt，谢谢你的帮助。我想这个问题已经解决了。Got客户机运行良好，但必须稍微进行调整才能成功测试错误并重试挂钩。我将努力在这里发布一点解决方案。再次感谢。

const http = require('http');
const https = require('https');
const got = require('got');
const _ = require('lodash');

const { name: packageName, version: packageVersion } = require('../../package.json');

const keepAliveOptions = { keepAlive: true, keepAliveMsecs: 20000 };
let clients = {};


const allowedHeaders = ['user-agent', 'x-forwarded-for', 'referer', 'content-length'];
const filterHeaders = headers => _.pick(headers, allowedHeaders);

const gotLoggingHooks = (name, logger) => ({
  hooks: {
    beforeRequest: [
      options => {
        const { url, method, headers } = options;
        logger.debug({
          message: `${name} request ${options.method} ${options.url}`,
          http_request: {
            method,
            target: url,
            direction: 'OUT',
            headers: filterHeaders(headers)
          },
          request: _.pick(options, ['url', 'method', 'headers', 'body', 'json'])
        });
      }
    ],
    beforeRetry: [
      (options, error, retryCount) => {
        const {
          response: { statusCode, ip } = {},
          request: { options: { method, headers = {} } = {}, requestUrl: url } = {},
          timings: {
            // eslint-disable-next-line camelcase
            phases: { total: duration_ms } = {}
          } = {}
        } = error;
        logger.warn({
          message: `${name} will retry request, attempt ${retryCount}/${options.retry.limit} ${method} ${url} (${error.code} ${error.message})`,
          err: error,
          http_request: {
            method,
            target: url,
            status: statusCode,
            server_ip: ip,
            duration_ms,
            direction: 'OUT',
            protocol: headers.via,
            headers: filterHeaders(headers)
          }
        });
      }
    ],
    beforeError: [
      error => {
        const {
          response: { statusCode, ip } = {},
          request: { options: { method, headers } = {}, requestUrl: url } = {},
          timings: {
            // eslint-disable-next-line camelcase
            phases: { total: duration_ms } = {}
          } = {}
        } = error;
        if (!statusCode) {
          logger.error({
            message: `${name} request error ${method} ${url} (${error.code} ${error.message})`,
            err: error,
            http_request: {
              method,
              target: url,
              status: statusCode,
              server_ip: ip,
              duration_ms,
              direction: 'OUT',
              protocol: headers.via,
              headers: filterHeaders(headers)
            }
          });
        }
        // eslint-disable-next-line no-param-reassign
        error.serviceName = name;
        return error;
      }
    ],
    afterResponse: [
      response => {
        const {
          statusCode,
          body,
          url,
          ip,
          headers = {},
          request: { options: { method } = {} } = {},
          timings: {
            // eslint-disable-next-line camelcase
            phases: { total: duration_ms } = {}
          } = {},
          retryCount
        } = response;
        logger.debug({
          message: `${name} response ${method} ${url}`,
          response: { body, retryCount, headers },
          http_request: {
            method,
            target: url,
            status: statusCode,
            server_ip: ip,
            duration_ms,
            direction: 'OUT',
            protocol: headers.via,
            headers: filterHeaders(_.get(response, 'request.options.headers'))
          }
        });
        return response;
      }
    ]
  }
});

const gotClient = ({ name, logger, keepAlive = true, gotOptions = {} }) => {
  if (!clients[name]) {
    clients[name] = got
      .extend({
        headers: {
          'user-agent': `${packageName} ${packageVersion}`
        },
        ...(keepAlive && {
          agent: {
            http: new http.Agent(keepAliveOptions),
            https: new https.Agent(keepAliveOptions)
          }
        }),
        responseType: 'json',
        timeout: 5000
      })
      .extend(gotLoggingHooks(name, logger))
      .extend(gotOptions);
  }

  return clients[name];
};

gotClient.clearAll = () => {
  clients = {};
};

module.exports = gotClient;

const nock = require('nock');
const { name: packageName, version: packageVersion } = require('../../../package.json');
const gotClient = require('../../../src/lib/got-client');

const BASE_URL = 'https://subdomain.domain.com/';
const BASE_ENDPOINT = 'path';

const logger = {
  error: jest.fn(),
  debug: jest.fn(),
  info: jest.fn(),
  log: jest.fn(),
  warn: jest.fn(),
};
describe('got client', () => {

  afterEach(gotClient.clearAll);

  test('should log requests', async () => {
    const client = gotClient({
      name: 'test',
      logger,
      gotOptions: {
        prefixUrl: BASE_URL,
      },
    });

    nock(BASE_URL).get(`/${BASE_ENDPOINT}`).reply(200, { success: true });
    await client.get(BASE_ENDPOINT);
    // console.log('mock call 0', logger.debug.mock.calls[0][0]);
    // TODO: match message
    expect(logger.debug).toBeCalled();

    expect(logger.debug).toBeCalledWith(
      expect.objectContaining({
        message: expect.stringContaining(`request GET ${BASE_URL}${BASE_ENDPOINT}`),
      })
    );

    expect(logger.debug).toBeCalledWith(
      expect.objectContaining({
        message: expect.stringContaining(`response GET ${BASE_URL}${BASE_ENDPOINT}`),
      })
    );

    nock(BASE_URL).get(`/${BASE_ENDPOINT}/error`).reply(500, { success: false });
    try {
      await client.get(`${BASE_ENDPOINT}/error`, { retry: 0 });
    } catch (e) {}
    expect(logger.error).toBeCalledWith(
      expect.objectContaining({
        message: expect.stringContaining(`request error GET ${BASE_URL}${BASE_ENDPOINT}/error`),
      })
    );
  });
});

Error: expect(jest.fn()).toBeCalledWith(...expected)

Expected: ObjectContaining {"message": StringContaining "request error GET https://subdomain.domain.com/path/error"}

Number of calls: 0

    at Object.<anonymous> (/Users/user/Documents/company/teams/team/project/test/unit/lib/got-clients.spec.js:62:26)
    at processTicksAndRejections (internal/process/task_queues.js:97:5)

const nock = require('nock');
const { name: packageName, version: packageVersion } = require('../../../package.json');
const gotClient = require('../../../src/lib/got-client');

const BASE_URL = 'https://subdomain.domain.com/';
const BASE_ENDPOINT = 'path';

const logger = {
  error: jest.fn(),
  debug: jest.fn(),
  info: jest.fn(),
  log: jest.fn(),
  warn: jest.fn(),
};

const defaultClient = gotClient({
  name: 'test',
  logger,
  gotOptions: {
    prefixUrl: BASE_URL,
  },
});

describe('got client', () => {
    afterEach(gotClient.clearAll);
    
    test('should log requests', async () => {
        nock(BASE_URL).get(`/${BASE_ENDPOINT}`).reply(200, { success: true });
        await defaultClient.get(BASE_ENDPOINT);
    
        expect(logger.debug).toBeCalledWith(
          expect.objectContaining({
            message: expect.stringContaining(`request GET ${BASE_URL}${BASE_ENDPOINT}`),
          })
        );
      });
    
      test('should log responses', async () => {
        nock(BASE_URL).get(`/${BASE_ENDPOINT}`).reply(200, { success: true });
        await defaultClient.get(BASE_ENDPOINT);
    
        expect(logger.debug).toBeCalledWith(
          expect.objectContaining({
            message: expect.stringContaining(`response GET ${BASE_URL}${BASE_ENDPOINT}`),
          })
        );
      });
    
      test('should log errors', async () => {
        const endpoint = `${BASE_ENDPOINT}/error`;
        nock(BASE_URL).get(`/${endpoint}`).replyWithError({
          message: 'something awful happened',
          code: 'ECONNRESET',
        });
        try {
          await defaultClient.get(endpoint, { retry: 0 });
        } catch (e) {}
        expect(logger.error).toBeCalledWith(
          expect.objectContaining({
            message: expect.stringContaining(`request error GET ${BASE_URL}${endpoint}`),
          })
        );
      });
    
      test('should log retries', async () => {
        nock(BASE_URL)
          .get(`/${BASE_ENDPOINT}`)
          .replyWithError({
            message: 'something awful happened',
            code: 'ECONNRESET',
          })
          .get(`/${BASE_ENDPOINT}`)
          .reply(500, { success: false })
          .get(`/${BASE_ENDPOINT}`)
          .reply(500, { success: false })
          .get(`/${BASE_ENDPOINT}`)
          .reply(200, { success: true });
    
        await defaultClient.get(BASE_ENDPOINT, { retry: { limit: 3, calculateDelay: () => 1 } });
    
        expect(logger.warn).toBeCalledTimes(3);
    
        expect(logger.warn).toBeCalledWith(
          expect.objectContaining({
            message: expect.stringContaining(`will retry request`),
          })
        );
      });
  });