Wat is die eenheid toets?

https://stackoverflow.com/questions/1383

08-06-2019
|

Vra

Ek het baie vrae vra " hoe "om eenheid te toets in'n spesifieke taal, maar daar is geen vraag te vra "wat", "waarom", en "toe".

Wat is dit?
Wat beteken dit vir my doen?
Hoekom moet ek dit gebruik?
Wanneer moet ek dit gebruik (ook wanneer nie)?
Wat is'n paar algemene slaggate en wanopvattings

Oplossing

Eenheid toets is, rofweg gesproke, die toets van stukkies van jou kode in isolasie met die toets-kode.Die onmiddellike voordele wat kom na gedagte is:

Die bestuur van die toetse word outomatiseer-staat en herhaal
Jy kan dit toets op'n veel meer gedetailleerde vlak as punt-en-kliek die toets via'n GUI

Let daarop dat indien jou toets skryf kode om'n lêer, maak'n databasis konneksie of doen iets oor die netwerk, dit is meer gepas geklassifiseer as'n integrasie toets.Integrasie toetse is'n goeie ding, maar moet nie verwar word met die eenheid toetse.Eenheid toets-kode moet kort wees, soet en vinnig uit te voer.

Nog'n manier om te kyk na eenheid toets is dat jy skryf die toetse eerste.Dit is bekend as Toets-Gedrewe Ontwikkeling (TDD vir kort).TDD bring bykomende voordele:

Jy hoef nie te skryf spekulatiewe "ek moet dalk hierdie in die toekoms" kode-net genoeg om die toetse te slaag
Die kode wat jy geskryf het is altyd gedek deur toetse
Deur die skryf van die toets die eerste keer, is jy gedwing om te dink oor hoe jy wil om te bel die kode, wat gewoonlik die verbetering van die ontwerp van die kode in die lang termyn.

As jy nie doen eenheid toets nou, ek beveel aan jy begin op dit.Kry'n goeie boek, feitlik enige xUnit-boek sal doen, want die konsepte is baie oordraagbaar tussen hulle.

Soms skryf eenheid toetse kan pynlik wees.Wanneer dit dat die pad, probeer om iemand te vind om jou te help, en die versoeking weerstaan om te "skryf net die damn kode".Eenheid toets is'n baie soos die was van die skottelgoed.Dit is nie altyd aangenaam nie, maar dit hou jou metaforiese kombuis skoon te maak, en jy regtig wil om dit te wees skoon te maak.:)

Edit:Een misverstand kom na vore, maar ek is nie seker of dit is so algemeen.Ek het gehoor'n projek bestuurder sê dat die eenheid toetse het die span skryf al die kode twee keer.As dit lyk en voel dat die pad, goed, jy doen dit verkeerd.Nie net het die skryf van die toetse gewoonlik die bespoediging van die ontwikkeling, maar dit gee jou ook'n gerieflike "nou is ek klaar" aanduiding dat jy sou nie andersins.

Ander wenke

Ek het nie eens nie met Dan (hoewel'n beter keuse kan net wees om nie te antwoord nie)...maar...

Eenheid toets is die proses van die skryf kode om die toets van die gedrag en funksionaliteit van jou stelsel.

Dit is duidelik dat toetse die verbetering van die gehalte van jou kode, maar dit is net'n oppervlakkige voordeel van die eenheid toets.Die werklike voordele is:

Maak dit makliker om te verander die tegniese implementering terwyl om seker te maak jy nie die gedrag te verander (refactoring).Behoorlik eenheid getoets kode kan aggressief wees refactored/skoongemaak met min kans om iets te breek sonder om dit te merk.
Gee ontwikkelaars vertroue wanneer die toevoeging van gedrag of die maak van verbeterings.
Dokument jou kode
Dui die gebiede van die kode wat is dig tesame.Dit is moeilik om eenheid toets-kode wat dig tesame
Verskaf'n middel om te gebruik om jou API en kyk vir probleme vroeg op
Dui metodes en klasse wat nie baie samehangende

Jy moet eenheid toets want dit is in jou belang om te lewer'n onderhoubare en kwaliteit van die produk aan jou kliënt.

Ek stel voor jy gebruik dit vir enige stelsel, of'n deel van'n stelsel, wat modelle in die werklike wêreld gedrag.In ander woorde, dit is besonder goed geskik is vir die onderneming se ontwikkeling.Ek sou nie dit gebruik vir die gooi-weg/nut programme.Ek sou nie dit gebruik vir dele van'n stelsel wat is problematies om te toets (UI is'n algemene voorbeeld, maar dit is nie altyd die geval)

