Det här är ett kort exempel på hur man skulle kunna lägga upp testdriven utveckling av en funktion som ska ta in en sträng och parsa den och returnera ett nummer.
I TDD är det tre steg man alltid gör om och om igen tills allt är klart, stegen är:
• Skriv ett test som inte går igenom
Ingen kod utan ett fallerande test
• Få testet att lyckas
Med så enkel kod som möjligt
• Gör koden bättre
Refaktorera
När man skriver första testet ska det vara det enklaste sättet att få funktionen att lyckas. Allra enklaste hade jag tyckt var att skicka in en tom sträng, men eftersom kravet inte sa någonting om det så blir det första jag får man först se till att kravet är tydligt genom att fråga sin chef eller kund istället för att gissa. Nu har vi fått ett tydligare krav och vet att skickar man in en tom sträng ska funktionen returnera 0.
Vi börjar skriva testet, skapar en i stort sett tom funktion så att vi kan kompilera projektet och köra testet.
//Testprojektet
[TestMethod]
public void CanParseEmptyStringToInteger()
{
ParseStringToInteger parser = new ParseStringToInteger();
int actual = parser.ParseToInteger(String.Empty);
Assert.AreEqual(0, actual);
}
//Logik klassen
public int ParseToInteger(string stringToParse)
{
return -1;
}
När vi kör testet första gången får vi ett rött fallerande test precis som väntat.
Det absolut minsta vi behöver göra för att få koden att fungera är att ändra så att vi skicka tillbaks 0. Vi uppdaterar koden så att det står return 0;
i funktionen istället och kör testet igen. Det blir grönt för att testet gick igenom. Kommer det här fungera senare? Det spelar ingen roll! För man koncentrerar sig på ett test i taget och det absolut lättaste sättet att få det att gå igenom var att göra såhär. Då är det rätt sätt.
Uppenbarligen har vi inte täckt in alla krav än så vi skapar ett test till där vi skickar in 1.
[TestMethod]
public void CanParseStringWithNumberOneInToInteger()
{
ParseStringToInteger parser = new ParseStringToInteger();
int actual = parser.ParseToInteger("1");
Assert.AreEqual(1, actual);
}
Testet misslyckas så våran nuvarande kod täcker inte in det nya testfallet än. Vi gör följande uppdatering:
public int ParseToInteger(string stringToParse)
{
return int.Parse(stringToParse);
}
Nu går det andra testet igenom men det första misslyckas. Vi måste lägga till ett sätt för att se om strängen är tom och sen vet vi sen tidigare att vi bara behöver returnera 0 för att kravet ska uppfyllas för det första testet också.
public int ParseToInteger(string stringToParse)
{
if (string.IsNullOrEmpty(stringToParse))
{
return 0;
}
return int.Parse(stringToParse);
}
Nu vet vi att funktionen gör precis det vi förväntar oss av den. Den parsar en sträng till en siffra och alla krav är uppfyllda och vi skapade först tester från kraven och sen funktioner som uppfyllde testerna.
Är det krav på att vi ska validera det som kommer in kan vi förstås lägga till funktioner för det och fortsätta på samma sätt som vi gjort hittills.
Så lätt är TDD, kan kännas lite konstigt i början man har man väl vant sig vill man aldrig sluta.