Как часто мы должны записать модульные тесты?

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

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

Прочтите блог Мишко Хевери , прочтите несколько книг (мне понравился Test Driven Лассе Коскела), воспользуйтесь некоторыми инструментами покрытия кода, такими как Clover и затем напишите несколько тестов.

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

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

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

Правильный / исчерпывающий ответ на этот вопрос должен быть длинным, поскольку это ключевой вопрос для каждого процесса тестирования, но я отвечу следующими простыми (?) Правилами:

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

2. Если вам дольше 5 секунд интересно, является ли что-то важным достаточно для тестирования, тогда предположите, что это: -)

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

Лично я использую модульные тесты, когда у меня большой объем данных, и я не хочу копировать / вставлять много System.out.println и проверять их один на один. { {1}} С модульными тестами вы теряете 1 час на их написание и сохраняете много времени на тестирование. Для тривиальных вещей я предпочитаю использовать println tecnic или проверять переменные отладки.

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

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

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

Мой наставник / руководитель разработки просит меня написать новый модульный тестовый пример для недавно написанного потока управления

Как появился этот поток управления написано, разве это было необходимо для прохождения неудачного теста? Согласно определению TDD , производственный код не будет существовать, если сначала не будет проведен неудачный тест, требующий написания этого фрагмента кода. Значит, вы, должно быть, писали код, используя метод последнего тестирования, а не TDD.

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

Я думаю, что ваш наставник, использующий фразу «всякий раз, когда это имеет смысл», может быть вредным, особенно для людей, плохо знакомых с TDD, потому что невозможно принять правильное решение по этому поводу, пока не будет много лет опыта, после один достиг Ri-уровня . Однажды, когда Кент Бек решил не писать тест , это было правильно прокомментировано Роном Джеффрисом: «Я доверяю вам и еще трем другим людям принимать правильные решения в короткой игре. . "

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

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

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

Если вы думаете, что это излишество, спросите себя: "Если я не протестирую этот код, как я узнаю, что он работает?"

Модульные тесты:

• дадут вам уверенность в необходимости внесения изменений в рефакторинг, зная, что вы больше ничего не нарушаете.
• действуют как своего рода «живая документация» вашего кода, позволяя другим точно знать, как код будет вести себя в различных обстоятельствах.
• при соблюдении строгой TDD, описанной в @Justin , прохождение всех модульных тестов, написанных до того, как вы начали писать код, сообщит вам, когда вы "закончили" кодирование. По моему опыту, это также приводит к значительно упрощенному и более понятному (более чистому) коду.

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

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