Как я могу написать юнит-тесты, которые упрощают особенность реализации?

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

Некоторые примеры из моего опыта. Часто системы должны отправлять уведомления пользователям, когда происходят определенные события. С помощью соответствующего теста, это's легкий для того чтобы издеваться сообщения электронной почты и убедитесь, что они выходят на улицу, добраться до адресата и сказать, что они'вэ должен сказать. Однако, это's не хорошая идея, чтобы утверждать, просто "когда это произойдет, этот пользователь получает точное текстовое сообщение и". Такое испытание было не всегда, когда как i18n тексты пересматриваются. Это'ы гораздо лучше утверждать, что "сообщение содержит идентификатор пользователя's новый пароль / ссылка на объявленного ресурса / пользователя's имя и приветствие" и, таким образом, что испытуемый продолжает работать и только ломает, когда подпрограмма делает, на самом деле, не делать работы.

Аналогично, при тестировании автоматически сгенерированные идентификаторы для чего-то, никогда не думайте, что все, что значение генерируется в момент всегда будет. Даже при тестовых проводов не'т изменение, внедрение этой функции может изменяться так, что результаты изменений, в то же время выполнение своего контракта. Опять же, вы не'т хотим, чтобы утверждать, что "первый пользователь получает идентификатор ААА", но скорее "и первый пользователь получает код, состоящий из буквы, а второй пользователь получает ID, который также состоит из букв и отличаются от первого и".

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

Для программного обеспечения, чтобы быть высоко проверяемых, должны быть спроектированы и реализованы с тестированием в виду. Это дополняет Киллиан Foth'ы ответьте, где программное обеспечение разработано согласно договору, и испытание проводится для проверки договора.

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

(Слово "по швам" это заимствовано из книги эффективно работать с унаследованным кодом Майкл перья. Еще рекомендуется книга в xUnit Шаблоны тест: рефакторинг кода тестов Джерард Месарош, который представляет собой тяжелый, но того стоит.)

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

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

Наконец, программист, который имеет достаточный опыт работы с программирования и проектирования к испытаниям придет, чтобы посмотреть на "тесты" не выгодно.

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

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

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

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

один из моих начинающих коллег говорит, что тесты делать вещи сложнее.

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

Если мы сосредоточимся на написании исполняемого файла(/компилируемые/и т. д.) код, после написания тестов не убедитесь, что сложнее, просто потому, что там's больше кода, чтобы посмотреть после. Например, если мы сделаем ломать-менять, как переименование функции, нам придется тоже обновить тестовый код, для того, чтобы достичь нашей цели "в исполняемый код и".

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

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

Смысл тестирования заключается в том, чтобы попытаться объективно отслеживать "и buginess" и наборы функций. При наличии проверка тестов, что существующие особенности работы, мы даем себе некоторую уверенность, что наша работа увеличение набор функций, а не добавление нового за счет старого. Имея набор тестов проверки входов/дорожки, которые важны, как ожидается, вызовет проблемы (край-дел) или ранее вызывало проблемы (регрессионное тестирование), мы даем себе некоторую уверенность, что "buginess" Это уменьшается, а не закрепления новых ошибок за счет старого.

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

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

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

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

он утверждал, что тесты были постоянно в его сторону, когда он пытался реализовать новую функцию. Тесты не после того, как он изменил код. Поэтому ему пришлось адаптировать тесты, которые, конечно, увеличило его нагрузку. Это номер один способ, в котором тесты помогают реализовать новые возможности. тесты потерпел бы неудачу после того, как он изменил код. Код-отстой. Возможно, тест код-отстой. Скорее всего, его код-отстой. В любом случае, код-отстой. Позвольте'ы сказать, что там's о 95% вероятности, что это его код, который высосал, 2% шанс, что тестовый код сосет по назначению ("Мы должны отвергнуть дела а ведь в то время как он'ы вообще прекрасно, это вызывает проблемы со странными устаревший клиент-программа установки Б так мы'повторного тестирования, чтобы убедиться, что никто не делает ее") и 3% шанс, что тест код-отстой. Теперь, что'ы очень щедро, но даже, если ставки были до 99,99% это не'т сказать ничего плохого об этом человеке'квалификации и мастерства. (Подумайте, как часто вы попали к ошибке компилятора; что'ы код, который сосал очень плохо, даже запустить тесты, но общую работу в этот день может быть фантастическим, а может конечного продукта при фиксированном источнике этих ошибках компилятора). В самом деле, его не очень щедро нажмите здесь любые проценты, проверить код как правило, код виновата реже просто потому, что это's меньше часто менялись, значит он имеет меньше шансов приобрести новые ошибки. И помните, что мы're говоря о случае выявленные поломки, а не о том, как часто эти неудачи случаются. Во всяком случае, с теми процентами есть 98% шанс, что что-то неправильно, что нужно исправить, а 2% шанс, что что-то неправильно, вне вашего контроля, которые должны быть обслужены, и с вероятностью 100%, что нужно что-то изменить. На 3% шанс, что тест некорректен далее распадаются на несколько вариантов:

