Что нужно сделать в первую очередь: обзоры кода или модульные тесты?

Ответ 1

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

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

Ответ 2

в моей компании мы строго следим, чтобы сначала выполнить единичный тест. Основная причина заключается в том, что функциональность, для которой происходит изменение кода, - это обеспечивается в unit test. Если это не сделано полностью, нет смысла делать обзор кода.

Ответ 3

Если проверка кода происходит до написания модульных тестов, не означает ли это, что никто не проверяет модульные тесты? Или вы ожидаете, что это будет сделано во втором обзоре?

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

Ответ 4

Так как вы всегда должны начинать свой unit test, прежде чем начинать свой класс/метод и записывать два в тандеме, unit test должен быть таким же полным, как и код, который просматривается.

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

Ответ 5

Если бы время было коротким, что бы вы предпочли?

Как было сказано выше, обзор кода хорош, но модульное тестирование имеет жизненно важное значение.

В моем опыте тестирование модулей обнаруживает больше ошибок, чем проверка кода. Поэтому сначала выполняйте модульное тестирование.

Кроме того, когда я делаю обзоры кода, мне нужно знать, что код работает, так что я могу рискованно смотреть на структуру кода, как создается SQL, независимо от того, удовлетворяет ли код требованиям функциональности и т.д. Намного сложнее рассмотреть код, который я НЕ ЗНАЮ, работает.

С точки зрения логистики вам нужно запланировать, чтобы кто-то просматривал код, но вам не нужно это для модульного тестирования.

Тестирование модулей всегда перед просмотром кода.

Ответ 6

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

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

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

До и после

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

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

Почему не оба одновременно?

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

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

Ответ 7

I в блоге об этой замечательной статье IEEE от Robert Glass назвал часто забытые фундаментальные факты о разработке программного обеспечения, которые имеют отношение к вашему вопросу.

• Вам действительно нужны как экспертные оценки, так и тестирование в белом ящике.
• Если бы мне пришлось выбирать между обзорами кода и модульным тестированием, я бы выбрал ни. Наиболее эффективная деятельность по устранению дефектов - это дизайн.

Ответ 8

Во-первых, необходимо точно определить, что делается во время модульного тестирования и что сделано во время проверки.

(Я предполагаю, что есть требования или какое-то описание задачи до того, как кодер начал кодировать)

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

проверка - это "код делает это правильно".
валидация - это "код делает правильную вещь".

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

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

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

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

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

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

С учетом сказанного, правильное требование в первую очередь обычно требует фактического кодирования. Все это сводится к процессу водопада (сначала дизайн) и быстрый процесс прототипирования (сначала код). Ключом является управление процессом в ваших обстоятельствах. Для этого вам нужно понимать свои обстоятельства, а не слепо использовать "лучшие практики". Поэтому я не рекомендую сначала сначала делать обзор, либо тесты, я рекомендую выяснить, что подходит вашим обстоятельствам.

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

ура!
/Per

Ответ 9

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

Ответ 10

Хорошо, если вы возьмете Test Driven Development (TDD, хорошо им нравится называть это Behavioral таким образом BDD сейчас), тогда вы должны написать модульные тесты перед кодом.

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

Ответ 11

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

Ответ 12

Мы пытаемся сделать следующее:

• Лицо A пишет код (конечно, с тестами)
• Лицо B пишет некоторые модульные тесты против кода
• Лицо A + B делает обзор кода и тестов

Ответ 13

Так как "просмотр кода" здесь означает просмотр кем-то, кроме автора кода, тогда мне нужно будет повторить проверку кода во-вторых и, таким образом, модульные тесты. Но не по каким-либо причинам, приведенным до сих пор.

Львиная доля стоимости программного обеспечения находится в обслуживании: исправления и расширения. Самая большая причина дефектов в этой фазе - неправильные изменения, потому что поддерживающий разработчик не совсем понял код, который он/она меняет. Поэтому наиболее рентабельным направлением обзора кода является читаемость. Не тривиальные проблемы стиля, но читаемость = понятность + правильный уровень детализации в каждой области.

Целью автора кода является создание читаемого кода, зная, что рецензент кода запросит код для того, чтобы он был недостаточно читабельным. Автор кода должен сначала сделать все возможное, чтобы сначала прочитать код для себя. Написание модульных тестов - отличный способ сделать это, потому что он заставляет автора кода перечитывать свой собственный код и следить за тем, чтобы он был понятен простой и неумолимой аудитории: unit test. Фактически передача модульных тестов - это бонус - это неудачные модульные тесты, которые того стоят, потому что они заставляют автора кода снова прочитать код и исправить его. Другими словами, написание модульных тестов является самым близким автором кода, которое может прийти "выйти за пределы себя" и объективно проанализировать его собственный код.

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

Следовательно,

• Напишите модульные тесты
• Получить обзор кода

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

Ответ 14

Я сторонник пересмотра кода, являющийся конечным шагом после того, как разработчик выполнил все свои испытания (модульное тестирование, интеграционное тестирование, переход по коду, предоставление кода предупреждения бесплатно, и что когда-либо "черное" полевое тестирование подходящее). Теперь я могу запросить обратную связь по коду (эй, как это выглядит для API) задолго до этого, если у меня есть вопросы о чем-то. Мой опыт в том, что обзоры кода обнаруживают ошибки, но не тонну сверхжестких логических схем, если вы не тратите много времени на просмотр обозревателем кода. Рецензент может задать пару трудных вопросов (насколько безопасен этот поток? Что произойдет, если x не удастся?), Но действительно сложно определить все случаи кода, о которых вы не думали какое-то время. По-прежнему очень полезно помочь отслеживать, что происходит в остальной части проекта.

Ответ 15

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

(с другой стороны, если код не был проверен модулем перед обзором, вы никогда не узнаете, что эти изменения сломают что-либо: 0)

Ответ 16

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

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

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

Проблема с написанием тестового кода позже состоит в том, что иногда могут произойти две вещи: 1. Dev может написать тестовый код с учетом его кода. 2. При написании тестового кода разработчик может понять, что, эй!, Мой код не прошел бы это, и он снова отправится и исправит свой код, и напишет тестовый код, который явно обуглен, чтобы передать код, который он только что написал.

Всегда полезно сначала написать тестовый сценарий.

Ответ 17

Проверка кода, но с явной целью, чтобы вы определяли тестовые случаи для записи, как вы делаете обзор. Это фокусирует рецензента на поиске аномалий, которые могут быть протестированы, например: проверка входов, краевых случаев и т.д.

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

Ответ 18

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

Ответ 19

Мой ответ: обзор кода.

Модульные тесты могут быть переписаны из-за изменения дизайна или функциональности в результате проверки кода.

Ответ 20

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

Ответ 21

Кодовые обзоры должны выполняться сначала.

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

Ответ 22

Проверка кода должна выполняться до фиксации элемента управления. Также исправлено исправление ошибок. Таким образом просматривается любой код в исходном элементе управления.

Как часть обзора кода, я получаю девелопер для демонстрации функциональности, так что можно проверить, что она работает.