Что делает хороший модульный тест? [закрытый]

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

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

Часто модульные тесты основаны на фиктивном объекте или дразнят данные. Мне нравится писать три вида модульных тестов:

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

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

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

Я второй "ПРОХОЖДЕНИЕ" ответ, за исключением того, что тесты ДОЛЖНЫ полагаться друг на друга!!!

, Почему?

DRY - не Повторяет Себя - относится к тестированию также! Тестовые зависимости могут помочь 1) сохранить время установки, 2) сохранить ресурсы приспособления и 3) точно определить к отказам. Конечно, только, учитывая, что Ваша среда тестирования поддерживает первоклассные зависимости. Иначе я признаю, они плохи.

Продолжают http://www.iam.unibe.ch/~scg/Research/JExample/

Никогда не предполагайте, что будут работать тривиальные 2 метода строки. Запись быстрого модульного теста является единственным способом предотвратить недостающий пустой тест, неуместный знак "минус" и/или тонкую ошибку обзора от кусания Вас, неизбежно когда у Вас есть еще меньше времени для контакта с ним, чем теперь.

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

Наилучшие пожелания

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

способ, которым я определяю "хорошие" модульные тесты, то, если они отряды следующие три свойства:

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

• Поблочное тестирование просто тестирует внешний API Вашей Единицы, Вы не должны тестировать внутреннее поведение.
• Каждый тест TestCase должен протестировать один (и только один) метод в этом API.
  • Тесты Aditional должны быть включены для случаев возникновения отказов.
• Тест покрытие Ваших тестов: Однажды единица это тестируется, 100% строк в этой единице должны, был выполнен.

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

Что Вы, после формирование рисунка поведений класса под тестом.

1. Проверка ожидаемых поведений.
2. Проверка ошибочных случаев.
3. Покрытие всех путей выполнения кода в классе.
4. Осуществление всех функций членства в классе.

основное намерение является увеличением Ваша уверенность в поведении класса.

Это особенно полезно при рассмотрении рефакторинга кода. У Martin Fowler есть интересное статья относительно тестирования на его веб-сайте.

HTH.

аплодисменты,

Rob

свойства Some больших модульных тестов:

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

• , Когда Вы осуществляете рефакторинг, никакие тесты не должны перестать работать.

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

• Все тесты должны всегда передавать; никакие недетерминированные результаты.

• Модульные тесты должны быть хорошо учтены, точно так же, как Ваш производственный код.

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

РЕДАКТИРОВАНИЕ: был комментарий о дублировании, вызванном "одним утверждением на тест". А именно, если у Вас есть некоторый код, чтобы настроить сценарий, и затем хотеть сделать несколько утверждений об этом, но только иметь одно утверждение на тест, Вы могли бы дублирование установка через несколько тестов.

я не проявляю тот подход. Вместо этого я использую тестовые приспособления на сценарий . Вот грубый пример:

[TestFixture]
public class StackTests
{
    [TestFixture]
    public class EmptyTests
    {
        Stack<int> _stack;

        [TestSetup]
        public void TestSetup()
        {
            _stack = new Stack<int>();
        }

        [TestMethod]
        [ExpectedException (typeof(Exception))]
        public void PopFails()
        {
            _stack.Pop();
        }

        [TestMethod]
        public void IsEmpty()
        {
            Assert(_stack.IsEmpty());
        }
    }

    [TestFixture]
    public class PushedOneTests
    {
        Stack<int> _stack;

        [TestSetup]
        public void TestSetup()
        {
            _stack = new Stack<int>();
            _stack.Push(7);
        }

        // Tests for one item on the stack...
    }
}

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

Помните об этих целях (адаптированный из книги xUnit Тестовые Шаблоны Meszaros)

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

Некоторые вещи сделать это легче:

• Тесты должны только перестать работать из-за одной причины.
• Тесты должны только протестировать одну вещь
• , Минимизируют тестовые зависимости (никакие зависимости от баз данных, файлов, ui и т.д.)

не забывают, что можно сделать intergration, тестирующий с xUnit платформой также , но сохранить тесты intergration и модульные тесты отдельными

