Vous êtes sur la page 1sur 17

Les tests unitaires

sous PowerShell avec PSExpect


Par Laurent Dardenne, le 28 mai 2008.

Niveau

PSExpect est un framework de test pour PowerShell, voyons comment il facilite


l’écriture de scénarios de tests unitaires.

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 1 / 17
Chapitres

1 TESTS UNITAIRES ..........................................................................................................................................3

2 INSTALLATION DE PSEXPECT...................................................................................................................4
2.1 CONFIGURATION OPTIONNEL DU PROFILE DE POWERSHELL ........................................................................4
3 UN PREMIER TEST.........................................................................................................................................4
3.1 LISTES DES OBJECTIFS LES PLUS COURANT ..................................................................................................8
3.2 LE RESULTAT DE L'EXPRESSION DOIT ETRE VRAI .........................................................................................8
3.3 VERIFIER QU'UNE VALEUR EST BIEN LA VALEUR ATTENDUE ........................................................................8
3.4 VERIFIER QU'UNE VARIABLE OU UNE PROPRIETE N'EST PAS ASSIGNEE .........................................................8
3.5 VERIFIER QU'UNE VARIABLE OU UNE PROPRIETE A ETE ASSIGNEE ...............................................................8
3.6 VERIFIER QUE 2 VARIABLES POINTENT SUR LA MEME REFERENCE...............................................................9
3.7 VERIFIER QU'UNE VALEUR EXISTE DANS UN TABLEAU .................................................................................9
3.8 VERIFIER QU'UNE VALEUR EST D’UNE CLASSE DONNEE ...............................................................................9
3.9 VERIFIER QU’UNE CHAINE DE CARACTERES MATCH UNE EXPRESSION REGULIERE.......................................9
3.10 VERIFIER QU'UNE EXCEPTION EST BIEN GENEREE ......................................................................................10
3.11 LE TEST NE DOIT PAS GENERER D'EXCEPTION ............................................................................................10
3.12 FILTRER L’AFFICHAGE DU RESULTAT DES TESTS .......................................................................................11
3.13 FILTRER L’EXECUTION DES TESTS .............................................................................................................11
4 LISTE DES FONCTIONS DE TESTLIB ......................................................................................................12
4.1 ASSERT-BLOCK .........................................................................................................................................12
4.2 ASSERT......................................................................................................................................................12
4.3 ASSERTEQUAL ..........................................................................................................................................12
4.4 ASSERTNOTEQUAL ...................................................................................................................................12
4.5 ASSERTINTOLERANCE...............................................................................................................................13
4.6 ASSERTINSTANCEOF .................................................................................................................................13
4.7 ASSERTMATCH .........................................................................................................................................13
4.8 ASSERTNOMATCH ....................................................................................................................................13
4.9 ASSERTNULL ............................................................................................................................................13
4.10 ASSERTNOTNULL .....................................................................................................................................13
4.11 ASSERTSAME ............................................................................................................................................13
4.12 ASSERTNOTSAME .....................................................................................................................................14
4.13 ASSERTTHROWS........................................................................................................................................14
4.14 ASSERTFASTER .........................................................................................................................................14
4.15 ASSERTCONTAINS .....................................................................................................................................14
4.16 FAIL ..........................................................................................................................................................14
4.17 BUILDLOGENTRY......................................................................................................................................14
4.18 BUILDMESSAGE ........................................................................................................................................15
4.19 RAISEASSERTIONS ....................................................................................................................................15
4.20 GETFOREGROUNDCOLOUR .......................................................................................................................15
4.21 SET-RAISEASSERTIONFILTER....................................................................................................................15
4.22 GET-RAISEASSERTIONFILTER ...................................................................................................................15
4.23 SET-TESTCONDITIONFILTER .....................................................................................................................16
4.24 GET-TESTCONDITIONFILTER ....................................................................................................................16
4.25 RESET-RAISEASSERTIONFILTER ...............................................................................................................16
4.26 RESET-TESTCONDITIONFILTER .................................................................................................................16
4.27 INVOKE-BLOCK .........................................................................................................................................16

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 2 / 17
Pré-requis
Connaissance des principes et concepts de script de PowerShell ainsi que des notions de bases
sur les tests unitaires.
La distribution, un ensemble des scripts PowerShell, est disponible sur CodePlex :
http://www.codeplex.com/psexpect

Site de l’auteur : http://laurent-dardenne.developpez.com/

1 Tests unitaires
Vous trouverez dans les tutoriels suivant des explications sur les principes et usages des tests
unitaires. Bien qu’écrit dans d’autres langages, les principes restent identiques.
Les tests unitaires :
http://smeric.developpez.com/java/astuces/tests/

Les assertions, le principe de base de tout framework de test :


http://smeric.developpez.com/java/astuces/assertions/

Le développement dirigé par les tests :


http://bruno-orsier.developpez.com/tutoriels/TDD/pentaminos/index.php

Anti-patrons de tests unitaires (les choses à éviter) :


http://bruno-orsier.developpez.com/anti-patterns/james-carr/

Utilisation de frameworks de Mock en .Net :


http://philippe.developpez.com/articles/IntroductionMock/

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 3 / 17
2 Installation de PSExpect
Une fois l’archive décompressée, un seul répertoire nous intéresse dans un premier temps :
..\Ps1TestLib\src
Il contient une suite de tests portant sur les fonctions déclarées dans le script principal nommé
TestLib.ps1. Le script nommé TestLibConstants.ps1, contenant les constantes et variables
utilisées par PSExpect ainsi que les messages d’erreur, est appelé automatiquement par le script
principal.
Le script DataLib.ps1 contient des fonctions de manipulation de données d’un fichier Excel.
Le répertoire ..\Ps1TestLib\samples contient des tests autour d’assemblies .NET. Certains de ces
scripts de démonstration utilisent le cmdlet Join-String disponible dans PSCX (PowerShell
Community Extensions : http://www.codeplex.com/PowerShellCX ).

Blog de l’auteur de PSExpect : http://testfirst.spaces.live.com/

2.1 Configuration optionnel du profile de PowerShell


Vous pouvez ajouter ces quelques lignes dans votre fichier de profile afin d’accéder rapidement
aux fonctions de tests :
$PSProfile=$Home+"\Mes documents\WindowsPowerShell"
$PSTools=$PSProfile+"\Tools"

function TestLib{
if (!(Test-Path variable:_TESTLIB))
{ & "$PSTools\Ps1TestLib\src\TestLib.ps1"
Write-Host "Librairie de test chargée." -foreground Green
}
else {Write-Host "La librairie de test est déjà chargée." -foreground
Yellow}
}

3 Un premier test
L’appel suivant déclare les fonctions de test :
if (!(Test-Path variable:_TESTLIB)) { .\TestLib.ps1 }
Notez qu’elles sont globales il n’est donc pas nécessaire d’utiliser le dot sourcing.
Chaque test devra être exécuté en déclarant au préalable le paramétrage suivant :
set-psdebug -strict -trace 0
Ce qui force PowerShell à déclencher une exception si une variable est référencée avant qu’elle
n’ait été déclarée.

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 4 / 17
Les résultats des tests sont mémorisés dans une liste nommée $Assertions. Chaque élément de
cette liste contient une hash table :
Nom Description
Label Nom du test
Ex : Test sans paramètre de Close-Resource
Timestamp Date et heure de fin d’exécution du test
Ex : 06/05/2008 10:29:28
Message Message d’informations
Ex : System.SystemException expected but was
System.Management.Automation.RuntimeException
Result Résultat du test. Voir la hashtable ResultPrefix("PASSED","FAILED")
Ex : FAILED
Intent Indique le résultat attendu lors de l'évaluation du test. SHOULDFAIL permet
de tester les cas qui échouent, par exemple les cas d’erreurs gérés
explicitement dans le script.
Voir Intention("SHOULDPASS","SHOULDFAIL")
Ex : SHOULDPASS
Certaines fonctions de test, tel que AssertThrows, peuvent créer plusieurs éléments dans la liste
$Assertions.
Toutes les fonctions nommées AssertXXX comportent un paramètre nommé $Intent qui est par
défaut initialisé avec la valeur $Intention.ShouldPass.

PSExpect permet de mémoriser, dans un fichier ASCII, le résultat des tests au fur et à mesure de
leurs exécutions. Voici les variables se rapportant au logging :
$LogFileName Nom complet du fichier de log.
Valeur par défaut : "./acceptance-test-log.txt"
$ LogFileFieldSeparator Séparateur de champs, utilisé dans la fonction BuildLogEntry.
Valeur par défaut : ","
$ LogFileLineLength Longueur de la ligne de caractères, voir le paramètre -width du
cmdlet Out-File
Valeur par défaut : 240
Si vous souhaitez annuler l’opération de log, affectez la valeur $Null à $LogFileName
$Global:LogFileName = "./acceptance-test-log.txt"
Effectuons un premier test vérifiant la proposition, ou l’assertion, suivante : 1 est égale à 1
Assert (1 -eq 1)

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 5 / 17
Notez que dans ce cas on passe en paramètre le résultat d’une expression évaluée en premier.
Affichons le contenu de la liste générée par l’exécution de ce test :
$Assertions
Name Value
---- -----
Label
Timestamp 06/05/2008 13:54:59
Message
Result PASSED
Intent SHOULDPASS

Il nous manque une description du test, ajoutons-la :


$Assertions.clear() # raz de la liste des tests
Assert (1 -eq 1) –Label “Test 1 –eq 1”
$Assertions
Name Value
---- -----
Label Test 1 -eq 1 #note de l’auteur $Assertions[0]
Timestamp 06/05/2008 13:57:09
Message
Result PASSED
Intent SHOULDPASS

Maintenant utilisons la fonction AssertEqual qui nécessite 2 valeurs pour effectuer le


test demandé. D’autres formes d’appel sont possibles, consulter le code de cette fonction pour
retrouver les règles qui s’appliquent.
La première est la valeur à tester ou le résultat obtenu s’il s’agit d’une expression ou d’un
scriptbloc et la seconde le résultat attendu, dans l’exemple suivant on souhaite vérifier la réussite
de notre premier test en contrôlant si $Assertions[0].Result) est égal à $ResultPrefix.Passed:
AssertEqual $Assertions[0].Result $ResultPrefix.Passed "Contrôle sur le
résultat du premier test"
$Assertions[1]
Name Value
---- -----
Label Contrôle sur le résultat du premier test #note de l’auteur $Assertions[1]
Timestamp 06/05/2008 13:59:53
Message
Result PASSED
Intent SHOULDPASS
Attention à la casse de la variable $ResultPrefix.Passed.
On peut voir que pour ce dernier test, le champ Message est renseigné et nous indique que la
valeur contenue dans $Assertions[0].Result est bien égale à $ResultPrefix.Passed.

