Jasmine Framework Tutorial: Enhedstest med eksempel

⚡ Smart opsummering

Jasmine er den adfærdsdrevne JavaScripttestframework, der kører Node.js-enhedstests uden en browser eller DOM ved hjælp af describe-blokke. Det specificerer og forventer, at matchere verificerer, at alle eksporterede funktioner opfører sig som dokumenteret.

  • 🔘 Rammerolle: Jasmin tester enhver JavaScript uden browsere, DOM eller hjælpebiblioteker.
  • ☑️ Miljøopsætning: Installer modulet, kør jasmine init, og undersøg derefter spec/support/jasmine.json.
  • Specifikationsmønster: beskriv navnene på en suite, den definerer en specifikation, forvent at hævde resultatet.
  • 🧪 Matchere: toBe, toEqual, toContain, toThrow og toHaveBeenCalled dækker de fleste påstande.
  • 🛠️ Moderne løber: Den vedligeholdte jasmine-pakke erstatter det ikke-vedligeholdte jasmine-node-modul.
  • 📊 Valg af ramme: Jasmine sender påstande og spioner, mens Jest tilføjer parallelle løb og snapshots.

Jasmine framework-vejledning til enhedstestning af Node.js-applikationer

Hvad er JasmineJS?

Jasmine er en open source og mest populær JavaScript bibliotek testramme til at teste enhver form for JavaScript applikation. Jasmine følger Behavior Driven Development (BDD) procedure for at sikre, at hver linje af JavaScript-sætningen er korrekt enhedstestet.

Hvad bruges Jasmine Framework til?

Testning er et nøgleelement i enhver applikation. Til Node.js-enhedstestning hedder det tilgængelige framework til testning Jasmine. I begyndelsen af ​​2000 var der et framework til testning JavaScript applikationer kaldet JsUnit. Later denne ramme blev opgraderet og er nu kendt som Jasmine.

Jasmine hjælper med at automatisere Enhedstest, noget der er blevet en ret central praksis, når man udviklerping og implementering af moderne webapplikationer.

I denne Jasmine-tutorial lærer du, hvordan du får dit miljø opsætning med Jasmine, og hvordan du kører Jasmine-tests for din første Node.js-applikation.

Jasmine til test af Node.js-applikationer

Jasmine er en Adfærdsdrevet udvikling (BDD) testramme for JavaManuskript. Det gør den ikke stole på browsere, DOM eller andre JavaScript-framework. Derfor er det velegnet til hjemmesider, node.js projekter, eller andre steder, der JavaScript kan køre. For at begynde at bruge Jasmine skal du først downloade og installere de nødvendige Jasmine-moduler.

Sådan opsætter du Jasmine testmiljø

I denne Jasmine Node.js-tutorial skal du initialisere dit miljø og inspicere Jasmine-konfigurationsfilen. Trinene nedenfor viser, hvordan du konfigurerer Jasmine i dit miljø.

Trin 1) Installer NPM-moduler
Du er nødt til Installer NPM jasmine-modulet til at bruge Jasmine-frameworket fra en Node-applikation. For at installere jasmine-node-modulet skal du køre nedenstående kommando.

npm install jasmine-node

Versionsnotat (2026): den historiske kommando ovenfor virker stadig, men jasmin-knude Modulet er i vedligeholdelsestilstand og inkluderer Jasmine 1.3, så behold det kun til ældre projekter. Nyt Node.js-arbejde installerer det vedligeholdte Jasmin CLI som en dev-afhængighed og kalder den via npx:

npm install --save-dev jasmine
npx jasmine init

Jasmin 6.x er den nuværende hovedlinje og understøtter Node.js 20, 22 og 24, og Node.js 24 er den aktive LTS-udgivelse i 2026.

Trin 2) Initialiser jasminmiljøet
Initialisering af projektet – Ved at gøre dette opretter Jasmine en spec-mappe og konfigurations-json til dig. Spec-mappen bruges til at gemme alle dine testfiler. Ved at gøre dette vil Jasmine vide, hvor alle dine tests er, og derefter kan udføre dem i overensstemmelse hermed. JSON Filen bruges til at gemme specifikke konfigurationsoplysninger om Jasmine.

For at initialisere Jasmine-miljøet skal du køre nedenstående kommando

jasmine init

Trin 3) Undersøg din konfigurationsfil.
Konfigurationsfilen vil blive gemt i spec/support-mappen som jasmine.json. Denne fil opregner de kildefiler og spec-filer, du gerne vil have, at Jasmine runner skal inkludere.

Skærmbilledet nedenfor viser et typisk eksempel på jasmine.json-filen til Jasmine.

Jasmine-konfigurationsfilen i spec support-mappen, der viser spec-mappen og spec_files

  1. Bemærk, at spec-mappen er angivet her. Som nævnt tidligere, når jasmine kører, søger den efter alle tests i denne mappe.
  2. Den næste ting at bemærke er parameteren spec_files – Dette angiver, at uanset hvilke testfiler der oprettes, skal de tilføjes 'spec' nøgleordet.

