Начало TDD – проблемы?Решения?Рекомендации?[закрыто]

StackOverflow https://stackoverflow.com/questions/24965

Вопрос

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

  • При работе с коллекциями будет ли по-прежнему проверяться на очевидное успешное добавление/удаление/вставка, даже если они основаны на дженериках и т. д., где мы как бы «знаем», что это будет работать?
  • Кажется, что реализация некоторых тестов занимает целую вечность.Например, при работе со строковым выводом, есть ли «лучший» способ сделать это?(например.протестируйте объектную модель перед синтаксическим анализом, разбейте синтаксический анализ на небольшие операции и протестируйте там). На мой взгляд, вы всегда должны проверять «конечный результат», но он может сильно различаться и его утомительно настраивать.
  • У меня нет среды тестирования (за нее не будут платить), поэтому я могу больше «практиковаться».Есть ли хорошие, бесплатные для коммерческого использования?(на данный момент я использую старый добрый Отладка.Утверждение :)
  • Наверное, самый большой..Иногда я не знаю, чего ожидать НЕТ произойдет..Я имею в виду, вы получаете зеленый свет, но меня всегда беспокоит, что я могу пропустить тест..Копаете ли вы глубже, чтобы попытаться взломать код, или оставляете все как есть и ждете, пока все упадет позже (что будет стоить дороже).

Так что, по сути, то, что я здесь ищу, это не " просто сделай это "но больше" Я сделал это, были проблемы с этим, решил их этим "..А личный опыт :)

Это было полезно?

Решение

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

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

Принимая во внимание приведенный выше абзац, давайте посмотрим на ваши вопросы:

  1. Если я использую коллекцию в тестируемой системе, я настраиваю ожидание, чтобы убедиться, что код был вызван для вставки элемента, а затем подтвердить счетчик коллекции.Я не обязательно проверяю метод Add в своем внутреннем списке.Я просто проверяю, что он был вызван при вызове метода, добавляющего элемент.Я делаю это, добавляя к своей среде тестирования фреймворк для макетирования.
  2. Тестирование строк в качестве вывода может быть утомительным.Вы не можете учесть каждый результат.Вы можете тестировать только то, что ожидаете, исходя из функциональности тестируемой системы.Вы всегда должны разбивать свои тесты на наименьший элемент, который он тестирует.Это означает, что у вас будет много тестов, но небольших и быстрых, которые проверят только то, что нужно, и ничего больше.
  3. Существует множество сред тестирования с открытым исходным кодом на выбор.Я не буду спорить, что лучше.Просто найдите тот, который вам нравится, и начните его использовать.
  4. Все, что вы можете сделать, это настроить тесты так, чтобы они учитывали то, что вы хотите.Если возникает сценарий, который приводит к ошибке в вашей функциональности, по крайней мере, у вас есть тест этой функциональности, чтобы добавить этот сценарий в тест, а затем изменять свою функциональность до тех пор, пока тест не пройдет.Один из способов узнать, где мы могли пропустить тест, — использовать покрытие кода.

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

Один из способов помочь в использовании TDD, помимо чтения об этом процессе, — это наблюдать за тем, как люди это делают.Рекомендую посмотреть скринкасты JP Boodhoo на ДНРТВ.Проверьте это:

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

Я думаю, что поступил бы несправедливо по отношению к сообществу, если бы не обновил это, добавив новую серию Кента Бека на Разработка через тестирование для Pragmatic Programmer.

Другие советы

Из моего собственного опыта:

  1. Тестируйте только свой собственный код, а не код базовой платформы.Поэтому, если вы используете общий список, нет необходимости тестировать «Добавить», «Удалить» и т. д.

  2. Нет 2.Посмотри туда!Обезьянки!!!

  3. НУнит это путь.

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

Мое мнение по этому поводу следующее:

  • +1 за то, что вы не тестируете код платформы, но вам все равно может потребоваться протестировать классы, производные от классов платформы.
  • Если какой-то класс/метод сложно тестировать, это может быть явным признаком того, что с проектированием что-то не так.Я стараюсь следовать принципу «1 занятие – 1 ответственность, 1 метод – 1 действие».Таким образом, вам будет намного проще тестировать сложные методы, делая это меньшими порциями.
  • +1 за xUnit.Для Java вы также можете рассмотреть ТестНГ.
  • TDD — это не отдельное событие, это процесс.Поэтому не пытайтесь предусмотреть все с самого начала, а убедитесь, что каждая обнаруженная в коде ошибка действительно покрывается тестом после ее обнаружения.

