Насколько большим должен быть мой проект, чтобы я смог его протестировать? [закрыто]

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

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

Ваш проект уже достаточно большой.

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

    class Simple {
        boolean reallySimple() {
            return true; // how do we make sure it doesn't change to false?
        }
    }


    class SimpleTest {
        void assertReallySimple() {
            // ensure reallySimple return value isn't changed unexpectedly
            UnitTestFramework.assertTrue(new Simple().reallySimple());
        }
    }

Я никогда не увлекался идеей «Вы должны все протестировать», хотя, конечно, есть люди, которые имеют (см . Ответ Гнат !).

Насколько мне известно, основными преимуществами модульного тестирования являются:

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

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

Номер 1 обычно достаточен для написания тестов. По моему опыту,> 95% кода рано или поздно модифицируется.

Все просто: вам не нужно юнит-тестирование, если вы откажетесь от программы после ее запуска один раз.

Если это кажется вам чрезмерным, подумайте, что будет означать альтернатива. Если бы был какой-то размер, ниже которого юнит-тестирование не окупается, вам бы приходилось думать: «Я уже достиг магического размера? Должен ли я начать писать тесты?» Теперь программисты, как известно, плохо предсказывают будущее, и они, как известно, плохо оценивают свои навыки. Код, который теперь кажется вам кристально чистым, станет непонятным даже для вас, даже если вы будете ждать месяц. Проект, в котором вы абсолютно уверены, никогда больше не будет использоваться, и у вас есть лишь небольшой шанс, что вы захотите посмотреть, как вы решили что-то раньше, будете снова запрашивать и получать запросы на изменение.

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

Некоторое время назад я нашел хороший пост: почему юнит-тестирование ускоряет разработку . Это может помочь вам ответить на вопрос.

... Что делать, если кодовая база ... была обеспечена значительным набором юнит-тестов. Набор, который говорит: «если все тесты пройдут успешно, я гарантирую, что код все еще делает то, что должен», а если тест не пройден, он точно показывает, где какое-то поведение нарушено. Это замечательно, я мог бы изменить код, чтобы добавить вещи, которые я хочу, не бродя, если код все еще делает то, что должен, я просто запускаю ... тесты и у меня есть вера. Это прекрасный мир для программиста. Я заметил, что могу продвигаться намного быстрее ...

У меня есть вера".

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

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

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

Майкл Фезерс представил в одной из своих книг два способа работы с изменениями в коде:

• редактировать и молиться,
• накрыть и изменить.

Неважно, насколько велика база кода.

Согласно Кенту Беку в ответе на вопрос о переполнении стека Насколько глубоки ваши юнит-тесты? , вы должны проверить код, который вы склонны ошибаться.

Если я обычно не совершаю какую-то ошибку (например, устанавливаю неправильные переменные в конструкторе), я не проверяю это.

Проведены юнит-тесты для экономии времени и улучшения:

• отслеживание ошибок
• рефакторинг и / или переписывание кода
• интеграционное тестирование
• регрессионное тестирование и др.

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

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

На вопрос «Должен ли я выполнить это модульное тестирование» обычно можно ответить, ответив на следующий вопрос: «Важно ли, чтобы эта функция работала правильно, и важно ли для меня знать, когда она перестанет работать?»

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

Если вы не собираетесь писать код без его тестирования, вы всегда будете нести расходы на тестирование.

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

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

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

Недавно мне предложили использовать Test Driven Development, и я обнаружил, что это полное откровение. Теперь я твердо убежден, что у меня нет времени не писать юнит-тесты .

По моему опыту, разрабатывая с учетом тестирования, вы получаете более чистые интерфейсы, более сфокусированные классы и модули и, как правило, более твердый , тестируемый код.

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

TL; версия DR :

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

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

Проверьте, как только вы заметите, что произошли регрессии или страх вызвал некоторые изменения и не заметил.

Разожгите этот страх, дайте ему вырасти до адекватного размера: чем раньше вы протестируете, тем лучше.

Обратите внимание: в зависимости от вашей роли в проекте модульные тесты могут быть не единственным видом тестов, который вы хотите написать.

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

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

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

Цитата из «Чистого кода» Роберта Мартина : «Если писать тривиально, тестировать тривиально», поэтому нет повода пропускать тестирование для коротких и тривиальных программ.

Это действительно не вопрос размера - это то, что вы делаете с ним (и сколько ему лет). Если я буду изучать, как работает технология, и планирую выбросить ее (мы называем это шипом в Scrum), я просто напишу код, не выполняя большого количества тестирования. Если вы планируете развивать его дальше (даже если вы просто дурачитесь), вы должны написать тесты вокруг кода. TDD - это метод проектирования, даже до того, как это будет методика тестирования. Вы хотите иметь четкое представление о том, что вы хотите, чтобы код делал, прежде чем вы будете связаны с деталями выполнения. Я бы тоже НЕрекомендую пытаться писать обширные модульные тесты для большого количества унаследованного кода. Попробуйте определить те части, которые являются сложными (имеют высокую цикломатическую сложность / чувство спагетти к ним) и те части, которые часто выходят из строя (они часто будут одинаковыми). Как и предполагали другие, я бы прочитал книгу Кента Бека о TDD и обязательно прочитал книгу Майкла Фезера. То, что они не покрывают очень много, является политическим аспектом написания модульных тестов вокруг кода. Многие разработчики ненавидят необходимость изменять свой код, чтобы сделать его тестируемым, и многие разработчики вообще не испытывают необходимости тестировать код. Это то, над чем мы должны работать как профессия. Любая другая инженерная дисциплина должна доказать (часто математически), что их работа соответствует спецификации. Мы должны сделать то же самое.

Связывание проектов в пределах классов или функциональных возможностей, а затем оценка того, подходит ли это для модульного тестирования, может быть неправильным. Есть много преимуществ модульного тестирования приложения, но настоящая красота начинается, когда вам нужно поддерживать приложение или работать в распределенной среде. Так что выбор приходит сюда. Даже небольшое изменение в вашем коде может привести к бедствиям.
Я бы не только предложил «Модульное тестирование», но и рекомендовал бы проверить покрытие вашего кода, убедившись, что максимум вашего кода покрыт модульным тестированием. Порог для покрытия кода должен быть не менее 95%, а цель должна быть около 100% . Вы можете воспользоваться инструментами для отслеживания покрытия кода и создания отчета.
Visual Studio предоставляет данные покрытия -http://msdn.microsoft.com/en-us/library/ms182496(v=vs.80).aspx
Также вы можете использовать NCover или dotCover.