Konfigurationsbemærkning: I Jasmine 6.x accepterer den samme fil også hjælpere, som indlæses én gang før hver specifikation, og en env blokholdingsindstillinger såsom tilfældig og stopSpecOnExpectationFailure. Standard spec_files glob er **/*[sS]pec.?(m)js, og en anden fil kan sendes med –konfiguration eller JASMINE_CONFIG_PATH variabel.

Næste i denne Jasmine framework tutorial vil vi lære, hvordan man bruger Jasmine til at teste Node.js applikationer.

Sådan bruger du Jasmine til at teste Node.js-applikationer

For at bruge Jasmine-enhedstest til Node.js-applikationer skal en række trin følges.

I vores eksempel nedenfor definerer vi et modul, der lægger 2 tal sammen, som skal testes. Vi definerer derefter en separat kodefil med testkoden og bruger Jasmine til at teste Add-funktionen i overensstemmelse hermed.

Trin 1) Definer den kode, der skal testes. Vi skal definere en funktion, som tilføjer 2 tal og returnerer resultatet. Denne kode vil blive skrevet i en fil kaldet "Add.js."

Skærmbilledet nedenfor viser det færdige Add.js-modul, og den samme kode gentages som tekst nedenunder.

Add.js-modul eksporterer AddNumber-funktionen, der returnerer summen af ​​to parametre

var exports=module.exports={};
exports.AddNumber=function(a,b)
{
return a+b;
};

Code Forklaring

  1. Nøgleordet "eksport" bruges til at sikre, at den funktionalitet, der er defineret i denne fil, faktisk kan tilgås af andre filer.
  2. Vi definerer derefter en funktion kaldet 'AddNumber'. Denne funktion er defineret til at tage 2 parametre, a og b. Funktionen tilføjes til modulet "eksporter" for at gøre funktionen til en offentlig funktion, der kan tilgås af andre applikationsmoduler.
  3. Vi får endelig vores funktion til at returnere parametrenes merværdi.

Trin 2) Dernæst skal vi definere vores Jasmine testkode, som skal bruges til at teste vores "Add"-funktion i Add.js-filen. Nedenstående kode skal placeres i en fil kaldet add-spec.js.

BemærkOrdet 'spec' skal tilføjes til testfilen, så det kan detekteres af Jasmine.

Skærmbilledet nedenfor viser den samme specifikationsfil åben i et editor.

add-spec.js-filen med en describe-suite og en it-specifikation, der hævder AddNumber, returnerer 11

var app=require("../Add.js");
describe("Addition",function(){
it("The function should add 2 numbers",function() {
var value=app.AddNumber(5,6);
expect(value).toBe(11);
});
});

Code Forklaring

  1. Vi skal først inkludere vores Add.js-fil, så vi kan teste funktionen 'AddNumber' i denne fil.
  2. Vi er nu ved at lave vores testmodul. Første del af testmodulet er at beskrive en metode, som grundlæggende giver et navn til vores test. I dette tilfælde er navnet på vores test "Addition".
  3. Den næste bit er at give en beskrivelse af vores test ved hjælp af 'it'-metoden.
  4. Vi kalder nu vores AddNumber-metode og sender 2 parametre ind, 5 og 6. Dette vil blive sendt til vores AddNumber-metode i Add.js-filen. Returværdien gemmes derefter i en variabel kaldet værdi.
  5. Det sidste trin er at udføre sammenligningen eller vores faktiske test. Da vi forventer, at værdien returneret af AddNumber-funktionen er 11, definerer vi dette ved hjælp af metoden expect(value).toBe(den forventede værdi).

Produktion

  1. For at køre testen skal man køre kommandoen jasmine.
  2. Skærmbilledet nedenfor viser, at efter at jasmine-kommandoen er kørt, vil den registrere, at der er en test kaldet add-spec.js, og udføre testen i overensstemmelse hermed. Hvis der er fejl i testen, vil det blive vist i overensstemmelse hermed.

Konsoloutput fra jasmine-kommandoen, der rapporterer den udførte add-spec-test

Eksemplet "Add" bruger en enkelt matcher, men Jasmine leverer et komplet sæt af dem. Tabellen nedenfor viser dem, der dækker næsten alle de påstande, du vil skrive.

Jasmin-tændstikkere, du vil bruge mest

En matcher er den sammenligning, der følger expect(). Kæd .not før nogen matcher for at invertere den, som i expect(value).not.toBe(11).

matchere Hvad den kontrollerer Typisk brug
at være Streng identitet, samme sammenligning som === forventer(værdi).atVære(11)
til Lige Dyb lighed mellem objekter og arrays forventer(bruger).tillig({id: 1})
at indeholde Medlemskab i et array eller en streng forventer(filer).toContain('add-spec.js')
skal defineres Værdien er ikke udefineret expect(app.TilføjNummer).toBeDefined()
at kaste Den indpakkede funktion giver en fejl forventer(callAdd).toThrow()
at være blevet kaldt En spion blev tilkaldt mindst én gang forventer(logger.write).atHaveBlivetKaldt()

To vaner holder fejl læsbare. Brug kun toBe til primitiver og identiske referencer, fordi to objekter med samme indhold aldrig er ===. Brug toEqual til strukturer, og tilføj toHaveBeenCalledWith, når argumenterne er lige så vigtige som selve kaldet.

Opsætning, nedtagning og spioner i Jasmine

Ægte suiter kræver delt tilstand og dobbeltværelser for langsomme samarbejdspartnere. Jasmine leverer begge uden ekstra pakker.

  • førHver og efterHver kør før og efter hver specifikation i en beskrivelsesblok, hvilket er det naturlige sted at genopbygge inventar.
  • før alt og efter alt kør én gang for hele blokken, så reserver dem til dyrt arbejde såsom at åbne en forbindelse.
  • spyOn(objekt, 'metode') erstatter en reel metode med en tracking double; tilføj .and.returnValue() for at kontrollere, hvad den svarer.
  • jasmin.createSpy('navn') opbygger en selvstændig double til et callback, der ikke har noget objekt at tilknytte til.
  • Asynkrone specifikationer kan erklæres asynkron og afventes, kan returnere et løfte eller kan acceptere et udført tilbagekald, der skal kaldes præcis én gang.

Spioner nulstilles mellem specifikationer, så en suite lækker aldrig en stubbet metode til den næste test. Denne isolering er det, der får en fejlende specifikation til at pege på én defekt i stedet for en kæde af dem, hvilket er den samme disciplin beskrevet i enhedstest grundlæggende.

Jasmin vs Mocha vs Jest

Jasmine er et af tre frameworks, der dominerer JavaScripttestning, og valget kommer normalt ned til, hvor meget ledningsføring du vil eje.

Aspect Jasmine mokka der er
påstande Bygget i Tilsat, normalt Chai Bygget i
Spioner og spottere Bygget i Tilføjet, normalt Sinon Bygget i
Udførelse Seriel Seriel Parallelle på tværs af processer
Snapshots Ingen Ingen Ja
Fælles hjem Angular, almindelig Node.js Fleksible Node.js-stakke React og moderne bundlere

Pick mokka når du vil sammensætte din egen påstands- og spottende stak, og der er Når parallelle løb, dækning og snapshots betyder mere end konfigurationskontrol, er Jasmine stadig den letteste løsning, der stadig leveres komplet, hvilket er grunden til, at den forbliver almindelig i automatiseringstest suiter.

Ofte Stillede Spørgsmål

Jasmine læser spec_dir som et præfiks, derefter alle globs, der er angivet i spec_files, så kun matchende filer kører. Stier, der starter med et udråbstegn, er udelukket, og hjælpere indlæses én gang før specs for at registrere delt opsætning.

Erklær specifikationen async og afvent kaldet, returner et løfte eller accepter et færdigt tilbagekald. asynkron guide advarer om, at done skal udløses præcis én gang, ellers lander fejl på den forkerte specifikation.

Før en sti eller glob efter løberen, for eksempel npx jasmine spec/appSpec.js. –filter-flaget accepterer et mønster, der matcher navnet `describe`, hvilket holder feedbacken hurtig, mens du arbejder på en enkelt suite.

jasmin-knude Pakken er i vedligeholdelsestilstand, indeholder stadig Jasmine 1.3 og viser Node.js 10 og 12 som aktuelle. Den officielle jasmine-pakke tracks frameworket og understøttede Node.js-udgivelser i stedet.

Sæt præfikset x til en spec, som i xit eller xdescribe, og Jasmine rapporterer den som ventende. Sæt præfikset f til den, som i fit eller fdescribe, og kun de fokuserede specs kører. Fjern begge præfikser før commit.

AI-assistenter udarbejder beskrivelser af blokke, matchere og edge cases fra et eksisterende modul på få sekunder, og de markerer suiter, der fejler periodisk. Hver genereret specifikation skal stadig gennemgås, fordi en sikker påstand om forkert adfærd skjuler fejlen.

GitHub Copilot fuldfører specifikationsteksterne, mens du skriver, og dens agenttilstand kan åbne en pull request, der reparerer defekte specifikationer efter en refactoring. Behandl diff'en som et forslag, og kør pakken selv.

Angular still stilladser Jasmine specifikationer, og omtracTor brugte Jasmine som standardframework, før det blev arkiveret. Teams parrer nu Jasmine med Karma til browsere eller flytter browserflows til Cypress og Dramatiker.

Opsummer dette indlæg med: