Что такое поблочное тестирование? [закрытый]
Если вы не против установки пакета для него, вы можете использовать json-tricks :
pip install json-tricks
После этого вам просто нужно импортировать dump(s) из json_tricks вместо json, и он обычно работает:
from json_tricks import dumps
json_str = dumps(cls_instance, indent=4)
, который даст
{
"__instance_type__": [
"module_name.test_class",
"MyTestCls"
],
"attributes": {
"attr": "val",
"dct_attr": {
"hello": 42
}
}
}
И это в основном это!
Это будет отлично работать в целом. Существуют некоторые исключения, например. если в __new__ происходят особые вещи, или происходит больше метаклассической магии.
Очевидно, что загрузка также работает (в противном случае в чем смысл):
from json_tricks import loads
json_str = loads(json_str)
Это предполагает, что module_name.test_class.MyTestCls могут быть импортированы и не изменены несовместимыми способами. Вы вернете экземпляр, а не какой-либо словарь или что-то еще, и он должен быть идентичной копией того, который вы сбросили.
Если вы хотите настроить, как что-то получает (де) сериализован, вы можете добавить специальные методы для вашего класса, например:
class CustomEncodeCls:
def __init__(self):
self.relevant = 42
self.irrelevant = 37
def __json_encode__(self):
# should return primitive, serializable types like dict, list, int, string, float...
return {'relevant': self.relevant}
def __json_decode__(self, **attrs):
# should initialize all properties; note that __init__ is not called implicitly
self.relevant = attrs['relevant']
self.irrelevant = 12
, который в качестве примера сериализует только часть параметров атрибутов.
И как бесплатный бонус, вы получаете (de) сериализация массивов numpy, date & amp; временами, упорядоченные карты, а также возможность включать комментарии в json.
Отказ: я создал json_tricks , потому что у меня была та же проблема, что и вы.
18 ответов
Поблочное тестирование, примерно разговор, тестируя биты Вашего кода в изоляции с тестовым кодом. Прямые преимущества, которые приходят на ум:
- Запущение тестов становится, автоматизируют - способный и повторяемый
- , можно протестировать на намного большем детализированном уровне, чем тестирование "укажи и выбери" с помощью Примечания GUI
, которое, если тестовый код пишет в файл, открывает соединение с базой данных или делает что-то по сети, это более соответственно категоризировано как интеграционный тест. Интеграционные тесты являются хорошей вещью, но не должны быть перепутаны с модульными тестами. Код модульного теста должен быть коротким, сладким и быстрым для выполнения.
Другой способ посмотреть на поблочное тестирование состоит в том, что Вы пишете тесты сначала. Это известно как Разработка через тестирование (TDD, если коротко). TDD приносит дополнительные преимущества:
- Вы не пишете спекулятивный, "Мне, возможно, понадобилось бы это в будущем" коде - как раз, чтобы заставить тесты передать
- код, который Вы записали, всегда покрывается тестами
- Путем записи теста сначала, Вы принуждены к размышлению о том, как Вы хотите назвать код, который обычно улучшает дизайн кода в конечном счете.
, Если Вы не делаете поблочного тестирования теперь, я рекомендую начать на нем. Получите хорошую книгу, практически любая xUnit-книга сделает, потому что понятия очень передаваемы между ними.
Иногда модульные тесты записи могут быть болезненными. Когда это получает тот путь, попытайтесь найти, что кто-то, чтобы помочь Вам и сопротивляться искушению к "просто пишет проклятый код". Поблочное тестирование много похоже на то, чтобы мыть посуду. Это не всегда приятно, но это содержит Вашу метафорическую кухню в чистоте, и Вы действительно хотите, чтобы он был чист.:)
<час>Редактирование: Одно неправильное представление приходит на ум, хотя я не уверен, распространено ли это настолько. Я услышал, что менеджер проектов говорит, что модульные тесты заставили команду записать весь код дважды. Если это стили тот путь, ну, в общем, Вы делаете его неправильно. Не только делает записи, тесты обычно ускоряют разработку, но и это также дает Вам удобное, "теперь я сделан" индикатор, который Вы не имели бы иначе.
Я не не соглашаюсь с Dan (хотя лучший выбор может просто состоять в том, чтобы не ответить)..., но...
Поблочное тестирование является процессом записи кода для тестирования поведения и функциональности системы.
, Очевидно, тесты улучшают качество Вашего кода, но это - просто поверхностное преимущество поблочного тестирования. Реальная выгода к:
- Облегчают изменять техническую реализацию при проверке, что Вы не изменяете поведение (рефакторинг). Правильно протестированная единица кодирует, может настойчиво осуществляться рефакторинг/очищаться с небольшим шансом повреждения чего-либо без того, чтобы замечать его.
- Вселяют веру разработчиков при добавлении поведения, или создание фиксирует.
- Документируют Ваш код
- области Indicate Вашего кода, которые сильно связываются. Это твердо к коду модульного теста, который это сильно связало
- , Обеспечивают, средство использовать Ваш API и искать трудности рано на
- Указывает на методы и классы, которые не являются очень связны
, Вы должны модульный тест потому что в Вашем интересе поставить удобный в сопровождении и качественный продукт Вашему клиенту.
я предложил бы, чтобы Вы использовали его для любой системы или части системы, который модели реальное поведение. Другими словами, это особенно хорошо подходит для развития предпринимательства. Я не использовал бы его для throw-away/utility программ. Я не использовал бы его для частей системы, которые проблематичны для тестирования (UI является типичным примером, но это не всегда имеет место)
, самая большая ловушка - то, что разработчики тестируют слишком большую единицу, или они считают метод единицей. Это особенно верно, если Вы не поймете Инверсия Управления - в этом случае, то Ваши модульные тесты будут всегда превращаться в сквозное интеграционное тестирование. Модульный тест должен протестировать отдельные поведения - и большинство методов имеет много поведений.
самое большое неправильное представление состоит в том, что программисты не должны тестировать. Только плохие или ленивые программисты верят этому. Должен парень, создающий Вашу крышу не, тестирует его? Должен доктор, заменяющий сердечный клапан не, тестирует новый клапан? Только программист может протестировать тот свой код, делает то, что он предназначил его, чтобы сделать (QA может протестировать пограничные случаи - как код ведет себя, когда этому говорят сделать вещи, программист не предназначал, и клиент может сделать, приемочное испытание - делает код, делают что что клиент, оплаченный его, чтобы сделать)
, Что Вы делаете, если Вам дают груду дерьма и походите, Вы застреваете в бесконечном состоянии очистки, которую Вы знаете с добавлением какой-либо новой возможности, или код может повредить текущий набор, потому что текущее программное обеспечение похоже на карточный домик?
, Как мы можем сделать поблочное тестирование тогда?
Вы начинаете с малого. Проект, в который я просто вошел, не имел никакого поблочного тестирования до несколько месяцев назад. Когда покрытие было то, что низко, мы просто выберем файл, который не имел никакого покрытия, и нажмите "add tests".
Прямо сейчас мы готовы к более чем 40%, и нам удалось собрать большую часть низко висящего плода.
(Большая часть - то, что даже на этом низком уровне покрытия, мы уже столкнулись со многими экземплярами кода, делающего неправильную вещь и тестирование, поймал его. Это - огромный фактор мотивации, чтобы продвинуть людей добавлять больше тестирования.)
Я перешел к представлению поблочного тестирования в FoxForward 2007 и не был сказан никогда модульному тесту ничего, что работает с данными. В конце концов, если Вы тестируете на живых данных, результаты непредсказуемы, и если Вы не тестируете на живых данных, Вы на самом деле не тестируете код, который Вы записали. К сожалению, это - большая часть кодирования, которое я делаю в эти дни.:-)
я действительно взял выстрел в TDD недавно, когда я писал стандартную программу, чтобы сохранить и восстановить настройки. Во-первых, я проверил, что мог создать объект хранения. Затем то, что это имело метод, который я должен был назвать. Затем то, что я мог назвать его. Затем то, что я мог передать его параметры. Затем то, что я мог передать его определенные параметры. И так далее, пока я наконец не проверял, что это сохранит указанную настройку, позволит мне изменять его, и затем восстанавливать его, для нескольких различных синтаксисов.
я не добирался до конца, потому что я needed-the-routine-now-dammit, но это было хорошее осуществление.
Разработка через тестирование имеет вид принятых термин Модульный тест. Как старый таймер я упомяну более универсальное определение его.
Модульный тест также означает тестировать единственный компонент в большей системе. Этот единственный компонент мог быть dll, exe, библиотекой классов, и т.д. Это могла даже быть единая система в мультисистемном приложении. Таким образом, в конечном счете Модульный тест заканчивает тем, что был тестированием того, что Вы хотите назвать единственной частью большей системы.
Вы тогда переместились бы до комплексного испытания или тестирования системы путем тестирования, как все компоненты сотрудничают.
Используйте Testivus. Все, что необходимо знать, тут же:)
Поблочное тестирование является тестированием единицы кода (например, единственная функция) без потребности в инфраструктуре, на которую полагается та единица кода. т.е. протестируйте его в изоляции.
, Если, например, функция, что Вы тестируете подключения к базе данных и делаете обновление в модульном тесте, Вы не могли бы хотеть делать то обновление. Вы были бы, если это был интеграционный тест, но в этом случае это не.
, Таким образом, модульный тест осуществил бы функциональность, включенную в "функцию", которую Вы тестируете без побочных эффектов обновления базы данных.
Говорят, что Ваша функция получила некоторые числа от базы данных и затем выполнила вычисление стандартного отклонения. Что Вы пытаетесь протестировать здесь? То, что стандартное отклонение вычисляется правильно или что данные возвращаются из базы данных?
В модульном тесте Вы просто хотите протестировать это, стандартное отклонение вычисляется правильно. В интеграционном тесте Вы хотите протестировать вычисление стандартного отклонения и извлечение базы данных.
Это - мое взятие на нем. Я сказал бы, что поблочное тестирование является практикой записи тестов программного обеспечения, чтобы проверить, что Ваше реальное программное обеспечение делает то, к чему это предназначено. Это запустилось с jUnit в мире Java и стало лучшей практикой в PHP также с SimpleTest и phpUnit. Это - базовая практика Экстремального программирования и помогает Вам быть уверенными, что Ваше программное обеспечение все еще работает, как предназначено после редактирования. Если у Вас есть достаточное тестовое покрытие, можно сделать основной рефакторинг, устранение ошибки или добавить опции быстро с намного меньшим количеством страха перед представлением других проблем.
является самым эффективным, когда все модульные тесты могут быть выполнены автоматически.
Поблочное тестирование обычно связывается с разработкой OO. Основная идея состоит в том, чтобы создать сценарий, который настраивает среду для Вашего кода и затем осуществляет ее; Вы пишете утверждения, определяете намеченный вывод, что необходимо получить и затем выполнить сценарий тестирования с помощью платформы, такой как упомянутые выше.
платформа запустит все тесты против Вашего кода и затем сообщит успешность или неуспешность каждого теста. phpUnit выполняется из командной строки Linux по умолчанию, хотя существуют интерфейсы HTTP, доступные для него. SimpleTest веб-по своей природе и намного легче встать и выполнение, IMO. В сочетании с xDebug phpUnit может дать Вам автоматизированную статистику для покрытия кода, которое некоторые люди находят очень полезными.
Некоторые команды пишут рычаги из своего репозитория подрывной деятельности так, чтобы модульные тесты были выполнены автоматически каждый раз, когда Вы фиксируете изменения.
Это - хорошая практика для хранения модульных тестов в том же репозитории как приложение.
Я использую модульные тесты, чтобы сэкономить время.
При создании бизнес-логики (или доступ к данным) тестирование функциональности может часто включать материал ввода в большое количество экранов, которые могут или еще не могут быть закончены. Автоматизация этих тестов экономит время.
Для меня модульные тесты являются своего рода построенной из модулей тестовой обвязкой. Обычно существует по крайней мере один тест на государственную функцию. Я пишу дополнительные тесты для покрытия различных поведений.
Все особые случаи, о которых Вы думали при разработке кода, могут быть зарегистрированы в коде в модульных тестах. Модульные тесты также становятся источником примеров о том, как использовать код.
Это намного быстрее для меня, чтобы обнаружить, что мой новый код повреждается, что-то в моих модульных тестах затем, чтобы зарегистрироваться в коде и иметь некоторого разработчика фронтенда находит проблему.
Для тестирования доступа к данным я пробую к тестам записи, которые или не иметь никакого изменения или очищают после себя.
Модульные тесты aren’t собирающийся быть в состоянии решить все требования тестирования. Они будут в состоянии сохранить время разработки и тестовые части ядра приложения.
Вхождение в долю на философских профессионалах поблочного тестирования и TDD здесь является несколькими из, их включают наблюдения "лампочки", которые ударили меня на моих предварительных первых шагах на пути к просвещению TDD (ни одно исходное или обязательно новости)...
-
TDD НЕ означает писать дважды объем кода. Тестовый код является обычно довольно быстрым и безболезненным для записи и является ключевой ролью процесса проектирования и критически.
-
TDD помогает Вам понять, когда прекратить кодировать! Ваши тесты вселяют Вам веру, что Вы сделали достаточно на данный момент и можете прекратить настраивать и идти дальше к следующей вещи.
-
тесты и код сотрудничают для достижения лучшего кода. Ваш код мог быть плох / багги. Ваш ТЕСТ мог быть плох / багги. В TDD Вы полагаетесь на возможности ОБА являющийся плохим / багги, являющийся довольно низким. Часто это - тест, которому нужна фиксация, но это - все еще хороший результат.
-
TDD помогает с кодированием запора. Вы знаете, что чувство, что у Вас есть так много, чтобы сделать Вас едва, знает, где запустить? Это - день пятницы, если Вы просто откладываете в течение пары большего количества часов... TDD позволяет Вам излагать в деталях очень быстро, что Вы думаете, что должны сделать и получаете свое кодирование, перемещающееся быстро. Кроме того, как крысы лаборатории, я думаю, что все мы отвечаем на тот большой зеленый свет и работаем усерднее для наблюдения его снова!
-
В том же духе, эти типы разработчика видят то, что они продолжают работать. Они могут блуждать прочь для сока / сигарета / повреждение iPhone и возвратиться к монитору, который сразу дает им визуальный индикатор как, туда, где они добрались до. TDD дает нам что-то подобное. Легче видеть, где мы добрались до того, когда жизнь вмешивается...
-
я думаю, что это был Fowler, который сказал: "Несовершенные тесты, запускаемые часто, намного лучше, чем идеальные тесты, которые никогда не пишутся вообще". Я interprete это как предоставление мне разрешение к тестам записи, где я думаю, что они будут самыми полезными, даже если остальная часть моего покрытия кода будет горестно неполной.
-
TDD помогает во всех видах удивительных путей по линии. Хорошие модульные тесты могут помочь документу, что что-то, как предполагается, делает, они могут помочь Вам переместить код от одного проекта до другого и дать Вам неоправданное чувство превосходства над Вашими нетестирующими коллегами:)
Это представление является превосходным введением во все вкусное тестирование совершенства, влечет за собой.
Мне никогда не преподавали поблочное тестирование в университете, и это взяло меня некоторое время для "получения" его. Я читал об этом, пошел "ах, право, автоматизированное тестирование, которое могло быть прохладно, я предполагаю", и затем я забыл об этом.
Это взяло вполне немного дольше, прежде чем я действительно выяснил точку: Скажем, Вы работаете над большой системой, и Вы пишете маленький модуль. Это компилирует, Вы проверяете его в деле, это работает отлично, Вы идете дальше к следующей задаче. Девять месяцев по линии и две версии позже, которые кто-то еще вносит изменением в [приблизительно 110] по-видимому несвязанная часть программы, и это повреждает модуль. Хуже, они тестируют свои изменения и свои работы кода, но они не тестируют Ваш модуль; черт, они даже не могут знать, что Ваш модуль существует .
И теперь у Вас есть проблема: поврежденный код находится в соединительной линии, и никто даже не знает. Лучший случай является внутренним тестером, находит его перед поставкой, но устраняющий код, который поздно в игре является дорогим. И если никакой внутренний тестер не находит его... хорошо, который может стать очень дорогим действительно.
решением являются модульные тесты. Они поймают проблемы, когда Вы запишете код - который прекрасен - но Вы, возможно, сделали это вручную. Реальная выплата - то, что они поймают проблемы девять месяцев по линии, когда Вы будете теперь работать над совершенно другим проектом, но летний интерн думает, что это будет выглядеть более опрятным, если те параметры были в алфавитном порядке - и затем модульный тест, Вы записали, что путь назад перестал работать, и кто-то бросает вещи в интерн, пока он не возвращает порядок параметра. Это "почему" из модульных тестов.:-)
Я думаю, что вы не понимаете, что фреймворки модульного тестирования, такие как NUnit (и подобные), помогут вам в автоматизации малые и средние тесты. Обычно вы можете запускать тесты в графическом интерфейсе (например, в случае с NUnit ), просто щелкнув кнопку, а затем, надеюсь, увидев, что индикатор выполнения остается зеленым. Если он станет красным, фреймворк покажет вам, какой тест не прошел и что именно пошло не так. В обычном модульном тесте вы часто используете утверждения, например Assert.AreEqual (ожидаемое значение, фактическое значение, «некоторое описание») - поэтому, если два значения не равны, вы увидите сообщение об ошибке «некоторое описание: ожидаемое <ожидаемое значение>, но было <фактическое значение>».
В заключение, модульное тестирование сделает тестирование более быстрым и более удобным для разработчиков. Вы можете запустить все модульные тесты перед фиксацией нового кода, чтобы не нарушить процесс сборки других разработчиков в том же проекте.
Библиотеки, такие как NUnit , xUnit или JUnit , просто обязательны, если вы хотите разрабатывать свои проекты с использованием подхода TDD , популяризированного Кент Бек:
Вы можете прочитать Введение в разработку через тестирование (TDD) или книгу Кента Бека Разработка через тестирование: на примере .
Затем, если вы хотите убедиться, что ваши тесты охватывают «хорошую» часть кода, вы можете использовать такие программы, как NCover , JCover , PartCover ] или что-то еще. Они сообщат вам процент покрытия вашего кода. В зависимости от того, насколько вы разбираетесь в TDD, вы будете знать, достаточно ли вы его практиковали :)
Я хотел бы порекомендовать книгу xUnit Testing Patterns Джерарда Месароса. Это большой, но отличный ресурс по модульному тестированию. Вот ссылка на его веб-сайт, где он обсуждает основы модульного тестирования. http://xunitpatterns.com/XUnitBasics.html
Прежде всего, если говорить о Модульное тестирование или любые другие виды автоматизированного тестирования (интеграция, нагрузка, тестирование пользовательского интерфейса и т. Д.), Ключевое отличие от того, что вы предлагаете, заключается в том, что оно автоматизировано, воспроизводимо и не требует использования каких-либо человеческих ресурсов (= ни у кого нет для выполнения тестов они обычно запускаются одним нажатием кнопки).
Модульное тестирование - это практика, позволяющая убедиться, что функция или модуль, который вы собираетесь реализовать, будет вести себя так, как ожидалось (требования), а также чтобы убедитесь, как он ведет себя в таких сценариях, как граничные условия и недопустимый ввод.
xUnit , NUnit , mbUnit и т. Д. - это инструменты, которые помогут вам в написании тестов.
Модульное тестирование - это написание кода, который тестирует код вашего приложения.
Часть названия Unit связана с намерением тестировать небольшие блоки кода (например, один метод) за раз.
xUnit должен помочь с этим тестированием - это фреймворки, которые помогают в этом. Частично это автоматизированные программы запуска тестов, которые сообщают вам, какой тест не прошел, а какой прошел.
У них также есть средства для установки общего кода, который вам нужен для каждого теста, до его начала и удаления его, когда все тесты будут завершены.
У вас может быть тест, чтобы проверить, что было сгенерировано ожидаемое исключение, без необходимости самостоятельно писать весь блок try catch.
Основное отличие модульного тестирования от «простого открытия нового проекта и тестирования этого конкретного кода» заключается в том, что оно автоматизировано , таким образом повторяемый .
Если вы протестируете свой код вручную, это может убедить вас, что код работает идеально - в его текущем состоянии . Но как насчет недели спустя, когда вы внесли в него небольшие изменения? Готовы ли вы повторно протестировать его вручную, когда что-нибудь изменится в вашем коде? Скорее всего, нет: - (
Но если вы можете запускать тесты в любое время, одним щелчком мыши, точно так же, в течение нескольких секунд , тогда они покажут вам сразу, как только что-то сломается.И если вы также интегрируете модульные тесты в свой автоматизированный процесс сборки, они будут предупреждать вас об ошибках даже в тех случаях, когда, казалось бы, совершенно не связанное с этим изменение что-то сломало в отдаленной части кодовой базы - когда вам даже не пришло бы в голову, что существует необходимость повторно протестировать эту конкретную функциональность.
Это главное преимущество модульных тестов перед ручным. Но подождите, это еще не все:
- модульные тесты значительно сокращают цикл обратной связи разработчиков : с отдельным отделом тестирования может потребоваться несколько недель, чтобы узнать, что в вашем коде есть ошибка, и к этому времени вы уже забыли большую часть контекста, поэтому на поиск и исправление ошибки у вас могут уйти часы; OTOH с модульными тестами, цикл обратной связи измеряется в секундах, а процесс исправления ошибок обычно проходит по принципу «ох черт, я забыл проверить это условие здесь»: -)
- Эффективные модульные тесты документ (ваше понимание) поведения вашего кода
- модульное тестирование заставляет вас пересмотреть свой выбор дизайна, что приводит к более простому и понятному дизайну
Фреймворки модульного тестирования, в свою очередь, делают вам легко писать и запускать тесты.