чтобы сделать его тестируемым. Напишите тесты и получите 95% охват. Это научило меня всему, что мне нужно знать о написании тестируемого кода. Я не против TDD, но изучение специфики того, что делает код тестируемым или непроверяемым, помогает вам думать о тестируемости во время разработки.

Проверьте этот разговорАвтоматизированные тестовые шаблоны и запахи. One of the main take aways for me, was to make sure that the UnitTest code is in high quality. If the code is well documented and well written, everyone will be motivated to keep this up.

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

1.Using a framework/pattern like MVC to separate your UI from you
business logic will help a lot. 
2. Use dependency injection so you can create mock test objects.
3. Use interfaces.

что вы изучаете первым делом в ООП, но многие, кажется, забывают:Code Against Interfaces, Not Implementations.

если вы не проверяете его с помощью тестов.

Я не большой поклонник написания тестов первым. Но я очень сильно верю в то, что код должен быть проверенwith тесты. Даже час или около того,togther, Я думаю, что порядок, в котором они написаны, менее важен, если они входят вместе.

Не пишите непроверяемый код

тестирования".

Вместо этого можно использовать насмешливый инструментарий для устранения проблем с тестируемостью. Одним из таких инструментов являетсяJMockit.

ряйте себя (принцип СУХОГО). Если у вас есть тестовые данные, которые полезны для более чем одного теста, поместите их туда, где оба теста могут их использовать. Не копируйте код в оба теста. Я знаю, это кажется очевидным, но я вижу, что это происходит постоянно.

)

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

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

Они тратят время на обучение, обслуживание, снижение производительности и т. Д. Иногда это того стоит, иногда это не так, но вам никогда не следует ставить шоры и делать ставку на то, чтобы сделать ваш код более «тестируемым».

To prepare your code to be testable:

To get the most out of your unit tests, consider the following:

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

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

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

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

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

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

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

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

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