Die grootste slaggat is dat ontwikkelaars toets te groot'n eenheid, of hulle beskou as'n metode om'n eenheid.Dit is veral waar as jy nie verstaan nie Omkering van Beheer - in welke geval jou eenheid toetse sal altyd draai in'n end-tot-end integrasie toets.Eenheid toets, moet die toets van individuele gedrag - en die meeste metodes het baie gedrag.

Die grootste wanopvatting is dat programmeerders nie moet toets.Net slegte of lui programmeerders glo dat.Moet die man die bou van jou dak nie toets dit?Moet die dokter die vervanging van'n hart klep nie die toets van die nuwe valve?Net'n programmeerder kan toets wat sy kode doen wat hy bedoel het om dit te doen (QA kan toets rand gevalle - hoe kode optree wanneer dit is gesê om dinge te doen op die programmeerder het nie van plan is, en die kliënt kan doen aanvaarding toets - nie die kode te doen wat die kliënt betaal vir dit om te doen)

Die belangrikste verskil van die eenheid toets, in teenstelling met "net die opening van'n nuwe projek en die toets van hierdie spesifieke kode" is dat dit is outomatiese, so herhaal.

As jy toets jou kode met die hand, dit kan jy oortuig dat die kode is perfek werk - in sy huidige toestand.Maar wat oor'n week later, wanneer jy'n effense verandering in dit?Is jy bereid om te hertoets dit weer deur die hand wanneer enigiets veranderinge in die kode?Die meeste waarskynlik nie :-(

Maar as jy kan hardloop jou toetse enige tyd, met'n enkele kliek, presies dieselfde manier, binne'n paar sekondes, dan sal hulle sal wys jy dadelik wanneer iets is gebreek.En as jy ook integreer die eenheid toetse in jou outomatiese bou proses, sal hulle bewus te maak van foute, selfs in gevalle waar'n skynbaar heeltemal niks verander het iets in'n afgeleë deel van die kodebasis - wanneer dit sou nie selfs voorkom jy dat daar is'n behoefte om te hertoets daardie spesifieke funksies.

Dit is die grootste voordeel van die eenheid toetse oor die hand van die toets.Maar wag, daar is meer:

eenheid toetse verkort die ontwikkeling terugvoer lus dramaties:met'n afsonderlike toets departement dit kan weke neem vir jou om te weet dat daar is'n fout in jou kode, wat deur die tyd wat jy het al vergeet veel van die konteks, dus kan dit neem ure om te vind en op te los die fout;OTOH met eenheid toetse, die terugvoer siklus word gemeet in sekondes, en die fout fix proses is tipies langs die lyne van'n "o sh*t, ek het vergeet om te kyk vir dat die toestand hier" :-)
eenheid toetse effektief dokument (jou begrip van) die gedrag van jou kode
eenheid toets magte om jou te herevalueer jou ontwerp keuses, wat die resultate in eenvoudiger, skoner ontwerp

Eenheid toets raamwerke, op sy beurt, maak dit maklik vir jou om te skryf en hardloop jou toetse.

Ek was nog nooit geleer eenheid toets aan die universiteit, en dit het my'n rukkie om te "kry" dit.Ek lees oor dit, het "ag, reg, outomatiese toets, wat kan cool wees ek dink", en dan het ek vergeet dit.

Dit het nogal'n bietjie langer voor ek regtig gedink die punt:Kom ons sê jy werk op'n groot stelsel en jy skryf'n klein module.Dit stel, jy sit dit deur middel van sy treë, dit werk baie goed, jy beweeg op na die volgende taak.Nege maande af die lyn en die twee weergawes later iemand anders maak'n verandering na'n paar skynbaar onverwante deel van die program, en dit breek die module.Erger nog, hulle toets hul veranderinge, en hul kode werk, maar hulle het nie die toets van jou module;hel, hulle kan nie eens weet wat jou module bestaan.

En nou het jy het'n probleem:gebreekte kode is in die stam en niemand, selfs nie weet nie.Die beste geval is'n interne tester vind dit voordat jy die skip, maar die vasstelling van die kode wat laat in die spel is duur.En as daar geen interne tester vind dit...wel, dit kan baie duur inderdaad.

Die oplossing is eenheid toetse.Hulle sal vang probleme wanneer jy skryf kode - wat is goed - maar jy kon gedoen het wat deur die hand.Die werklike beloning is dat hulle sal vang probleme nege maande af in die lyn wanneer jy nou werk op'n heeltemal ander projek, maar'n somer intern dink dit sal kyk tidier as diegene parameters is in alfabetiese volgorde - en dan die eenheid toets wat jy het die pad terug nie, en iemand gooi dinge by die intern totdat hy verander die parameter om terug. Dit is die "hoekom" van die eenheid toetse.:-)

