Тестовете като предпазна мрежа

Код на:JavaC#PythonJavaScript

Накратко: Характеризиращите тестове (characterization tests) заковават какво прави старият код днес, затова хващат всяка неволна промяна на поведението, докато го подреждаш.

Проблем

Безобидната промяна

Магазинът смята доставката с функцията deliveryFee. Писана е преди три години, тестове няма. Доставката е 4,50 €, извън София е с 2 € повече, до Видин с още 3 €, а над 10 кг се плаща по 0,50 € за всеки килограм отгоре. От 50 € нагоре е безплатна.

export function deliveryFee(total, kg, city) {
  let fee = 4.5;
  if (city !== "София") {
    fee = fee + 2;
  }
  if (city === "Видин") {
    fee = fee + 3;
  }
  if (kg > 10) {
    fee = fee + (kg - 10) * 0.5;
  }
  if (total >= 50) {
    fee = 0;
  }
  return fee;
}

Миналия месец колега я „подреди“: щом поръчката е безплатна, защо да смятаме, и премести проверката най-отгоре. Написа total > 50 вместо total >= 50. Цяла седмица поръчките за точно 50 € плащаха доставка. Никой не забеляза, докато не дойдоха оплакванията.

Сега на теб ти трябва да добавиш нов град. Пипаш ли тази функция? Ако не я пипаш, всяко ново правило се лепи отгоре и кодът става все по-страшен. Ако я пипаш, може да счупиш нещо, което работи, и да не разбереш.

Идеята

Мрежа под въжето

Въжеиграчът върви по въжето спокойно, защото отдолу има мрежа. Ако падне, мрежата го хваща, преди да стане беля.

За кода мрежата са тестовете. Преди да смениш как е написан кодът, пишеш тестове, които казват какво прави той днес. После сменяш и пускаш тестовете. Зелено: поведението е същото. Червено: нещо се е сменило, и знаеш точно кое.

Такива тестове се казват характеризиращи (characterization tests): те не проверяват дали кодът е верен, а описват как се държи. Ако днес кодът прави нещо странно, тестът записва и странното. Това е предпазната мрежа: никакъв код не се пипа, докато под него няма тестове.

Виж го

Запиши какво прави днес

Не гадаеш какво би трябвало да връща функцията. Питаш нея. Една кратка програма я вика с няколко поръчки и печата отговорите:

console.log(`20 €, 2 кг, София → ${deliveryFee(20, 2, "София")}`);
console.log(`20 €, 2 кг, Пловдив → ${deliveryFee(20, 2, "Пловдив")}`);
console.log(`20 €, 16 кг, София → ${deliveryFee(20, 16, "София")}`);
console.log(`50 €, 2 кг, Пловдив → ${deliveryFee(50, 2, "Пловдив")}`);
console.log(`60 €, 25 кг, Пловдив → ${deliveryFee(60, 25, "Пловдив")}`);

Изход

20 €, 2 кг, София → 4.5
20 €, 2 кг, Пловдив → 6.5
20 €, 16 кг, София → 7.5
50 €, 2 кг, Пловдив → 0
60 €, 25 кг, Пловдив → 0

Последният ред е изненада. Пакетът е 25 кг, а доставката е безплатна: безплатната доставка маха и надценката за тегло. Грешка ли е? Може би. Но днес е така, клиентите го ползват, и решението дали да се смени не е твое, докато подреждаш кода. Записваш го такова, каквото е.

Всеки ред от пробата става тест:

import { test } from "node:test";
import assert from "node:assert/strict";
import { deliveryFee } from "./delivery.js";

test("София", () => {
  assert.equal(deliveryFee(20, 2, "София"), 4.5);
});

test("извън София", () => {
  assert.equal(deliveryFee(20, 2, "Пловдив"), 6.5);
});

test("над 10 кг", () => {
  assert.equal(deliveryFee(20, 16, "София"), 7.5);
});

test("от 50 € е безплатно", () => {
  assert.equal(deliveryFee(50, 2, "Пловдив"), 0);
});

test("безплатно и при 25 кг (така е днес)", () => {
  // Така е днес: безплатната доставка маха и надценката за тегло.
  assert.equal(deliveryFee(60, 25, "Пловдив"), 0);
});

Резултат

ОК    София
ОК    безплатно и при 25 кг (така е днес)
ОК    извън София
ОК    над 10 кг
ОК    от 50 € е безплатно
Тестове: 5, минали: 5, паднали: 0

Пет теста, пет зелени. Мрежата е опъната.

По-точно, за любопитните

