Стратегии рефакторинга

Рефакторинг тестов с использованием Jest — важный процесс, который позволяет повысить качество и поддержку тестов в долгосрочной перспективе. Рефакторинг не ограничивается лишь улучшением читаемости кода, но также помогает оптимизировать производительность тестов и упрощает их модификацию при изменении логики приложения. Важность рефакторинга заключается в том, что тесты, как и любой другой код, со временем могут становиться сложными, избыточными или неэффективными.

Рефакторинг с учётом принципа DRY

Одной из основных стратегий рефакторинга является соблюдение принципа DRY (Don’t Repeat Yourself). Этот принцип акцентирует внимание на исключении дублирования кода в тестах. Повторяющийся код в тестах затрудняет их поддержку и увеличивает вероятность ошибок при изменении логики. В Jest для сокращения повторений используются следующие методы:

1. Использование вспомогательных функций

Вместо того чтобы повторно писать один и тот же код в нескольких тестах, можно вынести общие операции в вспомогательные функции или моки. Это помогает уменьшить избыточность и повысить читаемость тестов.

Пример:

function setupMocks() {
  return {
    fetchData: jest.fn().mockResolvedValue('data'),
  };
}

describe('MyComponent', () => {
  it('should fetch data on mount', () => {
    const { fetchData } = setupMocks();
    // тест с использованием fetchData
  });

  it('should handle fetch errors', () => {
    const { fetchData } = setupMocks();
    fetchData.mockRejectedValueOnce('error');
    // тест с использованием fetchData
  });
});

2. Использование хуков beforeAll, beforeEach, afterAll, afterEach

Для уменьшения повторений в тестах можно использовать хуки, которые позволяют выполнить подготовку или очистку данных до или после каждого теста.

Пример:

describe('UserService', () => {
  let userService;

  beforeAll(() => {
    userService = new UserService();
  });

  it('should fetch user data', async () => {
    const data = await userService.getUser(1);
    expect(data).toEqual({ id: 1, name: 'John' });
  });

  it('should throw error for invalid user ID', async () => {
    await expect(userService.getUser(-1)).rejects.toThrow('Invalid ID');
  });
});

В этом примере подготовка и очистка данных выполняется один раз перед всеми тестами, что исключает дублирование логики.

Использование моков и шпионов для улучшения тестирования

Моки и шпионы (spies) играют ключевую роль в рефакторинге тестов, особенно когда речь идёт о взаимодействиях с внешними сервисами или сложными зависимостями. Моки позволяют заменить реальные имплементации функций, а шпионы — отслеживать вызовы функций и их аргументы.

1. Моки для имитации зависимостей

Моки используются для имитации зависимостей в тестах, чтобы сосредоточиться на логике компонента или функции, не зависеть от внешних сервисов.

Пример:

const fetchData = jest.fn(() => Promise.resolve({ id: 1, name: 'John' }));

describe('UserService', () => {
  it('should fetch user data correctly', async () => {
    const data = await fetchData();
    expect(data).toEqual({ id: 1, name: 'John' });
  });
});

2. Шпионы для проверки вызовов

Шпионы используются для проверки того, что функция была вызвана с правильными аргументами или с правильной частотой.

Пример:

const myFunction = jest.fn();

describe('Function call tests', () => {
  it('should call function once', () => {
    myFunction();
    expect(myFunction).toHaveBeenCalledTimes(1);
  });

  it('should call function with correct argument', () => {
    myFunction('test');
    expect(myFunction).toHaveBeenCalledWith('test');
  });
});

Разбиение тестов на более мелкие блоки

Ещё одной важной стратегией рефакторинга является разбиение больших тестов на более мелкие и специализированные блоки. Большие тесты сложно поддерживать и они могут скрывать детали, которые важны для правильного понимания тестируемого поведения. Малые тесты с чётко определёнными задачами проще поддерживать и анализировать.

Пример до рефакторинга:

describe('UserService', () => {
  it('should fetch user data, handle errors, and update UI correctly', async () => {
    const userService = new UserService();
    const data = await userService.getUser(1);
    expect(data).toEqual({ id: 1, name: 'John' });

    // Дополнительная логика обработки ошибок и обновления UI
  });
});

Пример после рефакторинга:

describe('UserService', () => {
  it('should fetch user data correctly', async () => {
    const userService = new UserService();
    const data = await userService.getUser(1);
    expect(data).toEqual({ id: 1, name: 'John' });
  });

  it('should handle fetch errors correctly', async () => {
    const userService = new UserService();
    await expect(userService.getUser(-1)).rejects.toThrow('Invalid ID');
  });
});

Разбиение тестов позволяет значительно улучшить структуру кода и упростить диагностику ошибок.

Устранение ненужных зависимостей

Часто в процессе рефакторинга тестов можно обнаружить ненужные зависимости, которые увеличивают сложность тестов без явной пользы. Например, использование глобальных переменных, тяжёлых моков или тестов, которые проверяют слишком много аспектов поведения одновременно. Это приводит к избыточности и усложнению кода тестов.

Пример избыточной зависимости:

describe('UserService', () => {
  it('should fetch and save user data', async () => {
    const userService = new UserService();
    const data = await userService.getUser(1);
    await userService.saveUser(data);
    expect(data).toEqual({ id: 1, name: 'John' });
  });
});

В данном примере происходит тестирование не только получения данных, но и их сохранения, что не должно быть частью одного теста. Лучше разделить эти действия на два отдельных теста.

Повторное использование существующих тестов

Когда появляется необходимость внести изменения в логику программы, важно не писать тесты с нуля, а пытаться переиспользовать существующие. Переиспользование тестов снижает количество написанного кода и повышает общую консистентность. В Jest можно использовать такие механизмы, как импорты и mock-функции для эффективного переиспользования.

Пример:

import { fetchData } from './api';

jest.mock('./api');

describe('UserService', () => {
  it('should fetch user data correctly', async () => {
    fetchData.mockResolvedValue({ id: 1, name: 'John' });
    const data = await fetchData();
    expect(data).toEqual({ id: 1, name: 'John' });
  });

  it('should throw error for invalid data', async () => {
    fetchData.mockRejectedValue(new Error('Invalid data'));
    await expect(fetchData()).rejects.toThrow('Invalid data');
  });
});

Этот подход минимизирует дублирование и облегчает поддержку кода в будущем.

Заключение

Рефакторинг тестов в Jest не только улучшает их структуру и читаемость, но и помогает оптимизировать их выполнение, повышая эффективность тестирования. Применяя стратегии, такие как соблюдение принципа DRY, использование моков и шпионов, разделение тестов на более мелкие блоки, устранение ненужных зависимостей и повторное использование существующих тестов, можно значительно улучшить качество тестов и упростить их поддержку.

Оглавление