Какова ценность проверки при неудачных юнит-тестах?

Хотя существуют способы не допустить выполнения модульных тестов, какова ценность проверки при неудачных модульных тестах?

Я буду использовать простой пример: чувствительность к регистру. Текущий код чувствителен к регистру. Допустимый вход в метод - «Cat», и он будет возвращать перечисление Animal.Cat. Однако желаемая функциональность метода не должна учитывать регистр символов. Таким образом, если описанный метод был передан как «cat», он может вернуть что-то вроде Animal.Null вместо Animal.Cat, и модульный тест завершится неудачей. Хотя простое изменение кода сделает эту работу, более сложная проблема может занять несколько недель, но выявление ошибки с помощью модульного теста может быть менее сложной задачей.

Приложение, которое в настоящее время анализируется, имеет 4 года кода, который «работает». Однако недавние обсуждения, касающиеся модульных тестов, обнаружили недостатки в коде. Некоторым просто нужна явная документация по реализации (например, с учетом регистра или нет) или код, который не выполняет ошибку в зависимости от того, как она в данный момент вызывается. Но могут быть созданы модульные тесты, выполняющие определенные сценарии, которые приведут к появлению ошибки и являются допустимыми входными данными.

Какова ценность проверки в модульных тестах, которые осуществляют ошибку до тех пор, пока кто-то не сможет исправить код?

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

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

Я не люблю проверенные юнит-тесты потому что они производят ненужный шум. После каждого юнит-теста мне придется проверять все неисправности (красный). Это красный, потому что есть новая проблема или потому что есть старый открытый, чтобы сделать / исправить. Это не хорошо, если есть более 20 юниттестов.

Вместо этого я использую

• [Ignore("Reason")]атрибут, который делает результат желтым или
• throw new NotImplementedException()это делает результат серым

Примечание: я использую NUnit для .net. Я не уверен, присутствует ли «серая» функция в других инфраструктурах unittest.

Поэтому мне нравится следующее значение результатов юнит-теста.

• зеленый: все готово
• серый: запланированные новые функции, которые должны быть выполнены, но с низким приоритетом
• желтый: ошибки еще не исправлены. Должен быть исправлен в ближайшее время
• красный: новые ошибки. Должны быть исправлены немедленно

Все, кроме "красного" может быть проверено.

Чтобы ответить на вопрос: проверка «red-failed-testes» приносит больше вреда, чем значения, но проверка в «yellow-ignored-tests» или «grey-NotImplementedYet-tests» может быть полезна в качестве списка задач.

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

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

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

Короче говоря, неудачные юнит-тесты дают команде список «TODO».

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

[* При условии, что модульные тесты действительно проверяют что-то полезное.]

Целью модульных тестов является утверждение ожидаемого поведения системы, а не документирование дефектов. Если мы используем модульные тесты для документирования дефектов, то их полезность для подтверждения ожидаемого поведения уменьшается. Ответ на вопрос «Почему этот тест не прошел?» не просто «О, что-то сломано, что я не ожидал, что сломается». Стало неизвестным, ожидаемый или неожиданный сбой теста.

Вот параграф с начала главы 13 « Эффективной работы с устаревшим кодом» :

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

Но сломаны те, которые выявляют ошибки в новом проекте, названном таковым. Таким образом, вы можете увидеть, что они ДОЛЖНЫ сломаться ... Когда они будут исправлены, они станут зелеными и перемещены в обычный набор тестов.

ПРИМЕЧАНИЕ. Этот проект должен быть настроен так, чтобы не быть собранным на сервере сборки, если ваш сервер сборки предотвращает проверки, нарушающие сборку (при условии, что вы определяете сломанную сборку как ту, в которой не проходят все тесты)

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

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

Суть модульного тестирования не в том, чтобы достичь 100% успеха, а в том, чтобы находить и исправлять ошибки в коде. Не делать тесты - это простой способ достичь 100% успеха, но это не очень выгодно для проекта.

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

Как я вижу, TDD завершен с реализацией тестов для незавершенного кода, сначала пишите тесты с атрибутом [ExpectedException] или подобным. Первоначально это должно пройти, поскольку неполный код не будет содержать никакой логики и будет писать новый код Exception (). Хотя сквозное исключение является неправильным, это по крайней мере заставило бы тесты пройти сначала и пригодно для регистрации. Мы можем забыть проигнорированный тест, но можем наверстать упущенное или заполнить неполный код. Когда мы сделаем это, автоматически соответствующий тест, который ожидал исключения, теперь начал бы проваливаться и сигнализировать вам об этом. Это может включать небольшое изменение теста, чтобы избавиться от ExpectException и вместо этого сделать реальные утверждения. CI, Dev, тестеры и клиенты все счастливы и беспроигрышная ситуация?