Тестовете тук се пускат както в урока за тестовете от модул „Програми в истинския свят“. Проверената програма записва delivery.js и delivery.test.js във временна папка и ги пуска с run() от node:test, като подрежда резултатите по име. Така изходът е един и същ при всяко пускане.

Стойностите в теста са каквото JavaScript отпечата. В JavaScript числото е едно (number), а сумите тук са кратни на 0,50 и се пазят точно, затова assert.equal стига.

Виж го

Безобидната промяна под мрежата

Сега колегата прави същата промяна, но под мрежа. Проверката отива най-отгоре:

export function deliveryFee(total, kg, city) {
  if (total > 50) {
    return 0;
  }
  let fee = 4.5;
  if (city !== "София") {
    fee = fee + 2;
  }
  if (city === "Видин") {
    fee = fee + 3;
  }
  if (kg > 10) {
    fee = fee + (kg - 10) * 0.5;
  }
  return fee;
}

Резултат

ОК    София
ОК    безплатно и при 25 кг (така е днес)
ОК    извън София
ОК    над 10 кг
ПАДА  от 50 € е безплатно: 6.5 !== 0
Тестове: 5, минали: 4, паднали: 1

Един тест е червен и казва точно кой случай: поръчка за 50 € извън София. Очаквано 0, а е 6,50 €. Грешката е хваната на бюрото, не от клиент.

import { test } from "node:test";
import assert from "node:assert/strict";
import { deliveryFee } from "./delivery.js";

test("София", () => {
  assert.equal(deliveryFee(20, 2, "София"), 4.5);
});

test("извън София", () => {
  assert.equal(deliveryFee(20, 2, "Пловдив"), 6.5);
});

test("над 10 кг", () => {
  assert.equal(deliveryFee(20, 16, "София"), 7.5);
});

test("от 50 € е безплатно", () => {
  assert.equal(deliveryFee(50, 2, "Пловдив"), 0);
});

test("безплатно и при 25 кг (така е днес)", () => {
  // Така е днес: безплатната доставка маха и надценката за тегло.
  assert.equal(deliveryFee(60, 25, "Пловдив"), 0);
});

Стъпка по стъпка, с думи

1. Пет теста, по един за всеки ред от пробата. Всеки вика deliveryFee и сравнява с отговора, който дава днес.
2. deliveryFee(20, 2, "София") връща 4.5. Тестът го заковава.
3. deliveryFee(20, 2, "Пловдив") връща 6.5. Тестът го заковава.
4. deliveryFee(20, 16, "София") връща 7.5. Тестът го заковава.
5. deliveryFee(50, 2, "Пловдив") връща 0. Тестът го заковава.
6. deliveryFee(60, 25, "Пловдив") връща 0, макар пакетът да е 25 кг. Странно, но днес е така: тестът го пази, не го поправя.
7. Колегата мести проверката за безплатна доставка най-отгоре и пише > вместо >=. Мрежата се пуска цялата.
8. „от 50 € е безплатно“ пада: очаквано 0, а е 6.5. Поръчка за точно 50 € вече плаща доставка.
9. С >= петте теста са зелени. Промяната е безопасна: мрежата я провери.

С >= всичко е зелено:

export function deliveryFee(total, kg, city) {
  if (total >= 50) {
    return 0;
  }
  let fee = 4.5;
  if (city !== "София") {
    fee = fee + 2;
  }
  if (city === "Видин") {
    fee = fee + 3;
  }
  if (kg > 10) {
    fee = fee + (kg - 10) * 0.5;
  }
  return fee;
}

Резултат

ОК    София
ОК    безплатно и при 25 кг (така е днес)
ОК    извън София
ОК    над 10 кг
ОК    от 50 € е безплатно
Тестове: 5, минали: 5, паднали: 0

Промяната е същата като онази, която мина незабелязано цяла седмица. Разликата е само мрежата.

Пробвай

Предвиди изхода

Някой сменя реда за надценката за тегло и забравя да извади първите 10 кг:

fee = fee + kg * 0.5;

Тестовете от картата „Запиши какво прави днес“ се пускат пак. Какво става?

export function deliveryFee(total, kg, city) {
  let fee = 4.5;
  if (city !== "София") {
    fee = fee + 2;
  }
  if (city === "Видин") {
    fee = fee + 3;
  }
  if (kg > 10) {
    fee = fee + kg * 0.5;
  }
  if (total >= 50) {
    fee = 0;
  }
  return fee;
}

Отговор

Пада само над 10 кг

И петте минават: промяната е малка