Afsplintering in op die filosofiese voordele van eenheid toets en TDD hier is'n paar van hulle het die sleutel "gloeilamp" waarnemings wat my opgeval het op my tentatiewe eerste stappe op die pad na TDD verligting (geen oorspronklike of noodwendig nuus)...

TDD beteken NIE dat die skryf van twee keer die bedrag van die kode.Toets-kode is gewoonlik redelik vinnig en pynloos te skryf en is'n belangrike deel van jou ontwerp-proses en krities.
TDD help jou om te besef wanneer om te stop kodering!Jou toetse gee jou die vertroue wat jy gedoen het genoeg vir nou en kan stop die opstel en skuif op na die volgende ding.
Die toetse en die kode saam te werk om te bereik beter kode.Jou kode kan wees slegte / buggy.Jou TOETS kan sleg wees / buggy.In TDD jy is die bank op die kanse van BEIDE die feit dat slegte / karretjie om redelik laag.Dikwels sy die toets wat bevestiging nodig het, maar dit is nog steeds'n goeie uitkoms.
TDD help met die kodering hardlywigheid.Jy weet dat die gevoel dat jy het so baie om te doen wat jy skaars weet waar om te begin?Dit is vrydag middag, as jy net uitstel vir'n paar meer ure...TDD kan jy na die vlees uit baie vinnig wat jy dink jy nodig het om te doen, en kry jou kodering beweeg vinnig.Ook, soos laboratorium rotte, ek dink ons almal reageer op wat groot groen lig en harder werk om dit weer te sien!
In'n soortgelyke trant, hierdie ontwerper tipes kan SIEN wat hulle besig is op.Hulle kan dwaal af vir'n sap / sigaret / iphone breek en terug te keer na'n monitor wat onmiddellik gee hulle'n visuele cue as waar hulle gekry het.TDD gee ons iets soortgelyk.Dit is makliker om te sien waar ons het om te wanneer die lewe ingryp...
Ek dink dit was Fowler wat gesê het:"Onvolmaakte toetse, loop gereeld, is baie beter as die perfekte toetse wat nog nooit geskryf op alle".Ek interprete dit as die gee my toestemming om toetse te skryf waar ek dink hulle sal wees meeste nuttig, selfs as die res van my kode dekking is hopeloos onvolledig.
TDD help in alle vorme van die verrassende maniere af in die lyn.Goeie eenheid toetse kan help dokument iets wat veronderstel is om te doen, hulle kan jou help om migreer kode van die een projek na die ander en gee jou'n ongegrond gevoel van superioriteit oor jou nie-toetsing kollegas :)