Essayons maintenant de tester une assertion que l’on sait erronée :


AssertEqual (1 –eq 2) $true –label "Test-1 d’échec"

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 6 / 17
Name Value
---- -----
Label Test-1 d’échec
Timestamp 06/05/2008 15:33:27
Message False expected but was but True.
Result FAILED
Intent SHOULDPASS

Ici le test échoue (result=FAILED), son résultat sera affiché en rouge lors de l’appel à
RaiseAssertions, fonction affichant un compte rendu basé sur des codes couleurs.
Précisons notre intention par l’ajout du paramètre –intent $Intention.ShouldFail :
AssertEqual (1 –eq 2) $true –label "Test-2 de logique inverse " –intent
$Intention.ShouldFail
Name Value
---- -----
Label Test-2 de logique inverse
Timestamp 06/05/2008 15:33:27
Message False expected but was True.
Result FAILED
Intent SHOULDFAIL
Ici le test échoue également mais comme on précise, à l’aide du paramètre -Intent, qu’on attend
un échec ($Intention.ShouldFail) son résultat sera affiché en jaune.
Enfin utilisons l’assertion AssertNotEqual qui facilite la lecture et l’interprétation des tests au
lieu d’utiliser une logique inverse :
AssertNotEqual (1 –eq 2) $true –label "Test-3 réécriture "
Name Value
---- -----
Label Test-3 réécriture
Timestamp 06/05/2008 15:33:27
Message
Result PASSED
Intent SHOULDPASS
Ici le test d’échec réussie ;-) son résultat sera affiché en vert.
L’appel de RaiseAssertions nous affichera donc le résultat suivant :