Падат над 10 кг и безплатно и при 25 кг (така е днес)

Провери

Пробвай

Какво пишеш като очаквано

Пробата отпечата за 60 €, 25 кг и Пловдив: 0. Ти си сигурен, че правилната доставка е 14 €. Какво пишеш в теста преди промяната?

test("безплатно и при 25 кг (така е днес)", () => {
  assert.equal(deliveryFee(60, 25, "Пловдив"), );
});

Провери

Идеята

Малки стъпки

Мрежата помага най-много, когато падаш от ниско. Ако смениш двадесет неща наведнъж и един тест падне, не знаеш кое от двадесетте е виновно. Ако смениш едно и тестът падне, виновникът е ясен.

Затова се работи в ритъм: една малка промяна, пускаш тестовете, зелено, следващата. Червено значи: върни последната промяна (Ctrl+Z или git checkout на файла) и я направи на още по-малки парчета. Така кодът почти през цялото време е в състояние, което работи.

Подреди стъпките:

1. Направи една малка промяна↑↓
2. Пусни тестовете пак↑↓
3. Пусни тестовете: всички са зелени↑↓
4. Добави тестове за пътя, който ще пипаш↑↓
5. Зелено: запази (commit). Червено: върни само последната промяна↑↓

Провери

Пробвай

Намери грешката

Някой е написал теста за 50 € така. После колегата прави промяната с total > 50 от картата „Безобидната промяна под мрежата“:

import { test } from "node:test";
import assert from "node:assert/strict";
import { deliveryFee } from "./delivery.js";

test("София", () => {
  assert.equal(deliveryFee(20, 2, "София"), 4.5);
});

test("извън София", () => {
  assert.equal(deliveryFee(20, 2, "Пловдив"), 6.5);
});

test("над 10 кг", () => {
  assert.equal(deliveryFee(20, 16, "София"), 7.5);
});

test("от 50 € е безплатно", () => {
  console.log(deliveryFee(50, 2, "Пловдив"));
});

test("безплатно и при 25 кг (така е днес)", () => {
  // Така е днес: безплатната доставка маха и надценката за тегло.
  assert.equal(deliveryFee(60, 25, "Пловдив"), 0);
});

Резултат

ОК    София
ОК    безплатно и при 25 кг (така е днес)
ОК    извън София
ОК    над 10 кг
ОК    от 50 € е безплатно
Тестове: 5, минали: 5, паднали: 0

Грешната сума е върната, а тестовете са зелени. На кой ред е грешката?

Избери реда с грешката.

