Являются ли тесты хрупкой единицы всегда плохими?

Ответ 1

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

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

Ответ 2

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

...

или я пропущу точку вопроса?

Изменить: Я должен уточнить свой более ранний ответ.

Я был немного педантичен в отношении языка. "хрупкий" просто означает "легко сломать". A unit test следует легко разбить. Термин "хрупкие тесты" действительно должен быть "чрезмерно хрупким"; тесты, которые ломаются, когда они не должны. Тем не менее, гораздо легче исправить чрезмерный хрупкий тест, чем исправить ошибку, которая проскользнула из-под хрупкого теста, поэтому продолжайте и напишите свои хрупкие тесты!

Ответ 3

IMO, если ваши тесты удостоверяются, что ваш код приложения делает то, что он должен делать, а если он изменен, тесты терпят неудачу, тогда ваши тесты в порядке. Не могли бы вы определить, что именно вы подразумеваете под "хрупким"?

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

Ответ 4

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

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

Определенный "запах" случайного хрупкого теста - это использование функции sleep() в тесте.

Ответ 5

Да, хрупкость тестов всегда плохая. Но, похоже, это одна из тех вещей, с которыми нам нужно жить, чтобы полностью протестировать наши классы. Многие классы не могут быть протестированы, как черные ящики, которые принимают некоторый вклад и возвращают некоторый результат, как вы могли бы видеть с помощью Math.cos(). Большинство из них имеют побочные эффекты для других классов или сущностей в системе, и вы должны проверить, что эти объекты были правильно обработаны классом. Это означает, что тест должен знать подробности реализации тестируемого класса, что создает хрупкие классы.

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

Ответ 6

Когда изменение кода означает "внутреннее" для класса (т.е. не меняющее API), приводит к сбою теста, возможны две возможности:

• В коде есть новая ошибка, OR
• Код верный, проверка требует фиксации

Попробуйте уменьшить # 2. Это "хрупкие" тесты.

Ответ 7

Модульные тесты по определению являются хрупкими. Они ломаются, когда изменяется связанный код (тестируемая система). Это по дизайну. То, как модульные тесты предоставляют ценность.

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

К сожалению, избежать такой хрупкости нелегко. Во всех, кроме простейших случаях, unit test будет иметь некоторые знания о реализации тестируемой системы (например, mocked objects). Пока это правда, тест будет хрупким.

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