Les lignes affichés en vert indique un test réussi, celle en rouge un test en échec et celles en
jaune un test devant échouer.
Consultez les scripts de tests de la distribution, ils contiennent de nombreux cas d’exécution qu’il
n’est pas nécessaire de reprendre ici.
Notez que lorsque je dis «l’appel de RaiseAssertions nous affichera donc le résultat suivant » je
présuppose pour ce procédé de test des conditions de fonctionnement correct.
La construction des chapitres suivant est inspirée du tutoriel : Les tests unitaires avec Nunit
http://jab.developpez.com/tutoriels/dotnet/nunit/

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 7 / 17
3.1 Listes des objectifs les plus courant
Chaque exemple de code peut être précédé de l’instruction suivante :
$Assertions.Clear()
Tout en sachant que l’appel suivant effectue indirectement la même opération :
RaiseAssertions

3.2 Le résultat de l'expression doit être vrai


On utilisera l’assertion Assert.
$F= dir C:\*.*
Assert ($F.Count –gt 2) –label "Test d’expression vrai "
RaiseAssertions

3.3 Vérifier qu'une valeur est bien la valeur attendue


On utilisera l’assertion AssertEqual.
$Test=(Test-Path variable:_TESTLIB)
AssertEqual $Test $true –label "Test d’existence de la variable _TESTLIB"
RaiseAssertions

3.4 Vérifier qu'une variable ou une propriété n'est pas assignée


On utilisera l’assertion AssertNull.
$newvar = $null
AssertNull $newvar –label "Test-1 d’assignation à `$Null"
$newvar = "variable assignée"
AssertNull $newvar –label "Test-2 d’assignation à `$Null"
RaiseAssertions

3.5 Vérifier qu'une variable ou une propriété a été assignée


On utilisera l’assertion AssertNotNull.
$newvar = $null
AssertNotNull $newvar –label "Test-1 d’assignation différent de `$Null"
$newvar = "variable assignée"
AssertNotNull $newvar –label "Test-2 d’assignation différent de `$Null"
RaiseAssertions

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 8 / 17
3.6 Vérifier que 2 variables pointent sur la même référence.
On utilisera l’assertion AssertSame.
$a = new-object System.Collections.Arraylist
$b = $a
AssertSame $a $b "Test de références identiques"
$a = new-object System.Collections.Arraylist
$b = new-object System.Collections.Arraylist
AssertSame $a $b "Test de références différentes"
RaiseAssertions

3.7 Vérifier qu'une valeur existe dans un tableau


On utilisera l’assertion AssertContains.
$msg="Test de présence d’une valeur dans un tableau"
$c = "red", "blue"
$services = get-service
foreach ($s in $services) { $c = $c + $s.Name }
AssertContains $c $services[2].Name -Label $msg
RaiseAssertions

3.8 Vérifier qu'une valeur est d’une classe donnée