Hierdie aanbieding is'n uitstekende bekendstelling aan al die lekker goedheid toets behels.

Ek wil graag aan te beveel die xUnit Toets Patrone boek deur Gerard Meszaros. Dit is groot, maar is 'n groot bron van eenheid toets. Hier is 'n skakel na sy webwerf waar hy bespreek die basiese beginsels van eenheid toets. http://xunitpatterns.com/XUnitBasics.html

Ek gebruik eenheid toetse om tyd te bespaar.

Wanneer die bou van besigheid logika (of toegang data) toets funksie kan dikwels betrek tik dinge in 'n baie skerms wat mag of nie mag nie nog klaar. Outomatisering hierdie toetse spaar tyd.

Vir my eenheid toetse is 'n soort van modulêre toets tuig. Daar is gewoonlik ten minste een toets per openbare funksie. Ek skryf bykomende toetse om verskillende gedrag te dek.

Al die spesiale gevalle wat jy gedink het van wanneer die ontwikkeling van die kode kan aangeteken word in die kode in die eenheid toetse. Die eenheid toetse ook 'n bron van voorbeelde oor hoe om die kode te gebruik word.

Dit is 'n baie vinniger vir my om te ontdek dat my nuwe kode breek iets in my eenheid toetse dan gaan in die kode en het 'n paar front-end ontwikkelaar vind 'n probleem.

Vir toegang tot die inligting te toets probeer ek om toetse wat óf het geen verandering skryf of skoon te maak na hulself.

Eenheid toetse gaan nie in staat wees om al die toets vereistes te los. Hulle sal in staat wees om die ontwikkeling tyd en toets kern dele van die aansoek te red.

Dit is my neem op dit. Ek sou sê eenheid toets is die praktyk van die skryf van programmatuur toetse om te bevestig dat jou regte sagteware doen wat dit veronderstel is om te. Dit begin met Junit in die Java wêreld en het 'n beste praktyk in PHP sowel met SimpleTest en phpUnit . Dit is 'n kern praktyk van Extreme Programming en help jou om seker te wees dat jou sagteware nog werk soos bedoel na redigering. As jy genoeg toets dekking, kan jy groot refactoring, oplossing van bugs doen of funksies by te voeg vinnig met baie minder vrees vir die bekendstelling van ander probleme.

Dit is die mees doeltreffende wanneer al eenheid toetse outomaties kan gebruik word.

Eenheid toets is oor die algemeen verband hou met OO ontwikkeling. Die basiese idee is om 'n script wat stel die omgewing vir jou kode en dan oefen dit skep; jy bewerings skryf, spesifiseer die beoogde produksie wat jy moet kry en dan uit te voer jou toets script met behulp van 'n raamwerk soos dié hierbo genoem.

Die raamwerk sal al die toetse teen jou kode uit te voer en dan terug te rapporteer sukses of mislukking van elke toets. phpUnit is vanaf die Linux command line by verstek, maar daar is HTTP koppelvlakke beskikbaar vir dit. SimpleTest is web-gebaseerde deur die natuur en is baie makliker om aan die gang te kry, IMO. In kombinasie met xDebug, kan phpUnit jy outomatiese statistieke vir kode dekking wat sommige mense vind baie nuttig gee.

Sommige spanne skryf hakies uit hul ondermyning repository sodat eenheid toetse uit te voer outomaties wanneer jy veranderinge te pleeg.

Dit is goeie praktyk om jou eenheid toetse in dieselfde bron as jou aansoek te hou.

biblioteke soos NUnit , xUnit of JUnit is net verpligtend as jy wil om jou projekte te ontwikkel met behulp van die TDD benadering gewild gemaak deur Kent Beck :

