Share
Het schrijven van shellscripts lijkt veel op programmeren. Sommige scripts vergen weinig tijdinvestering; overwegende dat andere complexe scripts mogelijk een gedachte, planning en een grotere betrokkenheid vereisen. Vanuit dit perspectief is het logisch om een testgestuurde aanpak te volgen en onze shellscripts te testen.
Om het beste uit deze zelfstudie te halen, moet u bekend zijn met de opdrachtregelinterface (CLI); Misschien wil je de tutorial 'De commandoregel is je beste vriend' eens bekijken als je een opfriscursus nodig hebt. Je hebt ook een basiskennis nodig van Bash-achtige shell-scripting. Ten slotte wilt u misschien bekend raken met de testgestuurde ontwikkeling (TDD) concepten en het testen van eenheden in het algemeen; Zorg ervoor dat je deze PHP-zelfstudies met teststuring bekijkt om het basisidee te krijgen.
Ten eerste hebt u een teksteditor nodig om uw shellscripts en unit-tests te schrijven. Gebruik je favoriet!
We zullen het shUnit2 shell unit testing framework gebruiken om onze unit tests uit te voeren. Het is ontworpen voor en werkt met bas-achtige schelpen. shUnit2 is een open source framework uitgebracht onder de GPL-licentie, en een kopie van het framework is ook opgenomen in de broncode van deze tutorial.
Het installeren van shUnit2 is heel eenvoudig; download en extraheer het archief eenvoudig naar elke locatie op uw harde schijf. Het is geschreven in Bash en als zodanig bestaat het framework uit alleen scriptbestanden. Als je van plan bent om vaak ShUnit2 te gebruiken, raad ik je ten zeerste aan om het op een locatie in je PATH te plaatsen.
Voor deze zelfstudie, shUnit uitpakken in een map met dezelfde naam in uw bronnen map (zie de code die bij deze zelfstudie hoort). Maak een Tests map binnen bronnen en een nieuwe bestandsoproep toegevoegd firstTest.sh.
#! / usr / bin / env sh ### firstTest.sh ### functie testWeCanWriteTests () assertEquals "het werkt" "het werkt" ## Bel en voer alle testen uit. "... /shunit2-2.1.6/src/shunit2"
Maak vervolgens uw testbestand uitvoerbaar.
$ cd __uw_code_folder __ / Test $ chmod + x firstTest.sh
Nu kunt u het gewoon uitvoeren en de uitvoer bekijken:
$ ./firstTest.sh testWeCanWriteTests Ran 1-test. OK
Er staat dat we een succesvolle test hebben uitgevoerd. Laten we nu de test laten mislukken; verander de assertEquals zodat de twee strings niet hetzelfde zijn en voer de test opnieuw uit:
$ ./firstTest.sh testWeCanWriteTests ASSERT: verwacht:maar was: Ran 1-test. FAILED (mislukkingen = 1)
U schrijft acceptatietests aan het begin van een project / kenmerk / verhaal wanneer u een specifieke vereiste duidelijk kunt definiëren.
Nu we een werkende testomgeving hebben, laten we een script schrijven dat een bestand leest, beslissingen neemt op basis van de inhoud van het bestand en informatie naar het scherm uitvoert.
Het belangrijkste doel van het script is om de score van een tennisspel tussen twee spelers te tonen. We zullen ons alleen concentreren op het bijhouden van de score van een enkel spel; al het andere is aan jou. De scoreregels zijn:
Onze applicatie leest de score van een bestand. Een ander systeem zal de informatie in dit bestand pushen. De eerste regel van dit gegevensbestand bevat de namen van de spelers. Wanneer een speler een punt scoort, staat zijn naam aan het einde van het bestand. Een typisch score-bestand ziet er als volgt uit:
John - Michael John John Michael John Michael Michael John John
U kunt deze inhoud vinden in de input.txt bestand in de Bron map.
De uitvoer van ons programma schrijft de score regel voor regel naar het scherm. De uitvoer moet zijn:
John - Michael John: 15 - Michael: 0 John: 30 - Michael: 0 John: 30 - Michael: 15 John: 40 - Michael: 15 John: 40 - Michael: 30 Deuce John: Advantage John: Winnaar
Deze uitvoer is ook te vinden in de output.txt het dossier. We zullen deze informatie gebruiken om te controleren of ons programma correct is.
U schrijft acceptatietests aan het begin van een project / kenmerk / verhaal wanneer u een specifieke vereiste duidelijk kunt definiëren. In ons geval roept deze test eenvoudig ons binnenkort te maken script op met de naam van het invoerbestand als parameter, en het verwacht dat de uitvoer identiek is aan het handgeschreven bestand uit het vorige gedeelte:
#! / usr / bin / env sh ### acceptanceTest.sh ### function testItCanProvideAllTheScores () cd ... /tennisGame.sh ./input.txt> ./results.txt diff ./output.txt ./results.txt assertTrue 'Verwachte output verschilt.' $? ## Bel en voer alle tests uit. "... /shunit2-2.1.6/src/shunit2"
We zullen onze tests uitvoeren in de Bron / Tests map; daarom, CD… neemt ons mee naar de Bron directory. Vervolgens probeert het uit te voeren tennisGamse.sh, wat nog niet bestaat. Dan de diff commando vergelijkt de twee bestanden: ./output.txt is onze handgeschreven uitvoer en ./results.txt bevat het resultaat van ons script. Tenslotte, assertTrue controleert de eindwaarde van diff.
Maar voor nu retourneert onze test de volgende fout:
$ ./acceptanceTest.sh testItCanProvideAllTheScores ./acceptanceTest.sh: regel 7: tennisGame.sh: opdracht niet gevonden diff: ./results.txt: geen bestand of directory ASSERT: verwachte uitvoer verschilt. Ran 1-test. FAILED (mislukkingen = 1)
Laten we van die fouten een leuke fout maken door een leeg bestand te maken met de naam tennisGame.sh en maak het uitvoerbaar. Wanneer we onze test uitvoeren, krijgen we geen foutmelding:
./acceptanceTest.sh testItCanProvideAllTheScores 1,9d0 < John - Michael < John: 15 - Michael: 0 < John: 30 - Michael: 0 < John: 30 - Michael: 15 < John: 40 - Michael: 15 < John: 40 - Michael: 30 < Deuce < John: Advantage < John: Winner ASSERT:Expected output differs. Ran 1 test. FAILED (failures=1)
Maak nog een bestand met de naam unitTests.sh voor onze unit tests. We willen ons script niet voor elke test uitvoeren; we willen alleen de functies uitvoeren die we testen. Dus we zullen maken tennisGame.sh voer alleen de functies uit waarin deze zich bevinden functions.sh:
#! / usr / bin / env sh ### unitTest.sh ### source ... /functions.sh function testItCanProvideFirstPlayersName () assertEquals 'John "getFirstPlayerFrom' John - Michael" ## Bel en voer alle tests uit. "... /shunit2-2.1.6/src/shunit2"
Onze eerste test is eenvoudig. We proberen de naam van de eerste speler te achterhalen wanneer een regel twee namen bevat, gescheiden door een koppelteken. Deze test mislukt omdat we nog geen hebben getFirstPlayerFrom functie:
$ ./unitTest.sh testItCanProvideFirstPlayersName ./unitTest.sh: regel 8: getFirstPlayerFrom: opdracht niet gevonden shunit2: ERROR assertEquals () vereist twee of drie argumenten; 1 gegeven shunit2: ERROR 1: John 2: 3: Ran 1-test. OK
De implementatie voor getFirstPlayerFromis heel eenvoudig. Het is een reguliere expressie die door de. Wordt geduwd sed commando:
### functions.sh ### function getFirstPlayerFrom () echo $ 1 | sed -e's /-.*// '
Nu passeert de test:
$ ./unitTest.sh testItCanProvideFirstPlayersName Ran 1-test. OK
Laten we nog een test schrijven voor de naam van de tweede speler:
### unitTest.sh ### [...] functie testItCanProvideSecondPlayersName () assertEquals 'Michael "getSecondPlayerFrom' John - Michael"
De mislukking:
./unitTest.sh testItCanProvideFirstPlayersName testItCanProvideSecondPlayersName ASSERT: verwacht:maar was: Ran 2-tests. FAILED (mislukkingen = 1)
En nu de functie-implementatie om het te laten slagen:
### functions.sh ### [...] function getSecondPlayerFrom () echo $ 1 | sed -e's /.*-// '
Nu hebben we tests afgelegd:
$ ./unitTest.sh testItCanProvideFirstPlayersName testItCanProvideSecondPlayersName Ran 2 tests. OK
Vanaf dit punt zullen we een test en de implementatie schrijven, en ik zal alleen uitleggen wat het verdient om genoemd te worden.
Laten we testen of we een speler hebben met slechts één score. De volgende test toegevoegd:
function testItCanGetScoreForAPlayerWithOnlyOneWin () standings = $ 'John - Michael \ nJohn' assertEquals '1 "getScoreFor' John '" $ klassement "'
En de oplossing:
functie getScoreFor () player = $ 1 stand = $ 2 totalMatches = $ (echo "$ standings" | grep $ player | wc -l) echo $ (($ totalMatches-1))
We gebruiken enkele fancy-broeken met aanhalingstekens om de newline-reeks te passeren (\ n) binnen een stringparameter. Dan gebruiken we grep om de regels te vinden die de naam van de speler bevatten en tel ze mee wc. Ten slotte trekken we er een af van het resultaat om de aanwezigheid van de eerste regel tegen te gaan (het bevat alleen niet-scoregegevens).
Nu zijn we in de refactoringfase van TDD.
Ik realiseerde me net dat de code eigenlijk voor meer dan één punt per speler werkt, en we kunnen onze tests refactoren om dit weer te geven. Wijzig de bovenstaande testfunctie naar het volgende:
function testItCanGetScoreForAPlayer () standings = $ 'John - Michael \ nJohn \ nMichael \ nJohn' assertEquals '2 "getScoreFor' John '" $ klassement "'
De tests gaan nog steeds voorbij. Tijd om verder te gaan met onze logica:
function testItCanOutputScoreAsInTennisForFirstPoint () assertEquals 'John: 15 - Michael: 0' "'displayScore' John '1' Michael '0'"
En de implementatie:
function displayScore () if ["$ 2" -eq '1']; then spelerOneScore = "15" fi echo "$ 1: $ playerOneScore - $ 3: $ 4"
Ik controleer alleen de tweede parameter. Dit lijkt erop dat ik valsspeel, maar het is de eenvoudigste code om de test te laten slagen. Het schrijven van een andere test dwingt ons om meer logica toe te voegen, maar welke test moeten we daarna schrijven??
Er zijn twee paden die we kunnen nemen. Testen of de tweede speler een punt krijgt, dwingt ons een ander te schrijven als verklaring, maar we hoeven alleen maar een toe te voegen anders verklaring als we ervoor kiezen om het tweede punt van de eerste speler te testen. Dit laatste impliceert een eenvoudiger implementatie, dus laten we dat eens proberen:
function testItCanOutputScoreAsInTennisForSecondPointFirstPlayer () assertEquals 'John: 30 - Michael: 0' "'displayScore' John '2' Michael '0'"
En de implementatie:
function displayScore () if ["$ 2" -eq '1']; then playerOneScore = "15" else playerOneScore = "30" fi echo "$ 1: $ playerOneScore - $ 3: $ 4"
Dit ziet er nog steeds vreemd uit, maar het werkt perfect. Verdergaand op het derde punt:
function testItCanOutputScoreAsInTennisForTHIRDPointFirstPlayer () assertEquals 'John: 40 - Michael: 0' "'displayScore' John '3' Michael '0'"
De implementatie:
function displayScore () if ["$ 2" -eq '1']; then playerOneScore = "15" elif ["$ 2" -eq '2']; then playerOneScore = "30" else playerOneScore = "40" fi echo "$ 1: $ playerOneScore - $ 3: $ 4"
Deze if-elif-else begint me te irriteren. Ik wil het veranderen, maar laten we eerst onze testen refactoren. We hebben drie zeer vergelijkbare tests; dus laten we ze in een enkele test schrijven die drie beweringen doet:
function testItCanOutputScoreWhenFirstPlayerWinsFirst3Points () assertEquals 'John: 15 - Michael: 0' "'displayScore' John '1' Michael '0'" assertEquals 'John: 30 - Michael: 0' "'displayScore' John '2' Michael '0' "assertEquals 'John: 40 - Michael: 0'" 'displayScore' John '3' Michael '0' "
Dat is beter, en het gaat nog steeds over. Laten we nu een soortgelijke test maken voor de tweede speler:
function testItCanOutputScoreWhenSecondPlayerWinsFirst3Points () assertEquals 'John: 0 - Michael: 15' "'displayScore' John '0' Michael '1'" assertEquals 'John: 0 - Michael: 30' "'displayScore' John '0' Michael '2' "assertEquals 'John: 0 - Michael: 40'" 'displayScore' John '0' Michael '3' "
Het uitvoeren van deze test resulteert in interessante resultaten:
Accentsconagua