On utilisera l’assertion AssertInstanceOf.
AssertInstanceOf Int32 1 -Label "Test sur le type d’une variable"
AssertInstanceOf Int32 "String" -Label "Test sur le type d’une variable"
RaiseAssertions

3.9 Vérifier qu’une chaîne de caractères match une expression régulière


On utilisera l’assertion AssertMatch.
$MyRegexp="197\d{1}"
$str ="On recherche une date (1979)"
AssertMatch $str $MyRegexp -Label "Test avec une expression régulière "
$str ="On recherche une date (197A)"
AssertMatch $str $MyRegexp -Label "Test avec une expression régulière "
RaiseAssertions

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 9 / 17
3.10 Vérifier qu'une exception est bien générée
On utilisera l’assertion AssertThrows.
$msg = "la variable Required doit être renseignée."
Function Test-Parameter($Required=$(throw $msg)) { write "fait qq chose" }
$sbTest = { Test-Parameter }
AssertThrows System.Management.Automation.RuntimeException $msg $sbTest "
Appel sans paramètre"
RaiseAssertions

Pour cet exemple le test génère 2 lignes de compte rendu. La première concerne le résultat d’un
test sur le type de l’exception attendue et la seconde concerne le résultat d’un test sur une chaîne
devant être contenue dans le champ message de l’exception générée. La chaîne recherchée peut
être une expression régulière.
On peut donc avoir en résultat une combinaison d’état :
AssertThrows System.Management.Automation.RuntimeException "RAS" $sbtest "
Appel sans paramètre"
AssertThrows $null $msg $sbTest " Appel sans paramètre"
RaiseAssertions

3.11 Le test ne doit pas générer d'exception


On utilisera l’assertion AssertThrows couplée au paramètre $Intention.ShouldFail.
$Assertions.Clear()
$msg = "la variable Required doit être renseignée."
Function Test-Parameter($Required=$(throw $msg)) { write "fait qq chose" }
$sbTest = { Test-Parameter Test}
AssertThrows System.Management.Automation.RuntimeException $msg $sbTest
"Appel avec paramètre" -Intent $Intention.ShouldFail
RaiseAssertions

Notez que l’information de compte rendu indique qu’aucune exception n’a été déclenchée.

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 10 / 17
3.12 Filtrer l’affichage du résultat des tests
La variable globale $RaiseAssertionFilter est une expression régulière, elle permet de filtrer le
résultat des tests lors de l’appel à $RaiseAssertions. La reconnaissance s’effectue sur la
concaténation des champs Result et Label.
Dans l’exemple suivant on affichera les tests qui ont réussit, c’est à dire ceux dont le champ
Result est égal à PASSED, ET ceux dont le champ label, la description du test, contient la suite
de caractères "test" :
#voir le script ..\src\TestAll.ps1
$RaiseAssertionFilter = "PASSED(.*)test"

3.13 Filtrer l’exécution des tests


La variable globale $TestConditionFilter est une expression régulière, elle permet de filtrer
l’exécution des tests. La reconnaissance s’effectue sur le champ Label.
Dans l’exemple suivant on exécutera seulement les tests dont le champ label, la description du
test, contient la suite de caractères "TC-1\b" :
#voir le script ..\src\TestAll.ps1
$TestConditionFilter = "TC-1\b"
\b étant une expression indiquant une limite de mot.

A propos des expressions régulières :


http://msdn.microsoft.com/fr-fr/library/ae5bf541(VS.80).aspx
http://lgmorand.developpez.com/dotnet/regex/
http://technet.microsoft.com/fr-fr/magazine/cc137764.aspx

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 11 / 17
4 Liste des fonctions de TestLib
Dans les signatures des fonctions suivantes notez que :
$Expected est la valeur attendue en fin d’exécution,
$Actual est la valeur actuel ou réellement obtenue s’il s’agit d’une expression ou d’un
scriptbloc,
$Label est la description du test,
$Intent détermine l’objectif du test. Pour tester la réussite d’une opération indiquez
$Intention.ShouldPass qui est la valeur par défaut, pour tester l’échec d’une opération indiquez
$Intention.ShouldFail.

