Коли модульне тестування є недоречним або непотрібним?

It seems to be generally assumed (on Stack Overflow at least) that there should always be unit tests, and they should be kept up to date. But I suspect the programmers making these assertions work on different kinds of projects from me - they work on high quality, long-lasting, shipped software where bugs are A Really Bad Thing.

Якщо це кінець спектра, де модуль тестування є найціннішим, то який другий кінець? Де є найменш цінністю тестові одиниці? У яких ситуаціях ви б не турбувалися? Де б зусилля з підтримки тестів не коштували вартості?

95
Це питання задало щось подібне, і було зроблено висновок, що це не варто робити для них, так як пізніше вони заплатять виправити помилки: programmers.stackexchange.com/q/64592/1249
додано Автор Adam Lassek, джерело
А ось радості відповідей, які починаються з "Ви повинні " ...
додано Автор Adam Lassek, джерело
@gnat Це залежить від напрямку від тестування. Блокові тести особливо крихкі, коли вони заглиблюються в дрібниці і написані після впровадження, тому модульне тестування стає безплідним наздоганяючим заняттям і тому стає дуже дорогим у обслуговуванні. Цільове тестування старовинного коду з розумним рефакторингом може допомогти, але лише до певної міри. OTOH, проект, що керується поведінкою на зеленому полі, має тенденцію призводити до тестів, які зберігають вимоги замість тестів, оскільки змінені вимоги вимагають вилучення старих непридатних тестів, які більше не відповідають вимогам.
додано Автор S.Robins, джерело
"[в коді великого м'яча грязюки] ... одиничні тести, вони роблять речі протилежні тому, як я їх використовую в хорошому коді, як порушення розумних змін і нездатність зловити справжні помилки, які я роблю. - що ще можна очікувати від тестових блоків, які мають поганий дизайн? Замість того, щоб допомогти вам поліпшити дизайн, модульні тести часто працюють, щоб зберегти поганий код ... "- про це я писав у інший відповідь
додано Автор gnat, джерело
@ S.Robins звучить так, що ви надаєте перевагу модульним тестам у проекті, керованому поведінкою зеленого поля . Якщо так, то я з вами тут 200%; у випадках, подібних до цього модуля, тести наближаються до срібної кулі. І, так це приємно прийняти тести до мінливих вимог - коли все зрозуміло, тестування білої коробки прохолодне
додано Автор gnat, джерело
Як би ви знали, що щось, що ви змінили, порушило щось інше, якщо ви не проводили тестування?
додано Автор kingchris, джерело
Звичайний спосіб: збій часу виконання. Це страшна річ, якщо ваш продукт - це гра Xbox, але це не так уже й погано, якщо ваш продукт є власним сценарієм, який постійно генерує звіти.
додано Автор Steve Bennett, джерело

16 Відповіді

Особисто я не буду писати модульні тести для ситуацій, коли:

  1. Код не має гілок тривіальний. Геттер, який повертає 0, тестувати не потрібно, і зміни будуть охоплені тестами для своїх споживачів.

  2. Код просто проходить у стабільний API. Я припускаю, що стандартна бібліотека працює належним чином.

  3. Код повинен взаємодіяти з іншими розгорнутими системами; потім називається тест інтеграції.

  4. Якщо випробування успіху/невдачі - це те, що важко оцінити так, щоб не можна було достовірно виміряти, наприклад, стеганографія непримітна для людей.

  5. Якщо сам тест на порядок складніше написати, ніж код.

  6. Якщо код викидається або код заповнювача. Якщо є якісь сумніви, перевірте.

