如何测试依赖于useContext钩子的反应组件？

Question

我有一个使用useContext的组件，然后它的输出依赖于上下文中的值。一个简单的例子：

import React, { useContext } from 'react';

const MyComponent = () => {
  const name = useContext(NameContext);

  return <div>{name}</div>;
};

使用react和jest快照中的浅层渲染器测试此组件时。如何更改NameContext的值？

Answer 1

或者，如果您正在隔离测试组件，而没有安装父组件，您可以简单地嘲笑useContext：

jest.mock('react', () => {
  const ActualReact = jest.requireActual('react')
  return {
    ...ActualReact,
    useContext: () => ({ }), // what you want to return when useContext get fired goes here
  }
})

您仍然可以将动态useContext值与全局jest一起使用。fn

Answer 2

我尝试使用Enzyme. dive，但是当潜水时，它不识别上下文道具，而是获取默认道具。事实上，这是酶团队已知的问题。与此同时，我想到了一个更简单的解决方案，它包括创建一个自定义钩子，仅返回带有上下文的useContext，并在测试中嘲笑此自定义钩子的返回：

AppContext。js-创建上下文。

import React, { useContext } from 'react';

export const useAppContext = () => useContext(AppContext);

const defaultValues = { color: 'green' };
const AppContext = React.createContext(defaultValues);

export default AppContext;

应用程序。js — 提供背景

import React from 'react';
import AppContext from './AppContext';
import Hello from './Hello';

export default function App() {
  return (
    <AppContext.Provider value={{ color: 'red' }}>
      <Hello />
    </AppContext.Provider>
  );
}

你好js-使用上下文

import React from 'react';
import { useAppContext } from './AppContext';

const Hello = props => {
  const { color } = useAppContext();
  return <h1 style={{ color: color }}>Hello {color}!</h1>;
};

export default Hello;

你好测验js-使用Ezyme测试useContext

import React from 'react';
import { shallow } from 'enzyme';
import * as AppContext from './AppContext';

import Hello from './Hello';

describe('<Hello />', () => {
  test('it should mock the context', () => {
    const contextValues = { color: 'orange' };
    jest
      .spyOn(AppContext, 'useAppContext')
      .mockImplementation(() => contextValues);
    const wrapper = shallow(<Hello />);
    const h1 = wrapper.find('h1');

    expect(h1.text()).toBe('Hello orange!');
  });
});

查看完整的媒体文章https://medium.com/7shifts-engineering-blog/testing-usecontext-react-hook-with-enzyme-shallow-da062140fc83

Answer 3

一般来说，使用钩子不应该对测试策略有太大的改变。这里更大的问题实际上不是钩子，而是上下文的使用，这使事情变得复杂了一点。

有很多方法可以实现这一点，但我发现的唯一一种与'react-test-render/浅'一起工作的方法是注入一个模拟钩子：

import ShallowRenderer from 'react-test-renderer/shallow';

let realUseContext;
let useContextMock;
// Setup mock
beforeEach(() => {
    realUseContext = React.useContext;
    useContextMock = React.useContext = jest.fn();
});
// Cleanup mock
afterEach(() => {
    React.useContext = realUseContext;
});

test("mock hook", () => {
    useContextMock.mockReturnValue("Test Value");
    const element = new ShallowRenderer().render(
        <MyComponent />
    );
    expect(element.props.children).toBe('Test Value');
});

不过，这有点脏，而且是特定于实现的，因此如果您能够在浅层渲染器的使用上做出妥协，那么还有一些其他选项可用：

如果你不是浅层渲染，你可以在上下文提供程序中包装组件来注入你想要的值：

import TestRenderer from 'react-test-renderer';

test("non-shallow render", () => {
    const element = new TestRenderer.create(
        <NameContext.Provider value="Provided Value">
            <MyComponent />
        </NameContext.Provider>
    );
    expect(element.root.findByType("div").children).toEqual(['Provided Value']);
});

（免责声明：这应该可以，但当我测试它时，我遇到了一个错误，我认为这是我设置中的一个问题）

正如@skyboyer所评论的，ase的浅层渲染器支持. dive，允许您对浅层渲染组件的一部分进行深度渲染：

import { shallow } from "./enzyme";

test("enzyme dive", () => {
    const TestComponent = () => (
        <NameContext.Provider value="Provided Value">
            <MyComponent />
        </NameContext.Provider>
    );
    const element = shallow(<TestComponent />);
    expect(element.find(MyComponent).dive().text()).toBe("Provided Value");
});

最后，Hooks FAQ有一个用ReactDOM测试钩子的例子，它也可以工作。自然，使用ReactDOM意味着这也是一个深层渲染，而不是浅层渲染。

let container;
beforeEach(() => {
    container = document.createElement('div');
    document.body.appendChild(container);
});

afterEach(() => {
    document.body.removeChild(container);
    container = null;
});

test("with ReactDOM", () => {
    act(() => {
        ReactDOM.render((
            <NameContext.Provider value="Provided Value">
                <MyComponent />
            </NameContext.Provider>
        ), container);
    });

    expect(container.textContent).toBe("Provided Value");
});