1. Тест багги.
2. Тест уже не актуален.
3. Тест является недопустимым для конкретного случая и, как правило, применяется. Как таковое, даже если испытание виноват, он может не обязательно быть "неправильно" так же, как устарел, некоторые из Время. В те 3% случаев, имея дело с тестами обошлась вам дополнительную работу, которую вы не'т было, если вы не'т использовать тесты. Но как только работа сделана, он добавил поддержку 97% времени, когда еще что-то виноват. И в 97% случаев тест привел вас, чтобы сделать больше работы все то но в результате получается, что тестовый код не'т пить любую более (95% времени) или сделки с внешними вне вашего контроля выпуска штраф (2% времени). Обратите внимание, что 2% Не-твоя-вина, дело до сих пор воспринимается пользователем как "фтопку по". Так, 97% (реально больше) времени тест сделала код сосать меньше. Позвольте'ы рассмотреть альтернативные варианты Для, что 97% без модульных тестов поиска изъянов:
4. Код'ы проблемы были еще там, но ничего так и не попали в соответствующие код в реальной жизни. (Эй, это случается).
5. Код'ы проблемы были найдены, когда другой код не'т работать с ним.
6. Код'ы проблемы были найдены, когда другой разработчик должен что-то сделать с ним.
7. Код'ы проблемы были найдены в функцию тестирования или тестирования приложений.
8. Код'ы проблемы были найдены в пользователей-сдаточных испытаний.
9. Код'ы проблемы были обнаружены после того, как продукт был выпущен, на раздражает пользователей.
10. Код'ы проблемы были обнаружены после того, как продукт был выпущен, восхищенным сухари, которые потом используют его на компромисс ваши или ваших клиентов' обеспечение безопасности.
11. Код'ов проблемы были'т нашли, но так и привести к неправильному финансовых операций, травм, потери жизни или пролонгации врага жизни. (Последние применимы только для более специализированных применений и может к вам не относиться, но они, безусловно, применимы к некоторым программистам). Любой профессиональный программист, и любой любитель, который выпускает свою работу, как, впрочем, испытали первые 6 из этих случаев происходит. Некоторые из нас испытали финал 2. Они сценарии мы больше всего стараемся избежать, но они случаются. Когда предметы со 2 по 5, произошло, то влияние на нашу нагрузку гораздо больше, чем теста, блок. Очень часто больше времени тратится на решение этих проблем, чем развивающихся. Многие проекты никогда не вышла из Альфы, потому что они никогда не получали за такие вопросы. Для более поздних элементов в списке, воздействие на нагрузку, не может быть хуже о них. Абсолютное, подавляющее большинство времени у вас не модульного тестирования, вы были спасены от одним из указанных выше сценариев. Модульное тестирование выиграл'т спасти вас от всех из них, но это избавит вас от многих из них. Тесты, которые проходят хорошие. Они могут дать вам уверенность в том, что, по крайней мере, некоторые ошибок нет в некоторых, и что'ы большой. Тесты, которые не являются тестами, которые заработали их держать. Одна вещь, чтобы отметить: тесты потерпел бы неудачу после того, как он изменил код. Я надеюсь, что там тоже были тесты, не до он изменил код. Все тесты, связанные с новой функцией должно было начаться оказавшихся на грани банкротства, поскольку новая функция было'т реализовано.

Привет я новый программист и работаю на компанию, которая имеет много разных проектов, некоторые используют юнит-тесты и некоторые Дон'т. Мои личные переживания призывает меня сказать вам, чтобы использовать их. Но Дон'т беспокойтесь, вы получите, чтобы выбрать влияние, которое он оказывает на вашу рабочую нагрузку.

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

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