90
додано
Якщо метод має два або менше викликів до інших методів, які стають визначальними факторами результату методу, тест повинен бути розміщений на цих методах, а не на батьківському. Однак, за винятком двох таких викликів, здатність не випускати з уваги, як вона повинна працювати зі 100-відсотковою точністю, значно зменшується.
додано Автор Justin Poliey, джерело
@CarlManaster Я думаю, що це все. Якщо важко написати тестовий випадок, то важко зрозуміти і, швидше за все, створить багато вад у вашій програмі. Хитрість полягає в тому, як уникнути таких методів.
додано Автор Justin Poliey, джерело
@sparkleshy, я думаю, якщо вони були простими, ви могли б спокійно ігнорувати їх. Проте, чи є це просто суб'єктивно, на жаль. Якщо ви вважаєте, що результат цих операцій простий, хороший для вас. Я б, напевно, кинув його своїм власним методом і блок тестування його на добру міру.
додано Автор Justin Poliey, джерело
@sparkleshy Можливо, так, хоча я не думаю, що мені доведеться додати тестування до цього, якщо кінцевий продукт не повинен бути більше, ніж сума продуктів між a і b, і c і d.
додано Автор Justin Poliey, джерело
@sparkleshy Тому що я вважаю, vec_add і vec_mul - ваші власні методи, в межах яких виконуються власні внутрішні операції. Це робить речі дещо складнішими. Це все, що я мав на увазі.
додано Автор Justin Poliey, джерело
@sparkleshy З тієї ж причини, що будь-який написаний код може бути складним. Інвідідальні інструкції не є складними, але їх комбінована поведінка є.
додано Автор Justin Poliey, джерело
@Rangoric, припускаючи, що методи vec_mul і vec_add роблять те, що вони повинні робити, яких він не дає. Але хіба це не початок тестування блоку? Я припускаю, що a, b, c і d є векторами розміру n, що означає, що буде задіяний певний цикл, тому ми досягаємо рівня ускладнення, гідного одиничного тесту, на мою скромну думку.
додано Автор Justin Poliey, джерело
@sparkleshy тому, що ви дізналися про b + c d, починаючи з 1-го класу, що полегшує перегляд і знання того, що він робить. Інша партія функцій, яку ви тільки що написали, і ніхто, крім вас, знає, що він робить.
додано Автор user4891, джерело
@sparkleshy Ви маєте на увазі vec_add? Тепер ми маємо 2 значення. Але чи може це бути vec_mul і vec_add, як у дуже складних картах Малліган? І це для того, щоб визначити, чи мають вони обидва (a і b - умови в руці гравця 1, і c, d - для гравця 2. Тепер у нас є 3 значення. Тепер у нас є 4 значення, так що ні, це не говорить "Додати", як у математиці говорить "vec_add", і тільки ви, хто писав, знає, що це означає.
додано Автор user4891, джерело
@sparkleshy Але в цьому суть, вам доведеться кількісно визначити "дивну реалізацію". Тому що зазвичай, коли люди бачать + вони мають контекст, що повертається до 1 + 1 = 2. Отже, поки він не надто простий (a * b + c * d), він набагато простіший, ніж vec_add (vec_mul (a, b), vec_mul (c, d)) тому що ми не маємо такого контексту. Я б ще одиницю перевірити його, тому що, ймовірно, є деякі бізнес-правила для нього, але я міг бачити просто ігноруючи його на основі контексту (розмір 2 прямокутників? Немає необхідності в тесті блок, тому що знову він повертається до початкової школи), в той час як користування vec_add/vec_mul я б майже кожний раз проводив тест.
додано Автор user4891, джерело
@Neil Я кажу це. vec_add/vec_mul і їх використання набагато більш гідне одиничного тесту, ніж +/*.
додано Автор user4891, джерело
@Telastyn - чи корисний цей коментар? Будь-яка інформація може бути включена у відповідь. Повідомте нас, позначивши, щоб ми могли очистити.
додано Автор BruceW, джерело
Загалом я згоден, +1. Але стосовно №1: код без гілок не повинен бути тривіальним, і навіть якщо він в даний час викликаний щасливими обставинами, передбачувана поведінка все одно може вимагати перевірки.
додано Автор Paul Muir, джерело
Але якщо тест на порядок складніше написати - ви робите щось неправильне в оформленні вашого коду. І залежний код буде так само важко писати, як і тести - і глючить.
додано Автор Algernon_Asimov, джерело
"Кодекс повинен взаємодіяти з іншими розгорнутими системами, після чого вимагається тест інтеграції." - це те, що макет об'єктів для
додано Автор Michael, джерело
@Neil перший пост: ... або більше двох, якщо вони дійсно прості, наприклад, сказати vec_add (vec_mul (a, b), vec_mul (c, d)) (приклад - приклад)
додано Автор amara, джерело
@Neil: Ви б зробили те ж саме для a * b + c * d ?
додано Автор amara, джерело
@Neil: О, я запитував, чи хочете ви для цього тестування. Так що ви не хотіли. Але чому ні? a * b + c * d точно так само, як vec_add (vec_mul (a, b), vec_mul (c, d)) , просто інший синтаксис. Швидше за все, чому ви б тестували останнє?
додано Автор amara, джерело
@Neil: Потім блок тестує їх. Як це робить речі в коді я говорю про більш складним?
додано Автор amara, джерело
@Neil: ... циркулярний. Чому a * b + c * d досить простий для жодних тестів, але не vec_add (vec_mul (a, b), vec_mul (c, d)) ?
додано Автор amara, джерело
@Rangoric: не має значення; до теперішнього часу наше інтуїтивне розуміння додавання та множення охоплює інші речі, ніж досконале безмірне ціле число.
додано Автор amara, джерело
@Rangoric: Або, залежно від того, що ви мали на увазі: Ви не можете прочитати "додати"? У ньому йдеться додати. Це доповнення. Тепер, ми, ймовірно, повинні мати одиничні тести та інше для методу vec_add, але вся точка інкапсуляції полягає в тому, що вам не потрібно турбуватися про речі; вони просто такі, як вони виглядають.
додано Автор amara, джерело
@Rangoric: Erk. Ідіот. Чому мені не доводиться коментувати ... У мене немає особистого доступу до вас, тому для вираження дивної складної ідеї потрібно більше, ніж коментарі. (писав: def func [abcd]: a * b + c * d є достатньо простим; код> реалізації, тоді це не помилка func .
додано Автор amara, джерело
@Rangoric: Argh.
додано Автор amara, джерело
Якщо сам тест на порядок складніше написати, ніж код. Насправді я відчуваю це відчуття більшу частину часу: P
додано Автор Songo, джерело
@delnan: Дійсно. Я, можливо, маю це сказати інакше.
додано Автор Telastyn, джерело
@Songo: Я використовував, щоб отримати, що дуже багато, а також; як правило, це запах коду, який коду, який ви намагаєтеся протестувати, занадто зв'язаний або не є достатньо гнучким/перевіряним.
додано Автор Telastyn, джерело
@CarlManaster: Я бачив сценарії, де обраний дизайн був важко перевірити на користь ремонтопридатності або масштабованості або продуктивності. Як я вже сказав вище, це запах коду, але врешті-решт це компроміс дизайну, як і будь-який інший.
додано Автор Telastyn, джерело
@noahz: знущаються добре, але іноді складні (див. №5). Але знущання також не охоплює інтеграційні проблеми. Іноді обидва розумні (imo).
додано Автор Telastyn, джерело
@ChrisF: вибачте, я не розумію. Використання знущань для інтеграції може бути включено для роз'яснення, але я не був проданий достатньо, щоб зробити редагування. Я думав, що прапори є для проблемних відповідей, і хоча деякі з них можуть бути трохи поза темою, ніщо тут не гарантує цього.
додано Автор Telastyn, джерело
+1 для інтеграційних тестів за одиничними тестами. Якщо ви взаємодієте/витягуєте дані з зовнішньої системи, це насправді контрпродуктивно і може ввести помилки, щоб мати автономні тести, які використовують "знущання".
додано Автор halligan26, джерело

Якщо ви не збираєтеся писати код без тестування, ви завжди будете нести витрати на тестування.

Різниця між наявністю модульних тестів та їх відсутністю - це різниця між вартістю написання тесту та вартістю його проведення в порівнянні з витратами на тестування вручну.

Якщо вартість написання модульного тесту становить 2 хвилини, а вартість запуску модульного тесту практично дорівнює 0, але вартість ручного тестування коду становить 1 хвилину, то ви зламаєтеся навіть тоді, коли ви проходите тест двічі.


Протягом багатьох років я був під впливом нерозуміння, що у мене не вистачає часу для написання одиничних тестів для мого коду. Коли я писав тести, вони були роздуті, важкі речі, які тільки заохочували мене думати, що я повинен тільки писати одиничні тести, коли я знав вони були потрібні.

Recently I've been encouraged to use Test Driven Development and I found it to be a complete revelation. I'm now firmly convinced that I don't have the time not to write unit-tests.

In my experience, by developing with testing in mind you end up with cleaner interfaces, more focussed classes & modules and generally more SOLID, testable code.

Кожен раз, коли я працюю з успадкованим кодом, який не має тестових модулів, і я повинен вручну тестувати щось, я продовжую думати "це було б набагато швидше, якщо цей код вже мав одиничні тести". Кожен раз, коли я повинен спробувати і додати функціональність тестового модуля до коду з високою зв'язком, я продовжую думати "це було б набагато простіше, якби було написано де-зв'язаним способом".

Порівнюючи та контрастуючи дві експериментальні станції, які я підтримую. Один з них існує деякий час і має великий код, а інший - відносно новий.

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

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


TL;DR version:

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

Пам'ятайте, однак, що якщо ви використовуєте TDD, вартість написання тестів, ймовірно, знизиться, як ви краще в ньому, і якщо код абсолютно тривіальний, ви, ймовірно, в кінцевому підсумку запуску ваших тестів частіше, ніж ви очікували.

64
додано
Трохи поза темою, але будь-які джерела для підказок щодо написання тестів, які "в кінцевому підсумку роздуті, незручно і важко підтримувати"?
додано Автор mwalling, джерело
Ви пишете тести для тестування тестів? Ти повинен.
додано Автор gudenau, джерело
+1 для розробки онлайн (з системою wholw) проти офлайн (тільки один модуль плюс деякі макети плюс unittest-gui). Ваш аспект вартості також повинен враховувати константи збереження одиниць учасника: якщо код змінює, одиниці, що мають доступ, повинні бути оновлені
додано Автор naught101, джерело
@ SteveBennett - Я відповідаю, що перший розділ, ви не писати тести, якщо вартість ручного тестування дуже низька і/або вартість написання тестів дуже висока. TDD допомагає перенести економіку, завдяки чому письмові тести є більш дешевими та виконуються звичайні тести. Сподіваюся, що резюме, яке я додав наприкінці, допомагає зробити це зрозумілим.
додано Автор Mark Booth, джерело
@ k3b - Дійсно, але якщо ви перебуваєте в новому циклі зміни вимог, тоді у вас з'являться нові витрати на ручне тестування, а також оновлення модульного тесту та оновлення коду. Вам не потрібно змінювати unittests, якщо не змінюються вимоги, і якщо оновлення коду break , ви повинні зрозуміти, що порушено, тест або код, на основі цих вимог. Однією з переваг наявності тестових модулів є те, що бачите , коли зміни коду внаслідок змін у вимогах мають небажані побічні ефекти. Інакше ці побічні ефекти не можуть бути підібрані, поки не буде надто пізно.
додано Автор Mark Booth, джерело
@trinithis - Одним з принципів TDD є записування тесту на помилку, а потім написання коду, щоб він пройшов - так званий Червоний/Зелений цикл. Роблячи це таким чином, ви перевіряєте тести, як ви їх пишете.
додано Автор Mark Booth, джерело
@Thymine - Ви можете почати розробку програмного забезпечення про це, коментарі тут набувають роздуті, але в основному TDD допомагає зробити тести дешевими та легкими направляючи вас до інтерфейсів, які легко перевірити. Перш ніж робити TDD я написав інтерфейси, які здавалися зручними для мене, але які часто були важкими для написання тестів, тому мої тести мали встановити занадто багато стану, а зв'язок виявилася занадто високою для тестування окремих компонентів. разом.
додано Автор Mark Booth, джерело
@Tyymine - До речі, я припускав, що ви мали на увазі, що ви хочете уникнути написання роздутих тестів.
додано Автор Mark Booth, джерело
Добре, але ваша відповідь: "TDD - це чудово!" і моє запитання було "коли ти не пишеш одиничні тести?" Ви дійсно ніколи не робите кодування, коли модульне тестування неприйнятне? (Тобто, ігноруючи ситуації, де ви хочете, але не можете.)
додано Автор Steve Bennett, джерело
Чувак, ти говориш мій розум і мій досвід. Нещодавно я просто кусав кулю і писав макет об'єкта для деяких застарілих API для мого тестового блоку, тому що потрібно 10 хвилин, щоб завантажити мій код на сервер, розгорнути і протестувати.
додано Автор mellotrondon, джерело
Саме це! У мене є колеги, які час від часу говорять: "Я зробив з квитком, але тепер я повинен написати кілька одиничних тестів". Ці тестові одиниці часто закінчуються роздутою, незручною і важкою для підтримки.
додано Автор Tommy Smith, джерело

Особисто я взагалі не пишу модульні тести для:

  • Зміни до існуючого (не застарілого) коду. Хоча теоретично ніколи не пізно починати модульне тестування, на практиці вигоди від додавання одиничних тестів до коду ніколи не TDDed невеликі. Єдина перевага - запобігання регресії; ви можете побачити, який вплив робить зміна на області, які ви могли або не очікували, що це вплине. Проте, тест-модуль лише доводить, що код працює так, як це робилося, коли ви написали тест; оскільки тест не був написаний на основі вихідних вимог, тест не підтверджує, що поточна реалізація є "правильною". Здійснюючи тестові зміни в такій кодовій базі, це ще більше кошмар в моєму досвіді, а потім просто вносити зміни і вручну здійснювати уражені ділянки програми; спочатку потрібно написати належний тест модуля для розглянутого коду (який може вимагати рефакторингу коду, щоб дозволити знущання та іншу архітектуру TDD), довести, що він передає І що рефактор нічого не зламав (а коли це перший тестовий модуль, написаний коли-небудь для мільйонної кодової бази, що може бути важким), а потім змінити тест, щоб очікувати щось інше, і змінити код, щоб змінити прохід тесту.

  • Макет інтерфейсу користувача та поведінка верхнього рівня . У деяких випадках це просто неможливо; багато IDE з "дизайнерами" декларують елементи інтерфейсу як приватні, і вони не повинні бути публічними концептуально. Створення їх внутрішнім вимагатиме встановлення модульних тестів у ті ж самі збірки, як виробничий код (поганий), і зробити їх захищеними вимагати "тестового проксі", який відкриває те, що нам потрібно знати про елементи керування (також взагалі не так, як це зроблено). Навіть якщо було б прийнятним зробити всі органи управління публічними і таким чином мати доступ до їх типу, позиції, властивостей форматування тощо, тести, які перевіряють призначення інтерфейсу, як ви очікуєте, надзвичайно крихкі. Зазвичай ви можете ще обробляти обробку подій у блоці codebehinds/viewmodels, після чого тривіально довести, що натискання кнопки спрацьовує обробник.

  • Стійкість до бази даних . Це, за визначенням, інтеграційний тест. Ви завжди знущаєтеся над сховищем при роботі з кодом, який передає дані до сховища, і ви знущаєтеся з гачками ORM при розробці в самому сховищі. Незважаючи на наявність "тестових одиниць бази даних", і ви можете "знущатися" з базою даних, використовуючи щось подібне до SQLite, я вважаю, що ці тести ніколи не підходять на рівні одиниці.

  • Код третьої сторони . Ви перевіряєте свій код, як хочете, і вірте, що розробники сторонніх інструментів, які ви використовуєте (включаючи компоненти самої платформи .NET Framework, як WPF, WCF, EF і т.д.), зробили свою роботу правильно, поки не виявилися помилковими. Модульний тест, який підтверджує, що ви зробите правильний виклик WCF, не вимагає переходу проксі-сервісу, і не потрібно перевіряти, чи конкретний виклик служби WCF працює правильно у модульному тесті (чи працює він або не залежить від специфічних для середовища змінних, які можуть бути досконалими в локальному середовищі тестування, а не в побутовому боті, або в середовищах QA, Staging або UAT, де інтеграція вищого рівня, AAT і ручне тестування все ще мають значення) .

Майже в кожному іншому випадку методологія тестування має значну цінність у виконанні вимог та YAGNI, запобігаючи регресії, виявленню конфліктів вимог тощо. значення і тому ви можете довіряти, що в інших тестах «має значення для мене як розробника.

18
додано
@CodeWorks: я, як правило, погоджуюся з ОП. Так, додавання одиничних тестів є гарною ідеєю, але є початкова вартість їх додавання після факту (рефакторинг, налаштування рамки тощо). Якщо ви тільки робите невеликі зміни, робота не може бути виправданою.
додано Автор Julien Hoarau, джерело
@CodeWorks: Ну, "первісна вартість", про яку я згадував, часто не залежить від того, наскільки велика ваша зміна - так що саме для невеликих змін це не варто. Тим не менш, іноді можна швидко впровадити модульні тести в деяких областях (наприклад, для нового коду).
додано Автор Julien Hoarau, джерело
Ще один випадок: рутина, яка повертає щось випадкове, особливо щось складне і випадкове. Це дуже рідко в діловому світі, в ігровому світі чимало програм буде мати такі процедури в них.
додано Автор Sander Rijken, джерело
"Для того, щоб зробити їх внутрішніми, знадобиться помістити модульні тести в ті ж самі збірки, що й виробничий код".
додано Автор user8669, джерело
Якщо я працюю в успадкованій кодовій базі, вона вже має 0% покриття коду. Чи я впевнений, що це працює? Ну, кілька основних внутрішніх додатків використовувалися через три ітерації компанії через M&A, так що я повинен сказати «так». Хоча додавання модульних тестів до цих кодових баз є благородною метою для регресії, тести лише доводять, що код працює так само, як завжди, не обов'язково, щоб результати були правильними. Я стою за своєю первинною заявою, але редагував, щоб уточнити конкретну ситуацію.
додано Автор KeithS, джерело
Це правда, але тепер ви змінюєте те, як клас визначається, ні за яких інших причин, ніж щоб бути в змозі протестувати його. Більшість інших змін, які ви робите для цієї мети, мають значення в іншому місці, наприклад, ін'єкційні залежності. Я не кажу, що це неправильний спосіб зробити це, або що методи, які я згадував, є кращими, але ви повинні зважити плюси і мінуси кожного підходу, особливо враховуючи вартість того, що ви намагаєтеся включити (чи не так насправді потрібно тест-блок, який обробник події викликається, коли кнопка натиснута? Дійсно ?).
додано Автор KeithS, джерело
-1. Якщо ви не пишете тести для існуючого коду, то як у вас є упевненість, що ваш код працює ?? Ви маєте 0% покриття коду, або взагалі не довіряєте, що ваш існуючий код працює.
додано Автор CodeART, джерело
@sleske Привіт, я бачу вашу думку. Я також вважаю, що невеликі зміни потребують невеликих тестових одиниць.
додано Автор CodeART, джерело

Існує компроміс між вартістю написання модульних тестів і значенням, яке вони додають. Нехтування цим ризиком дає можливість надмірного тестування .

blueberryfields touched on one variable that affects the value of unit tests: stability of the project (or pace of development). I'd like to expand on that.

Значення модульних тестів приблизно відповідає наступній ділянці (yay, MS Paint!):

utility vs stability

  1. In the first zone, the code is unstable to the point that unit tests will often need to be rewritten or entirely scrapped. This might be a prototype that you know won't be used. Or it might be a project where you are new to the programming language or framework (and are often needing to redo large amounts of code).

    Unit tests are good for refactoring at the module level (i.e. changing functions). The problem is when code is unstable at the architectural level, where entire modules might be rewritten, removed, or completely redesigned. The unit tests then must be changed/removed/added, which is a burden.

    At this stage, limiting to system level integration tests, or even manual testing is a better approach (which one you choose again being dependent on the cost of writing the test vs. the value you get).

  2. The unit tests add the most value in the second zone, where code becomes stable above the module level, but not yet at the module level. If you have a stable codebase, and you are adding a module that has a high chance of staying, this is when unit testing is a big win.

  3. Unit tests also begin to have less value when the stability of the code under test is very high. Testing a simple wrapper of a standard library function is one example where unit testing is overkill.

    If a piece of code you are writing will likely never need to change, and you are confident you've got it right (maybe it's super simple?), there is less value to testing.

Блок тестування стає вигідним, коли корисність перевищує вартість, як показано на графіку нижче в зоні II.

utility and cost

Ця лінія витрат може бути на різних рівнях для різних людей (лінія 1 проти рядка 2). Якщо ви новачок у тестовому фреймворку, який використовується в проекті, це підвищує рівень і зменшує утиліту net . Більш висока вартість (лінія 2) зменшує діапазон, який придатний для тестування.

Лінія витрат не обов'язково має бути рівною. Особливо, якщо розглядати інші змінні, такі як розмір проекту, і чи існує тестова система для проекту, це може бути так.

16
додано
Насправді, тестування може допомогти у швидко рухаються проектах - але ви повинні бути більш обережними щодо того, що ви перевіряєте. Ви не можете перевірити речі, де ви ще не вирішили, який правильний результат :-).
додано Автор Julien Hoarau, джерело
Відмінне тестування відповідей є найменш корисним у швидкозмінних проектах з невідомими вимогами, а також у повільних проектах з дуже стабільним кодом. Враховуючи, що більша частина моєї роботи в першій, це гелі зі мною - але також ясно, що ми повинні отримати тестування відбувається, як все стабілізується.
додано Автор Steve Bennett, джерело
Це видатна відповідь. У ньому розглядаються компроміси, що беруть участь у виборі стратегії тестування у виміряному та орієнтованому на результат.
додано Автор jfs, джерело
@sleske: Так, але швидко розвиваються проекти, як правило, не мають специфічних (і стабільних) вимог, для яких можна провести тест. Часто все, що відомо, - це вимоги вищого рівня, які більше надають інтеграційних тестів.
додано Автор RyGuy, джерело

Де є найменш цінними модульні тести?

Ви повинні писати модульні тести тільки для логічного коду. Визначення логічного коду наведено нижче:

Логічний код - це будь-який фрагмент коду, який має в ньому якусь логіку, маленький, як може бути. Це логічний код, якщо він має один або більше наступні: оператор IF, цикл, вимикач або випадок випадку, розрахунки, або будь-який інший тип коду прийняття рішень.

Якщо це кінець спектру, де найбільш цінним є модульне тестування,   тоді що інший кінець?

  • Швидко зв'язаний код не можна легко перевірити. Іноді його взагалі не можна перевірити. Наприклад, веб-форми ASP.NET є кошмаром, а іноді неможливо протестувати, на відміну від ASP.NET MVC , створений з урахуванням модульного тестування.

  • Я можу вирішити не писати тести для дуже маленьких і простих проектів. Це цілком виправдано у світі з обмеженим часом та ресурсами. Так, це ризиковано, але це цілком прийнятно, коли компанія, в якій ви працюєте, має обмежений час на ринку.

Які ситуації ви б не турбували? Де б зусилля   підтримка тестів не коштує вартості?

Після встановлення модульних випробувань вартість їх обслуговування стає дуже незначною. Блокові тести з високим охопленням коду дають вам цінне почуття впевненості, що система поводиться так, як ви очікуєте. Те ж саме стосується і інтеграційних тестів, але це не ваше питання.

Моя відповідь базується на таких припущеннях:

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

Reference: Art of Unit Testing

10
додано
Ця відповідь (у світлі питання Q) дійсно виграє від прикладу коду (як у: функція/клас/...), що не є "логічним".
додано Автор Brock Woolf, джерело
Ви хотіли б визначити "дуже маленький і простий"? <500 рядків?
додано Автор Steve Bennett, джерело
Крім того, спасибі за те, що ви зрозуміли припущення, що "ви володієте однією з структур для тестування блоків". Це було для мене вбивцею. Останній (досить невеликий) проект вимагав, щоб я вивчав nodeJS, підкреслення, Atom, Handlebar і ще одну технологію, яку я забув. Тестові рамки були Vows, які були однією перешкодою занадто багато.
додано Автор Steve Bennett, джерело
Властивість Auto не є логічною, якщо вона не інкапсулює деяку логіку всередині, тобто, якщо оператор if/else.
додано Автор CodeART, джерело
Для мене невеликий і простий код, який я можу повністю зрозуміти протягом 30 хвилин. Я бачу, що ви вказуєте.
додано Автор CodeART, джерело

Кент Бек (людина, що стоїть за ідеєю тестування одиниць) говорить , що це чудово, щоб не писати одиничні випробування під час роботи над ідеєю (наприклад, прототипом), яку ви могли б викинути (якщо ви вирішите не працювати далі ). Навпаки, якщо ви пишете свій прототип і вирішите піти на нього, модульне тестування буде корисним з усіх причин, описаних у попередніх відповідях.

9
додано

Ви повинні мати тести для будь-якого коду, який ви збираєтеся запускати більше ніж один раз.

Якщо ви маєте намір запустити його один раз, а потім викинути його, тести можуть не бути корисними, хоча, якщо домен складний, я можу все одно написати тести, щоб допомогти мені з моїм розробкою та реалізацією.

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

7
додано
Хоча я погоджуюся, що всі виробничі коди потребують тестів, вони не обов'язково повинні бути модульними тестами - в деяких сценаріях інтеграційні тести мають більше сенсу.
додано Автор Julien Hoarau, джерело
@SteveBennett Має бути лише "Якщо вимоги потребуватимуть модифікації, тести також будуть коштувати дорожче"
додано Автор mwalling, джерело
Я був би вдячний за розуміння того, чому хтось вниз проголосував за цей пост.
додано Автор Ward, джерело
@noahz Так, я куплю це. Але за шкалою "треба, треба було б" я вибрав "повинен", а не "повинен" ...
додано Автор Ward, джерело
Так, я тестую ці сценарії. І вони не можуть бути перевірені з модульними тестами, але вони все ще можуть бути перевірені.
додано Автор Ward, джерело
Добре - але якщо код "буде потрібно модифікацій", тести також коштують дорожче, чи не так? Також ви перевіряєте сценарії оболонки? Створити сценарії?
додано Автор Steve Bennett, джерело
Не голосували, але я б запропонував, щоб ідея про те, що весь код має тест, - це релігійна лінія, а не завжди практична.
додано Автор halligan26, джерело

Я не маю жодної підказки про непотрібне , але я буду стріляти, коли я думаю, що Тести групи не підходять тим, що вони додають вартість без пропорційної вигоди:

Якщо наша організація/команда розробників не виконує жодних модульних тестів, тоді, якщо ви не зможете переконати своїх колег-розробників у запуску, фіксації (а також створення власних) тестових одиниць, тести, які ви створюєте, не будуть запускатися і підтримується. (Це означає, що ви працюєте над програмним забезпеченням разом з кимось іншим).

Не всі роблять модульні тести, вони іноді підтримуються локальною культурою команди, і в такому середовищі вам спочатку потрібно отримати їх для більшості розробників і, можливо, також для процесу збирання ("[безперервна] інтеграція" ) перед тим, як почати писати модульні тести, має сенс.

Враховуючи тимчасовий тиск і терміни постачання, і «ваше» відношення до команди - час, що залишився до написання модульних тестів, має сенс, може скласти місяці або роки.

6
додано
+1 для згадки про проблему обслуговування. Хоча я використовував одиничні тести з успіхом, як єдиний розробник. Тільки, коли я був на іншому проекті протягом декількох місяців, знадобилося кілька тижнів, поки всі модульні тести працювали знову ...
додано Автор Julien Hoarau, джерело

Іноді у вас немає часу на тестування. Нічого страшного.

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

But I still believe you should feel a little guilty about it. So when things start to fall apart, you will know it's because: "oh, yeah, I'm not testing stuff, let's start testing."

До цього моменту відчуття провини допоможе вам уникнути певних архітектурних варіантів , які б перешкодили вам автоматизувати тестування коду пізніше.

4
додано
у вас немає часу на тестування - величезний BS. Отже, немає часу на тестування, але завжди є час виправити помилки.
додано Автор Yonatan Maman, джерело
Кодування до вимог є ключовим у TDD. Ви повинні мати якийсь документ, який повідомлятиме вам, який код повинен робити в певній ситуації (це може бути так само просто, як "коли я натискаю цю кнопку, я очікую перейти на сторінку X", як PD як правила GAAP для обліку, Загальне як "нам потрібна система, яка буде приймати ці файли і виробляти цей висновок; піти зробити це"). Якщо ваші вимоги в певній області недостатньо деталізовані для написання одиничного тесту, який віддзеркалює їх, то ви повинні інтерполювати на основі того, що ви знаєте. Якщо ви не можете зробити навіть цього, то вам потрібно більше вимог.
додано Автор KeithS, джерело
... і, навпаки, я зараз до моєї шиї.
додано Автор ZJR, джерело
tru, @ VJovic. Але якщо ОП не відчуває НЕОБХІДНІСТЬ для перевірки, тому що не тестування ще не спалило його, і просто робить речі з сліпої віри . Ну, тоді я думаю, що це буде ще гірше, тому що отримання абіта від виконання речей з сліпої віри приводить вас до дуже дивних куточків.
додано Автор ZJR, джерело
Насправді, моєю причиною для нетестового тестування є відсутність часу - це, як правило, або я не знаю, що код буде робити достатньо, щоб визначити його, або я не знаю технологій досить добре, так що навчання і розгортання рамки тестування було б додатковим тягарем.
додано Автор Steve Bennett, джерело
на роботі i TDD. на особистих проектах поняття тесту не існує. мої персональні проекти швидкість віх і особливості набагато швидше (можливо, 10x), але мільйони доларів не проходять через них. Я вважаю, якщо вони стануть успішними, платити іншому чмочку, щоб написати мої тести (на зразок того, що я зараз, що це тепер).
додано Автор AlasdairC, джерело

Вартість не в підтримці тестів, а в не збереженні робочого коду. Якщо ви розлучаєтеся з тестуванням і реалізацією, ви припускаєте, що те, що ви пишете, працюватиме без користі доказу. Тести дають вам такий доказ і впевненість у підтримці коду з плином часу. Звичайно, ви можете подумати, що ви ніколи не будете повторювати цю програму, яку ви вважали викидкою, однак реальність така, що будь-який час, коли ви витрачаєте написання програмного забезпечення, є інвестицією, яку ваш роботодавець не хоче з легкістю лікувати. Подивимося правді в очі, розробники програмного забезпечення взагалі не дешево, і час, витрачений на викид коду - це гроші, які просто спалюються вашому роботодавцю.

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

2
додано
Тести не доводять, що код працює, вони дають вам доказ того, що вони не провалюють тестування тестів, вважаючи, що тести є правильними.
додано Автор Alex, джерело
Якщо ви не думаєте, що мій коментар скасовує вашу точку зору, ви не розумієте мого коментаря. Тести не доводять правильності, але ви стверджуєте, що вони роблять, коли ви говорите "Тести дають вам такий доказ [що те, що ви пишете буде працювати]".
додано Автор Alex, джерело
Щоб пояснити, слово «доказ» має певний сенс, і я розумію, що робочий код означає «код», який робить те, що він хотів зробити без винятку. Для створення доказів я б скористався інтерактивним асистентом. Тести забезпечують впевненість, але вони не можуть надати доказ того, що ваш код працює, якщо вони не виконують вичерпну перевірку моделі, що навряд чи можливо.
додано Автор Alex, джерело
Контекст - це програмне забезпечення. Якщо я попрошу докази правильності, я не чекаю тестового набору.
додано Автор Alex, джерело
@ S.Robins, Ви повністю відсутній пункт. Якби я хотів писати доказове правильне програмне забезпечення, я б використовував мова, залежну від типізації, або інші формальні методи. "Ручні перевірки та дорогі & документи важкі Q/A системи" - це форми тестування, які, як я вже сказав, не доводять правильності.
додано Автор Alex, джерело
@ S.Robins, ми згодні, це смішно, і я дійсно погоджуюся з рештою вашої відповіді, але ваше використання слова "доказ" в цьому контексті неправильно. Я працював над цим пунктом, тому що ви не визнали його і, здається, не розуміли його. Я не хотів і не мав наміру починати тривалу дискусію з цього питання. Я вже сперечаюся.
додано Автор Alex, джерело
@dan_waterworth Ваш коментар не скасовує мою точку зору. Є завжди припущення, коли тести використовуються, і, природно, якщо ваша методологія тестування є недосконалою, то ви не можете бути впевнені, що ваш продукт працює як потрібно. Це стрибок віри, але також виходячи з ваших знань про вимоги проекту, і, наскільки ви знаєте, що ви написали тести і код, щоб відповідати цим вимогам. Таким чином, якщо ви перевіряєте продукт, щоб підтвердити, що він працює як потрібно, то він працює. Отже, щоб відповісти на ваш коментар, якщо ви ніколи не "перевіряєте" свій код, як ви будете знати, якщо він працює?
додано Автор S.Robins, джерело
@dan_waterworth Поясніть, якщо ви хочете, як ваш коментар недійсний відповідь, що я написав тут, і пояснити також конкретний механізм, який ви б використовували, щоб надати доказ того, що ваш код робить те, що він повинен робити - Тобто: що він "працює" як передбачалося. Будь ласка, підтримайте ваше твердження, що я неправильно зрозумів ваш коментар, коли я звернувся до спроб роз'яснити заяви, що стосуються "доказів" і "робочого кодексу" у моєму попередньому коментарі до вас. Якщо ви хочете допомогти поліпшити якість відповіді, зробіть це, але давайте уникаємо дурної думки про те, що є тривіальністю.
додано Автор S.Robins, джерело
@dan_waterworth Я вважаю, що ви розбиваєте волосся над використанням слова, яке ви прийняли з контексту, з відповіддю. Крім того, ваш розуміння з урахуванням контексту відповіді є недосконалим, особливо стосовно визначеного значення слова Доказ . Щоб вказати підтвердження як "без виключення", це неправильно в значенні слово. Все це, однак, фактично є людиною, яка все ще не вирішує питання, яке ви вважаєте, що ваш коментар недійсний відповідь, яку я дав на питання ОП.
додано Автор S.Robins, джерело
@dan_ Неправильно знову. Контекст є Робоче програмне забезпечення . Різниця важлива, враховуючи позицію, яку ви взяли. Звичайно, існує безліч механізмів, які можуть бути використані для формування позиції, що стверджує, що програмне забезпечення працює правильно. Удачі з накладними витратами на технічне обслуговування, якщо ви є людиною, яка вважає за краще покладатися на ручні перевірки та дорогі та документальні системи Q/A. Я візьму тестовий набір кожного разу над іншими системами, щоб покращити витрати та вигоду, а також на надійність, яку приносить автоматизація, особливо коли для обслуговування потрібні тести для зміни.
додано Автор S.Robins, джерело
@dan це дійсно стає смішним. Ви продовжуєте ігнорувати пункт відповіді (про те, коли перевірити чи ні, і не про доказовість), і ви ще не пояснили, як ця неналежна потреба постійно відхилятися до точки тривіальності є будь-яким чином відповідним для вашого твердження моя відповідь недійсним цією дрібницею. Далі, повторюючи ту ж саму вузьку точку зору, ad-nauseum нічого не доводить у контексті відповіді, як написано. Якщо ви все ще відчуваєте потребу бити груди через це, взяти справу в автономному режимі і зробити з ним. Безглуздий аргумент тут нікому не допомагає.
додано Автор S.Robins, джерело
Ви повинні бути впевнені у своєму коді. +1
додано Автор CodeART, джерело

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

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

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

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

Тому я б сказав, що навіть якщо ви не пишете одиничні тести для кожної маленької частини системи, тестування здорового глузду слід робити незалежно.

1
додано

Тестові одиниці ІМО недоречні (не потрібні!) У будь-якій кодовій базі, де потрібно тонни рефакторингу або навіть прямий перезапис, щоб запровадити модульне тестування, тому що це було б дуже важко продати керівництву, щоб дозволити виділення цього часу .

1
додано

Кількість та якість модульного тестування, яке необхідно виконати в проекті, прямо пропорційно темпу розвитку та необхідній стабільності продукту.

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

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

[Є багато інших факторів, що впливають на ситуацію, кожен з яких сприяє тому чи іншому, наприклад, розмір вашої команди, ваш бюджет, талант ваших розробників, бажана стратегія розробки програмного забезпечення тощо ... Загалом, і Найбільш високий рівень абстракції, я вважаю, що ці дві \ t

1
додано

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

Уявіть цей загальний сценарій. У вас є якісь технології, за якими ваша компанія славиться, ваша команда продажів або головний виконавець йде до клієнта і може продавати їм інший продукт, який використовує вашу технологію. Вони продають його там, а потім обіцяють клієнту побачити бета-версію через місяць. У вас немає нічого, навіть команда розробників.

Що відбудеться далі - це швидко розробити рішення, засноване на узгоджених/проданих точках клієнту, зібрати команду (часто зіркових) інженерів і почати писати код. Було б ідеально, звичайно, якщо ваші дати не прослизнули (вони завжди роблять), і вам вдалося написати код за три тижні, а не за чотири. У цьому випадку у вас є додатковий тиждень, і якщо ви змогли забезпечити час команди QA на цьому тижні - ви перевірите його. Насправді у вас не буде додаткового тижня і/або ваша команда QA не буде замовлена ​​ще на два місяці, підтримуючи інші поставки продукції. Крім того, у вас не буде ніяких специфікацій дизайну, тому команда QA не матиме ніякої ідеї про те, що вони повинні тестувати. Таким чином, ви отримаєте те, що ви написали, з невеликою кількістю власного тестування на дим, що насправді не є тестуванням як таким, просто тому, що ви не кваліфіковані для перевірки власного коду. Найбільшим фактором тут є те, що клієнт дуже швидко побачить деякі з обіцяних функцій. Якщо ваш прототип виконає завдання, то ви повернетеся до креслярської дошки, де ви розробляєте і плануєте фактичну версію 1.0 - належним чином цього разу.

Що стосується модульних тестів, вони добре підтримують певні контракти (я обіцяю, що мій код зробить це, якщо ні - це порушено). У разі створення прототипів, ви, можливо, не піклуєтеся про контракти, тому що досить часто ваші прототипи не перейдуть до версії 1.0, тому що клієнт пішов, або тому, що ви розробили свою версію 1.0 за допомогою різних технологій/інструментів. Прикладом тут може бути швидкий веб-сайт прототипу, написаний дуже швидко на PHP протягом одного місяця однією людиною, а потім ви зберете команду, яка перепише її в JEE. Навіть база даних часто не переживе цієї зміни.

0
додано
Я бачив занадто багато "protype" і "тимчасового" коду, які йдуть у виробництво, щоб припустити, що це не буде. Одна справа сподіватися/спланувати повторне впровадження. Інша справа знайти час у розкладі.
додано Автор Peter Bernier, джерело
@jwernerny Ви говорите зі свого досвіду, я говорю з мого. Я думаю, що цей аргумент є контрпродуктивним. Часто існують вагомі комерційні причини, коли час виходу на ринок є більш важливим, ніж якість. Це сумна річ, у цьому немає сумнівів, але це факт життя.
додано Автор Tri, джерело

Блокові тести приємні і все, але в складних системах з великою кількістю "рухомих частин", вони насправді насправді не тестують.

Як відомо, тестові модулі гарантують, що даний вхід X для одиниці, ви отримаєте вихід Y, де X є всім відповідним входом і Y є всім відповідним виходом. Тим не менш, я вважаю, що більшість код робить те, що розробник думав, що він повинен .. але не потрібно, що це насправді повинно робити.
(Ви можете думати про неї як про пістолет. Пістолет має купу точних деталей, виготовлених окремо, а потім зібраний. Не має значення, якщо кожна окрема частина добре перевіряється на функціональність, якщо пістолет вибухає, коли насправді обстріляють. : Я нічого не знаю про вогнепальну зброю (:)

У цих випадках нам потрібні фактичні системні тести в типовому виробничому середовищі. Оскільки функціональність перевіряється тут, вартість модульних тестів трохи зменшилася.

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

0
додано
@mark На жаль, багато людей використовують свої голоси, щоб сказати, що їм не подобається те, що написано, або що вони особисто вважають, що відповідь (або її частина) є неправильною, і здається, це часто не дає автор користь читання всієї відповіді, щоб тримати речі повністю в перспективі.
додано Автор S.Robins, джерело
@ user606723 Опубліковано, ймовірно, через те, що оператор запитує коли недоречно створювати одиничні тести, тоді як ваша відповідь починається з ефективного підтвердження того, що модульні тести не випробовують багато чого в складній системі - це величезна кількість узагальнення, яке може бути фактично некоректним - і закінчується ефективним констатацією того, що тестові одиниці є цінними, оскільки вони захищають систему від функціональних змін - що не є цілком точним, ані контекстуально невідповідним до опублікованого питання.
додано Автор S.Robins, джерело
Пам’ятайте, що голоси не повинні бути Я не люблю вашу відповідь , вони просто я не знайшов вашу відповідь корисною , тому потрібно вчитися не сприймати це особисто. Я не знаю, як це відповідає фактичному запиту.
додано Автор Mark Booth, джерело
@ S.Robins - Домовлено, що частиною причини іноді згадувати, за що голосує для , є нагадування людям, які можуть віддавати ці голоси, що вони не мають на увазі або не подобається .
додано Автор Mark Booth, джерело
будь-яке пояснення для downvote?
додано Автор jaybers, джерело

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

В основному залежить, скільки ви можете тримати в голові відразу. Ви можете мати більше впевненості, що можете кодувати (повністю знаючи вплив ваших змін), доки не буде досягнуто певної складності. До тих пір, поки тестові одиниці не відволікають увагу, перешкода і сповільнюється. У команді, поріг буде набагато нижчим, тому ви потребуватимете одиничних тестів відразу, щоб протидіяти групі-дурості. Якщо ви підібрали проект, що не підлягає перевірці, від когось іншого (або ви забули про проект з давніх пір), ви захочете написати блокові тести, перш ніж що-небудь змінити, тому що ваше розуміння буде нульовим.

Примітка: написання меншого коду та практичне використання YAGNI, зберігає складність і, отже, кількість необхідних тестів.

0
додано
Отже ... Ви виступаєте за те, щоб писати тільки тестові одиниці, які допоможуть вам навчитися/захистити систему, з якою ви не знайомі, інакше - не тест на модуль? !! Можливо, я неправильно зрозумів вашу відповідь. Якщо ні, то це дійсно не те, для чого призначено модульне тестування. Зокрема, якщо ви захищаєте TDD, ви зрозумієте, що написання тесту спочатку спрямовує ваші зусилля на впровадження мінімального коду, тоді як рефакторинг допомагає вам підсилити ці зусилля. Таким чином, YAGNI закінчується як центральним принципом, так і побічним продуктом вашого методу розвитку. Якщо ваш блок тестування стає складним, IMHO ви, ​​ймовірно, робите це "неправильно".
додано Автор S.Robins, джерело
Так, це інше використання для тестування одиниць, але, звичайно, не конкретна мета одиничних тестів. Мої коментарі, однак, полягали в тому, щоб відповісти на надану відповідь, яка, на мою думку, насправді не задовольняє питання ОП. Зокрема, якщо ви відчуваєте, що тестові одиниці є відволікаючим фактом, або що вони потрібні лише для того, щоб допомогти розуміти найменш досвідченого члена команди, то або ви насправді не розумієте, як ефективно застосовувати одиничні тести, або ви, можливо, відчуваєте, що тести є завдання останньої милі. У будь-якому випадку, це не той напрямок, з яким ОП шукав своїх відповідей.
додано Автор S.Robins, джерело
Для чого варто, я згоден з вами, що там, де дуже важко зрозуміти програму, модульні тести дозволяють тестувати ідеї і використовувати випадки окремо, без необхідності створювати повноцінне додаток. Особисто я використовую API тестових модулів, щоб допомогти мені зіпсувати складні проблеми. Проте я завжди буду писати одиничні тести для мого коду, навіть там, де це може здатися досить тривіальним, і я роблю цей тест спочатку для того, щоб отримати реальну користь від тестів, що є впевненістю змінити код з плином часу, не побоюючись, що код зламається і вимагають подальшого незалежного тестування.
додано Автор S.Robins, джерело
Я кажу, що модульне тестування є мостом через прогалини у розумінні програми. Я сказав, що вони зобов'язані "розширювати" заявку, в тому сенсі, що іноді особливість і вплив її занадто важко відстежувати відразу, тому модульні тести можуть виступати в якості основи, щоб зробити це можливо.
додано Автор Benedict, джерело
Висловлюючи свою відповідь, я намагався скласти короткий і всеохоплюючий емпіричне правило, яке відповідає, чи підходить тестове тестування до того, що ви робите, чи ні. У зв'язку з цим, безпосередньо відповідаючи на питання ОП. Я також сказав, щоб написати тести, якщо складність ", ймовірно, в майбутньому перевищить" розуміння, щоб охопити той випадок, який ви запропонували "це може здатися досить тривіальним [зараз, але пізніше ...]".
додано Автор Benedict, джерело