Jy kan lees Inleiding te toets Gedryf Ontwikkeling (TDD) of boek Kent Beck se toets Driven Ontwikkeling: Deur Voorbeeld .

Dan, as jy wil om seker te wees jou toetse dek 'n "goeie" deel van jou kode, jy kan sagteware gebruik soos NCover , JCover , PartCover of wat ook al. Hulle sal jou vertel die dekking persentasie van jou kode. Afhangende van hoeveel jy bedrewe is by TDD, sal jy weet as jy dit het geoefen goed genoeg:)

Eenheid-toets is die toets van 'n eenheid van die kode (bv 'n enkele funksie) sonder die noodsaaklikheid vir die infrastruktuur wat daardie eenheid van kode staatmaak op. maw toets dit in isolasie.

As, byvoorbeeld, die funksie waar jy kontak kan jy die toets van 'n databasis en doen 'n update, in 'n eenheid toets jy dalk nie wil hê dat die werk te doen. Jy sou as 't ware 'n integrasie toets, maar in hierdie geval is dit nie.

So 'n eenheid toets die funksies ingesluit in die "funksie" sou uitoefen jy toets sonder newe-effekte van die databasis update.

Sê jou funksie opgespoor sommige nommers van 'n databasis en dan uitgevoer word 'n standaardafwyking berekening. Wat probeer jy hier te toets? Dat die standaardafwyking korrek of dat die data is terug van die databasis? Bereken

In 'n eenheid toets net wil hê jy moet toets wat die standaardafwyking korrek bereken. In 'n integrasie toets wil hê jy moet die standaardafwyking berekening en die databasis herwinning te toets.

Eenheid toets is oor die skryf van kode wat jou aansoek code toets.

Die Eenheid deel van die naam is van die voorneme om klein eenhede van kode (een metode byvoorbeeld) op 'n slag te toets.

xUnit is daar om jou te help met hierdie toets - hulle is raamwerke wat help met hierdie. Deel van wat outomatiese toets hardlopers wat jy vertel wat toets misluk en watter slaag.

Hulle het ook fasiliteite vir die opstel van gemeenskaplike kode wat jy nodig het in elke toets voor die hand en skeur dit af wanneer alle toetse voltooi.

Jy kan 'n toets te hê om seker te maak dat 'n verwagte uitsondering is gegooi, sonder om te skryf die hele probeer vang blok jouself.

Ek dink die punt wat jy nie verstaan nie, is dat die eenheid toets raamwerke soos NUnit (en dies meer) sal help om in outomatisering klein tot medium-grootte toetse.Gewoonlik kan jy begin die toetse in'n GUI (dit is die geval met NUnit, byvoorbeeld) deur te kliek op'n knoppie en dan - hopelik - sien die vordering bar bly groen.As dit blyk rooi, die raamwerk wys jou wat die toets misluk en wat presies verkeerd geloop het.In'n normale eenheid toets, jy dikwels gebruik bewerings, bv. Assert.AreEqual(expectedValue, actualValue, "some description") - so, as die twee waardes is ongelyke, sal jy sien'n fout te sê "sommige beskrywing:verwag <expectedValue> maar was <actualValue>".

So'n gevolgtrekking eenheid toets, sal die toets vinniger en'n baie meer gemaklik vir ontwikkelaars.Jy kan loop al die eenheid toetse voor die pleeg van'n nuwe kode, sodat jy nie breek die bou proses van ander ontwikkelaars op dieselfde projek.

Testivus . Al wat jy hoef te weet is reg daar:)

Eenheid toets is 'n praktyk om seker te maak dat die funksie of module wat jy gaan implementeer gaan om op te tree as verwag (vereistes) en ook om seker te maak hoe dit optree in scenario's soos randvoorwaardes, en ongeldig insette.

xUnit , NUnit , mbUnit , ens is gereedskap wat help jy in die skryf van die toetse.

Toets Driven Ontwikkeling het soort van geneem oor die termyn Eenheid Toets. As 'n ou timer sal ek die meer generiese definisie van dit noem.