Я думаю, что самая важная вещь (и фактически один из замечательных результатов, в некотором смысле рекурсивного) TDD — это успешное управление зависимостями.Вы должны убедиться, что модули тестируются изолированно, без необходимости сложной настройки.Например, если вы тестируете компонент, который в конечном итоге отправляет электронное письмо, сделайте отправителя электронного письма зависимостью, чтобы вы могли имитировать его в своих тестах.Это приводит ко второму моменту: шутки — ваши друзья.Познакомьтесь с фреймворками для макетирования и стилем тестов, которые они продвигают (поведенческие, в отличие от классических тестов на основе состояний), а также с выбором дизайна, который они поощряют (The «Расскажи, а не спрашивай» принцип).

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

В любом случае, чтобы ответить на ваши вопросы

  1. Вам не нужно тестировать то, что, как вы «знаете», будет работать, если только вы это не написали.Вы не писали дженерики, это сделала Microsoft;)
  2. Если вам нужно сделать так много для вашего теста, возможно, ваш объект/метод тоже делает слишком много.
  3. Скачать TestDriven.NET чтобы немедленно начать модульное тестирование в вашей Visual Studio (кроме случаев, когда это экспресс-версия)
  4. Просто проверьте правильно, что произойдет.Вы не нуждаться чтобы проверить все, что может пойти не так:для этого вам придется подождать, пока ваши тесты не пройдут.

Серьезно, просто сделай это, чувак.:)

Я ни в коем случае не эксперт в TDD, но вот мое мнение:

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

Платформы тестирования xUnit часто можно использовать бесплатно, поэтому, если вы разбираетесь в .Net, обратите внимание на NUnit, а если вам нравится Java, обратите внимание на JUnit.

Приведенный выше совет хорош, и если вам нужен список бесплатных фреймворков, вам не придется искать дальше, чем Список фреймворков xUnit в Википедии.Надеюсь это поможет :)

На мой взгляд (ваш опыт может отличаться):

1- Если вы этого не писали, не проверяйте.Если вы это написали и у вас нет теста, его не существует.

3. Как все уже говорили, xUnit бесплатен и великолепен.

2 и 4. Решение о том, что именно тестировать, — это одна из тех вещей, о которых вы можете спорить сами с собой вечно.Я пытаюсь провести эту линию, используя принципы проектирования по контракту.Подробную информацию об этом можно найти в разделах «Объектно-ориентированное создание программного обеспечения» или «Прагматичный программист».

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

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

За последний год я все больше и больше убеждаюсь в преимуществах TDD.Вещи, которые я узнал по пути:1) внедрение зависимостей — ваш друг.Я не говорю об инверсии управляющих контейнеров и фреймворков для сборки плагинных архитектур, просто о передаче зависимостей в конструктор тестируемого объекта.Это приносит огромные дивиденды в плане тестируемости вашего кода.2) Я начал со страстью/ревностностью новообращенного, взял фреймворк для макетов и начал использовать макеты для всего, что мог.Это приводило к нестабильным тестам, которые требовали множества мучительных настроек и прекращались, как только я начинал рефакторинг.Используйте правильный тип тестового дубля.Подделки, в которых вам просто нужно соблюдать интерфейс, заглушки для передачи данных обратно в тестируемый объект, макеты только там, где вам важно взаимодействие.3) Тест должен быть небольшим.Стремитесь к тому, чтобы в каждом тесте проверялось одно утверждение или взаимодействие.Я стараюсь это делать и в основном я там.Речь идет о надежности тестового кода, а также о степени сложности теста, когда вам придется вернуться к нему позже.

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

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

"TDD – Начало работы с разработкой через тестирование"- На данный момент я получил несколько хороших отзывов и был бы очень признателен, если бы вы, ребята, предложили еще что-нибудь.

Надеюсь, это поможет!:)

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top