Можно ли успешно добавить модульное тестирование в существующий производственный проект?Если да, то как и стоит ли это того? - PullRequest
129 голосов
/ 13 августа 2010

Я настоятельно рекомендую добавить модульное тестирование в существующий проект, который находится в производстве. Он был запущен 18 месяцев назад, прежде чем я действительно смог увидеть какую-либо пользу от TDD (лицо ладони) , так что теперь это довольно большое решение с рядом проектов, и я Туманная идея, с чего начать добавление юнит-тестов. Что заставляет меня задуматься об этом, так это то, что иногда старая ошибка, кажется, всплывает наружу, или ошибка фиксируется как исправленная без действительно исправления. Модульное тестирование уменьшит или предотвратит возникновение этих проблем.

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

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

Так что я думаю, что я тоже спрашиваю;

  • Стоит ли усилий для существующее решение, которое находится в производстве?
  • Было бы лучше проигнорировать тестирование для этого проекта и добавить его в возможное будущее переписать?
  • Что будет более полезным; расходы несколько недель, добавляя тесты или несколько недель добавляется функциональность?

(Очевидно, что ответ на третий пункт полностью зависит от того, говорите ли вы с руководством или разработчиком)


Причина получения награды

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

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

Ответы [ 23 ]

162 голосов
/ 18 августа 2010

Я ввел модульные тесты для кодовых баз, у которых его раньше не было.Последний крупный проект, с которым я был связан, когда я делал это, когда я прибыл в команду, продукт уже был в производстве с нулевыми юнит-тестами.Когда я ушел - спустя 2 года - у нас было около 4500+ тестов, дающих около 33% покрытия кода в базе кода с 230 000+ производственных LOC (финансовое приложение Win-Forms в реальном времени).Это может показаться низким, но результатом стало значительное улучшение качества кода и частоты дефектов, а также повышение морального духа и прибыльности.

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

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

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

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

Теперь, для ваших комментариев и вопросов:

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

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

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

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

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

Хорошая новость заключается в том, что по прошествии месяцев (и даже лет) ваш код постепенно начнет становиться «правильным» хорошо продуманным и хорошо протестированным кодом.

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

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

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

Обучайте своих сотрудников.

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

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

Время сборки всегда должно быть БЫСТРОМ.Если у вас медленное время сборки, ваши навыки юнит-тестирования отстают.Найдите медленные тесты и улучшите их (отделите производственный код и тестируйте отдельно).Хорошо написано, вы должны иметь возможность иметь несколько тысяч модульных тестов и все же завершить сборку менее чем за 10 минут (~ 1-несколько мс / тест - это хорошее, но очень грубое руководство, некоторые исключения могут применяться, например, код с использованием отражения и т. Д.).).

Проверка и адаптация.

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

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

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

Два грубых вторичных показателя - это общее покрытие кода и скорость сборки.

Стоит ли усилий для существующего решения, которое находится в производстве?

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

Было бы лучше проигнорировать тестирование для этого проекта и добавить его в возможной переписке в будущем?

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

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

Что будет более полезным;потратить несколько недель на добавление тестов или несколько недель на добавление функциональности?

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

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

Кроме того, добавление модульных тестов кСуществующая кодовая база любого размера проекта - это БОЛЬШОЕ обязательство, которое требует приверженности и настойчивости.Вы не можете изменить что-то фундаментальное, ожидать многого на пути к обучению и попросить своего спонсора не ожидать окупаемости инвестиций, останавливая поток стоимости бизнеса.Это не сработает, и, честно говоря, не должно.

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

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

Надежда, которая помогает

23 голосов
/ 13 августа 2010
  • Стоит ли усилий для существующего решения, которое находится в производстве?

Да!

  • Было бы этоЛучше проигнорировать тестирование для этого проекта и добавить его в будущем, возможно, переписать?

Нет!

  • Что будет более полезным;потратить несколько недель на добавление тестов или несколько недель на добавление функциональности?

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

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

Затем вставьте тест для каждой текущей ошибки в вашей базе данных ошибок, которая вызывает именно эту ошибкуи который пройдет, когда ошибка будет исправлена.Тогда исправьте эти ошибки!: -)

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

15 голосов
/ 13 августа 2010

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

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

12 голосов
/ 15 августа 2010

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

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

  • Сколько времени вам понадобится, чтобы протестировать весь этот код? Дни? Недели? Месяцы? Годы
  • Для кого вы пишете этот код? Платить клиентам? Профессор? Проект с открытым исходным кодом?
  • Каково ваше расписание? У вас есть жесткие сроки, которые вы должны соблюдать? У вас вообще есть какие-нибудь сроки?

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

  • Любой новый код, который вы пишете, должен полностью пройти модульный тест
  • Любой старый код, к которому вы прикоснулись (исправление ошибки, расширение и т. Д.), Должен быть подвергнут модульному тесту

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

Edit:

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

Это все равно, что спросить: "Каковы плюсы и минусы в использовании контроля версий?" или "Каковы плюсы и минусы интервьюирования людей перед их наймом?" или "Каковы плюсы и минусы для дыхания?"

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

8 голосов
/ 19 августа 2010

Когда мы начали добавлять тесты, речь шла о 10-летней кодовой базе размером примерно в миллион строк со слишком большой логикой в ​​пользовательском интерфейсе и в коде отчетности.

