标签: jest-fetch-mock

在下面放入一个小片段：

import xyz from '../xyz'
function calculate() {
  return xyz(arg1, arg2).catch((err) => {
    func1()
    func2()
  })
}
export default calculate

我只是想断言 xyz 是开玩笑地调用的。我该怎么做 ？

我尝试了以下方法但不起作用：

import * as myModule from '../xyz'
import calculate from '../../calculate'
const mock = jest.spyOn(myModule, 'xyz')
mock.mockReturnValue('mocked value')
const op = calculate()
expect(op).toBe('mocked value')

这给了我以下错误：

无法监视 xyz 属性，因为它不是函数；未定义给定代替

我在react功能组件中调用api。我正在编写组件的单元测试用例。我使用 jest-fetch-mock 模拟了 fetch。

global.fetch = require('jest-fetch-mock');

组件.ts

const Component = () => {

    useEffect(() => {
      return fetch(
          'url',
        )
          .then(response => response.json())
          .then(json => {
            setApiResult(json);
            setFilterResult(json?.videos);
          })
          .catch(error => {
            console.error(error);
          });
    }, []);

}

有谁知道如何开玩笑地模拟该组件的获取响应。

我是一个 Jest/React 初学者。在玩笑中，it我需要等到所有承诺都已执行后再实际检查。

我的代码类似于：

export class MyComponent extends Component {
    constructor(props) {
        super(props);
        this.state = { /* Some state */ };
    }

    componentDidMount() {
        fetch(some_url)
            .then(response => response.json())
            .then(json => this.setState(some_state);
    }

    render() {
        // Do some rendering based on the state
    }
}

当组件被挂载时，render()运行两次：一次在构造函数运行之后，一次在fetch()(in componentDidMount()) 完成并且链式承诺完成执行之后)。

我的测试代码类似于：

