В TDD, в чем преимущество запуска тестов, прежде чем писать пустой метод?

Ответ 1

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

Помните также, что, когда вы впервые узнаете о вещах, обычно вам нужен четкий набор правил, чтобы дать вам контекст. Когда вы начнете переходить от Beginner к более продвинутому, вы получите больше контекста и сможете делать хитрости. Мне это звучит так, как ты.

Ответ 2

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

Попробуйте это как отредактированную последовательность:

1) Напишите свой тест в пределах комментарий, как если бы целевые объекты и API уже существует.

2) Напишите достаточно кода API для компиляции.

3) Раскомментируйте свой тестовый код.

4) Запустите тест и убедитесь, что он не работает.

5) Напишите достаточно кода для его получения пройти.

6) Запустите тест и посмотрите, как он проходит

7) Промыть и повторить...

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

Ответ 3

Рабочий процесс в Eclipse с JUnit (в отличие от Visual Studio с MSTest) - это то, где шаги 1-3 имеют наибольший смысл. Шаг 3 - это просто использование функциональности Eclipse Quick Fix (Ctrl-1) для создания кода-заглушки на основе unit test, который вы только что написали.

DoesntExistYet someObject = new DoesntExistYet();
int result = someObject.newMethod(" 123 ");
assertEquals (123, результат);

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

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

Ответ 4

Я думаю, что всем не хватает критической точки - как вы ЗНАЕТЕ, что желаемого метода еще не существует? Написав unit test, который вызывает метод, который еще не должен существовать, а затем наблюдать за сбоем, проверяет, что ваше предположение верно. На компилируемом языке он не должен компилироваться. На некомпилированном языке неудачное выполнение может быть намного быстрее, чем проверка API. В большинстве языков наследование и полиморфизм могут привести к присутствию метода, который не регистрировался в вашей ментальной модели API.

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

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

EDIT: от Justin Standard...

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

ИЗМЕНИТЬ: От senfo...

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

@senfo: Слишком много сложностей в иерархии наследования, безусловно, может возникнуть, но это другая проблема с очевидным решением. Даже если ваш существующий код идеален, по-прежнему полезно начинать с unit test, который пытается вызвать возможный несуществующий метод, просто чтобы быстро доказать себе, что он не существует. Конечно, пропустить этот шаг понятно - я мог бы вернуться к нему в конкретной ситуации, когда мой тест ошибочен (чтобы проверить в той конкретной ситуации, что я не вызываю ничего, кроме того, что я только что написал).

Ответ 5

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

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

Ответ 6

запись тестов сначала заставляет вас решать интерфейсы

то есть все.

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

EDIT: я действительно должен внимательно прочитать вопрос, OP искал более конкретный ответ. Вот он: опустите шаг 2 в visual studio, вместо этого закройте методы/классы. Нет никаких оснований быть педантичным в том, чтобы следовать этому расширенному рецепту, когда он явно не нужен с помощью инструментов, которые вы используете.

Ответ 7

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

Если вы используете более мощные IDE для редактирования кода, например, то, что у вас есть на Java (Eclipse, Netbeans, IntelliJ), первые два шага имеют больше смысла. Быстрые исправления и средства генерации кода, доступные там, делают запись теста против несуществующего класса или метода самым быстрым способом создания этого конкретного класса или объявлением этого конкретного метода; вы можете просто нажать кнопку, и для вас будет создан отсутствующий класс или метод. Написание вызова метода или создания объекта быстрее, чем сначала создать класс или метод, а затем использовать их. Например, когда вы вызываете метод, он задается именем метода и типами параметров, какова должна быть подпись метода, поэтому для их создания легко создать среду IDE. Это действительно замечательный процесс, и я бы не программировал иначе. Объедините это с преимуществами фактической работы с api, прежде чем он существует, ваш описанный способ выполнения TDD имеет большой смысл.

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

Для пользователей Visual Studio, если вы хотите поделиться этим опытом, установите плагин Resharper для Visual Studio. Это даст многие из тех же функций, которые доступны в Java IDE.

Ответ 8

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

Ответ 9

Что касается поддержки Visual Studio для TDD, я согласен с тем, что intellisense иногда мешает, но вы действительно можете использовать VS для TDD, хотя он все еще несколько ограничен. Если метод проверки относится к несуществующему методу тестируемого класса, вы можете создать VS для вас, нажав Ctrl-K, Ctrl-M.

К сожалению, это не работает для свойств в VS2008, но насколько я могу судить по нотам для VS2010, в этой области есть много улучшений в этой версии.

Ответ 10

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

Я признаюсь, что обычно делаю большую часть этого в моей голове и начинаю с шага (3).

Ответ 11

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

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

Ответ 12

В книге нет разработки, основанной на тестах. "официальный" TDD-процесс, как описано в разделе "Испытательное развитие на основе теста Beck: на примере":

• Быстро добавить тест
• Запустите все тесты и откройте новый
• измените немного
• Запустите тесты и просмотрите их все успешно
• Рефакторинг для удаления дублирования

Ответ 13

Насколько я понимаю, "см. красное squiggle" == компилятор не удалось. Помните, что оригинальные манифесты unit test/TDD были написаны без использования IDE. Хорошие IDE были очень редки в мире java тогда, и, как отмечали другие, динамические языки все еще не могут определить, что метод не существует во время компиляции, период.

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

Ответ 14

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

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