1. не пишут тесты ginormous. , Поскольку 'единица' в 'модульном тесте' предлагает, сделайте, каждый максимально атомарный и изолировал . Если Вы должны, создать предварительные условия с помощью фиктивных объектов, вместо того, чтобы воссоздать слишком много среды типичного пользователя вручную.
2. не тестируют вещи, это, очевидно, работает. Стараются не тестировать классы от стороннего поставщика, особенно тот, предоставляющий базовые API платформы, в которой Вы кодируете. Например, не тестируйте добавление объекта к классу Хеш-таблицы поставщика.
3. Рассматривают использование инструмента покрытия кода , такого как NCover, чтобы помочь обнаружить пограничные случаи, которые необходимо все же протестировать.
4. Попытка, пишущий тест прежде реализация. Думают о тесте как о большем количестве спецификации, которой будет придерживаться Ваша реализация. Cf. также управляемая поведением разработка, более определенное ответвление разработки через тестирование.
5. Быть последовательным. , Если Вы только тесты записи на часть Вашего кода, это едва полезно. Если Вы работаете в команде, и некоторые или все другие не делают тестов записи, это не очень полезно также. Убедите себя и всех остальных важности (и экономящий время свойства) тестирования, или не беспокойтесь.

Мне нравится Правильный акроним BICEP от вышеупомянутого Прагматическое Поблочное тестирование книга:

• Право : результаты право ?
• B: действительно ли все эти корректные условия b oundary?
• я : мы можем проверить я nverse отношения?
• C: Можем мы результаты ross-проверки c с помощью других средств?
• E: мы можем вызвать условия e rror произойти?
• P: характеристики p erformance в границах?

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

Хорошие тесты должны сопровождаться.

Я не совсем понял, как это сделать для сложных сред.

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

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

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

Где вы храните тестовые наборы в своей кодовой базе?

• Как вы документируете свои тестовые наборы?
• можно ли повторно использовать тестовые приборы для сохранения обслуживания тестового набора?
• Что происходит при ночных тестах? выполнение дела не удается? Кто делает сортировку?
• Как вы поддерживаете фиктивные объекты? Если у вас есть 20 модулей, каждый из которых использует свой собственный интерфейс API для искусственного ведения журналов, вы можете быстро сменить API. Меняются не только контрольные примеры, но и 20 фиктивных объектов. Эти 20 модулей были написаны в течение нескольких лет многими разными командами. Это классическая проблема повторного использования.
• люди и их команды понимают ценность автоматизированных тестов, им просто не нравится, как это делает другая команда. : -)

Я мог бы продолжать вечно, но моя точка зрения такова:

Тесты должны быть ремонтопригодны.

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

5 законов написания тестов Вомпа:

1 , Используйте длинные описательные названия методов тестирования.

   - Map_DefaultConstructorShouldCreateEmptyGisMap()
   - ShouldAlwaysDelegateXMLCorrectlyToTheCustomHandlers()
   - Dog_Object_Should_Eat_Homework_Object_When_Hungry()

2. Напишите свои тесты в стиле Упорядочить / Действовать / Утвердить .

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

3. Всегда предоставляйте сообщение об ошибке вместе с вашими утверждениями.

Assert.That(x == 2 && y == 2, "An incorrect number of begin/end element 
processing events was raised by the XElementSerializer");

• Простая, но полезная практика, которая делает очевидным в вашем приложении runner, что не удалось. Если вы не предоставите сообщение, вы обычно получите что-то вроде «Ожидаемое истинное, было ложным» в вашем сообщении об ошибке, что заставляет вас фактически прочитать тест, чтобы выяснить, что не так.

4. Прокомментируйте причину теста - каковы бизнес-предположения?

  /// A layer cannot be constructed with a null gisLayer, as every function 
  /// in the Layer class assumes that a valid gisLayer is present.
  [Test]
  public void ShouldNotAllowConstructionWithANullGisLayer()
  {
  }

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

5. Каждый тест должен всегда возвращать состояние любого ресурса, которого он касается.

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

Я использую согласованное соглашение об именах тестов, описанное Стандарты именования модульных тестов Роя Ошерова Каждый метод в данном классе тестового примера имеет следующий стиль именования MethodUnderTest_Scenario_ExpectedResult.

Первая секция имени теста - это имя метода в тестируемой системе.

Далее идет тестируемый конкретный сценарий.

Наконец, результаты этого сценария.

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

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

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