1import { test } from "node:test";2import assert from "node:assert/strict";3import { deliveryFee } from "./delivery.js";45test("София", () => {6 assert.equal(deliveryFee(20, 2, "София"), 4.5);7});89test("извън София", () => {10 assert.equal(deliveryFee(20, 2, "Пловдив"), 6.5);11});1213test("над 10 кг", () => {14 assert.equal(deliveryFee(20, 16, "София"), 7.5);15});1617test("от 50 € е безплатно", () => {18 console.log(deliveryFee(50, 2, "Пловдив"));19});2021test("безплатно и при 25 кг (така е днес)", () => {22 // Така е днес: безплатната доставка маха и надценката за тегло.23 assert.equal(deliveryFee(60, 25, "Пловдив"), 0);24});

Провери

Идеята

Какво мрежата не хваща

Мрежата хваща само там, където е опъната. За Видин тест няма. Някой „подрежда“ градовете с else if:

export function deliveryFee(total, kg, city) {
  let fee = 4.5;
  if (city === "Видин") {
    fee = fee + 3;
  } else if (city !== "София") {
    fee = fee + 2;
  }
  if (kg > 10) {
    fee = fee + (kg - 10) * 0.5;
  }
  if (total >= 50) {
    fee = 0;
  }
  return fee;
}

Тестовете

ОК    София
ОК    безплатно и при 25 кг (така е днес)
ОК    извън София
ОК    над 10 кг
ОК    от 50 € е безплатно
Тестове: 5, минали: 5, паднали: 0

Видин преди и след

Видин преди: 9.5
Видин след: 7.5

Тестовете са зелени, а доставката до Видин поевтиня с 2 €: преди Видин плащаше и 2 € извън София, и 3 € отгоре. Никой тест не минава през този път, затова никой не пада.

Преди да пипнеш код, виж кои пътища имат тестове и добави за тези, които ще пипаш. Това показва покритието (coverage): кои редове са минали при пускането на тестовете.

Node го има вграден: node --test --experimental-test-coverage печата за всеки файл кои редове не са минали.

В JavaScript има още нещо: компилатор, който да прочете целия файл, няма. Някой преименува fee на price на ръка и го забравя в клона за Видин:

export function deliveryFee(total, kg, city) {
  let price = 4.5;
  if (city !== "София") {
    price = price + 2;
  }
  if (city === "Видин") {
    price = fee + 3;
  }
  if (kg > 10) {
    price = price + (kg - 10) * 0.5;
  }
  if (total >= 50) {
    price = 0;
  }
  return price;
}

Петте теста пак са зелени: никой от тях не стига до този ред. Грешката излиза чак когато някой поръча до Видин:

try {
  deliveryFee(20, 2, "Видин");
} catch (error) {
  console.log(`Видин: ${error.message}`);
}

Изход

Видин: fee is not defined

Затова тук тестовете пазят още повече, отколкото в Java и C#.

По-точно, за любопитните

Покритие 100% не значи, че всеки случай е проверен. Редът с total >= 50 е „покрит“ и от тест с 60 €, но точно 50 € е отделен случай, и само тестът за 50 € хваща >. Покритието казва къде мрежата има дупки. Колко е гъста там, където я има, зависи от случаите, които си избрал: границите (50 €, 10 кг), всеки клон на if и странните стойности от пробата.

Командите за покритие тук не се пускат: проверката на сайта е без мрежа и без външни пакети.

Упражнение

Мрежа за Видин

Реши задачата в редактора си.

Мрежа за Видин. Добави два теста към тестовете от картата „Запиши какво прави днес“: поръчка за 20 €, 2 кг до Видин и поръчка за 50 €, 2 кг до Видин. Първо пусни пробата, за да видиш какво връща кодът днес, и закови това.

Резултат

ОК    Видин
ОК    Видин от 50 € е безплатно
ОК    София
ОК    безплатно и при 25 кг (така е днес)
ОК    извън София
ОК    над 10 кг
ОК    от 50 € е безплатно
Тестове: 7, минали: 7, паднали: 0

После направи промяната с else if от картата „Какво мрежата не хваща“. Сега тя трябва да падне:

Резултат

ОК    Видин от 50 € е безплатно
ОК    София
ОК    безплатно и при 25 кг (така е днес)
ОК    извън София
ОК    над 10 кг
ОК    от 50 € е безплатно
ПАДА  Видин: 7.5 !== 9.5
Тестове: 7, минали: 6, паднали: 1

Още задачи

• Границата на теглото. Добави тест за точно 10 кг и за 11 кг. После смени kg > 10 на kg >= 10. Пада ли нещо? Защо?
• Новият град. Добави Варна с 1 € отгоре. Първо тест за Варна, който пада, после правилото, после пак всички тестове.
• Проба за всичко. Напиши пробата с цикъл по таблица от случаи (сума, тегло, град), така че нов случай да е нов ред в таблицата.

Тест

Провери се

1. Пробата показва, че поръчка за 60 € с пакет от 25 кг се доставя безплатно. Според теб това е грешка. Какво пишеш в теста преди промяната?

Стойността, която функцията връща днес, и бележка, че изглежда странноНищо: за такъв случай тест не се пишеСтойността, която би трябвало да е вярна

2. Пет теста минават. Пренареждаш функцията и един пада. Какво правиш?

Сменяш очакваната стойност в теста, за да минеИзтриваш теста, защото пречиВръщаш последната промяна и я правиш на по-малки стъпки

3. Защо стъпките са малки и тестовете се пускат след всяка?

За да има повече commit-иЩом тест падне, знаеш, че виновна е последната малка промянаЗащото тестовете са бързи само за малък код

4. Всички тестове са зелени. Значи ли това, че промяната не е сменила нищо?

Да, щом са зелениНе: тестовете пазят само случаите, които проверяват. Път без тест може да се е сменилДа, ако са повече от десет

5. Тест вика функцията и печата резултата, без да го сравнява. Какво пази той?

Всичко, което печатаНищо: минава при всеки резултат, освен ако програмата спре с грешкаСамо случая, който печата

Провери

Започни урока отначало

Свързани уроци

• Нужно отпреди: Тестове с node:test · Имена в кода · Функции: една работа, малко параметри, без скрити странични ефекти · Миризмите: дълъг метод, голям клас, дублиране, примитиви вместо типове, дълга верига if
• Продължава в: Refactoring на малки стъпки · Упражнение: разхвърлян клас, изчистен стъпка по стъпка · Зависимостите: чужд код, който пуска твоят
• Задачи по темата: Чист код и refactoring