React Native中Jest质数测试用例全部失败问题求助

我用Jest为React Native编写质数判断函数的测试用例，手动执行函数功能正常，但所有测试用例均失败。以下是相关代码及错误日志：

Home.js #

import {Text, View, StyleSheet, TextInput} from 'react-native';
import React, {Component} from 'react';

export default class Home extends Component {
  primeNumber = num => {
    let isPrime = false;
    if (num === undefined) {
      throw new Error('Please pass a input value');
    } else if (typeof num !== 'number') {
      throw new Error('The input value should be a integer only');
    } else if (num < 0) {
      throw 'Negative integers cannot be prime';
    } else if (num == 0 || num == 1) {
      throw new Error('O or 1 is neither prime not composite number');
    } else if (num > 1) {
      for (let i = 2; i <= num; i++) {
        if (num % i == 0) {
          isPrime = false;
          break;
        }
      }
      if (isPrime) return 'Its a prime number';
      else return 'Its not a prime number';
    }
  };


   render() {
      return (
         <View> 
            <Text> Home </Text>
         </View>
      )
   }
}

Home-test.js #

import React from 'react';
import Home from './home';
import renderer from 'react-test-renderer';

describe('Prime Number', () => {
  let homeInstance = renderer.create(<Home />).getInstance();

  it('should throw an error if called without an argument', () => {
    expect(homeInstance.primeNumber).toThrow('Please pass a input value');
  });

  it('should throw an error if the input value is a string', () => {
    expect(homeInstance.primeNumber('Ahmed')).toThrow(
      'The input value should be a integer only',
    );
  });

  it('Negative number cannot be prime', () => {
    expect(homeInstance.primeNumber(-1)).toThrow(
      'Negative integers cannot be prime',
    );
  });

  it('0 is not a prime number', () => {
    expect(homeInstance.primeNumber(0)).toThrow(
      'O or 1 is neither prime not composite number',
    );
  });

  it('1 is not a prime number', () => {
    expect(homeInstance.primeNumber(1)).toThrow(
      'O or 1 is neither prime not composite number',
    );
  });

  it('Prime Number', () => {
    expect(homeInstance.primeNumber(2)).toEqual('Its a prime number');
  });

  it('Prime Number', () => {
    expect(homeInstance.primeNumber(4)).toEqual('Its not a prime number');
  });
});

错误日志 #

