TDD против модульного тестирования

Ответ 1

Если команда барахтается при внедрении TDD, но они не создавали никаких тестов Unit перед тем, как... затем начните их, создав Unit Tests после написания их кода. Даже модульные тесты, написанные после кода, лучше, чем никаких тестов на единицу!

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

Ответ 2

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

Я считаю, что хорошим прагматичным способом привлечения команды в TDD является предоставление альтернативного метода "тестирования во время разработки" в переходный период или, возможно, в долгосрочной перспективе. Их следует поощрять к разделам TDD кода, которые кажутся ему естественными. Однако в разделах кода, которые трудно подходить к тестированию, или при использовании объектов, которые предопределены непереходным процессом A & D, разработчикам может быть предоставлена ​​возможность написать небольшой раздел кода, а затем написать тесты для покройте этот код и повторите этот процесс. Написание блок-тестов для некоторого кода сразу после написания этого кода лучше, чем вообще не писать никаких модульных тестов.

Ответ 3

В моем скромном мнении лучше иметь 50% -ный охват тестированием "сначала код, тест после" и 100% заполненную библиотеку, чем 100% -ное охват тестирования и 50% заполненную библиотеку с TDD. Через некоторое время ваши разработчики, надеюсь, посчитают это интересным и учебным для написания тестов для всего кода public, который они пишут, поэтому TDD прорвется в свою программу разработки.

Ответ 4

Я просто прочитал это в календаре: "Каждое правило, выполненное до предела, становится смешным или даже опасным". Поэтому мое предложение не должно быть религиозным. Каждый член вашей команды должен найти баланс между тем, что они считают "правильным", когда дело доходит до тестирования. Таким образом, каждый член вашей команды будет наиболее продуктивным (вместо, скажем, мышления "зачем мне писать этот тест sti ****?" ).

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

Ответ 5

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

Одно из предложений, которое я могу дать вам, чтобы попытаться убедить вашу команду в принятии TDD, использует некоторые из методов, описанных в Мэри Линн и Линда Восходящая книга: Шаблоны для введения новых идей

Ответ 6

Если они новы к тестированию, чем IMO, начните тестирование кода, который уже был написан, и сначала медленно закончите писать тесты. Поскольку кто-то пытается изучить TDD и новый для модульного тестирования, я обнаружил, что трудно сделать полный 180 и изменить свое мышление для написания тестов перед кодом, поэтому подход, который я принимаю, - это своего рода 50-50 mix; когда я точно знаю, как будет выглядеть код, я напишу код, а затем напишу тест, чтобы проверить его. В ситуациях, когда я не совсем уверен, я начну с теста и вернусь назад.

Также помните, что нет ничего плохого в написании тестов для проверки кода, вместо написания кода для тестирования. Если ваша команда не хочет идти по маршруту TDD, не нажимайте на них.

Ответ 7

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

Нет абсолютно никаких сомнений в том, что в модульном тестируемом коде есть ценность (независимо от того, когда были написаны тесты), и я включаю "код, проверенный модулем" в "Определении Готово". Люди могут использовать TDD или нет, если они проверяют.

Что касается управления версиями, мне нравится использовать "ветки разработки" с политикой с модулем тестирования (т.е. компиляция и сборка кода, все модульные тесты проходят). Когда функции выполняются, они публикуются из ветвей разработки в туловище. Другими словами, ветвь соединительной линии - это "Готовая ветка" (без мусора на багажнике!) И имеет shippable политику (может выпускаться в любое время), которая является более строгой и включает в себя больше вещей, чем "unit tested".

Ответ 8

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

Около 5 лет назад я обнаружил nUnit при работе над проектом. Мы почти завершили V1.0, и я создал несколько тестов, чтобы попробовать этот новый инструмент. У нас было много ошибок (очевидно!), Потому что мы были новой командой, в сжатые сроки, с высокими ожиданиями (хорошо знакомы?) И т.д. В любом случае мы получили 1.0 и начали 1.1. Мы немного изменили команду, и у меня было назначено 2 разработчика. Я сделал для них 1-часовую демонстрацию и сказал им, что все, что мы написали, должно было иметь тестовый пример. Мы постоянно "отставали" от остальной команды во время цикла 1.1 dev, потому что мы писали больше кода, модульные тесты. Мы закончили работать больше, но здесь выигрыш - когда мы, наконец, попали в тестирование, у нас было ровно 0 ошибок в нашем коде. Мы помогли всем остальным отлаживать и исправлять свои ошибки. В postmortem, когда подсчет ошибок появился, он получил КАЖДОЕ внимание.

Я не настолько глуп, чтобы думать, что вы можете проверить свой путь к успеху, но я действительно верю, когда дело доходит до модульных тестов. Проект принял nUnit и вскоре распространился на компанию для всех .Net проектов в результате 1 успеха. Общий период времени для нашего выпуска V1.1 составлял 9 деб. Недель, поэтому он определенно НЕ был успешным за всю ночь. Но в долгосрочной перспективе это оказалось успешным для нашего проекта и компании, для которой мы построили решения.

Ответ 9

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

Я был в аналогичной ситуации, потому что я был разработчиком "noob", я часто разочаровывался при работе над проектом команды тем, что вклад взломал сборку. Я не знал, виноват ли я или даже в некоторых случаях, кто виноват. Но меня больше беспокоило, что я делаю то же самое с моими коллегами-разработчиками. Это осознание побудило принять некоторые стратегии TDD. У нашей команды начались глупые игры и правила, например, вы не можете вернуться домой, пока все ваши тесты не пройдут, или если вы что-то сдадите без теста, тогда вам придется покупать все "пиво/обед/и т.д.", И это сделало TDD более увлекательным.

Ответ 10

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

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

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

Ответ 11

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

Кроме того, чтобы быть тупым, я узнал больше о том, как писать тестовый код, пытаясь протестировать написанный код, чем от начала с TDD. Вначале это может быть слишком абстрактным, если вы пытаетесь задуматься о контрактах, которые достигнут конечной цели и позволят провести тестирование. Но когда вы смотрите на код и можете сказать: "Этот синглтон здесь полностью портит инъекцию зависимостей и делает тестирование невозможным", вы начинаете понимать, какие шаблоны облегчают вашу тестовую жизнь.

Ответ 12

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

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

В стороне, но BDD также может представлять интерес

Ответ 13

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

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

Ответ 14

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

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

• Сообщается об ошибке
• при необходимости создайте тестовый класс JUnit
• добавьте тест, который воспроизводит ошибку
• исправить код
• запустите тест, чтобы показать, что текущий код не воспроизводит ошибку

Вы можете объяснить, что "документирование" ошибок таким образом предотвратит повторение этих ошибок позже. Это преимущество, которое команда может испытать сразу.

Ответ 15

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

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

Этот подход много работал у меня в прошлом.

Ответ 16

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

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

Ответ 17

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

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

Я обычно делаю автоматические приемочные тесты необоротными, но разрешаю разработчикам принимать TDD по своему усмотрению. У меня есть опытные TDDers, которые обучают/наставляют остальных и "доказывают" полезность на примере в течение многих месяцев.

Это социальное/культурное изменение, так как оно является техническим.