В TDD я должен сначала написать Test или Interface?

Я изучаю TDD, используя c #, насколько я знаю, тест должен управлять разработкой , то есть сначала написать провальный тест, а затем написать минимальный код для прохождения теста, а затем выполнить рефакторинг.

Но также сказано, что « Программа для интерфейса, а не для реализации », поэтому сначала напишите интерфейс . Здесь начинается мое замешательство. Если я сначала пишу интерфейс, то это нарушает две вещи

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

2. Это не самый минимум, очевидно, я могу написать это простым классом.

Должен ли я начать с написания тестов для интерфейса также? без какой-либо реализации, что я собираюсь проверить?

Если этот вопрос звучит глупо, извините за это, но я совершенно сбит с толку. Может быть, я воспринимаю вещи слишком буквально.

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

public class CalculatorTest {
    @Test
    public void testAddTwoIntegers() {
        Calculator calc = new Calculator();
        int result = calc.add(2, 2)
        Assert.assertEquals(4, result);
    }
}

Ваш тест только что определил интерфейс. Это addметод, понимаете? addпринимает два аргумента и возвращает их сумму. Позже вы можете определить, что вам нужно несколько калькуляторов, и извлечь (в данном случае) интерфейс Java в это время. Тогда ваши тесты не должны меняться, так как вы тестировали открытый интерфейс этого класса.

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

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

Что мы делаем, когда пишем interface? Мы пишем код или мы проектируем?

Я не фанат идеи Test Driven Design, но мне нравится Test Driven Development . Лично я добился лучших результатов, когда спроектировал класс заранее, разработав интерфейс перед написанием теста. Я не считаю интерфейс как код. Интерфейс - это дизайн, который я буду реализовывать с использованием TDD. Скорее всего, это изменит эволюцию, когда я работаю, но это моя дорожная карта (вместе с моим тестовым списком).

Я остановлюсь прежде, чем начну разглагольствовать, но, надеюсь, это поможет вам подумать об этом.

В TDD я должен сначала написать Test или Interface?

Все зависит от того, насколько православным / религиозным вы хотите заниматься TDD .

Я учусь TDD

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

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

2. Помимо TDD или нет: вопрос, использовать интерфейс или нет, в первую очередь не интересен. Конечно, если вы уверены, что у вас разное поведение, которое вы хотите распределить по нескольким объектам, имеет смысл подумать об использовании интерфейса: например, если у вас есть какой-то вывод в разные пункты назначения, имеет смысл реализовать его через Интерфейс Writer и имеют разные классы для вывода ( FileWriter , Printer и т. д.). Хотя это обычное высказывание - писать в интерфейс , но это не значит: использовать интерфейс для всего . Иногда это один уровень косвенности для многих. Btw. То же самое касается услуг. Но это другая тема.

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

TDD или BDD означали бы сначала выполнение интерфейсов вашего домена, а затем написание тестов на них по моей интерпретации. Реализация интерфейса имеет ожидаемое поведение.

он все еще тестируется перед кодом, потому что интерфейс не содержит тестируемой логики, это структура, против которой вы пишете тест.

Я бы сделал это следующим образом

1. Напишите Полу Формальное Поведение (Дано: Когда: Тогда :)

2. Напишите интерфейс (для размещения метода инкапсуляции поведения)

3. Напишите тест, который он идентифицирует (введите данное, вызовите когда, протестируйте затем)

4. Записать / изменить бетон (класс, реализующий интерфейс) для прохождения теста

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

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

Можно писать интерфейс / код / ​​тест одновременно, если их включение в проект является атомарным.

Если ваш начальник не верит в TDD, в этом случае вам, вероятно, придется написать пустой интерфейс -> test -> минимальный код (бессмысленный шаг) -> больше тестов -> больше бессмысленного кода -> больше тестов -> наконец написать реальный код - > сделано.