4.1 Assert-Block
Assert-Block([ScriptBlock]$Script, $Label, $Message, $Intent = $Intention.ShouldPass)
$Message : description de l’erreur si le test échoue.
Traitement de base utilisé par toutes les fonctions d’assertion. Evalue le scriptblock si toutefois il
répond aux critères fixés, voir le chapitre « Filtrer l’affichage du résultat des tests ».
Le résultat du test est écrit dans le fichier de log contenu dans la variable globale
$LogFileName, et une entrée est ajoutée à la liste $Assertions.

4.2 Assert
Assert($BoolExpr, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : l’expression booléenne est vraie.

4.3 AssertEqual
AssertEqual($Expected, $Actual, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : les deux arguments ont la même valeur.

4.4 AssertNotEqual
AssertNotEqual($Expected, $Actual, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : les deux arguments n’ont pas la même valeur.

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 12 / 17
4.5 AssertInTolerance
AssertInTolerance([double]$Expected, [double]$Actual, [double]$Tolerance, $Label, $Intent =
$Intention.ShouldPass)
Vérifie la proposition : les deux arguments sont considérés comme égaux s’il respecte une
tolérance.
AssertInTolerance 2.1 2.2 0.1 "Ce test réussi"
AssertInTolerance 2.1 2.7 0.3 "Ce test échoue"

4.6 AssertInstanceOf
AssertInstanceOf($ExpectedType, $Actual, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : le type de l’objet ($Actual) est du type attendu ($ExpectedType).

4.7 AssertMatch
AssertMatch([string]$ContainingString, [string]$RegExpr, $Label, $Intent =
$Intention.ShouldPass)
Vérifie la proposition : la chaîne de caractères ($ContainingString) est reconnue par l’expression
régulière ($RegExpr).

4.8 AssertNoMatch
AssertNoMatch([String]$ContainingString, [String]$RegExpr, $Label, $Intent =
$Intention.ShouldPass)
Vérifie la proposition : la chaîne de caractères ($ContainingString) n’est pas reconnue par
l’expression régulière ($RegExpr).

4.9 AssertNull
AssertNull($Proposition, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : l’objet, l’expression ou le résultat d’appel d’un code est $null.

4.10 AssertNotNull
AssertNotNull($Proposition, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : l’objet, l’expression ou le résultat d’appel d’un code n’est pas $null.

4.11 AssertSame
AssertSame($Expected, $Actual, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : les deux arguments référencent le même objet.

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 13 / 17
4.12 AssertNotSame
AssertNotSame($Expected, $Actual, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : les deux arguments ne référencent pas le même objet.

4.13 AssertThrows
AssertThrows($ExceptionExpected, $MessageExpectedRegExpr, [ScriptBlock]$Script, $Label,
$Intent = $Intention.ShouldPass)
Vérifie la proposition : le type de l’exception attendue et le message recherché correspondent.
On cherche à savoir si une exception c’est bien déclenchée et que son champ message contient
bien la chaîne de caractères recherchée.

4.14 AssertFaster
AssertFaster([Int32]$MaximumTime, [ScriptBlock]$Script, $Label, $Intent =
$Intention.ShouldPass)
Vérifie la proposition : le scriptblock s’exécute dans le temps imparti ($MaximumTime). L’unité
est la milliseconde.

4.15 AssertContains
AssertContains($Container, $Item, $Label, $Intent = $Intention.ShouldPass)
Vérifie la proposition : le tableau $Container contient l’élément $Item.

4.16 Fail
Fail($Label)
Label : Nom de l’entrée créé
Crée, indépendamment de l’exécution d’une assertion, une entrée dans la liste $Assertions.
Le champ Message contient la chaîne : Intentionally failed.

4.17 BuildLogEntry
BuildLogEntry($Intent, $ResultPrefix, $Label, $Message)
Crée, indépendamment de l’exécution d’un bloc de code, une entrée dans la liste $Assertions.
$entry = BuildLogEntry $Intention.ShouldPass $ResultPrefix.Passed
"Création manuelle" " Message"
[void]$Assertions.Add($entry)
RaiseAssertions
Note : dans ce cas le fichier $LogFileName n’est pas mis à jour.

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 14 / 17
4.18 BuildMessage
BuildMessage([System.Collections.Hashtable]$TestResult)
Construit une ligne de message pour l’affichage ou le fichier de log.
$entry = BuildLogEntry $Intention.ShouldPass $ResultPrefix.Passed
"Création manuelle" " Message"
$logEntry = BuildMessage $entry
#Ecriture dans le fichier de log
$logEntry | out-file $LogFileName -append -width $LogFileLineLength
#Affichage sur la Console
$backColour = $ResultColour.Background
$foreColour = GetForegroundColour $entry
write-host $logEntry -foregroundcolor $foreColour -backgroundcolor
$backColour

4.19 RaiseAssertions
Affiche sur la console, à l’aide de Write-Host, le contenu de la liste $Assertions. Attention cette
fonction efface le contenu de la liste $Assertions. Vous pouvez utiliser le logging afin de ne pas
perdre d’informations.

4.20 GetForegroundColour
GetForegroundColour($decision)
Détermine et renvoi, d’après le contenu des champs intent et result, la couleur du texte utilisée
lors de l’affichage sur la console.
La hashtable $ResultColour contient les valeurs suivantes :
Error=Red
Warning=Yellow
Success=Green
Background=Black

4.21 Set-RaiseAssertionFilter
Set-RaiseAssertionFilter([string]$filter)
Affecte une valeur à la variable globale $RaiseAssertionFilter.

4.22 Get-RaiseAssertionFilter
Obtient la valeur de la variable globale $RaiseAssertionFilter.

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 15 / 17
4.23 Set-TestConditionFilter
Set-TestConditionFilter([string]$filter)
Affecte une valeur à la variable globale $TestConditionFilter.

4.24 Get-TestConditionFilter
Obtient la valeur de la variable globale $TestConditionFilter.

4.25 Reset-RaiseAssertionFilter
Affecte la valeur $DefaultRaiseAssertionFilter à la variable globale $RaiseAssertionFilter.

4.26 Reset-TestConditionFilter
Affecte la valeur $DefaultTestConditionFilter à la variable globale $TestConditionFilter.

4.27 Invoke-Block
Invoke-Block([string]$Label, [ScriptBlock]$Script)
Crée une entrée et l’ajoute à la liste $Assertions, puis l’enregistre dans le fichier de log contenu
dans la variable globale $LogFileName. Et enfin évalue le scriptblock passé en paramètres.
Les trois alias Given, When et Then pointent tous sur cette fonction qui ne vérifie aucune
proposition.

A propos de la convention «Given-When-Then»


Behavior Driven Development:
http://en.wikipedia.org/wiki/Behavior_driven_development
Behaviour Driven Development with Powershell:
http://testfirst.spaces.live.com/blog/cns!7E0657B7A0134A74!188.entry
Projet d’implémentation .NET disponible sur Codeplex :
http://www.codeplex.com/NBehave

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 16 / 17
Enfin en conclusion n’oubliez pas cette réflexion :
“Testing can prove the presence of bugs, but never their absence.” (Dijkstra)
“Les tests peuvent prouver la présence de bogues, mais jamais leur absences.“
http://en.wikiquote.org/wiki/Edsger_Dijkstra

Bon tests :-)

Laurent Dardenne, libre de droits pour tous les usages non commerciaux. Page 17 / 17