Я прочитал много сообщений, которые убедили меня, что я должен начать писать unit test, я также начал использовать инъекцию зависимостей (Unity) ради упрощения насмешек, но я все еще не совсем уверен, на каком этапе я должен начните писать модульные тесты и издевательства, и как и где начать.
Будет ли предпочтительный способ писать модульные тесты перед методами, описанными в методологии TDD?
Есть ли какая-либо другая методология или способ для модульного тестирования?
Тест сначала/тест после:
Следует отметить, что "тест сначала" как часть TDD имеет такое же значение (если не больше) для дизайна, как и для модульного тестирования. Это технология разработки программного обеспечения сама по себе - запись тестов приводит к постоянному уточнению дизайна.
В отдельном примечании: если есть одно существенное преимущество для TDD с точки зрения чистого модульного тестирования, то это намного сложнее (хотя и не невозможно), чтобы написать тест, который был неправильным при выполнении TDD. Если вы пишете тест заранее, он должен всегда терпеть неудачу, потому что логика, необходимая для прохождения теста, еще не существует. Если вы потом напишете тест, логика должна быть там, но если тест прослушивается или тестируется неправильно, он может пройти независимо.
т.е. если вы пишете плохой тест раньше, вы можете получить зеленый свет, когда вы ожидаете красного (так что вы знаете, что тест плох). Если после этого вы напишите плохой тест, вы получите зеленый свет, когда вы ожидаете зеленого цвета (не подозревая о плохом тесте).
Книги
Книга прагматического тестирования модулей стоит посмотреть, как и Рой Ошерове "Искусство модульного тестирования". Прагматическая книга более узко ориентирована на различные типы тестовых входов, которые вы можете попытаться найти ошибки, тогда как TAOUT охватывает более широкое распространение таких тем, как двойные тесты, стратегии, ремонтопригодность и т.д. Либо книга хороша; это зависит от того, что вы хотите от него.
Кроме того, здесь ссылка на беседу, которую Рой Ошероув сделал на модульном тестировании. Это стоит посмотреть (так же, как и некоторые из видеозаписей, которые он записал, так как он указывает на различные проблемы и dos/don'ts вместе с причинами).
Как начать
Там ничего лучше, чем писать код. Найдите довольно простой класс, который больше не ссылается. Затем начните писать несколько тестов.
Всегда спрашивайте себя: "Что я хочу попробовать и доказать с этим тестом?" перед тем, как вы его напишете, дайте ему достойное имя (обычно включающий вызываемый метод, сценарий и ожидаемый результат, например, в стеке: "Pop WhenStackIsEmpty ThrowsException" ).
Подумайте обо всех входных данных, которые вы можете наложить на него, различных комбинаций методов, которые могут дать интересные результаты и т.д.
Если вам интересно узнать о модульном тестировании, лучший способ узнать, попробуйте. Сначала вы начнете писать интеграционные тесты, но это нормально. Когда они кажутся слишком трудными для поддержания или слишком много работы для написания, читайте больше о том, какие тесты существуют (единицу, функциональность, интеграция) и пытайтесь узнать разницу.
Если вы заинтересованы в том, чтобы начать с TDD, дядя Боб - хороший источник. Particalulary this.
Подробнее об модульном тестировании
Убедитесь, что вы получаете согласованные результаты тестирования. Повторяя один и тот же тест, вы должны последовательно возвращать те же результаты.
Тесты не требуют настройки.
Порядок тестирования не должен иметь значения. Это означает, что частичные тестовые прогоны могут работать правильно. Кроме того, если вы придерживаетесь этой философии дизайна, это, скорее всего, поможет в создании теста.
Помните, что любое тестирование лучше, чем отсутствие тестирования. Трудность может быть обнаружена при написании хороших чистых модульных тестов, которые способствуют простоте создания и обслуживания. Чем сложнее структура тестирования, тем больше оппозиции будет использовать ее. Тестирование - ваш друг.
В С# и с визуальной студией я нахожу следующую процедуру очень полезной:
Подумайте! Сделайте небольшой авангардный дизайн. Вы должны иметь четкое представление о том, какие классы вам нужны и как объекты должны относиться друг к другу. Сосредоточьтесь только на одном классе/объекте (класс/объект, который вы хотите реализовать) и одну связь. В противном случае вы получите слишком тяжелый дизайн. Я часто заканчиваю несколькими эскизами (всего несколько коробок и стрелок) на запасном листе бумаги.
Создайте класс в производственном коде и назовите его соответствующим образом.
Выберите одно поведение класса, который вы хотите реализовать, и создайте для него заглушку метода. С визуальной студией создание пустых меток - кусок пирога.
Напишите тест для него. Поэтому вам нужно будет инициализировать этот объект, вызвать метод и сделать утверждение для проверки результата. В самом простом случае утверждение требует другого заглушки метода или свойства в производственном коде.
Скомпилируйте и пусть тестовый бегун покажет вам красную полосу!
Введите требуемое поведение в производственном коде, чтобы увидеть зеленую полосу.
Переход к следующему поведению.
Для этой процедуры важны две вещи:
Тест сначала или не первый тест?
Мне обычно сложнее переориентировать тесты на существующий производственный код. В большинстве случаев это связано с запутанными зависимостями с другими объектами, когда объект, который находится под тестированием, должен быть инициализирован. TDD обычно избегает этого, потому что вы хотите инициализировать объект в тестовых случаях с меньшими усилиями, насколько это возможно. Это приведет к очень свободному соединению.
Когда я модифицирую тесты, необходимо выполнить громоздкое задание инициализации тестируемого объекта. Также утверждениями может быть много работы из-за запутанных зависимостей. Для этого вам нужно будет изменить производственный код и разбить зависимости. При правильной инъекции зависимостей это не должно быть проблемой.
Да, предпочтительный способ сделать TDD - сначала написать тест (как это подразумевается под названием Test-Driven Development). Когда вы начинаете с TDD, может быть трудно узнать, с чего начать писать тесты, поэтому я предлагаю быть прагматичным в этом отношении. В конце концов, самая важная часть нашей работы - доставка рабочего кода, а не столько, как создавался код.
Итак, вы можете начать с написания тестов для существующего кода. Как только вы узнаете, как структурированы модульные тесты, какие из них, похоже, делают хорошую работу и какие из них кажутся не такими богами, тогда вам будет легче погрузиться в первый подход к тестированию. Я обнаружил, что сначала пишу тесты в большей степени по прошествии времени. Это просто становится более естественным с увеличением опыта.
Стив Сандерсон отлично поработал над лучшими практиками TDD.
http://feeds.codeville.net/~r/SteveCodeville/~3/DWmOM3O0M2s/
Кроме того, существует большой набор учебников для проекта ASP.net mvc, в котором обсуждаются многие принципы TDD (если вы не возражаете, изучая ASP.net MVC на этом пути) http://www.asp.net/learn/mvc-videos/ Найдите серию "Storefront" в нижней части страницы.
MOQ, кажется, в последнее время является горячей фальшивой структурой, вы можете также изучить это
В общем, попробуйте написать тест, чтобы проверить что-то, что вы пытаетесь архивировать, а затем реализовать код, чтобы он работал.
Шаблон известен как Красный - Зеленый - Рефактор. Также сделайте все возможное, чтобы минимизировать зависимости, чтобы ваши тесты могли сфокусироваться на одном компоненте.
Лично я использую Visual Studio Unit Tests. Я не хардкорный разработчик TDD, но мне нравится делать это:
Я также чувствую, что очень полезно добавить функциональность на выходе из базы кода. Если вы хотите добавить новую функцию, сначала создайте unit test для того, что вы хотите добавить, пройдите через код, чтобы увидеть, что вам нужно изменить, затем перейдите в процесс TDD.
Выберите небольшое некритическое приложение и реализуйте его с помощью TDD. Сначала новый образ мышления будет казаться странным, но, может быть, через неделю или две практики он наполняется естественным чувством.
Вот учебное приложение (в разделе "Учебное пособие" ), которое показывает, какие тесты нужно писать. В этом учебном пособии вы пишете код, чтобы передать предопределенные тестовые примеры, чтобы вы попали в ритм, а затем вы затем пишете свои собственные тесты. Файл README содержит инструкции. Он написан на Java, но вы можете легко адаптировать его к С#.
Я бы взял TDD, тестовую первую разработку, перед запугиванием и зависимостью. Разумеется, издевательства могут помочь вам лучше изолировать ваши подразделения - и, таким образом, лучше провести тестирование модулей, но, на мой взгляд, насмешка и DI - более продвинутые концепции, которые могут помешать ясности просто написать ваши тесты в первую очередь.
Mocks и DI, имеют свое место; они являются хорошими инструментами для вашего инструментария. Но они берут некоторую изощренность, более совершенное понимание, чем типичный тестирующий неофит. Однако писать ваши тесты в первую очередь так же просто, как кажется. Так что легче взять на себя, и это мощно все само собой (без издевок и DI). Вы получите раньше, легче выиграть, сначала написали безделушки, чем пытались начать с макетов, и TDD, и DI все сразу.
Начать сначала тестирование; когда вам это очень удобно, и когда ваш код говорит вам, что вам нужны издевки, тогда возьмите насмешки.
Я работал в компаниях, которые слишком много тестируют тестирование/интеграцию, и те, которые делают слишком мало, поэтому мне нравится думать, что у меня хороший баланс между ними.
Я бы рекомендовал TDD - Test Driven Development. Это гарантирует, что у вас есть хороший охват, но он также фокусирует ваше внимание на правильном месте и проблемах.
Итак, первое, что вы делаете для каждой части новой разработки, пишите unit test - даже если у вас нет одного класса для тестирования.
Подумайте о том, что вы тестируете. Теперь запустите тест. Почему бы это не скомпилировать? Потому что вам нужен класс. Создайте класс и запустите тест. Почему он не компилируется? Потому что у него нет метода А. Напишите метод один и снова запустите unit test. Почему тест терпит неудачу? Потому что метод А не реализован. Внесите методА и выполните тест. Почему это терпит неудачу? Поскольку методA не возвращает правильное ожидаемое значение... etc
Вы продолжаете, как это делаете тесты, когда будете разрабатываться, а затем, в конце концов, тест пройдет, и часть функциональности будет завершена.
Расширение ответа Стива Фримена: книга Дейва Астеля называется "Test-driven Development - практическое руководство". Если вид приложения, который вы пишете, является графическим приложением, тогда это должно быть полезно. Я читал книгу Кента Беккса, но я не мог понять, как начать проект с TDD. Astel book test - управляет полным нетривиальным графическим приложением от начала до конца, используя истории. Это очень помогло мне начать с TDD, он показал мне, где и как начать.
Развитие, основанное на тестах, может ввести в заблуждение для новичков, много книг, которые я прочитал, когда я изучаю TDD, научит вас писать тесты Unit для класса Calculator, но, похоже, очень мало помогает создавать приложения для реального мира, которые являются более ориентированными на данные, если осмелюсь сказать. Для меня прорыв был тогда, когда я понял, что такое Behavior Driven Development или BDD, и как начать проводить тестирование извне. Теперь я могу просто посоветовать вам сосредоточиться на поведении вашего приложения и написать модульные тесты для его проверки. Существует много дискуссий между TDD и BDD, но я думаю, что хорошо написанные автоматизированные тесты на каждом уровне добавляют ценность и для их написания нам нужно сосредоточиться на поведении.
У Хади Харири есть отличный пост здесь http://hadihariri.com/2012/04/11/what-bdd-has-taught-me/
Я также написал несколько статей по теме, которые, как мне кажется, помогут понять все концепции, связанные с TDD здесь.
http://codecooked.com/introduction-to-unit-testing-and-test-driven-development/
http://codecooked.com/different-types-of-tests-and-which-ones-to-use/
Прочитайте Прагматическое тестирование модуля в С# с помощью NUnit. Он содержит исчерпывающую информацию о начале написания тестов и структурировании кода, чтобы сделать его более удобным для тестирования.
Если вы еще не писали модульные тесты, просто выберите некоторые классы и начните писать свои модульные тесты и продолжите работу над разработкой дополнительных модульных тестов.
По мере того, как вы получаете опыт, вы можете начать издеваться над базой данных, например, используя инфраструктуру Unity, но я бы предложил начать просто и получить опыт, прежде чем совершать этот прыжок.
Как только вам будет удобно записывать модульные тесты, вы можете попробовать сделать TDD.
Я предпочитаю подход KentBeck, который хорошо объясняется в книге "Разработка, основанная на тестах" на примере - Кент Бек.
из вашего вопроса я могу сделать вывод, что вы не уверены в работе тестового фрейма - выбор правильной работы тестового кадра очень важен для TDD или написания модульных тестов (в общем).
Только практическая проблема с TDD - "Рефакторинг" (нам также нужен код рефакторинга) занимает много времени.
Я думаю, что книга Дэйва Астелля по-прежнему остается одним из лучших представлений. Это для Java, но вы должны уметь переводить.