describe('MyComponent', () => {

    fetchMock.get('*', some_response);

    it('renders something', () => {
        let wrapper = mount(<MyComponent />);
        expect(wrapper.find(...)).to.have.something();
    };
}

无论我从什么返回it，它都会在第一次render()执行之后但在第二次执行之前运行。例如，如果我 return …

我正在尝试使用 jest 编写一个单元测试用例，并且需要模拟以下模式。我收到 TypeError: 不是构造函数。

用例：我的用例如下所述

我的组件.js：

 import serviceRegistry from "external/serviceRegistry";


        serviceRegistry.getService("modulename", "servvice").then(
              service => {
                let myServiceInstance = new service();
                myServiceInstance.init(p,d) 
        })

我的组件.spec.js

jest.mock('external/serviceRegistry', () => {
      return {
        getService: jest.fn(() => Promise.resolve({
          service: jest.fn().mockImplementation((properties, data, contribs) => {
            return {
              init: jest.fn(),
              util: jest.fn(),
              aspect: jest.fn()

            };
          })
        }))
      };
    }, {virtual: true});

我有这个常数：

export const clientData = fetch(`${process.env.SERVER_HOST}clientData.json`)
    .then(response => response.json());

哪个工作正常，现在我正在用 Jasmine 和 fetch-mock 测试这个

这是我的测试：

import { clientData } from '../../../src/js/services/client-data.fetch';
import fetchMock from 'fetch-mock';

describe('test', () => {
    const exampleResponse = {
        clientData: 'test'
    };

    beforeAll(() => {
        fetchMock.mock('*', exampleResponse);
    });

    it('ooo', () => {
        console.log('here', clientData);
        var a = clientData;
        a.then(b=> console.log(b))
    });
});

的 console.logclientData返回一个Promise（这很好），但then永远不会触发。

不明白为什么，我的代码有什么问题？

所以，这是我的 touchablehighlight 代码，我使用模拟来调用 onpress 函数，但它不起作用任何人都可以帮助我。

 <TouchableHighlight style={styles.touchableButtonview} 
      onPress = {(this.authUser.bind(this))}>
      <Text style={styles.buttonText}>Sign in</Text>
    </TouchableHighlight>

jest-fetch-mock 有一个我遵循的 Typescript 设置指南：https ://www.npmjs.com/package/jest-fetch-mock

// package.json
, "devDependencies": {
    "@types/jest": "^24.0.23",
    "jest": "^24.9.0",
    "jest-fetch-mock": "^2.1.2",
    "ts-jest": "^24.2.0",
    "typescript": "^3.7.2"
  },
  "jest": {
    "automock": false,
    "setupFiles": ["./setupJest.ts"]
  }

// setupJest.ts
import {GlobalWithFetchMock} from "jest-fetch-mock";

const customGlobal: GlobalWithFetchMock = global as GlobalWithFetchMock;

customGlobal.fetch = require('jest-fetch-mock');
customGlobal.fetchMock = customGlobal.fetch;

但是当我尝试设置一个虚拟的解析值时：

// ScriptTag.test.ts
  test("", async () => {
    fetch.mockResponseOnce(JSON.stringify(1));
    const data = await fetchMock("x");

    await expect(data.json()).resolves.toStrictEqual(2);
  })

// terminal
 FAIL  functions/src/classes/__tests__/ScriptTag.test.ts
  ? Test suite failed to run

    TypeScript diagnostics (customize using `[jest-config].globals.ts-jest.diagnostics` …

我正在编写一个 React Native 应用程序，我正在使用 Jest 对我的代码进行单元测试。

我写了一个函数，而不是检查是否有互联网连接。我知道想写它的单元测试。我被卡住了，因为我不知道如何在单元测试中模拟设备的连接状态。

您将如何在单元测试中模拟设备离线或在线？

编辑：

这是函数：

import { NetInfo } from "react-native";
import { NO_NETWORK_CONNECTION } from "../../../../config/constants/errors";

const checkNetwork = (): Promise<boolean | string> =>
  new Promise((resolve, reject) => {
    NetInfo.isConnected
      .fetch()
      .then(isConnected => (isConnected ? resolve(true) : reject(NO_NETWORK_CONNECTION)))
      .catch(() => reject(NO_NETWORK_CONNECTION));
  });

export default checkNetwork;

我想在我的测试中测试它，看看它是否正确解析为 true 如果设备已连接并拒绝字符串，如果请求失败。为此，我需要在单元测试中模拟设备连接。

我正在编写一个 Jest 测试，其中我调用一个函数并期望返回一个对象，如下所示：

const repository = container => {

  const makeBooking = (user, booking) => {
    'make booking function called'
  }

  const generateTicket = (paid, booking) => {
    console.log('generate ticket function called')
  }

  const getOrderById = orderId => {
    console.log('get order by ID called')
  }

  const disconnect = () => {
    console.log('disconnect method called')
  }

  return {
    makeBooking,
    getOrderById,
    generateTicket,
    disconnect
  }
}

为了举例，所有这些函数现在都是示例。我现在导出函数，然后在测试中使用它，如下所示：

container = {}

describe('Repository', () => {
  it('should connect with a container', () => {
    let …

我正在尝试模拟尚未在 npm 存储库中发布的外部依赖项。

import Utils from 'external-dependency';
jest.mock('external-dependency', () => ({
default: ()=> jest.fn()
}));

上面的笑话模拟显示以下错误，因为该依赖项尚不存在。

找不到模块“外部依赖”

如何在 Jest 中模拟不存在的依赖关系？

jest.mock(..)似乎不适用于我的测试的“描述”级别。

如果我有以下内容：

import React from 'react';
import {someFunction} from "./something/someFile";

describe('Overview Test', () => {

    jest.mock(someFunction);

    test(' snapshot', () => {

    });
});

然后运行“测试”（即在测试级别），工作正常。

但是，如果我运行“描述”（即描述级别或套件级别），则会出现以下错误：

TypeError: moduleName.split is not a function

    at Resolver.resolveModuleFromDirIfExists (A:\frontend\node_modules\jest-resolve\build\index.js:224:30)
    at Resolver.resolveModule (A:\frontend\node_modules\jest-resolve\build\index.js:252:12)

如果我有这个：

describe('Overview Test', () => {
    test(' snapshot', () => {
        jest.mock(someFunction);
    });
});

那么这两种方式都不起作用。

我也试过这个：

import React from 'react';
import {someFunction} from "./something/someFile";


describe('Overview Test', () => {

    beforeEach(() => {
        jest.mock(someFunction);
    });

    test(' snapshot', () => {

    }); …

我正在尝试在 Jest 中模拟慢速网络（使用 React 测试库）。我试图设置的条件是这样的：

1. UI 处于特定状态
2. 异步 AJAX 请求被触发
3. 用户界面改变状态
4. 异步请求完成

在我看来，这是一个相当常见的要求，因为使用异步编程，您必须了解 AJAX 请求发送和完成之间可能发生的情况。但是，我根本找不到该领域的任何讨论或工具。