Вроде бы принято считать (на стек&ампер;усилитель; nbsp;переливом по крайней мере), что всегда должны быть юнит-тесты, и они должны быть в курсе. Но я подозреваю, что программисты делая эти утверждения работают на различных проектах от меня - они работают на высокое качество, долгий срок службы, поставляется программное обеспечение, где ошибки-это очень плохо.
Если это's в конце спектра, где модульное тестирование-это самое ценное, то, что'с другого конца? Где модульные тесты наименее ценным? В каких ситуациях бы вы не заморачивались? Где бы усилий поддержания тесты не стоят?
Я лично не пишу юнит-тесты для ситуаций, когда:
Код <удар>не имеет филиалов в</удара> это тривиально. Геттер, который возвращает 0 Не'т должны быть проверены, и изменения будут покрыты тестами для своих потребителей.
Код просто проходит через На стабильного API. Я'МР предположить, что стандартная библиотека работает правильно.
Код должен взаимодействовать с другими системами; затем интеграционный тест для.
Если тест на успех/провал-это то, что так трудно, чтобы не быть надежно измерена, например, стеганография быть незаметным для человека.
Если сам тест на порядок сложнее, чем писать код.
Если код выбрасывать или шаблонный код. Если там'ы всякого сомнения, тест.
Если вы собираетесь писать код без тестирования, вы всегда будете нести расходы по проведению испытаний.
Разница между юнит-тестами и не имея их-это разница между стоимостью написании теста и затратам на ее эксплуатацию по сравнению с затратами на тестирование вручную.
Если стоимость написания юнит-тестов-2 минуты и стоимость выполнение модульного теста практически 0, но стоимость тестирования вручную код-1 минута, то ты нарушаешь даже тогда, когда вы запустите тест со второго раза.
В течение многих лет я был в заблуждении, что я этого'т иметь достаточно времени, чтобы написать юнит-тесты для моего кода. Когда я пишу тесты, они опухли, тяжелые вещи, которые только побуждали меня думать, что я только когда-либо писать юнит-тесты, когда я знал, что они были необходимы.
В последнее время я'вэ рекомендуется использовать управляемой тестами разработки, и я нашел его, чтобы быть полным откровением. Я'm сейчас твердо убежден, что я Дон'т иметь время не написание unit-тестов.
По моему опыту, путем разработки с тестированием в виду, вы в конечном итоге с чистого интерфейсы, более конкретные классы & модули и вообще больше твердый, проверяемый код.
Каждый раз, когда я работаю с унаследованным кодом, который не'т иметь модульные тесты, и я должен вручную проверить что-то, я продолжаю думать, что "это было бы намного быстрее, если этот код уже был тесты на" подразделения;. Каждый раз я должен попробовать и добавить функциональности модульных тестов для кода с высоким сцепления, я продолжаю думать, что "это было бы намного проще, если бы она была написана в де-Связного и".
Сравнивая две экспериментальные станции, которые я поддерживаю. Один был вокруг некоторое время и имеет много устаревшего кода, в то время как другие относительно новые.
При добавлении функциональности в старую лабораторию, он часто в случае получения в лабораторию и проводить много часов, работая через влияние на функциональность они нужны и как я могу добавить эту функциональность без ущерба для любых других функций. Код просто не создан, чтобы позволить офф-лайн тестирования, поэтому почти все, что необходимо разработать он-лайн. Если я пытался развивать офф-лайн, то я бы в конечном итоге с более имитаций, чем было бы разумно.
В новой лаборатории, я, как правило, добавить функциональности, развивая его он-лайн на моем столе, издевательски только те вещи, которые необходимы сразу, а потом только кратковременно в лаборатории, устранить любые остающиеся проблемы не подобрал офф-лайн.
TL;доктор версии:
Написать тест, когда стоимость написания теста, плюс стоимость запуска его столько раз, сколько вам нужно, скорее всего, будет меньше, чем стоимость тестирования вручную столько раз, сколько вам нужно.
Помните, что если вы использовать TDD, затраты на написание тестов, скорее всего, сойдет как вы лучше на него, и если код не будет совсем тривиальным, вы, вероятно, в конечном итоге тесты выполняются чаще, чем вы ожидаете.
Существует компромисс между стоимостью написания модульных тестов, и ценности, которую они добавляют. Пренебрежение этим риски возможности за-тестирование.
blueberryfields коснулись одной переменной, которая влияет на стоимость модульных тестов: устойчивость проекта (или темпы развития). Я'd, как продолжать.
Значение наличия юнит-тестов примерно следующего участка (ура, MS краска!):
Юнит-тесты хороши для рефакторинга на уровне модуля (т. е. изменение функции). Проблема в том, что код неустойчив на архитектурном уровне, где все модули могут быть переписаны, снять, или полностью переработан. Модульные тесты должны быть изменены/удалены/добавлены, который является обузой.
На данном этапе, ограничивая интеграционных тестов системного уровня, или даже ручное тестирование-это лучший подход (который вы снова выберете зависит от стоимости написания теста и качества, которое вы получаете).
Модульные тесты наиболее ценными во второй зоне, где код становится стабильным выше уровень модуля, но не на уровне модуля. Если у вас есть стабильная кодовая база, и вы добавляете модуль, который имеет высокий шанс остаться, это когда модульное тестирование-это большая победа.
Модульные тесты также начинают иметь меньшее значение для стабильности тестируемого кода очень высока. Тестирование простой оболочки стандартная функция библиотеки является одним из примеров, где модульное тестирование-это перебор.
Если кусок кода, который вы пишете, вероятно, никогда не нужно изменить, а вы уверены, что вы'ве получили это право (может быть, это's супер просто?), меньше значение к тестированию.
Модульное тестирование становится выгодно, когда полезность превышает стоимость, как показано на диаграмме ниже, в зону II.
Эта линия стоимость может быть на разных уровнях для разных людей (Линия 1 против 2). Если вы новичок в рамках теста, используемых в проекте, при этом повышается уровень, и делает чистая полезности меньше. Более высокую стоимость (линия 2) сужает спектр модульного тестирования является целесообразным.
Линии стоимость не'т обязательно должны быть плоскими. Особенно если учесть такие факторы, как размер проекта, и уже существует тестового фреймворка для проекта, это может быть так.
Лично я вообще не пишу юнит-тесты для:
Изменения в существующие номера-тестирования (устаревший) код. Хотя теоретически это's никогда не слишком поздно, чтобы запустить юнит-тестирование, на практике выигрыш от добавления модульных тестов для кода, который никогда не был TDDed маленькие. Единственным преимуществом является предотвращение регрессии; вы можете увидеть, какой эффект это изменение делает на территории вы можете или не можете ожидать, чтобы это повлияло. Однако, модульный тест лишь доказывает, что код все еще работает так, как это было, когда ты написал тест, потому что тест не'т написана на основе оригинальных требованиям, то данное испытание не доказывает текущей реализации есть "правильные" по. Изготовление блок-проверенные изменения такого кода еще больший кошмар по моему опыту, то просто вносит изменения и вручную осуществлять пораженных участков программы, вы должны сначала написать модульный тест для код в вопрос (который может потребовать рефакторинга кода, чтобы разрешить насмешливый и другие ТДД-архитектуры), доказать, что она проходит и что рефакторинг не'т сломать что-нибудь (и когда это первый модульный тест, когда-либо написанных на миллион-Лок кода, что может быть сложно), затем измените тест, чтобы ожидать чего-то другого и изменить код, чтобы изменить тест пройти.
Пользовательский интерфейс макета и верхнего уровня поведения. В некоторых случаях это's просто не представляется возможным; многие IDE с "дизайнеров" и объявить элементы пользовательского интерфейса, как частные, и они должны'т быть открытыми концептуально. Делая их внутреннего потребует сдачи модульных тестов в той же сборки как рабочий код (БАД) и делает их защищенными потребует "и тест прокси-сервера", что подвергает, что нам нужно знать об элементах управления (также, как правило, не так оно и'ы сделали). Даже если это было приемлемо, чтобы все элементы общественного и, следовательно, иметь доступ к их тип, положение, свойства форматирования и т. д., тесты для проверки пользовательского интерфейса разработана так, как вы ожидаете чрезвычайно хрупкие. Вы можете обычно все еще модульного тестирования обработчиков событий в codebehinds/просмотр моделей и потом он'ы тривиально, чтобы доказать, что при нажатии кнопки срабатывает обработчик.
Сохранение Данных. Это, по определению, интеграционный тест. Вы всегда макет репозитория при работе с кодом, который передает данные в хранилище, а вы глумиться ОРМ's крючки для развивающихся внутри самого хранилища. В то время как есть "и модульные тесты базы данных" и можно на "макет" по базе данных, используя что-то вроде SQLite, которая, я считаю, что эти тесты просто не поместиться на уровне единицы.
Сторонний код. Тем не менее вы проверить ваш код вы хотите, и верить, что разработчики сторонних средств вы'повторно используя (в том числе компонентов .Чистая рамки себя, как в WPF, WCF, что эф и т. д.) сделал свою работу, пока не доказано неправильно. Блок тест, который докажет вам сделать правильный вызовов WCF не требует пересечения обслуживание прокси-сервера, и нет необходимости, чтобы проверить, что конкретный службу WCF вызов работает правильно в модульный тест (работает ли оно или нет, зависит от конкретной среды переменных, которые могут быть совершенны в локальной тестовой среде, но не на создание бота, или в ОК, промежуточной или ЕСХН среды; это куда более высокого уровня интеграции, ААТ и ручное тестирование по-прежнему имеет значение).
В почти всех других случаях, тест-первая методика имеет существенное значение в обеспечении соблюдения требований и YAGNI, предотвращения регрессии, выявления конфликтов требований и т. д. Даже в случае с "обычный" и код, что проверка, что "Да, это свойство делает еще возвращать это значение, а значит, вы можете верить, что в других тестах" есть ценность для меня как разработчика.
где модульные тесты наименее ценным?
Вы должны писать юнит-тесты только для логического кода. Определение логической код ниже:
Логический код-это любой кусок кода, который имеет какую-то логику в нем, маленький, как это может быть. Это логический код, если он имеет один или более из следующий: инструкция if, цикл, переключатель или случае заявления, расчеты, или любой другой тип принятия решений код.
если что's в конце спектра, где модульное тестирование-это самое ценное, то, что'с другого конца?
Плотно соединенный код может'т быть легко проверены. Иногда это может'т быть проверены на всех. Например ASP.NET веб-форм являются кошмаром, а иногда и невозможно проверить, в отличие от ASP.NET в MVC, который строится с модульного тестирования в виду.
Мне можете не писать тесты для небольших и простых проектов. Это вполне оправдано в мире с ограниченным временем и ресурсами. Да, это'ы рискованным, но это'ы идеально подходят, когда вы работаете в компании, имеет ограниченное время на рынке.
В каких ситуациях бы вы не заморачивались? Где бы усилий поддержание тесты не стоят?
Как только юнит-тесты на месте, стоимость их обслуживания будет очень незначительным. Модульные тесты с высокое покрытие кода придать вам чувство уверенности, что система ведет себя так, как вы ожидаете. То же самое касается и интеграционных тестов, но, что's не ваш вопрос.
Мой ответ базируется на следующих предположениях:
Кент Бек (человек за идею модульного тестирования) говорит, что это's прекрасно не писать модульные тесты, когда работали над идеей (например. прототипа), что вы могли бы выбросить (если вы решили не работать дальше). Наоборот, если вы напишите свой прототип и решили пойти на это, модульное тестирование будет полезно для всех причинам, рассмотренным в предыдущих ответах.
Вы действительно должны иметь тесты на любой код, который вы намереваетесь работать на более чем 1 случай.
Если вы намерены запустить его один раз, затем выбросить, тесты могут не пригодиться, хотя если домен является сложным, я бы все равно писать тесты, чтобы помочь мне с моей конструкцией и реализацией.
В противном случае, даже если только анализы сделать, это подтвердить, что ваши предположения правильные, они ценны. И любой код, который длится более одного сеанса понадобятся модификации, при котором тестов, окупится в 10 раз.
Я понятия не имею, о лишних но я'будете снимать, когда я думаю, что юнит-тесты неуместно в том, что они добавляют стоимость без пропорционального преимущества:
Если наша организация на / dev команда вовсе'т делать какие-либо тесты, то если вы сможете убедить ваших коллег-разработчиков, запуск, ремонт (а также создает самостоятельно) unit-тестов, тестов, которые вы создаете разве'т будет работать и поддерживаться. (Это означает, что вы работаете на кусок программного обеспечения вместе с кем-то еще.)
Не каждый делает модульного тестирования, они'вновь иногда некачественно поддерживают местные команды, и в таких условиях необходимо сначала сделать их на месте для большинства разработчиков и, вероятно, также для процесса сборки (на"[непрерывный] интеграция с") перед тем начать писать юнит-тесты смысл.
С учетом дефицита времени и даты доставки и "вашу" относительная стоя с командой -- время, оставшееся до написания модульных тестов имеет смысл легко может быть месяцев или лет.
Иногда вы не'т иметь время, чтобы проверить блок. Что'ы в порядке.
Существует внешних ограничений, и вы не можете чувствовать себя необходимости для тестов в данный момент, как вы думаете, у вас есть четкое представление о всей государственной системы и знать, как изменения пульсации через это.
Но я все еще верю, вы должны чувствую себя немного виноватой об этом. Поэтому, когда вещи начинают разваливаться, вы будете знать это's, потому что: "О, да, я'м не испытания материала, позвольте'ы начать испытания.&ьquot;
До этого момента, чувство вины поможет вам избежать определенных архитектурных решений что бы предотвратить возможность автоматизировать тесты, потом код.
Стоимость это'т в поддержании тестов, а не поддержание рабочего кода. Если вы разведетесь тестирование и внедрение, вы предполагаете, что то, что ты пишешь будет работать без доказательства. Тесты дают вам доказательства, и уверенность, чтобы сохранить код, как проходит время. Конечно, вы думаете, что вы'll никогда не вернуться к этому приложение вы думал было выбрасывать, однако реальность такова, что любой раз, когда вы проводите писать программное обеспечение это инвестиция, что ваш работодатель не'т хотим, чтобы легкомысленно относиться. Позвольте's смотреть на его, разработчики программного обеспечения не'т, как правило, недешево, да и время, потраченное на код, чтобы выбросить деньги просто жгли для вашего работодателя.
Если вы не спикинг проблемой, написания нескольких строк кода, чтобы увидеть, как что-то работает, или просто бросали вместе пример для программистов.ЮВ, то это's действительно случай создания чего-то, что вы твердо намерены выбросить после того, как вы'вэ удовлетворил ваше понимание проблемы. В таких случаях, модульное тестирование может быть помехой для решения этой задачи и может спокойно оставаться в стороне. Во всех других случаях, однако, я'd не сказать, что тестирование-это всегда уместно, даже если программа кажется незначительным, и вы всегда должны стремиться писать программы на профессиональном уровне с достаточно протестировать поддержку, чтобы уменьшить трудности в поддержании код в будущем.
Количество и качество модульное тестирование должно быть сделано в проекте прямо пропорционально темпам развития и необходимую стабильность продукта.
На одном конце, для одноразового скрипта, тривиально демо, или в быстрый темп-запуск среды на самых ранних стадиях, это'ы вряд ли модульные тесты будут иметь значения или быть полезным для чего-либо. Они почти всегда, почти наверняка, пустая трата времени и ресурсов.
На другом конце, при написании программного обеспечения для управления темпами производители, или пилот ракеты-корабли, или, когда работать на поддержание стабильных, весьма сложной, программного обеспечения, систем (скажем, компилятор с тяжелыми принятия по мультивселенной) несколько слоев unit-тестирования, и другие покрытия, имеют решающее значение.
[Есть множество других конкретных ситуационных факторов, которые каждый из вас так или иначе, такие как размер вашей команды, вашего бюджета, талант разработчиков, предпочтительное программное обеспечение для разработки стратегии, и т. д... В общем, и на самом высоком уровне абстракции, я нахожу эти два крупнейших разницы]
ИМО модульные тесты являются неадекватными (не лишние!) в любой код, где это потребует тонны часов рефакторинг или даже простой рерайт для того, чтобы внедрить модульное тестирование, потому что это будет очень трудно продать для управления, чтобы обеспечить, что время, отведенное.
Юнит-тесты-это мило и все такое, но в сложных системах с большим количеством "и движущиеся детали и", они действительно Дон'т на самом деле проверить.
Как мы знаем, модульные тесты, убедиться, что данный входной сигнал X на единицу, вы получаете на выходе Y, где X-все необходимые входные и y всех соответствующих выходных данных. Однако, я считаю, что большинство код делает то, что разработчик думал, что это нужно.. но не обязательно, что это вообще следует делать. <БР>(вы можете думать о нем как пистолет. Пистолет имеет много прецизионных деталей, изготовленных отдельно и затем собраны. Это не'т имеет значения, если каждая конкретная деталь проходит проверку на функциональность, если пистолет взорвется, когда на самом деле уволили. Отказ от ответственности: я ничего не знаю о огнестрельного оружия (: )
В данном случае, нужны реальные испытания системы в модели производственной среды. Поскольку функциональность в любом случае здесь, стоимость юнит-тестов немного уменьшилась.
Тем не менее, юнит-тесты-это все еще ценно в этом случае, потому что они дают уверенность в том, что функционал, который пожелал остаться неизменным, по сути, остаются неизменными. Это достаточно ценно, потому что это дает вам уверенность на местах системы нужно целенаправленное тестирование.
Вы должны написать юнит-тесты, когда при логическом осмыслении, необходимых для поддержания или продления или общаться на логику приложения без недостатков превышает (или, вероятно, в будущем превысит) способность наименее знающих членов вашей команды, чтобы встретиться с этим пониманием.
В основном зависит от того, сколько вы можете держать в голове сразу. По своему усмотрению вы могли бы иметь больше уверенности в том, что вы можете код (в полном объеме знаний о последствиях ваших изменений) до тех пор, пока определенные сложности была достигнута. До этого момента модульные тесты-это отвлекает, мешает и будет замедлять вас вниз. В команде, порог будет гораздо ниже, так что вы очень сильно нужны модульные тесты сразу по противодействию группы-глупость. Если вы подбираете проект testless от кого-то (или вы'вэ забыл о проекте не так давно) вы'll хочу написать юнит-тесты прежде, чем вы что-либо изменить, потому что ваше понимание будет ноль.
Примечание: писать меньше кода и практикующих YAGNI, подавляет сложность и, следовательно, количества необходимых тестов.
На мой взгляд, продукт/код прототипы Дон'т требует испытания, как они часто поступают, используя совершенно другой процесс, и для совершенно разных целей, чем готовый продукт.
Представьте себе, это общий сценарий. У вас есть какая-то технология, чтобы ваша компания славится, ваш отдел продаж или главный exec идет к клиенту и возможность продать их другой продукт, который использует свои технологии. Они продают его там и тогда, и обещаем клиенту они'll увидеть бета-версию в месячный срок. Вы Don't имеют ничего, даже команды разработчиков.
Что происходит дальше, вы быстро проектировать решения на основе согласованных пунктов/продается клиенту, собрать команду (часто звезды) инженеры и начать писать код. Было бы идеально конечно, если ваши даты не'т слип (они всегда делают) и вам удалось написать код в три недели, а не четыре. В этом случае у вас есть лишняя неделя, и если вы были в состоянии обеспечить команду QA's время на этой неделе - вы сможете протестировать его. На самом деле вы выиграли'т иметь дополнительную неделю и/или ваша команда QA забронированы еще два месяца поддержки других поставок товара. Кроме того вы выиграли'Т есть какие-либо чертежи, поэтому команда QA выиграл'Т есть какие-либо идеи, что они должны быть испытания. Так что вы в конечном итоге сделал то, что вы написали немного вашего собственного тестирования, что это'т действительно тестирования как такового, просто потому, что вы еще'т квалифицирован, чтобы проверить свой код. Самым большим фактором здесь является то, что клиент увидит некоторые из обещанных функциональности очень быстро. Если прототипа нет, то вы'вновь вернуться к чертежной доске, где вы проектировать и планировать текущая версия 1.0 - правильно на этот раз.
Насколько юнит-тесты, они хороши для поддержания определенных контрактов (обещаю, что мой код будет делать это, если это не'т это's сломанный). В случае прототипирования, вы, возможно, не столько забота контракты, потому что достаточно часто свои прототипы не будут жить, чтобы стать версии 1.0, то ли потому, что клиент ушел, или потому, что вы закончили разработку версии 1.0 с использованием различных технологий/инструментов. Примером здесь может служить сайт быстрый прототип написал очень быстро на PHP в месяц's время, один человек, а затем собрать команду, чтобы переписать его в JEE. Даже базы данных часто не переживут это изменение.
В стремительном небольшой организации, я считаю, что разработчики так давят, чтобы оставаться продуктивным и двигаться быстро, что зачастую они просто не'т беспокоить, чтобы проверить свои изменения.
У нас есть общая политика, которая гласит, что если вы вносите изменения (будь то исправление ошибок или улучшение) разработчик должен протестировать себя перед отправкой кода для дальнейшего тестирования.
Мы не'т на самом деле писать unit-тесты в большинстве случаев, потому что наши экраны в основном рассчитаны таким образом, при изменении на экране, в остальном логика должна быть пройдена до конца для того, чтобы узнать, если замена оказалась удачной, независимо от.
Я считаю необходимым, что разработчик делает свои собственные испытания, будь то документы или нет, потому что они являются теми, которые лучше знают, где потенциальные слабые места в логике может быть.
Так что я бы сказал, Даже если вы Don'т писать тесты для каждой маленькой части системы, здравый смысл испытания должно быть сделано, несмотря ни на что.