Мне было интересно, когда большинство людей написали свои модульные тесты, если вообще. Обычно я пишу тесты после написания своего исходного кода, чтобы убедиться, что он работает так, как предполагалось. Затем я фиксирую, что сломано.
Я был довольно успешным с помощью этого метода, но задавался вопросом, может ли быть предпочтительным переход к написанию теста?
когда это возможно, я стараюсь следовать чистому подходу TDD:
легко получить возбуждение и сначала начать кодирование функции, но это часто означает, что вы не будете заранее прорабатывать все общедоступные интерфейсы.
EDIT: обратите внимание, что если вы сначала пишете код, легко непреднамеренно написать тест, чтобы он соответствовал коду, а не наоборот: "round!
Я действительно хочу сначала написать код и часто делать. Но чем больше я занимаюсь реальной TDD, где я отказываюсь писать какой-либо код без теста, тем больше я нахожу, что пишу более тестируемый код и лучший код.
Итак, да, сначала напишите тест. Требуется сила воли и решительность, но она действительно дает лучшие результаты.
В качестве дополнительного бонуса TDD действительно помогла мне сосредоточиться в среде с отвлечениями.
Я следую подходу TDD, но я не такой пурист, как некоторые. Как правило, я грубый в классе/методе с заглушкой, которая просто бросает NotImplementedException. Затем я начну писать тест (ы). Одна функция за раз, по одному тесту за раз. Часто я обнаружил, что я пропустил тест - возможно, при написании других тестов или при обнаружении ошибки - тогда я вернусь и напишу тест (и исправление ошибки, если это необходимо).
Использование TDD помогает поддерживать код в соответствии с YAGNI (вам это не понадобится), пока вы только пишете тесты для функций, которые вам нужно разработать. И пишите только простейший код, который удовлетворит ваши тесты.
Мы пытаемся написать их раньше, но я полностью буду признавать, что наша среда иногда хаотична, и иногда этот шаг изначально передается и записывается позже.
Обычно я пишу список модульных тестов, которые я буду писать до того, как напишу код, и на самом деле буду кодировать модульные тесты после, но это потому, что я использую программу для создания заглушек unit test, а затем модифицирую их для тестирования соответствующие случаи.
Я использую модульные тесты для проверки кода, когда я его пишу. Таким образом, я использую то, что я пишу одновременно, поскольку я использую unit test для проверки кода, пока я его пишу. Очень похоже на консольное приложение.
Иногда я даже писал тесты без утверждений, просто отлаживал выходы, просто чтобы проверить, что я использую что-то, работает без исключений.
Итак, мой ответ после немного кодирования.
Я использую Test-Driven Development (TDD) для создания большей части моего производственного кода, поэтому сначала пишу свои юнит-тесты, если я не работаю над неэлектируемым устаревшим кодом (когда бар для записи тестов слишком высок).
В противном случае я пишу приемочные тесты на функциональном уровне, чтобы код был удовлетворительным.
Написание модульных тестов сначала позволит мне точно знать, "где я": я знаю, что то, что было закодировано до сих пор, является работоспособным и может быть интегрировано или отправлено в тестовую группу; это не ошибка, но она работает.
Я предлагаю, что я довольно новичок в написании модульных тестов и хочу, чтобы я написал их до того, как написал свой код. Или, по крайней мере, лучше понять, как писать более тестируемый код, а также лучше понимать понятия, такие как инъекции зависимостей, которые, как представляется, имеют решающее значение для написания тестируемого кода.
Обычно я пишу модульные тесты перед кодом. Они очень полезны и пишут их до того, как код имеет смысл. Инжекционная инъекция хорошо поддается тестированию на единицу. Включение зависимостей позволяет фрагментировать код вашего кода, поэтому вы проверяете только конкретный блок, т.е. Ваш код слабо связан, и поэтому его легко заменить на другую (в данном случае издеваемую) реализацию.