Eenheid Toets beteken ook die toets van 'n enkele komponent in 'n groter stelsel. Hierdie enkele komponent kan 'n dll, exe, klas biblioteek, ens Dit kan selfs 'n enkele stelsel in 'n multi-stelsel aansoek wees. So uiteindelik eindig Eenheid Toets up synde die toets van wat jy wil om 'n enkele stuk van 'n groter stelsel noem.

Jy sal dan beweeg om geïntegreerde of stelsel toets deur die toets van hoe al die komponente saam te werk.

In die eerste plek, of praat oor Eenheid toets of enige ander vorme van outomatiese toets (integrasie, load, UI toets ens), die belangrikste verskil van wat jy voorstel is dat dit outomatiese, herhaalbare en dit vereis nie enige menslike hulpbronne te verteer (= niemand het om die toetse uit te voer, is hulle gewoonlik loop op 'n druk van 'n knoppie).

Ek het na 'n aanbieding oor eenheid toets teen FoxForward 2007 en is nooit aan eenheid toets iets wat werk met data. Na alles, as jy toets op live data, die resultate is onvoorspelbaar, en as jy nie toets op live data, is jy nie eintlik die toets van die kode wat jy geskryf het. Ongelukkig, dit is die grootste deel van die kodering Ek doen deesdae. : -)

Ek het wel 'n kans op TDD onlangs toe ek skryf van 'n roetine te red en te herstel instellings. In die eerste plek het ek bewys dat ek die stoor voorwerp kon skep. Dan, wat dit moes die metode wat ek nodig het om te bel. Dan, dat ek kan dit noem. Dan, dat ek kan slaag dit parameters. Dan, dat ek kan dit slaag spesifieke parameters. En so aan, totdat ek uiteindelik bevestig dat dit die gespesifiseerde instelling sal red, laat my toe om dit te verander, en dan herstel, vir 'n paar verskillende syntaxes.

Ek het nie aan die einde, want ek nodig het-die-roetine-nou-dammit, maar dit was 'n goeie oefening.

Wat doen jy as jy kry 'n hopie kak en lyk soos jy is vas in 'n ewige toestand van opruim dat jy weet met die toevoeging van 'n nuwe funksie of kode kan die huidige stel breek omdat die huidige sagteware is soos 'n huis van kaarte?

Hoe kan ons dit doen eenheid toets dan?

Jy begin klein. Die projek het ek net in geen eenheid toets tot 'n paar maande gelede. Wanneer dekking was dat 'n lae, sou ons net 'n lêer wat geen dekking gehad optel en klik "toetse voeg".

Op die oomblik is ons tot meer as 40%, en ons het daarin geslaag om die meeste van die lae-hangende vrugte af te haal.