'Prime Number
    ✕ should throw an error if called without an argument (1 ms)
    ✕ should throw an error if the input value is a string
    ✕ Negative number cannot be prime
    ✕ 0 is not a prime number
    ✕ 1 is not a prime number
    ✕ Prime Number
    ✕ Prime Number

  ● 'Prime Number › should throw an error if called without an argument

    expect(received).toThrow(expected)

    Expected substring: "Please pass a input value"

    Received function did not throw

      36 |
      37 |   it('should throw an error if called without an argument', () => {
    > 38 |     expect(homeInstance.primeNumber).toThrow('Please pass a input value');
         |                                      ^
      39 |   });
      40 |
      41 |   it('should throw an error if the input value is a string', () => {

      at Object.toThrow (src/screens/Home/home.test.js:38:38)

  ● 'Prime Number › should throw an error if the input value is a string

    expect(received).toThrow(expected)

    Matcher error: received value must be a function

    Received has value: undefined

      40 |
      41 |   it('should throw an error if the input value is a string', () => {
    > 42 |     expect(homeInstance.primeNumber('Ahmed')).toThrow(
         |                                               ^
      43 |       'The input value should be a integer only',
      44 |     );
      45 |   });

      at Object.toThrow (src/screens/Home/home.test.js:42:47)

  ● 'Prime Number › Negative number cannot be prime

    thrown: "Negative integers cannot be prime"

      45 |   });
      46 |
    > 47 |   it('Negative number cannot be prime', () => {
         |   ^
      48 |     expect(homeInstance.primeNumber(-1)).toThrow(
      49 |       'Negative integers cannot be prime',
      50 |     );

      at it (src/screens/Home/home.test.js:47:3)
      at Object.describe (src/screens/Home/home.test.js:34:1)

  ● 'Prime Number › 0 is not a prime number

    expect(received).toThrow(expected)

    Matcher error: received value must be a function

    Received has value: undefined

      52 |
      53 |   it('0 is not a prime number', () => {
    > 54 |     expect(homeInstance.primeNumber(0)).toThrow(
         |                                         ^
      55 |       'O or 1 is neither prime not composite number',
      56 |     );
      57 |   });

      at Object.toThrow (src/screens/Home/home.test.js:54:41)

  ● 'Prime Number › 1 is not a prime number

    expect(received).toThrow(expected)

    Matcher error: received value must be a function

    Received has value: undefined

      58 |
      59 |   it('1 is not a prime number', () => {
    > 60 |     expect(homeInstance.primeNumber(1)).toThrow(
         |                                         ^
      61 |       'O or 1 is neither prime not composite number',
      62 |     );
      63 |   });

      at Object.toThrow (src/screens/Home/home.test.js:60:41)

  ● 'Prime Number › Prime Number

    expect(received).toEqual(expected) // deep equality

    Expected: "Its a prime number"
    Received: undefined

      64 |
      65 |   it('Prime Number', () => {
    > 66 |     expect(homeInstance.primeNumber(2)).toEqual('Its a prime number');
         |                                         ^
      67 |   });
      68 |
      69 |   it('Prime Number', () => {

      at Object.toEqual (src/screens/Home/home.test.js:66:41)

  ● 'Prime Number › Prime Number

    expect(received).toEqual(expected) // deep equality

    Expected: "Its not a prime number"
    Received: undefined

      68 |
      69 |   it('Prime Number', () => {
    > 70 |     expect(homeInstance.primeNumber(4)).toEqual('Its not a prime number');
         |                                         ^
      71 |   });
      72 | });
      73 |

      at Object.toEqual (src/screens/Home/home.test.js:70:41)

Test Suites: 1 failed, 1 total
Tests:       7 failed, 3 passed, 10 total
Snapshots:   0 total
Time:        0.563 s, estimated 1 s

解决方法 #

1. 修正Jest测试用例的toThrow用法 #

所有测试抛出错误的用例，必须将函数调用包裹在箭头函数中，让Jest捕获抛出的错误：

// 修正后的测试用例示例
it('should throw an error if called without an argument', () => {
  expect(() => homeInstance.primeNumber()).toThrow('Please pass a input value');
});

it('should throw an error if the input value is a string', () => {
  expect(() => homeInstance.primeNumber('Ahmed')).toThrow(
    'The input value should be an integer only',
  );
});

it('Negative number cannot be prime', () => {
  expect(() => homeInstance.primeNumber(-1)).toThrow(
    'Negative integers cannot be prime',
  );
});

it('0 is not a prime number', () => {
  expect(() => homeInstance.primeNumber(0)).toThrow(
    '0 or 1 is neither prime nor composite number',
  );
});

it('1 is not a prime number', () => {
  expect(() => homeInstance.primeNumber(1)).toThrow(
    '0 or 1 is neither prime nor composite number',
  );
});

原因：直接执行函数会立即抛出错误导致测试崩溃；直接传函数给expect而不调用，不会触发错误逻辑，Jest无法捕获到错误。

2. 修复质数判断函数的核心逻辑错误 #

原函数的质数判断逻辑完全错误，修正后的函数如下：

primeNumber = num => {
  if (num === undefined) {
    throw new Error('Please pass a input value');
  } else if (typeof num !== 'number' || !Number.isInteger(num)) {
    throw new Error('The input value should be an integer only');
  } else if (num < 0) {
    throw new Error('Negative integers cannot be prime');
  } else if (num === 0 || num === 1) {
    throw new Error('0 or 1 is neither prime nor composite number');
  } else if (num > 1) {
    let isPrime = true;
    // 遍历到平方根即可，提升效率
    for (let i = 2; i <= Math.sqrt(num); i++) {
      if (num % i === 0) {
        isPrime = false;
        break;
      }
    }
    return isPrime ? 'Its a prime number' : 'Its not a prime number';
  }
};

修正点：

• 将isPrime初始值设为true，默认假设数字是质数
• 循环遍历到Math.sqrt(num)即可，无需遍历到num
• 统一抛出Error对象（原代码中负数抛出字符串）
• 修正错误信息的拼写错误：O改为0，not改为nor
• 增加对非整数数字的判断（比如2.5这类浮点数）

3. 修正测试用例的重复命名 #

最后两个测试用例名称重复，改为明确的命名：

it('should return "Its a prime number" for 2', () => {
  expect(homeInstance.primeNumber(2)).toEqual('Its a prime number');
});

it('should return "Its not a prime number" for 4', () => {
  expect(homeInstance.primeNumber(4)).toEqual('Its not a prime number');
});

内容的提问来源于stack exchange，提问作者Shariq Ahmed -