Question

我已经写了一些测试用例，除了下面的测试用例外，其他一切看起来都不错。我得到一个文件的零分支封面。我搜索了两个博客，我开始了解该语句是否可以在调用分支覆盖的多种情况下执行。但是我发现我的代码不能以多种方式执行。

request.js

spec:
  podManagementPolicy: OrderedReady
  affinity:
    nodeAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
            - key: <some key>
              operator: In
              values:
                - <some value>
        topologyKey: "kubernetes.io/hostname"

reqeust.test.js

import axios from 'axios';

export default async (request, httpService = axios) => {
  const {
    method, url, data, headers,
  } = request;
  return httpService.request({
    method,
    url,
    headers: Object.assign({}, headers),
    data,
  });
};

修改

rquest.js

describe('requestServie', () => {
  it('should have a valid request object', async () => {
    const requestObj = {
      method: 'POST',
      url: 'http://mock.url',
      data: {},
    };

    const mockRequest = jest.fn(() => Promise.resolve({}));

    const httpService = {
      request: mockRequest,
    };

    await request(requestObj, httpService);
    expect(mockRequest).toHaveBeenCalledWith({
      method: requestObj.method,
      url: requestObj.url,
      headers: {},
      data: requestObj.data,
    });
  });

  it('should return a valid response (empty)', async () => {
    const response = {
      data: {
      },
      status: 200,
      statusText: 'OK',
      headers: {},
      config: {},
      request: {},
    };

    const mockRequest = jest.fn(() => Promise.resolve(response));

    const httpService = {
      request: mockRequest,
    };

    const res = await request({ url: 'http://mock.url' }, httpService);

    expect(res).not.toBe(null);
    expect(res).toMatchObject(
      {
        status: response.status,
      },
    );
  });
});

request.test.js

export default async (request, httpService = axios) => {
  const {
    method, url, data, headers,
  } = request;
  return httpService.request({
    method,
    url,
    headers: Object.assign({}, headers),
    data,
  }).then(successResponse, (error) => {
    throwHttpError(error);
  });
};

错误

更新了15 / Nov / 18

“开玩笑”：“ ^ 23.6.0”，

import HttpError from 'standard-http-error';
import axios from 'axios';
import request, { successResponse, throwHttpError } from './requestService';

describe('requestService', () => {

  jest.mock('axios', () => ({
    request: jest.fn(() => Promise.resolve({})),
  }));

  describe('successResponse', () => {
    const mockRes = {
      status: 9001,
      data: {
        stuff: 'stuff',
      },
    };
    it('should returns an object with only status and data properties', () => {
      const responseKeys = Object.keys(successResponse(mockRes));
      expect(responseKeys).toMatchObject(['status', 'data']);
      expect(responseKeys.length).toBe(2);
    });

    it('should map the status of the reponse to the status property', () => {
      expect(successResponse(mockRes).status)
        .toBe(mockRes.status);
    });

    it('should map the data of the reponse to the data property', () => {
      expect(successResponse(mockRes).data)
        .toMatchObject(mockRes.data);
    });

    it('should have a valid request object', async () => {
      const requestObj = {
        method: 'POST',
        url: 'http://mock.url',
        data: {},
        headers: {},
      };

      const mockRequest = jest.fn(() => Promise.resolve({}));

      const httpService = {
        request: mockRequest,
      };

      await request(requestObj, httpService);
      expect(mockRequest).toHaveBeenCalledWith({
        method: requestObj.method,
        url: requestObj.url,
        headers: {},
        data: requestObj.data,
      });
    });
  });

  describe('httpThrowError', () => {
    const mockErr = {
      response: {
        status: 9001,
        statusText: 'error message goes here',
      },
    };

    it('should map the status of the reponse to the error.status property', () => {
      try {
        throwHttpError(mockErr);
      } catch (e) {
        expect(e).not.toBe(null);
        expect(e.status).toBe(mockErr.response.status);
        expect(e.message).toBe(mockErr.response.statusText);
      }
    });

    it('should map the data of the reponse to the error.data property', () => {
      const mockErrWithData = Object.assign({}, mockErr);
      mockErrWithData.response.data = {};
      try {
        throwHttpError(mockErrWithData);
      } catch (e) {
        expect(e).not.toBe(null);
        expect(e.data).toBe(mockErrWithData.response.data);
      }
    });
  });

  describe('request', () => {
    const testCases = [
      ['should return error response on server error', 500],
      ['should return error response on bad request', 400],
      ['should return error response on unauthorised', 401],
    ];

    testCases.forEach(([testName, errorStatus]) => {
      it(testName, async () => {
        const errorResponse = {
          response: {
            status: errorStatus,
          },
        };
        const mockRequest = jest.fn(() => Promise.reject(errorResponse));

        const httpService = {
          request: mockRequest,
        };

        try {
          await request({ url: 'http://mock.url' }, httpService);
          throw new Error('Expected an exception, but none was thrown');
        } catch (err) {
          expect(err).not.toBe(null);
          expect(err).toMatchObject(
            new HttpError(errorResponse.response.status,
              errorResponse.response.statusText),
          );
        }
      });
    });

    it('should return an valid response (empty)', async () => {
      const response = {
        data: {
          meta: {},
          results: [],
        },
        status: 200,
        statusText: 'OK',
        headers: {},
        config: {},
        request: {},
      };

      const mockRequest = jest.fn(() => Promise.resolve(response));

      const httpService = {
        request: mockRequest,
      };

      const res = await request({ url: 'http://mock.url' }, httpService);

      expect(res).not.toBe(null);
      expect(res).toMatchObject(
        {
          status: response.status,
          data: response.data,
        },
      );
    });

    it('should use axios by default', async () => {
      const req = { url: 'http://mock.url', method: 'get' };
      await request(req);
      expect(axios.request).toHaveBeenCalled();
    });
  });
});

错误

Answer 1

要查看未涵盖的内容，可以转到coverage/Iconv-report并打开index.html。一旦您使用jest option运行--coverage，就会创建这些文件。

看起来未发现的分支是：httpService = axios。因此，您需要检查是否使用默认的axios。

为掩盖您可能不带httpService参数运行请求的情况-您可以在全局范围内mock axios，即：

import axios from 'axios';

// note that mock goes before any describe block

jest.mock('axios', () => {
  return {
    request: jest.fn(() => Promise.resolve({})),
  }
});

describe('requestService', () => {

  // ... your other tests

  it('should use axios by default', async () => {
    const opts = { url: 'http://mock.url', method: 'get' };
    const res = await request(opts);
    expect(axios.request).toHaveBeenCalled();
  });
});

请注意，jest.mock有一些buggy behavior when running inside a spec。

分支机构开玩笑率为零

1 个答案: