Я участвовал во многих проектах, как старых, так и новых, и одна вещь, которая у них есть, заключается в том, что почти никто из них не использовал модульное тестирование. Я предпочитаю использовать его, но часто клиент не готов заплатить за это, и предположим, что код работает так, как должен.
Итак, вы используете модульное тестирование в своих проектах или полагаетесь на свои навыки кодирования?
Использование модульного тестирования - это навык кодирования.
Я нахожу, что он добавляет очень мало накладных расходов на время кодирования. Кроме того, созданный код, как правило, намного легче понять и реорганизовать с невыясненным сокращением времени обслуживания.
Полное обсуждение преимуществ здесь: Требуется ли тестирование на единицу?
Буду честным. Я только недавно начал писать модульные тесты, и когда я возвращаюсь, чтобы изменить старую DLL, которая из моих старых старых дней, я буду сидеть и писать модульные тесты, чтобы получить около 100% покрытия кода. Я говорю "рядом", потому что последние несколько процентов могут быть труднодоступными из-за того, что код структурирован, что он не имел насмешливого или модульного тестирования (это очень часто встречается с абстрактными классами или классами, которые P/Invoke в собственный код). И хотя я понимаю, что 100% -ный охват кода - это не то же самое, что и 100% всех путей выполнения кода, я обнаружил, что наличие тестов имеет хороший способ сказать, когда я делаю что-то, что сильно сломается вещей.
Честно говоря, это, вероятно, одна из причин, по которой многие разработчики (включая меня) так долго ждали, чтобы перейти к модульному тестированию (пусть пока не войдет в TDD).
Я не говорю, что все это законные причины, но они более или менее пробивались мне в голову, и я уверен, они тоже прошли некоторые из твоих:
Во-первых, есть мысль по строкам "О, я написал горы кода с нулевыми тестами, и, видя, что я уже раздавлен этой горой, у меня нет времени добавьте еще несколько гор тестового кода поверх него."
Во-вторых, никто не любит говорить о том, что классический цикл кода-отладки на самом деле работает "достаточно хорошо", когда вы
В-третьих, модульные тесты легче оценить, когда вы поддерживаете существующий код, и если вы всегда пишете новый код, то преимущества не сразу очевидны. Когда ваша работа заключается в том, чтобы выпустить утилиту и никогда не трогать ее, разработчик может немного оценить значение в unit test, потому что они, вероятно, не будут работать над этой утилитой или в компании к тому времени, когда программист по обслуживанию (кто хочет появился unit test).
В-четвертых, модульное тестирование - довольно недавняя инновация. (О, тише... Я знаю, что идея существует навсегда, особенно в критически важных и DoD-приложениях, но для "Joe the Plumber Разработчик" вроде меня? упомянутый вообще во время всей моей студенческой карьеры CS в начале этого десятилетия, и в 2008 году я слышал, что это требование для всех проектов с уровня 101. Visual Studio даже не получала встроенную тестовую среду до этого года, и даже тогда только в профессиональном издании.) Было ли это блаженное невежество с моей стороны? Конечно, и я думаю, что многие люди, которые подписывают, потому что это их дневная работа (что хорошо) просто не знают. Если они есть, то они знают, что они должны оставаться текущими, но когда дело доходит до изучения новой методологии (в частности, которая включает в себя написание большего количества кода и принятие большего времени, когда вам нужна эта новая функция, сделанная вчера) означает, что она меня оттолкнут. Это длинный хвост, и через десять лет наши разговоры об модульном тестировании будут казаться странными, как наши бормотания об объектно-ориентированном программировании, позволяющем создать новую эру развития в 1990-х годах. Черт, если я начал модульное тестирование, конец должен быть рядом, потому что я обычно идиот.
В-пятых, модульное тестирование некоторых областей кода действительно сложно, и это напугало меня на некоторое время. Приходят на ум многопоточные очереди событий, графический рендеринг и графические интерфейсы. Многие разработчики это понимают и думают: "Ну, черт, модульное тестирование было бы здорово для библиотечного кода, но когда я в последний раз писал только библиотеку классов". Это займет некоторое время. С этой целью никакие юнит-тесты не обязательно означают, что плохой код впереди.
Наконец, уровень евангелизации, который иногда исходит от сторонников модульного тестирования, может быть пугающим и отстраненным. Серьезно, я думал, что я идиот, потому что я просто не мог понять, как издеваться над определенным интерфейсом и почему я хотел бы этого. Эгоистично, я хотел ненавидеть модульное тестирование, если бы только тот факт, что все не будут закрывать об этом. Нет серебряной пули.
Итак, извиняюсь за бессвязный пост. Вкратце:
Я долгое время не unit test. Теперь я это делаю. Модульные тесты - отличный инструмент, особенно при обслуживании.
Для существующих проектов вы можете по крайней мере войти и написать тест, который документирует текущий ввод и его вывод. Когда вы измените этот большой беспорядок мрачного кода в будущем, вы сможете увидеть, изменили ли вы этот маленький снимок. Это также отличный способ изменить культуру развития в вашей компании.
Пусть начнется огонь! =)
Модульное тестирование не может быть запоздалой мыслью, оно и должно быть чем-то, что влияет на ваш дизайн. Я бы зашел так далеко, что сказал, что даже если вы никогда не напишете или не назовете один unit test, преимущества, которые он имеет в руководстве по управлению жесткими компонентами, стоят усилий в 95% случаев.
После выхода на пару проектов, которые были в производстве, но нуждались в новых новых функциональных возможностях, одна из моих нижних линий в качестве технического руководства, запускающего проект, заключается в том, что модульные тесты являются обязательными.
Это просто стоит слишком много, чтобы попытаться переписать код, который был написан без модульных тестов. Код неизменно плохо структурирован (многотысячный сетевой веб-сервис в одном коде за кем-либо?) И внесение в него изменений (даже если он хорошо структурирован) без появления ошибок - это очень болезненный процесс.
Это становится особенно актуальным, когда проект входит в режим пожаротушения (и не имеет модульных тестов вносит вклад в проекты, попадающие в это состояние) - клиенты становятся сердитыми, они потеряли веру в проект, мало чем хуже, чем быть бедный парень пытается получить следующее исправление без введения целой кучи ошибок регрессии и даже не имеет модульных тестов.
Эти ситуации можно легко избежать или, по крайней мере, смягчить, объяснив ценность тестов впереди. Конечно, есть ситуации, когда модульные тесты не так важны, но они действительно являются исключением.
Итак, да, я настаиваю на модульных тестах и потратил много времени на исправление беспорядков, сделанных другими разработчиками, которые полагались на свои навыки кодирования.
Написание и запуск модульных тестов является частью здорового процесса кодирования, это не дополнение, которое клиент должен иметь, чтобы платить или не платить.
Стратегия тестирования - это проблема кодирования, как и любая другая: какие структуры данных использовать, соглашения об именах переменных, стандарты комментариев и т.д.
Я использую модульное тестирование и tdd, когда могу. Однако, по моему опыту, для каждого сторонника unit test есть три или более разработчиков, которые на самом деле не верят, что писать блок-тесты стоит того, и это замедляет развитие. Однако эти люди склонны молчать, поэтому вы вряд ли увидите много здесь.
Мне нравится аналогия Боба Мартина: представьте, что вы хирург. Что бы вы сказали пациенту, который хотел оплатить операцию, но сказал вам пропустить мытье раньше времени?
Когда клиент нанимает меня на код, они нанимают меня как профессионала, как человека с навыками и дисциплиной профессионала. Моя работа заключается в том, чтобы дать им "код, который работает так, как должен", и Я знаю, лучший способ сделать это - использовать TDD.
Я большой поклонник модульного тестирования, в основном потому, что он полностью аддиктивен - цикл "Code-Test-see-horrible red bar-fix-test-see lovely green bar" в JUnit серьезно получает закачку эндорфинов.
Я согласен с Кеном, что модульное тестирование является частью разработки программного обеспечения.
О вопросе стоимости, это правда, чем писать код плюс unit test длиннее, чем писать только код. Однако, когда вы пишете код вместе со своими тестами - который называется TDD - Test-Driven Development, вы заканчиваете "чистый код, который работает". Когда вы просто пишете код, вы должны заставить его работать, что может быть долгим и болезненным.
Еще одно преимущество заключается в том, что вы знаете, где вы находитесь, поскольку код, который был написан, уже был протестирован с помощью модуля.
Чтобы ответить на ваш вопрос, да, я использую модульное тестирование своих проектов, когда это возможно. Я пишу модульные тесты для всего нового кода, и я стараюсь использовать устаревший код.
Я часто использую модульное тестирование для сложных математических алгоритмов, например для таких функций, как LineIntersectsLine, где вы можете определить некоторые важные примеры для тестирования. После этого легче управлять этой функцией. Вы можете просто переписать/оптимизировать его и проверить, все ли работает, или вы можете добавить новые тесты, если вы столкнулись с ошибками, а затем попытаетесь исправить их.
Я нахожу, что более новые разработчики приносят больше пользы от модульного тестирования, чем более старые, которым приходилось учиться в школе с жесткими ударами подводных камней, которые могли бы сделать что-то неудачное. Модульное тестирование не приводит к хорошему дизайну - это просто приводит к дизайну, который более подвержен тестированию. Вам нужно проверить свой код, но способ, которым проповедуется модульное тестирование, опасен. "Это заставит вас лучше разработать код", "Как вы можете проверить, правильно ли это?".
Я предпочитаю иметь хорошо написанный структурированный код, который, когда вы читаете, автоматически сообщает вам просто, что он пытается выполнить и как он это делает. Функции/классы должны быть небольшими и краткими. У них должна быть только одна ответственность. Модульные тесты не защищают от логических ошибок.
Единичные тесты дают больше ложных срабатываний, чем что-либо еще, особенно когда проект впервые написан. Хорошие тесты козырей дизайна - тесты не должны быть стадией проверки. Я никогда не покупал тесты, прежде чем все остальное. По моему опыту, эта линия мышления способствует тестированию за счет расширяемого кода (может быть, хорошо для проектов с выбросом или одной утилиты, но иронически модульное тестирование для них не так важно).
Моя компания производит системные компоненты для различных компаний в аэрокосмической промышленности. FAA требует модифицированного состояния/разрешения для уровня качества. Программное обеспечение для обеспечения безопасности полетов (DO-178-B). Итак, для проверки мы делаем (снова от DO-178-B):
Обычно требуется анализ всего кода и отслеживаемости тестов и результатов для всех требований (в зависимости от уровня программного обеспечения).
Этот процесс обычно также включает в себя:
Инструменты тестирования на основе требований
Инструменты анализатора покрытия кодов
Другие имена тестов, выполненных в этом процессе, могут быть:
Тестирование устройств
Тестирование интеграции
Черное поле и приемочные испытания
Тестирование модулей обнаруживает ошибки кода все время.
Я знаю по опыту, что, когда я пишу код без модульных тестов, я получу несколько проблем, которые приходят в исправить, но когда я писал модульные тесты, я редко слышу о проблемах. Кроме того, из времени, затрачиваемого на выполнение блок-тестов, я начинаю писать лучший код. Я смотрю на методы и думаю о том, как они могут потерпеть неудачу, и с самого начала их не сбивать с толку или, по крайней мере, терпеть неудачу лучше.
Модульные тесты необходимы для написания лучшего кода, но он также сделает вас лучшим разработчиком, потому что вы просматриваете области, где все может пойти не так, и исправить их, прежде чем вы когда-нибудь доберетесь до тестирования.
Модульное тестирование является неотъемлемой частью разработки, и (я нашел) фактически сократит время до завершения проекта, улучшая общее качество, особенно когда это делается в TDD fasion.
Я делаю Unit test. Я действую в настоящее время, создавая в настоящее время механизм проверки ограничений, и мои клиенты хотят, чтобы это было доказательством пули. Ну, без unit test, я умру от стресса...
Так что да, я использую его!
Большинство функций, которые я пишу, имеют тесты. Как и многие из них, модульное тестирование является неотъемлемой частью разработки программного обеспечения. Итак, чтобы ответить на ваш вопрос, да, я ДЕЙСТВИТЕЛЬНО пишу и запускаю тесты.
Кроме того, с непрерывной интеграцией, регрессионные тесты будут автоматизированы и постоянно сообщаться.
Что касается моих навыков кодирования, я нахожу, что мои навыки кодирования действительно улучшаются, когда я использую TDD и полагаюсь на свои модульные тесты, чтобы исправить меня, когда я нарушаю тест. Вы узнаете, как использовать многие языковые функции, потому что вы можете сделать настройку для проверки предположения.
Еще одно очень полезное напоминание о том, почему вы хотите unit test, где бы вы ни находились, в этом сообщении: Топ-12 причин для написания модульных тестов Мне нужно, чтобы это было выгравировано на сетчатке.
Я могу лично засвидетельствовать ценность размышлений о том, как что-то будет проверено с самого начала, с испытаниями, разработанными на каждой итерации. Мне нужно быть более систематичным. Я распечатываю этот список прямо сейчас.
Ваши клиенты, вероятно, сэкономили бы деньги в целом, если бы тестирование модулей было на месте. Некоторые из ошибок, предотвращаемых модульным тестированием, являются гораздо большей ответственностью, если они будут найдены позже на стадии разработки, а не во время модульного тестирования. Это спасет так много головной боли в будущем, теперь, когда я его использую, я не думаю, что когда-нибудь смогу вернуться.