В какой момент вы достигаете переполнения Unit Testing?

Ответ 1

Можно ли использовать сразу несколько тестовых фреймворков?

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

Итак, когда вы достигаете избыточного тестирования единицы измерения?

Вы быстро доходите до модульного тестирования "overkill", и вы, возможно, уже достигли его. Существует несколько способов переусердствовать в тестах вообще, которые побеждают цель TDD, BDD, ADD и любой используемый вами подход. Вот один из них:

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

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

Итак, при написании модульных тестов есть пара сладких пятен, чтобы думать о том, когда пишите тесты:

unit test                 dirty hybrids               integration test
---------                 -------------               ----------------
* isolated                                            * using many classes 
* well defined                  |                     * tests a larger feature
* repeatable                    |                     * tests a data set
                                |
    |                           |                              |
    |                           |                              |
    v                           v                              v

    O  <-----------------------------------------------------> O 

    ^                           ^                              ^
    |                           |                              |

sweet spot              world full of pain                sweet spot

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

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

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

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

Вам нужно постоянно писать тесты?

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

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

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

Ответ 2

Вы переусердствовали, если вы тестируете один и тот же ввод снова и снова.

Пока каждый новый тестовый пример проверяет что-то другое, вы в порядке.

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

Я обычно проверяю границы. Если бы я написал функцию фибуначчи, я бы тестировал ее для значений -1, 0, 1, 10 и Maxvalue целого числа. Тестирование на 20 или 509 не будет проверять все, что еще не охвачено.

Ответ 3

Если вы потратили больше времени на тесты, чем на кодирование, возможно, вы переусердствовали. Но это мое личное мнение. Возможно, вам будет интересно взглянуть на Test-Driven Development как хороший подход, чтобы начать с тестов, гарантируя, что вы напишете код, который вам понадобится, и вы напишете его, как он должен работать (http://en.wikipedia.org/wiki/Test-driven_development)

Удачи!

Ответ 4

Нет такой вещи, как обертывание! Конечно, вы не хотите этого делать. Учитывая метод

public void tripleInt(int i);

вы не хотите тестировать его для бесконечного числа int. Это не будет практично. Вероятно, вы хотите проверить положительный, отрицательный, Integer.Max и т.д.

Ответ 5

Написание высокоуровневых модульных тестов иногда является излишним.

Точка модульных тестов:

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

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