Connect with us

Автоматическое тестирование приложений

Что такое мутационное тестирование

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

Опубликовано

/

     
     

Высокое покрытие кода тестами ещё не означает, что тесты действительно хорошо находят ошибки. Можно добиться 80–90% покрытия и при этом пропустить неправильное условие, пограничное значение или изменение бизнес-логики. Мутационное тестирование пытается проверить именно качество тестов, а не количество строк, через которые они проходят.

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

Как работает мутационное тестирование

Представим простое правило в Android-приложении:

fun canEnter(age: Int): Boolean { return age >= 18 }

Для него написаны тесты:

@ParameterizedTest
@CsvSource(
    "17, false",
    "19, true"
)
fun canEnterTest(age: Int, expected: Boolean) {
    assertEquals(expected, canEnter(age))
}

Оба теста проходят. Покрытие строки с условием будет полным, поэтому обычный отчёт о покрытии не покажет никаких проблем.

Теперь инструмент мутационного тестирования временно изменяет:

age >= 18

на:

age > 18

и снова запускает тесты. Оба теста по-прежнему проходят. Это означает, что тесты не проверяют самый важный граничный случай — возраст ровно 18 лет.

Такая мутация называется выжившей: в код внесли ошибку, но тесты её не обнаружили.

Чтобы «убить» мутацию, достаточно добавить проверку:

@CsvSource(
    "17, false",
    "18, true",
    "19, true"
)

Теперь изменение >= на > приведёт к падению теста.

Какие изменения вносит мутационное тестирование

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

Например:

price > 0

может временно превратиться в:

price >= 0

Условие:

if (isPremium)

может быть инвертировано.

Возвращаемое значение:

return true

может замениться на:

return false

Также могут удаляться вызовы методов, изменяться арифметические операции или условия циклов. Каждый изменённый вариант программы называется мутантом. После его создания запускаются тесты. Если хотя бы один тест падает, мутант считается убитым. Если тесты проходят — мутант выжил.

Почему обычного покрытия кода недостаточно

Покрытие отвечает преимущественно на вопрос:

«Выполнялась ли эта строка во время тестирования?»

Мутационное тестирование задаёт другой вопрос:

«Если поведение этой строки станет неправильным, заметят ли это тесты?»

Для мобильных приложений различие особенно важно. Например, тест может пройти через условие:

if subscription.isActive {
    showPremiumFeatures()
}

и обеспечить покрытие этой строки. Но если тест никогда не проверяет результат при isActive == false, изменение условия может остаться незамеченным.

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

Где это полезно в мобильной разработке

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

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

Например, приложение разрешает бесплатно определить пять объектов:

fun canRecognize(used: Int): Boolean {
    return used < 5
}

Тесты для значений 0 и 6 могут проходить, но ничего не говорить о значении 5. Мутация < → <= сразу покажет отсутствие проверки границы.

Для пользовательского интерфейса польза обычно меньше. Проверять таким способом цвет кнопки, положение элемента или конкретную SwiftUI/Compose-разметку зачастую бессмысленно. Такие вещи лучше проверяются снимками экрана, визуальными тестами и тестами пользовательских сценариев.

Мутационное тестирование в Android

В экосистеме JVM одним из наиболее известных инструментов является PIT. Он работает необычным способом: вместо изменения исходных .kt или .java файлов PIT модифицирует уже созданный JVM-байткод.

Это делает процесс быстрее, но для Kotlin создаёт дополнительную проблему.

Компилятор Kotlin генерирует JVM-код, которого непосредственно в исходном файле не было. Особенно много такого кода появляется вокруг suspend-функций, корутин, лямбда-выражений и других возможностей языка.

Например, PIT может сообщить о мутации вызова:

kotlin/ResultKt::throwOnFailure

хотя разработчик никогда явно не писал такой вызов. Его добавил компилятор Kotlin.

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

А что с iOS и Swift

Принцип не зависит от языка. Для Swift можно использовать тот же подход: временно менять выражения и проверять, обнаруживают ли изменения XCTest или Swift Testing.

Особенно полезным это может быть для моделей, преобразователей данных, Reducer, ViewModel и другой логики, отделённой от UIKit или SwiftUI.

Например:

func canUsePremiumFeature(remainingDays: Int) -> Bool {
    remainingDays > 0
}

Если мутация заменит > на >=, хороший тестовый набор должен заметить изменение поведения при remainingDays == 0.

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

Почему мутационное тестирование снова становится актуальным из-за ИИ

ИИ-агенты способны очень быстро создавать большое количество тестов. Но количество созданных тестов ничего не говорит об их качестве.

Агент может написать десятки тестов, получить зелёный результат и высокое покрытие. При этом все проверки могут повторять одни и те же очевидные сценарии и пропускать важные границы.

Мутационное тестирование создаёт дополнительную независимую проверку.

Получается полезный цикл:

ИИ пишет код → ИИ пишет тесты → инструмент намеренно ломает код → тесты должны обнаружить поломку.

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

Это намного надёжнее команды вроде «напиши хорошие тесты», потому что появляется объективный критерий результата.

Но не каждую выжившую мутацию нужно исправлять

Выживший мутант не всегда означает плохой тест.

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

Поэтому цель не обязательно заключается в том, чтобы добиться 100% уничтоженных мутантов.

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

Недостатки мутационного тестирования

Главный недостаток — стоимость выполнения.

При обычном тестировании набор тестов запускается один раз. При мутационном тестировании код изменяется десятки, сотни или тысячи раз, и для каждого значимого изменения тесты приходится запускать снова.

Для большого мобильного проекта это может занимать значительное время.

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

Особенно важно, чтобы основная логика имела быстрые модульные тесты. Если для проверки каждого мутанта необходимо запускать симулятор iOS или эмулятор Android, преимущества такого подхода быстро исчезают.

Как внедрить мутационное тестирование в мобильный проект

Начинать лучше не со всего приложения, а с небольшого критичного модуля — например, логики подписок, покупок, авторизации или расчётов.

Сначала запускаются существующие тесты и обычное измерение покрытия. Затем запускается мутационное тестирование и анализируются выжившие мутации.

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

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

Главное

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

Для мобильной разработки это особенно интересно в бизнес-логике, где одна незамеченная замена > на >=, неправильный статус подписки или ошибка в граничном значении может непосредственно повлиять на пользователей и деньги.

С распространением ИИ-агентов значение такого подхода только растёт. Теперь тесты можно генерировать практически без ограничений, поэтому главным вопросом становится уже не «написаны ли тесты?», а «действительно ли они способны обнаружить ошибку?»

И именно на этот вопрос отвечает мутационное тестирование.

Еще

Если вы нашли опечатку - выделите ее и нажмите Ctrl + Enter! Для связи с нами вы можете использовать info@apptractor.ru.
Telegram

Популярное

Сообщить об опечатке

Текст, который будет отправлен нашим редакторам: