Как Вы вводите поблочное тестирование в большое, наследие (C/C++) кодовая база?

Попробуйте использовать SQLCMD Mode. В SSMS щелкните Query -> SQLCMD Mode:

:setvar dbname "YourDB" 

SELECT * FROM $(dbName).dbo.YourTable

Подробнее о SQLCMD .

73
задан 2 revs, 2 users 98% 15 March 2016 в 21:37
поделиться

11 ответов

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

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

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

  • Написать модульные тесты для новых модулей.

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

  • Итерация.

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

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

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

  • Написать модульные тесты для новых модулей.

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

  • Итерация.

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

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

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

  • Написать модульные тесты для новых модулей.

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

  • Итерация.

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

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

  • Написать модульные тесты для новых модулей.

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

  • Итерация.

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

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

  • Написать модульные тесты для новых модулей.

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

  • Итерация.

    нам придется поддерживать некоторую обратную совместимость (пока) с вашим общим интеграционным тестом.

  • Написать модульные тесты для новых модулей.

  • Как только все это пройдет, выведите из эксплуатации старый API и исправьте то, что будет нарушено изменение. При необходимости переделать оригинальный интеграционный тест; он тестирует старый API, вы хотите протестировать новый API.

  • Итерация.

    нам придется поддерживать некоторую обратную совместимость (пока) с вашим общим интеграционным тестом.

  • Написать модульные тесты для новых модулей.

  • Как только все это пройдет, выведите из эксплуатации старый API и исправьте то, что будет нарушено изменение. При необходимости переделать оригинальный интеграционный тест; он тестирует старый API, вы хотите протестировать новый API.

  • Итерация.

    49
    ответ дан 4 revs, 2 users 94% 24 November 2019 в 12:22
    поделиться

    G'day,

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

    Затем начните смотреть, как код был выложен. Это логично? Возможно, начните разбивать большие файлы на более мелкие.

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

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

    Выберите хорошую платформу, мне нравятся CUnit и CPPUnit, и переходите оттуда.

    Это '

    3
    ответ дан Rob Wells 24 November 2019 в 12:22
    поделиться

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

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

    3
    ответ дан Jeff Kotula 24 November 2019 в 12:22
    поделиться

    Это намного проще сначала сделать его более модульным. Вы не можете провести модульное тестирование чего-либо с большим количеством зависимостей. Когда проводить рефакторинг - непростой расчет. Вам действительно нужно взвесить затраты, риски и выгоды. Будет ли этот код широко использоваться повторно? Или этот код действительно не изменится? Если вы планируете и дальше использовать его, то, вероятно, захотите провести рефакторинг.

    Похоже, вы хотите провести рефакторинг. Вам нужно начать с разбивки простейших утилит и развивать их. У вас есть модуль C, который делает множество вещей. Может быть, например, там есть какой-то код, который всегда определенным образом форматирует строки. Может быть, это можно сделать как отдельный служебный модуль. У вас есть новый модуль форматирования строк, вы сделали код более читабельным. Это уже улучшение. Вы утверждаете, что попали в ловушку 22. На самом деле нет. Просто перемещая вещи, вы сделали код более читабельным и удобным для сопровождения.

    Теперь вы можете создать unittest для этого разбитого модуля. Вы можете сделать это двумя способами. Вы можете создать отдельное приложение, которое просто включает ваш код и запускает множество кейсов в основной подпрограмме на вашем ПК, или, возможно, определить статическую функцию под названием «UnitTest», которая выполнит все тестовые примеры и вернет «1», если они пройдут успешно. Это может быть запущено на цели.

    Возможно, вы не сможете использовать этот подход на 100%, но это только начало, и он может заставить вас увидеть другие вещи, которые можно легко разбить на тестируемые утилиты.

    2
    ответ дан Doug T. 24 November 2019 в 12:22
    поделиться

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

    Однако иногда бывают случаи, когда почти невозможно создать модульные тесты (даже тесты характеристик). В этом случае я решаю проблему с помощью приемочных тестов (в данном случае Fitnesse ).

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

    8
    ответ дан Edison Gustavo Muenz 24 November 2019 в 12:22
    поделиться

    Упростите использование тестов.

    Я бы начал с того, что поставил «запуски автоматически» на место. Если вы хотите, чтобы разработчики (включая вас) написали тесты, упростите их запуск и посмотрите результаты.

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

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

    Тестирование того, что можно протестировать

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

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

    (Однако, вам нужно выполнить это. Не попадайтесь в ловушку «исправления всего» в процессе сборки.)

    Научите, как улучшить ваш код base

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

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

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

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


    1
    ответ дан peterchen 24 November 2019 в 12:22
    поделиться

    Я думаю, в основном у вас есть две отдельные проблемы:

    1. Большая база кода для рефакторинга
    2. Работа с команда

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

    Выполнение такой задачи с командой утомительно. Я сильно сомневаюсь, что «принуждение» разработчиков когда-либо будет работать. Мысли Iains очень хороши, но я хотел бы найти одного или двух программистов, которые могут и хотят «очистить» источники: Refactor, Modualrize, ввести модульные тесты и т. Д. Пусть эти люди выполняют свою работу, а другие представляют новые ошибки, функции aehm.

    2
    ответ дан 2 revs, 2 users 95% 24 November 2019 в 12:22
    поделиться

    Как сказал Джордж, Эффективная работа с Устаревшим Кодексом - это библия для такого рода вещей.

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

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

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

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

    Большинство разработчиков пишут какую-то форму модульного теста, иногда небольшой фрагмент одноразового кода, который они не регистрируют или не интегрируют в сборку. Упростите их интеграцию в сборку, и разработчики начнут покупать.

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

    Единственное место, на котором я настаиваю на модульных тестах, - это программный код. Там, где #ifdefs заменяются функциями / классами более высокого уровня для конкретной платформы, они должны быть протестированы на всех платформах с одинаковыми тестами. Это экономит массу времени при добавлении новых платформ.

    Мы используем boost :: test для структурирования нашего теста, простые функции саморегистрации облегчают написание тестов.

    Они заключены в CTest (часть CMake), которая запускает группу из исполняемых модулей модульных тестов и генерирует простой отчет.

    Наша ночная сборка автоматизирована с помощью ant и luntbuild (сборки ant c ++, .net и java)

    Вскоре я надеюсь добавить автоматическое развертывание и функциональные тесты в сборка.

    Ошибка на стороне практического.

    Единственное место, где я настаиваю на модульных тестах, - это программный код. Там, где #ifdefs заменяются функциями / классами более высокого уровня для конкретной платформы, они должны быть протестированы на всех платформах с одинаковыми тестами. Это экономит массу времени при добавлении новых платформ.

    Мы используем boost :: test для структурирования нашего теста, простые функции саморегистрации облегчают написание тестов.

    Они заключены в CTest (часть CMake), которая запускает группу из исполняемых модулей модульных тестов и генерирует простой отчет.

    Наша ночная сборка автоматизирована с помощью ant и luntbuild (сборки ant c ++, .net и java)

    Вскоре я надеюсь добавить автоматическое развертывание и функциональные тесты в сборка.

    Ошибка на стороне практического.

    Единственное место, где я настаиваю на модульных тестах, - это программный код. Там, где #ifdefs заменяются функциями / классами более высокого уровня для конкретной платформы, они должны быть протестированы на всех платформах с одинаковыми тестами. Это экономит массу времени при добавлении новых платформ.

    Мы используем boost :: test для структурирования нашего теста, простые функции саморегистрации облегчают написание тестов.

    Они заключены в CTest (часть CMake), которая запускает группу из исполняемых модулей модульных тестов и генерирует простой отчет.

    Наша ночная сборка автоматизирована с помощью ant и luntbuild (сборки ant c ++, .net и java)

    Вскоре я надеюсь добавить автоматическое развертывание и функциональные тесты в сборка.

    Там, где #ifdefs заменяются функциями / классами более высокого уровня для конкретной платформы, они должны быть протестированы на всех платформах с одинаковыми тестами. Это экономит массу времени при добавлении новых платформ.

    Мы используем boost :: test для структурирования нашего теста, простые функции саморегистрации облегчают написание тестов.

    Они заключены в CTest (часть CMake), которая запускает группу из исполняемых модулей модульных тестов и генерирует простой отчет.

    Наша ночная сборка автоматизирована с помощью ant и luntbuild (сборки ant c ++, .net и java)

    Вскоре я надеюсь добавить автоматическое развертывание и функциональные тесты в сборка.

    Там, где #ifdefs заменяются функциями / классами более высокого уровня для конкретной платформы, они должны быть протестированы на всех платформах с одинаковыми тестами. Это экономит массу времени при добавлении новых платформ.

    Мы используем boost :: test для структурирования нашего теста, простые функции саморегистрации облегчают написание тестов.

    Они заключены в CTest (часть CMake), которая запускает группу из исполняемых модулей модульных тестов и генерирует простой отчет.

    Наша ночная сборка автоматизирована с помощью ant и luntbuild (сборки ant c ++, .net и java)

    Вскоре я надеюсь добавить автоматическое развертывание и функциональные тесты в сборка.

    7
    ответ дан iain 24 November 2019 в 12:22
    поделиться

    Michael Перо написал Библию об этом, Эффективно работая с Устаревшим Кодексом

    25
    ответ дан George V. Reilly 24 November 2019 в 12:22
    поделиться

    Я работал как в проекте Green Field с полностью протестированными модульными базами кода, так и в больших C ++-приложениях, которые выросли за многие годы, и со многими разными разработчиками.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Или вы идете быстро, но у вас нестабильная кодовая база, пока все вы не достигнете высокого уровня охвата всего кода. (Таким образом, в итоге у вас есть 2 ветки, одна в производстве, одна для тестируемой модулем версии.)

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

    Или вы идете быстро, но у вас нестабильная кодовая база, пока все вы не достигнете высокого уровня охвата всего кода. (Таким образом, в итоге у вас есть 2 ветки, одна в производстве, одна для тестируемой модулем версии.)

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

    4
    ответ дан Jeroen Dirks 24 November 2019 в 12:22
    поделиться

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

    База кода состоит из набора COM-компонентов (ATL / MFC), кросс-платформенного картриджа данных C ++ Oracle и некоторых Java-компонентов, все из которых используют кроссплатформенную библиотеку ядра C ++. Некоторому коду уже почти десять лет.

    Первым шагом было добавление некоторых юнит-тестов. К сожалению, поведение в значительной степени зависит от данных, поэтому была предпринята некоторая первоначальная попытка создания структуры модульного тестирования (первоначально CppUnit, теперь расширенной для других модулей с JUnit и NUnit), которая использует тестовые данные из базы данных. Большинство первоначальных тестов были функциональными тестами, которые выполняли упражнения на самых внешних слоях, а не единичными тестами. Вам, вероятно, придется потратить некоторые усилия (на которые вам может потребоваться бюджет) для реализации тестового жгута.

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

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

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

    5
    ответ дан 24 November 2019 в 12:22
    поделиться
    Другие вопросы по тегам:

    Похожие вопросы: