Node.js & Best Practices voor het testen van JavaScript (2019)

Belangrijke opmerking: dit artikel werd een GitHub-repository met 15 extra best practices en community-discussies

Korte introductie

Als onafhankelijk Node.js-consultant ben ik betrokken en bekijk ik elk jaar meer dan 10 projecten en vragen mijn klanten terecht om zich te concentreren op testen. Een paar maanden geleden begon ik hier de inzichten en herhalende fouten die ik in het veld constateer te documenteren en plotseling stapelde het zich op in 30 testbest practices.

De onderstaande ideeën omvatten onderwerpen als het kiezen van de juiste testtypen, ze correct coderen, hun effectiviteit meten en ze op de juiste manier in een CI / CD-pijplijn hosten. Sommige voorbeelden worden geïllustreerd met Jest, anderen met Mocha - dit bericht gaat minder over tooling en meer over de juiste aanpak en technieken.

Mijn naam is Yoni Goldberg, een onafhankelijke Node.JS-consultant en de co-auteur van Node.js best practices. Ik werk met klanten in de VS, Europa en Israël bij het polijsten van hun Node.js-applicaties. Tot mijn dienst behoren ook testplanning, testreview en CI / CD-instellingen. Volg mij op Twitter ️

Beoordeeld en verbeterd door Bruno Scheufler

️ 0. De gouden regel: testen moet dood blijven - eenvoudig en helder als dag

Ben je bekend met die smileyvriend, familielid of misschien een filmpersonage die altijd beschikbaar is om zijn goed werkende handen te sparen, 24/7 assisteren wanneer je hem nodig hebt afgestemd met positieve energie en toch zo weinig voor zichzelf vraagt? Zo moet een testcode worden ontworpen - eenvoudig, waardevol en leuk. Dit kan worden bereikt door selectief cherry-picking-technieken, tools en testdoelen die kosteneffectief zijn en een geweldige ROI bieden. Test alleen zoveel als nodig is, probeer het behendig te houden, soms is het zelfs de moeite waard om enkele tests te laten vallen en handel betrouwbaarheid voor behendigheid en eenvoud.

Testen moet niet worden behandeld als een traditionele applicatiecode - een typisch team wordt toch uitgedaagd om de hoofdapplicatie te behouden (de functies die we coderen en verkopen), het kon geen extra complex "project" verdragen. Mocht testen een extra bron van pijn worden, dan wordt het verlaten of vertraagt ​​het de ontwikkeling aanzienlijk.

In die zin moet de testcode doodsimpel blijven, met minimale afhankelijkheden, abstracties en niveaus van indirection. Men moet naar een test kijken en meteen de intentie krijgen. De meeste adviezen hieronder zijn derivaten van dit principe

*** Sectie : De testanatomie ***

️ 1. Neem 3 delen op in elke testnaam

Doe: een testrapport moet uitwijzen of de huidige revisie van de toepassing voldoet aan de vereisten voor de mensen die niet noodzakelijk bekend zijn met de code: de tester, de DevOps-ingenieur die werkt en de toekomst u over twee jaar. Dit kan het beste worden bereikt als de tests op het vereiste niveau spreken en 3 delen omvatten:

(1) Wat wordt getest? Bijvoorbeeld de methode ProductsService.addNewProduct

(2) Onder welke omstandigheden en scenario? Er wordt bijvoorbeeld geen prijs doorgegeven aan de methode

(3) Wat is het verwachte resultaat? Het nieuwe product is bijvoorbeeld niet goedgekeurd

Anders: een implementatie is net mislukt, een test met de naam "Product toevoegen" is mislukt. Vertelt dit u wat precies defect is?

Doing It Right Voorbeeld: een testnaam die uit 3 delen bestaat

️☺ Doing It Right Voorbeeld: het testrapport lijkt op het document met vereisten

Neem in elke testcase 3 delen op, spreek de producttaal

️ 2. Beschrijf verwachtingen in een producttaal: gebruik BDD-achtige beweringen

Doe: door uw tests in declaratieve stijl te coderen, kan de lezer meteen de grijper pakken zonder zelfs maar een enkele hersen-CPU-cyclus uit te geven. Wanneer u een imperatieve code schrijft die vol zit met voorwaardelijke logica, wordt de lezer weggegooid in een moeizame mentale stemming. In die zin, codeer de verwachting in een mensachtige taal, declaratieve BDD-stijl met behulp van expect of should en zonder aangepaste code. Als Chai en Jest niet de gewenste bewering bevatten en deze zeer herhaalbaar is, kunt u overwegen Jest Matcher (Jest) uit te breiden of een aangepaste Chai-plug-in te schrijven

Anders: het team schrijft minder tests en decoreert de vervelende tests met .skip ()

Antipatroon Voorbeeld: de lezer moet door niet zo korte en imperatieve code bladeren om het testverhaal te krijgen

Doing It Right Voorbeeld: De volgende declaratieve test doorlopen is een makkie

️ 3. Lint met speciale plug-ins voor testen

Do: een set ESLint-plug-ins is speciaal gebouwd voor het inspecteren van de testcodepatronen en het ontdekken van problemen. Eslint-plugin-mocha zal bijvoorbeeld waarschuwen wanneer een test op mondiaal niveau wordt geschreven (geen zoon van een descript () -instructie) of wanneer tests worden overgeslagen, wat kan leiden tot een verkeerde overtuiging dat alle tests slagen. Op dezelfde manier kan eslint-plugin-jest bijvoorbeeld waarschuwen wanneer een test helemaal geen beweringen heeft (niets controleren)

Anders: als je 90% codedekking en 100% groene tests ziet, zal je gezicht alleen een grote glimlach dragen totdat je je realiseert dat veel tests nergens voor beweren en veel testsuites gewoon zijn overgeslagen. Hopelijk heeft u niets geïmplementeerd op basis van deze valse observatie

Antipatroonvoorbeeld: een testcase vol fouten, gelukkig worden ze allemaal gevangen door Linters

️ 4. Houd u aan black-box testen: test alleen openbare methoden

Doen: het testen van de interne onderdelen levert bijna niets op. Als uw code / API de juiste resultaten oplevert, zou u uw volgende 3 uur dan echt moeten investeren in testen HOE het intern werkte en deze fragiele tests dan onderhouden? Wanneer een openbaar gedrag wordt gecontroleerd, wordt de privé-implementatie ook impliciet getest en worden uw tests alleen verbroken als er een bepaald probleem is (bijvoorbeeld een verkeerde uitvoer). Deze aanpak wordt ook gedragstesten genoemd. Aan de andere kant, als je de interne onderdelen test (white box-benadering) - je focus verschuift van het plannen van de componentuitkomst naar nitty-gritty details en je test kan breken vanwege kleine codereactoren hoewel de resultaten prima zijn - dit verhoogt het onderhoud dramatisch last

Anders: je test gedraagt ​​zich als het kind dat wolf huilt: schiet hardop vals-positieve kreten (bijv. Een test mislukt omdat een naam van een privévariabele is gewijzigd). Het is niet verwonderlijk dat mensen binnenkort de CI-meldingen gaan negeren totdat op een dag een echte bug wordt genegeerd ...

Voorbeeld antipatroon: een testcase test de interne onderdelen zonder goede reden

️️5. Kies de juiste testdubbels: vermijd spotjes ten gunste van stompjes en spionnen

Doen: testdubbels zijn een noodzakelijk kwaad omdat ze gekoppeld zijn aan de interne applicaties, maar sommige bieden een enorme waarde (lees hier een herinnering over testdubbels: nep versus stomp versus spionnen). De verschillende technieken werden echter niet gelijk geboren: sommige, spionnen en stompjes, zijn gericht op het testen van de vereisten, maar als een onvermijdelijk neveneffect raken ze ook enigszins de binnenkant. Mocks, daarentegen, zijn gericht op het testen van de interne onderdelen - dit brengt enorme overhead met zich mee, zoals uitgelegd in de kogel "Stick to black box testing".

Voordat u testdubbels gebruikt, stelt u een heel eenvoudige vraag: gebruik ik deze om de functionaliteit te testen die in het document met vereisten verschijnt of zou kunnen verschijnen? Zo nee, het is een geur van testen met witte dozen.

Als u bijvoorbeeld wilt testen wat uw app redelijk gedraagt ​​wanneer de betalingsservice uitvalt, kunt u de betalingsservice stoppen en een ‘Geen reactie’ activeren om ervoor te zorgen dat het geteste apparaat de juiste waarde retourneert. Dit controleert ons applicatiegedrag / reactie / resultaat onder bepaalde scenario's. U kunt ook een spion gebruiken om te beweren dat een e-mail is verzonden wanneer die service niet beschikbaar is - dit is opnieuw een gedragscontrole die waarschijnlijk in een document met vereisten wordt weergegeven ("Stuur een e-mail als de betaling niet kon worden opgeslagen"). Aan de andere kant, als u de Betalingsservice bespot en ervoor zorgt dat deze met de juiste JavaScript-typen wordt aangeroepen, is uw test gericht op interne dingen die niets hebben met de toepassingsfunctionaliteit en die waarschijnlijk vaak zullen veranderen

Anders: Elke refactoring van codemandaten zoekt naar alle mocks in de code en werkt dienovereenkomstig bij. Tests worden meer een last dan een behulpzame vriend

Example Antipatroonvoorbeeld: spiegelt focus op de binnenzijde

Doing It Right Voorbeeld: spionnen zijn gericht op het testen van de vereisten, maar als een bijwerking raken de interne onderdelen onvermijdelijk

️ 6. Gebruik geen "foo", gebruik realistische invoergegevens

Do: Vaak worden productiebugs onthuld onder een zeer specifieke en verrassende input - hoe realistischer de testinput is, hoe groter de kans is om bugs vroeg te vangen. Gebruik speciale bibliotheken zoals Faker om pseudo-echte gegevens te genereren die lijken op de variëteit en de vorm van productiegegevens. Dergelijke bibliotheken genereren bijvoorbeeld willekeurige maar realistische telefoonnummers, gebruikersnamen, creditcards, bedrijfsnamen en zelfs ‘lorem ipsum’ -tekst. Overweeg zelfs echte gegevens uit uw productieomgeving te importeren en in uw tests te gebruiken. Wil je het naar het volgende niveau brengen? zie volgende bullet (testen op basis van eigenschappen)

Anders: al je ontwikkelingstests zullen vals groen lijken als je synthetische ingangen zoals "Foo" gebruikt, maar dan kan de productie rood worden wanneer een hacker een vervelende reeks doorgeeft zoals "@ 3e2ddsf. ## ’1 fdsfds. fds432 AAAA ”

Antipatroonvoorbeeld: een testpakket dat slaagt vanwege niet-realistische gegevens

☺Het goed doen Voorbeeld: realistische invoer willekeurig maken

7. Test veel invoercombinaties met op eigenschappen gebaseerde tests

Do: meestal kiezen we een paar invoervoorbeelden voor elke test. Zelfs als het invoerformaat lijkt op echte gegevens (zie opsommingsteken 'Don't foo'), behandelen we slechts enkele invoercombinaties (methode ('', true, 1), methode ("string", false ", 0) ), Tijdens de productie kan een API die wordt aangeroepen met 5 parameters worden opgeroepen met duizenden verschillende permutaties, een van hen kan ons proces verlagen (zie Fuzz-testen). Wat als u een enkele test zou kunnen schrijven die automatisch 1000 permutaties van verschillende ingangen verzendt en vastlegt voor welke ingang onze code niet de juiste reactie teruggeeft? Op eigenschappen gebaseerd testen is een techniek die precies dat doet: door alle mogelijke invoercombinaties naar uw geteste eenheid te sturen, verhoogt dit de serendipiteit van het vinden van een bug. Bijvoorbeeld, gegeven een methode - addNewProduct (id, naam, isDiscount) - zullen de ondersteunende bibliotheken deze methode aanroepen met vele combinaties van (nummer, string, boolean) zoals (1, "iPhone", false), (2, "Galaxy ”, Waar). U kunt op eigenschappen gebaseerde tests uitvoeren met uw favoriete testloper (Mocha, Jest, enz.) Met behulp van bibliotheken zoals js-verifieer of testcontrole (veel betere documentatie). Update: Nicolas Dubien suggereert in de reacties hieronder om snel te checken, wat een aantal extra functies lijkt te bieden en ook actief wordt onderhouden

Anders: onbewust kiest u de testingangen die alleen codepads bestrijken die goed werken. Helaas vermindert dit de efficiëntie van het testen als een voertuig om bugs bloot te leggen

☺ Doing It Right Voorbeeld: vele invoerpermutaties testen met "mokka-testcontrole"

️ 8. Blijf binnen de test: minimaliseer externe helpers en abstracties

Doe: inmiddels is het waarschijnlijk duidelijk dat ik pleit voor doodeenvoudige tests: het team kan zich geen ander softwareproject veroorloven dat een mentale inspanning vereist om de code te begrijpen. Michael Lync legt dit uit in zijn geweldige bericht:

Goede productiecode is goed doordacht; goede testcode ligt voor de hand ... Denk bij het schrijven van een test aan de volgende ontwikkelaar die de testonderbreking zal zien. Ze willen niet je hele testpakket lezen en ze willen zeker geen hele erfenisboom van testhulpprogramma's lezen.

Laat de lezer het hele verhaal krijgen zonder de test te verlaten, utils, hooks of enig extern effect op een testcase minimaliseren. Te veel herhalingen en copy-paste? OK, een test kan vertrekken met één externe helper en duidelijk blijven. Maar wanneer het groeit naar drie en vier helpers en haken, betekent dit dat het langzaam een ​​complexe structuur vormt

Anders: bevind je je plotseling met 4 helpers per testpakket, waarvan 2 erven van base util, veel setup- en ophaalhaken? gefeliciteerd, je hebt zojuist een ander uitdagend project gewonnen om te onderhouden, misschien schrijf je binnenkort tests tegen je testpakket

Antipatroonvoorbeeld: mooie en indirecte teststructuur. Begrijpt u de testcase zonder naar externe afhankelijkheden te navigeren?

☺ Doing It Right Voorbeeld: een test die u misschien begrijpt zonder verschillende bestanden te doorlopen

️ 9. Vermijd wereldwijde testopstellingen en zaden, voeg gegevens per test toe

Doe: volgens de gouden regel (opsommingsteken 0), moet elke test zijn eigen set DB-rijen toevoegen en er op reageren om koppeling te voorkomen en gemakkelijk over de teststroom te redeneren. In werkelijkheid wordt dit vaak geschonden door testers die de DB met gegevens zaaien voordat de tests worden uitgevoerd (ook bekend als 'testopstelling') omwille van prestatieverbetering. Hoewel prestaties inderdaad een terechte zorg zijn - het kan worden beperkt (zie "Component testen" bullet), echter, testcomplexiteit is een veel pijnlijk verdriet dat meestal andere overwegingen zou moeten beheersen. Praktisch, laat elke testcase expliciet de DB-records toevoegen die het nodig heeft en handel alleen op die records. Als prestaties een kritieke zorg worden - kan een uitgebalanceerd compromis komen in de vorm van het zaaien van de enige reeks tests die geen gegevens muteren (bijv. Zoekopdrachten)

Anders: weinig tests mislukken, een implementatie wordt afgebroken, ons team gaat nu kostbare tijd doorbrengen, hebben we een bug? laten we onderzoeken, oh nee - het lijkt erop dat twee tests dezelfde seed-gegevens muteerden

Voorbeeld van antipatroon: tests zijn niet onafhankelijk en zijn afhankelijk van een algemene haak om globale DB-gegevens te voeden

☺Het goed doen Voorbeeld: we kunnen binnen de test blijven, elke test werkt op basis van zijn eigen set gegevens

️ 10. Vang geen fouten, verwacht ze

Do: wanneer u probeert te beweren dat sommige invoer een fout veroorzaakt, lijkt het misschien goed om try-catch-eindelijk te gebruiken en te beweren dat de catch-clausule is ingevoerd. Het resultaat is een lastig en uitgebreid testgeval (voorbeeld hieronder) dat de eenvoudige testintentie en de resultaatverwachtingen verbergt

Een eleganter alternatief is het gebruik van de toegewijde Chai-bewering met één regel: expect (methode) .to.throw (of in Jest: expect (methode) .toThrow ()). Het is absoluut verplicht om er ook voor te zorgen dat de uitzondering een eigenschap bevat die het fouttype aangeeft, anders kan de toepassing, anders dan een generieke fout, niet veel doen in plaats van een teleurstellend bericht aan de gebruiker te tonen

Anders: het zal een uitdaging zijn om uit de testrapporten (bijvoorbeeld CI-rapporten) af te leiden wat er mis is gegaan

Antipatroon Voorbeeld: een lange testcase die probeert het bestaan ​​van een fout met try-catch te bevestigen

☺Het goed doen Voorbeeld: een voor mensen leesbare verwachting die gemakkelijk te begrijpen is, misschien zelfs door QA of technische PM

️10. Tag uw tests

Doen: verschillende tests moeten in verschillende scenario's worden uitgevoerd: snel roken, IO-minder, tests moeten worden uitgevoerd wanneer een ontwikkelaar een bestand opslaat of vastlegt, volledige end-to-end tests worden meestal uitgevoerd wanneer een nieuw pull-verzoek wordt ingediend, enz. Dit kan worden bereikt door tests te taggen met trefwoorden zoals #cold #api #sanity zodat u kunt grepen met uw testharnas en de gewenste subset kunt oproepen. Dit is bijvoorbeeld hoe je alleen de sanity-testgroep met Mocha zou aanroepen: mocha - grep ‘sanity’

Anders: het uitvoeren van alle tests, inclusief tests die tientallen DB-query's uitvoeren, elke keer dat een ontwikkelaar een kleine wijziging aanbrengt, kan het extreem langzaam zijn en houdt ontwikkelaars weg van het uitvoeren van tests

Doing It Right Voorbeeld: door tests te labelen als ‘# cold-test’ kan de testloper alleen snelle tests uitvoeren (Cold === snelle tests die geen IO uitvoeren en vaak kunnen worden uitgevoerd, zelfs terwijl de ontwikkelaar aan het typen is)

11. Andere generieke goede testhygiëne

Doen: dit bericht is gericht op testadvies dat gerelateerd is aan, of op zijn minst kan worden geïllustreerd met Node JS. Deze kogel groepeert echter enkele niet-knooppunt gerelateerde tips die bekend zijn

Leer en oefen TDD-principes - ze zijn uiterst waardevol voor velen, maar worden niet geïntimideerd als ze niet bij uw stijl passen, u bent niet de enige. Overweeg om de tests voor de code te schrijven in een rood-groene-refactor-stijl, zorg ervoor dat elke test precies één ding controleert, wanneer u een bug vindt - voordat u een test schrijft, schrijft u een test die deze bug in de toekomst detecteert, laat elke test ten minste mislukken vermijd, voordat u groen wordt, afhankelijkheid van de omgeving (paden, besturingssysteem, enz.)

Anders: je mist parels van wijsheid die tientallen jaren zijn verzameld

*** Sectie : Testtypen ***

️ 12. Verrijk uw testportfolio: kijk verder dan unit-tests en de piramide

Doe: de testpiramide, hoewel 10 jaar oud, is een geweldig en relevant model dat drie testtypen suggereert en de teststrategie van de meeste ontwikkelaars beïnvloedt. Tegelijkertijd ontstonden er meer dan een handvol glanzende nieuwe testtechnieken die zich verstoppen in de schaduw van de testpiramide. Is het, gezien alle dramatische veranderingen die we de afgelopen 10 jaar hebben gezien (Microservices, cloud, serverless), zelfs mogelijk dat een vrij oud model geschikt is voor * alle * soorten toepassingen? zou de testwereld niet moeten overwegen nieuwe testtechnieken te verwelkomen?

Begrijp me niet verkeerd, in 2019 zijn de testpiramide, TDD- en unit-tests nog steeds een krachtige techniek en zijn waarschijnlijk de beste match voor veel toepassingen. Alleen als elk ander model, ondanks zijn bruikbaarheid, moet het soms verkeerd zijn. Overweeg bijvoorbeeld een IOT-toepassing die veel gebeurtenissen in een berichtenbus zoals Kafka / RabbitMQ opneemt, die vervolgens naar een gegevensmagazijn vloeien en uiteindelijk worden ondervraagd door een aantal gebruikersinterface voor analyse. Moeten we echt 50% van ons testbudget besteden aan het schrijven van unit-tests voor een applicatie die op integratie gericht is en bijna geen logica heeft? Naarmate de diversiteit van toepassingstypes (bots, crypto, Alexa-vaardigheden) toeneemt, zijn de kansen om scenario's te vinden waarbij de testpiramide niet de beste match is.

Het is tijd om uw testportfolio te verrijken en vertrouwd te raken met meer testtypen (de volgende opsommingstekens suggereren enkele ideeën), denk aan modellen zoals de testpiramide, maar vergelijk testtypen ook met echte problemen waarmee u wordt geconfronteerd ('Hé, onze API is gebroken, laten we consumentgerichte contracttests schrijven! '), uw tests diversifiëren als een belegger die een portefeuille opbouwt op basis van risicoanalyse - beoordelen waar problemen kunnen optreden en enkele preventiemaatregelen koppelen om die potentiële risico's te beperken

Een woord van waarschuwing: het TDD-argument in de softwarewereld heeft een typisch vals-dichotomie-gezicht, sommigen prediken het overal te gebruiken, anderen denken dat het de duivel is. Iedereen die absoluut spreekt, heeft ongelijk:]

Anders: je gaat een aantal tools missen met een verbazingwekkende ROI, sommige zoals Fuzz, lint en mutatie kunnen waarde bieden in 10 minuten

☺ Doing It Right Voorbeeld: Cindy Sridharan suggereert een rijke testportfolio in haar geweldige post ‘Microservices testen - de gezonde manier’

Voorbeeld: YouTube: "Beyond Unit Tests: 5 Shiny Node.JS Test Types (2018)" (Yoni Goldberg)

5 glanzende testtechnieken door Yoni Goldberg

️ 13. Componenten testen is misschien uw beste zaak

Do: elke eenheidstest beslaat een klein deel van de applicatie en het is duur om het geheel te dekken, terwijl end-to-end testen gemakkelijk veel grond beslaan, maar vlokkiger en langzamer zijn, waarom geen gebalanceerde aanpak toepassen en tests schrijven die zijn groter dan eenheidstests maar kleiner dan end-to-end tests? Componenttesten is het onbezongen nummer van de testwereld - ze bieden het beste van beide werelden: redelijke prestaties en een mogelijkheid om TDD-patronen toe te passen + realistische en geweldige dekking.

Componenttests richten zich op de 'unit' van Microservice, ze werken tegen de API, bespotten niets dat bij de Microservice zelf hoort (bijv. Echte DB, of tenminste de in-memory-versie van die DB) maar stub alles dat extern is zoals oproepen naar andere Microservices. Door dit te doen, testen we wat we inzetten, benaderen de app van buiten naar binnen en winnen we in een redelijke tijd veel vertrouwen.

Anders: u kunt lange dagen besteden aan het schrijven van unit-tests om erachter te komen dat u slechts 20% systeemdekking heeft

☺ Doing It Right Voorbeeld: Supertest maakt het mogelijk om de Express API tijdens het proces te benaderen (snel en bestrijkt vele lagen)

️ 14. Zorg ervoor dat nieuwe releases de API niet breken met behulp van door consumenten gestuurde contracten

Doe: uw Microservice heeft dus meerdere clients en u voert meerdere versies van de service uit om redenen van compatibiliteit (iedereen tevreden houden). Dan verander je een veld en ‘boem!’, Een belangrijke klant die op dit veld vertrouwt, is boos. Dit is de Catch-22 van de integratiewereld: het is een enorme uitdaging voor de server om rekening te houden met alle verwachtingen van meerdere klanten. Anderzijds kunnen de clients geen tests uitvoeren omdat de server de releasedata beheert. Consumentengestuurde contracten en het framework PACT zijn geboren om dit proces te formaliseren met een zeer verstorende aanpak - niet de server definieert zelf het testplan, maar de client definieert de tests van de ... server! PACT kan de klantverwachtingen vastleggen en op een gedeelde locatie plaatsen, "broker", zodat de server de verwachtingen kan halen en elke build kan uitvoeren met behulp van PACT-bibliotheek om gebroken contracten te detecteren - een klantverwachting waaraan niet wordt voldaan. Hierdoor worden alle API-mismatches tussen server en client vroeg tijdens de build / CI vastgelegd en kunt u veel frustratie besparen

Anders: de alternatieven zijn vermoeiend handmatig testen of angst bij de inzet

☺ Doing It Right Voorbeeld:

️ 15. Test uw middlewares op zichzelf

Do: velen vermijden middleware-testen omdat ze een klein deel van het systeem vertegenwoordigen en een live Express-server vereisen. Beide redenen zijn onjuist - Middlewares zijn klein, maar beïnvloeden alle of de meeste aanvragen en kunnen eenvoudig worden getest als pure functies die JS-objecten {req, res} krijgen. Om een ​​middleware-functie te testen, moet je deze gewoon aanroepen en spioneren (bijvoorbeeld met Sinon) over de interactie met de objecten {req, res} om ervoor te zorgen dat de functie de juiste actie uitvoert. De bibliotheek node-mock-http gaat nog verder en factort de {req, res} -objecten en bespioneert hun gedrag. Het kan bijvoorbeeld aangeven of de http-status die is ingesteld op het res-object overeenkomt met de verwachting (zie het onderstaande voorbeeld)

Anders: een bug in Express middleware === een bug in alle of de meeste aanvragen

☺ Doing It Right Voorbeeld: middleware afzonderlijk testen zonder netwerkoproepen uit te voeren en de hele Express-machine te activeren

️ 16. Meet en refactor met behulp van statische analyse-instrumenten

Do: statische analysehulpmiddelen gebruiken helpt objectieve manieren om de codekwaliteit te verbeteren en uw code onderhoudbaar te houden. U kunt statische analysehulpmiddelen toevoegen aan uw CI-build om af te breken wanneer deze code ruikt. De belangrijkste verkoopargumenten boven gewone linting zijn de mogelijkheid om de kwaliteit te inspecteren in de context van meerdere bestanden (bijvoorbeeld duplicaten detecteren), geavanceerde analyses uit te voeren (bijvoorbeeld complexiteit van de code) en de geschiedenis en voortgang van codekwesties te volgen. Twee voorbeelden van tools die u kunt gebruiken zijn Sonarqube (2.600+ sterren) en Code Climate (1.500+ sterren)

Credit: Keith Holliday

Anders: met slechte codekwaliteit zullen bugs en prestaties altijd een probleem zijn dat geen glanzende nieuwe bibliotheek of geavanceerde functies kunnen oplossen

☺ Doing It Right Voorbeeld: CodeClimat, een commercieel hulpmiddel dat complexe methoden kan identificeren:

️ 17. Controleer uw gereedheid voor knooppuntgerelateerde chaos

Doen: Vreemd genoeg gaan de meeste softwaretests alleen over logica en gegevens, maar enkele van de ergste dingen die gebeuren (en echt moeilijk te verhelpen zijn) zijn infrastructurele problemen. Hebt u bijvoorbeeld ooit getest wat er gebeurt wanneer uw procesgeheugen overbelast is, of wanneer de server / het proces uitvalt, of realiseert uw controlesysteem zich wanneer de API 50% langzamer wordt ?. Om dit soort slechte dingen te testen en te verminderen - werd Chaos engineering geboren door Netflix. Het is bedoeld om bewustzijn, kaders en hulpmiddelen te bieden voor het testen van de veerkracht van onze app voor chaotische problemen. Een van de beroemde tools, de chaos-aap, doodt bijvoorbeeld willekeurig servers om ervoor te zorgen dat onze service gebruikers nog steeds kan bedienen en niet afhankelijk is van een enkele server (er is ook een Kubernetes-versie, kube-monkey, die pods doodt). Al deze tools werken op hosting- / platformniveau, maar wat als u pure Node-chaos wilt testen en genereren, zoals controleren hoe uw Node-proces omgaat met niet-opgevangen fouten, onverwerkte afwijzing van beloften, v8-geheugen overbelast met de maximaal toegestane van 1.7GB of of je UX blijft bevredigend als de event loop vaak wordt geblokkeerd? om dit aan te pakken heb ik geschreven, node-chaos (alpha) die allerlei Node-gerelateerde chaotische handelingen levert

Anders: geen ontsnapping hier, de wet van Murphy raakt je productie zonder genade

☺Het goed doen Voorbeeld: Node-chaos kan allerlei Node.js-grappen genereren, zodat u kunt testen hoe veerkrachtig uw app is voor chaos

*** Sectie : De effectiviteit van de test meten ***

️ 18. Zorg voor voldoende dekking om zelfverzekerd te zijn, ~ 80% lijkt het geluksgetal te zijn

Do: het doel van testen is om voldoende vertrouwen te krijgen om snel te gaan, uiteraard is het zo dat hoe meer code wordt getest, hoe zekerder het team kan zijn. Dekking is een maat voor hoeveel coderegels (en vertakkingen, verklaringen, enz.) Worden bereikt door de tests. Dus hoeveel is genoeg? 10–30% is duidelijk te laag om enig idee te krijgen van de correctheid van de build, aan de andere kant is 100% erg duur en kan uw focus verschuiven van de kritieke paden naar de exotische hoeken van de code. Het lange antwoord is dat het van veel factoren afhankelijk is, zoals het type toepassing - als je de volgende generatie Airbus A380 bouwt, is 100% een must, voor een website met stripfoto's is 50% misschien te veel. Hoewel de meeste testenthousiasten beweren dat de juiste dekkingsdrempel contextueel is, noemen de meeste ook het getal 80% als een duim van een regel (Fowler: "in de bovenste jaren 80 of 90") die vermoedelijk aan de meeste toepassingen zou moeten voldoen .

Implementatietips: misschien wilt u uw continue integratie (CI) configureren om een ​​dekkingsdrempel te hebben (Jest-link) en een build stoppen die niet aan deze standaard voldoet (het is ook mogelijk om de drempel per component te configureren, zie codevoorbeeld hieronder) . Overweeg bovendien het detecteren van afname van builddekking (wanneer een nieuw toegewezen code minder dekking heeft) - dit zal ontwikkelaars ertoe brengen de hoeveelheid geteste code te verhogen of op zijn minst te behouden. Dat gezegd hebbende, dekking is slechts één maatstaf, een kwantitatieve basis, die niet voldoende is om de robuustheid van uw testen te vertellen. En het kan ook voor de gek worden gehouden zoals geïllustreerd in de volgende kogels

Anders: vertrouwen en cijfers gaan hand in hand, zonder echt te weten dat je het grootste deel van het systeem hebt getest - er zal ook enige angst zijn. en angst zal je vertragen

☺ Voorbeeld: een typisch dekkingsrapport

Dekkingsrapport Istanbul

☺ Doing It Right Voorbeeld: dekking per component instellen (met Jest)

Contextuele dekking

️ 19. Inspecteer dekkingsrapporten om niet-geteste gebieden en andere eigenaardigheden te detecteren

Do: sommige problemen sluipen net onder de radar en zijn echt moeilijk te vinden met behulp van traditionele tools. Dit zijn niet echt bugs, maar meer verrassend applicatiegedrag dat een ernstige impact kan hebben. Vaak worden bijvoorbeeld sommige codegebieden nooit of zelden ingeroepen - u dacht dat de klasse 'PricingCalculator' altijd de productprijs bepaalt, maar het blijkt dat deze nooit wordt ingeroepen, hoewel we 10.000 producten in DB hebben en veel verkopen ... Codedekking rapporten helpen u te realiseren of de toepassing zich gedraagt ​​zoals u denkt dat het doet. Anders dan dat, kan het ook benadrukken welke typen code niet worden getest - wordt geïnformeerd dat 80% van de code wordt getest, niet of de kritieke onderdelen worden gedekt. Rapporten genereren is eenvoudig - voer uw app gewoon uit in productie of tijdens het testen met dekking volgen en zie vervolgens kleurrijke rapporten die aangeven hoe vaak elk codegebied wordt aangeroepen. Als je de tijd neemt om een ​​glimp van deze gegevens op te vangen, zul je misschien een paar gotcha's tegenkomen

Anders: als u niet weet welke delen van uw code niet getest zijn, weet u niet waar de problemen vandaan kunnen komen

Antipatroonvoorbeeld: wat is er mis met dit dekkingsrapport? gebaseerd op een real-world scenario waarin we ons applicatiegebruik in QA hebben gevolgd en interessante inlogpatronen ontdekken (Hint: het aantal inlogfouten is niet evenredig, er is duidelijk iets mis. Uiteindelijk bleek dat een frontend-bug steeds de backend login API)

️ 20. Meet logische dekking met behulp van mutatietesten

Doe: de traditionele dekking-metriek liegt vaak: het kan u 100% codedekking laten zien, maar geen van uw functies, zelfs niet één, retourneert het juiste antwoord. Hoe kan dat? het meet eenvoudig over welke coderegels de test heeft bezocht, maar het controleert niet of de tests daadwerkelijk iets hebben getest - beweerde de juiste reactie. Zoals iemand die voor zaken reist en zijn paspoortzegels toont - dit bewijst geen werk, alleen dat hij weinig luchthavens en hotels heeft bezocht.

Op mutatie gebaseerd testen is hier om te helpen door de hoeveelheid code te meten die daadwerkelijk werd GETEST, niet alleen BEZOCHT. Stryker is een JavaScript-bibliotheek voor mutatietests en de implementatie is echt netjes:

(1) het verandert opzettelijk de code en "plant bugs". De code newOrder.price === 0 wordt bijvoorbeeld newOrder.price! = 0. Deze "bugs" worden mutaties genoemd

(2) het voert de tests uit, als alles lukt, hebben we een probleem - de tests dienden niet om bugs te ontdekken, de mutaties zijn zogeheten overleefd. Als de tests mislukten, dan waren de mutaties gedood.

Wetende dat alle of de meeste mutaties zijn gedood, geeft veel meer vertrouwen dan de traditionele dekking en de installatietijd is vergelijkbaar

Anders: je wordt voor de gek gehouden door te geloven dat 85% dekking betekent dat je test fouten in 85% van je code zal detecteren

Voorbeeld antipatroon: 100% dekking, 0% testen

Doing It Right Voorbeeld: Stryker-rapporten, een tool voor het testen van mutaties, detecteert en telt de hoeveelheid code die niet is getest (mutaties)

Stryker-rapport - Wetende dat alle of de meeste mutaties zijn gedood, geeft veel meer vertrouwen dan de traditionele dekking en de installatietijd is vergelijkbaar

*** Sectie : CI- en andere kwaliteitsmaatregelen ***

️ 21. Verrijk uw linters en verbreek builds die pluisproblemen hebben

Do: Linters zijn een gratis lunch, met 5 minuten setup krijg je gratis een automatische piloot die je code bewaakt en een belangrijk probleem oploopt terwijl je typt. Voorbij zijn de dagen dat linting ging over cosmetica (geen dubbele punt!). Tegenwoordig kunnen Linters ernstige problemen vastleggen, zoals fouten die niet correct worden gegooid en informatie verliezen. Overweeg, naast je basisset van regels (zoals ESLint-standaard of Airbnb-stijl), enkele gespecialiseerde Linters zoals eslint-plugin-chai-expect op te nemen die tests kunnen ontdekken zonder beweringen, eslint-plugin-belofte kan beloften ontdekken zonder oplossing (je code zal nooit doorgaan), eslint-plugin-beveiliging die gretige regex-expressies kan ontdekken die kunnen worden gebruikt voor DOS-aanvallen, en eslint-plugin-u-niet-nodig-lodash-underscore kan alarmeren wanneer de code hulpprogramma-bibliotheekmethoden gebruikt die deel uitmaken van de V8-kernmethoden zoals Lodash._map (...)

Anders: overweeg een regenachtige dag waarop uw productie blijft crashen, maar de logs geen foutstapeltracering weergeven. Wat is er gebeurd? Uw code gooide per ongeluk een object zonder fouten en de stacktracering was verloren, een goede reden om met uw hoofd tegen een bakstenen muur te slaan. Een 5min linter setup kan deze TYPO detecteren en je dag redden

Voorbeeld antipatroon: het verkeerde object Error wordt per ongeluk weggegooid, voor deze fout wordt geen stack-trace weergegeven. Gelukkig krijgt ESLint de volgende productiefout

Het verkeerde object Error wordt per ongeluk weggegooid, voor deze fout wordt geen stack-trace weergegeven. Gelukkig krijgt ESLint de volgende productiefout

️ 22. Verkort de feedbacklus met lokale ontwikkelaar-CI

Doe: Een CI gebruiken met glanzende kwaliteitsinspecties zoals testen, linting, kwetsbaarheidscontrole, enz.? Help ontwikkelaars deze pijplijn ook lokaal uit te voeren om onmiddellijke feedback te vragen en de feedbacklus te verkorten. Waarom? een efficiënt testproces bestaat uit vele en iteratieve lussen: (1) try-outs -> (2) feedback -> (3) refactor. Hoe sneller de feedback is, hoe meer iteraties een ontwikkelaar per module kan uitvoeren en de resultaten kan perfectioneren. Aan de andere kant, wanneer de feedback te laat komt, kunnen er minder iteraties per dag worden ingepakt, het team kan al doorgaan naar een ander onderwerp / taak / module en is misschien niet in staat om die module te verfijnen.

In de praktijk staan ​​sommige CI-leveranciers (bijvoorbeeld: CircleCI load CLI) toe dat de pijplijn lokaal wordt uitgevoerd. Sommige commerciële tools zoals Wallaby bieden zeer waardevolle & testinzichten als een prototype voor ontwikkelaars (geen affiliatie). U kunt ook gewoon npm-script toevoegen aan package.json dat alle kwaliteitsopdrachten uitvoert (bijv. Test, lint, kwetsbaarheden) - gebruik tools zoals gelijktijdig voor parallellisatie en niet-nul exitcode als een van de tools is mislukt. Nu moet de ontwikkelaar slechts één opdracht aanroepen - bijv. ‘Npm run quality’ - om direct feedback te krijgen. Overweeg ook om een ​​commit af te breken als de kwaliteitscontrole niet is gelukt met een githook (husky kan helpen)

Anders: wanneer de kwaliteitsresultaten de dag na de code aankomen, wordt testen geen vloeiend onderdeel van ontwikkeling, maar een formeel artefact achteraf

☺ Doing It Right Voorbeeld: npm-scripts die de inspectie van codekwaliteit uitvoeren, worden allemaal parallel uitgevoerd op aanvraag of wanneer een ontwikkelaar nieuwe code probeert te pushen

️ 23. Voer e2e-testen uit via een echte productiespiegel

Do: End-to-end (e2e) testen zijn de belangrijkste uitdaging van elke CI-pijplijn - het creëren van een identieke kortstondige productiespiegel met alle bijbehorende cloudservices kan vervelend en duur zijn. Het beste compromis vinden is jouw spel: met Docker-compose kun je een geïsoleerde, gecoupeerde omgeving maken met identieke containers met behulp van een enkel tekstbestand, maar de achtergrondtechnologie (bijvoorbeeld netwerken, implementatiemodel) verschilt van real-world producties. U kunt het combineren met ‘AWS Local’ om te werken met een stub van de echte AWS-services. Als je zonder server bent gegaan, zijn meerdere frameworks zoals serverless en AWS SAM de lokale aanroep van Faas-code mogelijk.

Het enorme Kubernetes-ecosysteem moet nog een standaard handige tool voor lokale en CI-mirroring formaliseren, hoewel veel nieuwe tools vaak worden geïntroduceerd. Eén benadering is het uitvoeren van een ‘geminimaliseerde Kubernetes’ met behulp van tools zoals Minikube en MicroK8s die lijken op het echte werk, alleen met minder overhead. Een andere benadering is het testen via een 'echte Kubernetes' op afstand, sommige CI-providers (bijv. Codefresh) hebben native integratie met de Kubernetes-omgeving en maken het eenvoudig om de CI-pijplijn over het echte werk te laten lopen, anderen staan ​​aangepaste scripting toe tegen een externe Kubernetes.

Anders: het gebruik van verschillende technologieën voor productie en testen vereist het behoud van twee implementatiemodellen en houdt de ontwikkelaars en het ops-team gescheiden

Voorbeeld: een CI-pijplijn die direct een Kubernetes-cluster genereert (Credit: Dynamic-environment Kubernetes)

inzetten:
fase: inzetten
afbeelding: registry.gitlab.com/gitlab-examples/kubernetes-deploy
script:
- ./configureCluster.sh $ KUBE_CA_PEM_FILE $ KUBE_URL $ KUBE_TOKEN
- kubectl maakt ns $ NAMESPACE
- kubectl maak geheim -n $ NAMESPACE docker-registry gitlab-registry --docker-server = "$ CI_REGISTRY" --docker-gebruikersnaam = "$ CI_REGISTRY_USER" --docker-password = "$ CI_REGISTRY_PASSWORD" --docker-email = "$ GITLAB_USER_EMAIL"
- mkdir. gegenereerd
- echo "$ CI_BUILD_REF_NAME- $ CI_BUILD_REF"
- sed -e "s / TAG / $ CI_BUILD_REF_NAME- $ CI_BUILD_REF / g" templates / deals.yaml | tee ".generated / deals.yaml"
- kubectl toepassen - naamruimte $ NAMESPACE -f .generated / deals.yaml
- kubectl toepassen - naamruimte $ NAMESPACE -f sjablonen / my-sock-shop.yaml
milieu:
naam: test-voor-ci

️ 24. Testuitvoering parallel zetten

Doen: Als het goed wordt gedaan, is testen uw 24/7 vriend die vrijwel onmiddellijk feedback geeft. In de praktijk kan het uitvoeren van 500 CPU-begrensde eenheidsmetingen op een enkele thread te lang duren. Gelukkig kunnen moderne testlopers en CI-platforms (zoals Jest-, AVA- en Mocha-uitbreidingen) de test parallel laten lopen in meerdere processen en een aanzienlijke verbetering van de feedbacktijd bereiken. Sommige CI-leveranciers parallel ook testen over containers (!) Die de feedback-loop nog verder verkort. Of het nu lokaal is over meerdere processen, of over een cloud CLI met meerdere machines - parallellisering van de vraag houdt de tests autonoom omdat elk op verschillende processen kan worden uitgevoerd

Anders: testresultaten krijgen 1 uur lang na het pushen van nieuwe code, omdat je al de volgende functies codeert, is een geweldig recept om testen minder relevant te maken

Doing It Right Voorbeeld: Mokka parallel & Jest overtreffen gemakkelijk de traditionele Mokka dankzij het testen van parallellisatie (Credit: JavaScript Test-Runners Benchmark)

️ 25. Blijf uit de buurt van juridische problemen met een licentie- en plagiaatcontrole

Do: problemen met licenties en plagiaat zijn op dit moment waarschijnlijk niet uw grootste zorg, maar waarom dit vakje ook niet binnen 10 minuten aanvinken? Een aantal npm-pakketten zoals licentiecontrole en plagiaatcontrole (commercieel met gratis abonnement) kunnen eenvoudig in uw CI-pijplijn worden ingebakken en inspecteren op zorgen zoals afhankelijkheden met beperkende licenties of code die vanuit Stackoverflow is geplakt en blijkbaar sommige auteursrechten schendt

Anders: ontwikkelaars kunnen onbedoeld pakketten met ongepaste licenties gebruiken of commerciële code kopiëren en plakken en tegen juridische problemen aanlopen

Doing It Right Voorbeeld:

// installeer licentiecontrole in uw CI-omgeving of ook lokaal
npm install -g licentie-checker
// vraag het om alle licenties te scannen en mislukt met een andere exit-code dan 0 als het een ongeautoriseerde licentie heeft gevonden. Het CI-systeem moet deze fout opvangen en de build stoppen
licentiecontrole - samenvatting - failOn BSD

️26. Inspecteer voortdurend op kwetsbare afhankelijkheden

Do: zelfs de meest gerenommeerde afhankelijkheden zoals Express hebben bekende kwetsbaarheden. Dit kan gemakkelijk worden getemd met behulp van community-tools zoals npm audit, of commerciële tools zoals snyk (bied ook een gratis community-versie). Beide kunnen bij elke build worden opgeroepen vanuit uw CI

Anders: om uw code te beschermen tegen kwetsbaarheden zonder speciale tools, moet u voortdurend online publicaties over nieuwe bedreigingen volgen. Nogal vervelend

Voorbeeld: resultaten van NPM Audit

️ 27. Automatiseer afhankelijkheidsupdates

Doe: garen en npm laatste introductie van pakket-lock.json introduceerde een serieuze uitdaging (de weg naar de hel is geplaveid met goede bedoelingen) - standaard worden pakketten nu niet langer bijgewerkt. Zelfs een team met veel nieuwe implementaties met ‘npm install’ & ‘npm update’ krijgt geen nieuwe updates. Dit leidt in het beste geval tot onvoldoende afhankelijke pakketversies of in het slechtste geval tot kwetsbare code. Teams vertrouwen nu op de goodwill en het geheugen van ontwikkelaars om het pakket.json handmatig bij te werken of hulpmiddelen zoals ncu handmatig te gebruiken. Een betrouwbaardere manier zou kunnen zijn om het proces van het verkrijgen van de meest betrouwbare afhankelijkheidsversies te automatiseren, hoewel er geen silver bullet-oplossingen zijn, maar er zijn twee mogelijke automatiseringswegen: (1) CI kan mislukken met verouderde afhankelijkheden - met behulp van tools zoals 'npm verouderd 'of' npm-check-updates (ncu) '. Hierdoor worden ontwikkelaars gedwongen om afhankelijkheden bij te werken. (2) Gebruik commerciële tools die de code scannen en automatisch pull-aanvragen met bijgewerkte afhankelijkheden verzenden. Nog een interessante vraag is wat het afhankelijkheidsupdatebeleid moet zijn - bijwerken op elke patch genereert teveel overhead, bijwerken direct wanneer een major wordt vrijgegeven, kan wijzen op een onstabiele versie (veel pakketten kwetsbaar bevonden op de eerste dagen na de release, zie het incident met de eslint-scope). Een efficiënt updatebeleid kan enige ‘wachtperiode’ toestaan ​​- laat de code enige tijd en versies achter bij de @laatste voordat de lokale kopie als verouderd wordt beschouwd (bijv. Lokale versie is 1.3.1 en repository-versie is 1.3.8)

Anders: in uw productie worden pakketten uitgevoerd die door hun auteur expliciet als riskant zijn getagd

Voorbeeld: ncu kan handmatig of binnen een CI-pijplijn worden gebruikt om te detecteren in welke mate de code achterloopt op de nieuwste versies

️ 28. Andere, niet-knooppunt gerelateerde, CI-tips

Doen: dit bericht is gericht op testadvies dat gerelateerd is aan, of op zijn minst kan worden geïllustreerd met Node JS. Deze kogel groepeert echter enkele niet-knooppunt gerelateerde tips die bekend zijn

  1. Gebruik een declaratieve syntaxis. Dit is de enige optie voor de meeste leveranciers, maar oudere versies van Jenkins maken het gebruik van code of UI mogelijk
  2. Kies voor een leverancier met native Docker-ondersteuning
  3. Faal vroeg, voer eerst je snelste tests uit. Creëer een ‘rooktest’ stap / mijlpaal die meerdere snelle inspecties groepeert (bijv. Linting, unit tests) en geef snelle feedback aan de code committer
  4. Maak het gemakkelijk om alle build-artefacten door te nemen, inclusief testrapporten, dekkingsrapporten, mutatierapporten, logboeken, enz.
  5. Maak meerdere pijplijnen / taken voor elke gebeurtenis, gebruik stappen ertussen opnieuw. Configureer bijvoorbeeld een taak voor commits van een filiaal en een andere voor master PR. Laat elke logica hergebruiken met gedeelde stappen (de meeste leveranciers bieden een mechanisme voor hergebruik van code
  6. Neem nooit geheimen op in een opdrachtaangifte, pak ze niet uit een geheime winkel of uit de configuratie van de opdracht
  7. Bump de versie expliciet in een release-build of zorg er in ieder geval voor dat de ontwikkelaar dit heeft gedaan
  8. Bouw slechts één keer en voer alle inspecties uit over het enkele build-artefact (bijv. Docker-afbeelding)
  9. Test in een efemere omgeving die niet van status verandert tussen builds. Caching node_modules kan de enige uitzondering zijn

Anders: je mist jarenlange wijsheid

️ 29. Build-matrix: voer dezelfde CI-stappen uit met meerdere Node-versies

Do: Kwaliteitscontrole gaat over serendipiteit, hoe meer grond je bestrijkt, hoe meer geluk je hebt bij het vroegtijdig detecteren van problemen. Bij het ontwikkelen van herbruikbare pakketten of het uitvoeren van een productie voor meerdere klanten met verschillende configuratie- en knooppuntversies, moet de CI de pipeline van tests uitvoeren over alle permutaties van configuraties. Als we bijvoorbeeld aannemen dat we mySQL gebruiken voor sommige klanten en Postgres voor anderen - ondersteunen sommige CI-leveranciers een functie genaamd 'Matrix' waarmee het testen kan worden uitgevoerd op basis van alle permutaties van mySQL, Postgres en meerdere knooppuntversies zoals 8, 9 en 10. Dit gebeurt alleen met behulp van de configuratie zonder extra inspanningen (ervan uitgaande dat u tests of andere kwaliteitscontroles hebt). Andere CI's die Matrix niet ondersteunen, kunnen extensies of tweaks hebben om dat toe te staan

Anders: gaan we, na al dat harde werk van het schrijven van testen, alleen bugs laten binnensluipen vanwege configuratieproblemen?

☺ Voorbeeld: de bouwdefinitie Travis (CI-leverancier) gebruiken om dezelfde test op meerdere knooppuntversies uit te voeren

taal: node_js
node_js:
  - "7"
  - "6"
  - "5"
  - "4"
installeren:
  - npm installatie
script:
  - npm-looptest

Dank je. Andere artikelen die u misschien leuk vindt

  • Controlelijst: Node.js best practices voor productie (augustus 2018)
  • 19 manieren om in 2019 een betere Node.js-ontwikkelaar te worden
  • Node.js best practices voor beveiliging (september 2018)
  • YouTube: 5 geavanceerde en glanzende testtechnieken
  • Node.js best practices - 79 best practices voor een robuuste Node-toepassing

Wilt u meer? volg mij op Twitter

Heeft u een eigen testtip? PR hier en ik zal dit artikel zeker bijwerken