Первое, что мы сделали (после настройки сервера непрерывной сборки), - добавили регрессионные тесты. Это были сквозные испытания.

  • Каждый набор тестов начинается с инициализации базы данных до известного состояния. На самом деле у нас есть десятки наборов данных регрессии, которые мы храним в Subversion (в отдельном репозитории от нашего кода из-за огромного размера). FixtureSetUp каждого теста копирует один из этих наборов данных регрессии в временную базу данных, а затем запускается оттуда.
  • Затем настройка тестового устройства запускает некоторый процесс, результаты которого нас интересуют. (Этот шаг не является обязательным - некоторые регрессионные тесты существуют только для проверки отчетов.)
  • Затем каждый тест запускает отчет, выводит отчет в файл .csv и сравнивает содержимое этого .csv с сохраненным снимком. Эти снимки .csv хранятся в Subversion рядом с каждым набором данных регрессии. Если выходные данные отчета не соответствуют сохраненному снимку, тест не пройден.

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

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

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

У регрессионных тестов есть проблемы: они медленные, и есть слишком много причин, по которым они могут сломаться. Но, по крайней мере, для нас они были , поэтому того стоило. За последние пять лет они поймали множество ошибок и поймали их в течение нескольких часов, вместо того, чтобы ждать цикла QA. У нас все еще есть те оригинальные регрессионные тесты, которые распределены по семи различным машинам непрерывной сборки (отдельно от той, которая выполняет быстрые модульные тесты), и мы даже время от времени добавляем к ним, потому что у нас все еще так много кода, что наши 6000 + модульные тесты не охватывают.

7 голосов
/ 13 августа 2010

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

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

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

6 голосов
/ 19 августа 2010

Я добавлю свой голос и скажу да, это всегда полезно!

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

  • Черный ящик = тесты, которые пишутся без специальных знаний о реализации, обычно выискивая крайние случаи, чтобы убедиться, что все происходит так, как ожидал наивный пользователь.
  • White-box = тесты, которые написаны с знанием реализации, которые часто пытаются использовать известные точки отказа.
  • Юнит-тесты = тесты отдельных юнитов (функций, отдельных модулей и т. Д.). Например: убедитесь, что ваш класс массива работает должным образом, и что ваша функция сравнения строк возвращает ожидаемые результаты для широкого диапазона входных данных.
  • Функциональные тесты = тесты всей системы одновременно. Эти тесты будут одновременно выполнять большую часть системы. Например: init, открыть соединение, сделать что-то реальное, закрыть, завершить. Мне нравится проводить различие между этими и модульными тестами, потому что они служат разным целям.

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

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

Как и другие, я также напомню вам две самые важные вещи о TDD:

  1. Создание тестов - это непрерывная работа. Это никогда не останавливается. Вам следует пытаться добавлять новые тесты каждый раз, когда вы пишете новый код или изменяете существующий код.
  2. Ваш набор тестов никогда не бывает непогрешимым! Не позволяйте тому факту, что у вас есть тесты, уводят вас в ложное чувство безопасности. Тот факт, что он проходит тестовый набор, не означает, что он работает правильно, или что вы не ввели тонкую регрессию производительности и т. Д.
4 голосов
/ 19 августа 2010

Вы не упоминаете язык реализации, но если в Java, то вы можете попробовать этот подход:

  1. В отдельном исходном дереве построите регрессионные тесты или тесты 'smoke', используяинструмент для их генерации, который может получить около 80% покрытия.Эти тесты выполняют все логические пути кода и с этого момента проверяют, что код по-прежнему делает именно то, что он делает в данный момент (даже если присутствует ошибка).Это дает вам защиту от непреднамеренного изменения поведения при проведении необходимого рефакторинга, чтобы сделать код легко тестируемым вручную.

    • Предложение продукта - я использовал бесплатный веб-продукт Junit Factory, но, к сожалению,сейчас закрыто.Однако продукт работает в коммерчески лицензированном генераторе AgitarOne JUnit по номеру http://www.agitar.com/solutions/products/automated_junit_generation.html
  2. Для каждой ошибки, которую вы исправляете или добавляете с этого момента, используйте подход TDD дляубедитесь, что новый код предназначен для тестирования, и поместите эти тесты в обычное исходное дерево тестов.

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

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

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

4 голосов
/ 13 августа 2010

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

На данный момент, помните, что я говорю о выборочном добавлении модульных тестов, а не о попытке создать набор тестов, подобныхте, которые существовали бы, если бы вы практиковали TDD с самого начала.Поэтому в ответ на вторую половину вашего второго вопроса: обратите внимание на использование TDD в вашем следующем проекте, будь то новый проект или переписывание (извинения, но здесь есть ссылка на еще книгу, которую вы действительно должны прочитать: Растущее объектно-ориентированное программное обеспечение, основанное на тестах )

Мой ответ на ваш третий вопрос такой же, как и первый: он зависит от контекста вашего проекта.

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

3 голосов
/ 18 августа 2010

Мне очень нравится Рефакторинг низко висящих фруктов в качестве ответа на вопрос, с чего начать рефакторинг. Это способ улучшить дизайн, не откусывая больше, чем вы можете пережевать.

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

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...