(Die beste deel is dat selfs by hierdie lae vlak van dekking, het ons reeds loop in baie gevalle van die kode te doen die verkeerde ding, en die toets gevang het. Dit is 'n groot motiveerder om mense te stoot om meer toetsing voeg .)

Dit antwoord waarom jy moet doen eenheid toets.

Die 3 video's hieronder dekking eenheid toets in javascript maar die algemene beginsels van toepassing in die meeste tale.

Eenheid Toets: Minute nou Later Slaan Ure - Eric Mann - https://www.youtube com / kyk? v = _UmmaPe8Bzc

JS Eenheid Toets (baie goed) - https://www.youtube.com/watch ? v = -IYqgx8JxlU

Die skryf Toetsbare JavaScript - https://www.youtube.com/watch?v=OzjogCFO4Zo

Nou is ek net te leer oor die onderwerp so kan ek nie 100% korrek wees en daar is meer as net dit wat ek hier beskryf, maar my basiese begrip van eenheid toets is dat jy 'n paar toets-kode skryf (wat gehou word apart van jou hoof-kode) wat 'n funksie oproepe in jou kop kode met insette (argumente) wat die funksie vereis en die kode tjeks dan as dit kry terug 'n geldige terugkeer waarde. As dit terug te kry 'n geldige waarde van die eenheid toets raamwerk wat jy gebruik om die toetse uit te voer toon 'n groen lig (al goed) as die waarde is ongeldig jy 'n rooi lig en jy kan dan die probleem dadelik voor jy los vrylating van die nuwe kode vir produksie, sonder toets kan jy eintlik nie die fout gevang het.

Jy toetse vir jou huidige kode te skryf en skep die kode sodat dit verby die toets. Maande later jy of iemand anders nodig om die funksie in jou kop kode verander, want vroeër jy reeds geskrewe toets-kode vir die funksie wat jy nou weer uit te voer en die toets kan misluk omdat die kodeerder het 'n logika fout in die funksie of iets heeltemal terug anders as wat daardie funksie is veronderstel om terug te keer. Weer sonder die toets in plek wat fout kan moeilik wees om op te spoor as dit moontlik kan beïnvloed ander kode so goed en sal ongesiens.

Ook die feit dat jy 'n rekenaar program wat deur jou kode en toetse dit loop in plaas van jy dit met die hand te doen in die leser per bladsy spaar tyd (toets eenheid vir JavaScript). Kom ons sê dat jy 'n funksie wat gebruik word deur sommige script op 'n webblad te verander en dit werk alles goed en wel vir sy nuwe doel. Maar, laat ons ook sê vir argumente ter wille dat daar 'n ander funksie wat jy het iewers anders in jou kode wat afhanklik is van wat nuut verander funksie vir dit om behoorlik te werk. Dit hang funksie kan nou ophou werk as gevolg van die veranderinge wat jy gemaak het om die eerste funksie, egter sonder toetse in plek wat outomaties word gelei deur jou rekenaar sal jy nie agterkom dat daar 'n probleem met daardie funksie totdat dit eintlik uitgevoer word en jy sal hê om met die hand te navigeer na 'n webblad wat die script wat die afhanklike funksie uitvoer sluit, slegs dan sien jy dat daar 'n fout as gevolg van die verandering wat jy gemaak om die eerste funksie.

Om te herhaal, met toetse wat uitgevoer word terwyl die ontwikkeling van jou aansoek sal hierdie soort probleme te vang as jy kodering. Nie met die toetse in plek wat jy wil hê om met die hand te gaan deur jou hele aansoek en selfs dan kan dit moeilik wees om die fout raak te sien, is dit naïef stuur julle in produksie en na 'n ruk 'n soort gebruiker stuur jy 'n fout verslag (wat sal nie so goed soos jou fout boodskappe in 'n toets raamwerk) wees.

Dit is nogal verwarrend wanneer jy die eerste keer hoor van die onderwerp en jy dink aan jouself, ek nie reeds die toets van my kode? En die kode wat jy geskryf het werk soos dit veronderstel is om reeds, "hoekom moet ek nog 'n raamwerk nodig?" ... Ja, jy is reeds jou kode te toets, maar 'n rekenaar is beter by om dit te doen. Jy hoef net te goed genoeg toetse keer skryf vir 'n funksie / eenheid van kode en die res is versorg vir julle deur die magtige cpu in plaas van jou having met die hand te maak seker dat al jou kode is steeds besig wanneer jy 'n verandering aan jou kode te maak.

Ook, het jy nie hoef te eenheid toets jou kode as jy nie wil maar dit betaal af as jou projek / code base begin om groter as die kans van die bekendstelling van foute verhoog groei.

Eenheid-toetsing en TDD in die algemeen in staat stel om korter terugvoer siklusse oor die sagteware wat jy skryf het. In plaas daarvan om 'n groot toets fase aan die einde van die implementering, jy geleidelik toets alles wat jy skryf. Dit verhoog kode gehalte very much, as jy dadelik sien, waar jy foute kan hê.

Gelisensieer onder: CC-BY-SA met toeskrywing

Nie verbonde aan StackOverflow