summaryrefslogtreecommitdiff
path: root/tests/test_tools/simpletest/docs/fr/group_test_documentation.html
blob: 662f868e5e7156aa1469f71494ad59e451bbb793 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Documentation SimpleTest : Grouper des tests</title>
<link rel="stylesheet" type="text/css" href="docs.css" title="Styles">
</head>
<body>
<div class="menu_back">
<div class="menu">
<h2>
<a href="index.html">SimpleTest</a>
</h2>
<ul>
<li>
<a href="overview.html">Overview</a>
</li>
<li>
<a href="unit_test_documentation.html">Unit tester</a>
</li>
<li>
<a href="group_test_documentation.html">Group tests</a>
</li>
<li>
<a href="server_stubs_documentation.html">Server stubs</a>
</li>
<li>
<a href="mock_objects_documentation.html">Mock objects</a>
</li>
<li>
<a href="partial_mocks_documentation.html">Partial mocks</a>
</li>
<li>
<a href="reporter_documentation.html">Reporting</a>
</li>
<li>
<a href="expectation_documentation.html">Expectations</a>
</li>
<li>
<a href="web_tester_documentation.html">Web tester</a>
</li>
<li>
<a href="form_testing_documentation.html">Testing forms</a>
</li>
<li>
<a href="authentication_documentation.html">Authentication</a>
</li>
<li>
<a href="browser_documentation.html">Scriptable browser</a>
</li>
</ul>
</div>
</div>
<h1>Documentation sur le groupement des tests</h1>
<div class="content">
        <p>
<a class="target" name="grouper">
<h2>Grouper des tests</h2>
</a>
</p>
            <p>
                Pour lancer les sc&eacute;narios de tests en tant que groupe, ils devraient &ecirc;tre plac&eacute;s dans des fichiers sans le code du lanceur...
<pre>
<strong>&lt;?php
    require_once('../classes/io.php');

    class FileTester extends UnitTestCase {
        ...
    }

    class SocketTester extends UnitTestCase {
        ...
    }
?&gt;</strong>
</pre>
                Autant de sc&eacute;narios que n&eacute;cessaires peuvent &ecirc;tre mis dans un fichier unique. Ils doivent contenir tout le code n&eacute;cessaire, entre autres la biblioth&egrave;que test&eacute;e, mais aucune des biblioth&egrave;ques de SimpleTest.
            </p>
            <p>
                Si vous avez &eacute;tendu l'un ou l'autre des sc&eacute;narios de test, vous pouvez aussi les inclure.
<pre>
&lt;?php
    require_once('../classes/io.php');
<strong>
    class MyFileTestCase extends UnitTestCase {
        ...
    }
    SimpleTestOptions::ignore('MyFileTestCase');</strong>

    class FileTester extends MyFileTestCase {
        ...
    }

    class SocketTester extends UnitTestCase {
        ...
    }
?&gt;
</pre>
                La classe <span class="new_code">FileTester</span> ne contient aucun test v&eacute;ritable, il s'agit d'une classe de base pour d'autres sc&eacute;narios de test. Pour cette raison nous utilisons la directive <span class="new_code">SimpleTestOptions::ignore()</span> pour indiquer au prochain groupe de test de l'ignorer. Cette directive peut se placer n'importe o&ugrave; dans le fichier et fonctionne quand un fichier complet des sc&eacute;narios de test est charg&eacute; (cf. ci-dessous). Nous l'appelons <em>file_test.php</em>.
            </p>
            <p>
                Ensuite nous cr&eacute;ons un fichier de groupe de test, disons <em>group_test.php</em>. Vous penserez &agrave; un nom plus convaincant, j'en suis s&ucirc;r. Nous lui ajoutons le fichier de test avec une m&eacute;thode sans risque...
<pre>
&lt;?php
    require_once('simpletest/unit_tester.php');
    require_once('simpletest/reporter.php');<strong>
    require_once('file_test.php');

    $test = &amp;new GroupTest('All file tests');
    $test-&gt;addTestCase(new FileTestCase());
    $test-&gt;run(new HtmlReporter());</strong>
?&gt;
</pre>
                Ceci instancie le sc&eacute;nario de test avant que la suite de test ne soit lanc&eacute;e. &Ccedil;a pourrait devenir assez on&eacute;reux avec un grand nombre de sc&eacute;narios de test : il existe donc une autre m&eacute;thode qui instancie la classe uniquement quand elle devient n&eacute;cessaire...
<pre>
&lt;?php
    require_once('simpletest/unit_tester.php');
    require_once('simpletest/reporter.php');
    require_once('file_test.php');

    $test = &amp;new GroupTest('All file tests');<strong>
    $test-&gt;addTestClass('FileTestCase');</strong>
    $test-&gt;run(new HtmlReporter());
?&gt;
</pre>
                Le probl&egrave;me de cette technique est que pour chaque sc&eacute;nario de test suppl&eacute;mentaire nous aurons &agrave; <span class="new_code">require_once()</span> le fichier de code de test et &agrave; manuellement instancier chaque sc&eacute;nario de test. Nous pouvons nous &eacute;pargner beaucoup de dactylographie avec...
<pre>
&lt;?php
    require_once('simpletest/unit_tester.php');
    require_once('simpletest/reporter.php');

    $test = &amp;new GroupTest('All file tests');<strong>
    $test-&gt;addTestFile('file_test.php');</strong>
    $test-&gt;run(new HtmlReporter());
?&amp;gt;
</pre>
                Voici ce qui vient de se passer : la classe <span class="new_code">GroupTest</span> a r&eacute;alis&eacute; le <span class="new_code">require_once()</span> pour nous. Ensuite elle v&eacute;rifie si de nouvelles classes de sc&eacute;nario de test ont &eacute;t&eacute; cr&eacute;&eacute;es par ce nouveau fichier et les ajoute automatiquement au groupe de test. D&eacute;sormais tout ce qu'il nous reste &agrave; faire, c'est d'ajouter chaque nouveau fichier.
            </p>
            <p>
                Il y a deux choses qui peuvent planter et qui demandent un minimum d'attention...
                <ol>
                    <li>
                        Le fichier peut d&eacute;j&agrave; avoir &eacute;t&eacute; analys&eacute; par PHP et dans ce cas aucune classe ne sera ajout&eacute;e. Pensez &agrave; bien v&eacute;rifier que les sc&eacute;narios de test ne sont inclus que dans ce fichier et dans aucun autre.
                    </li>
                    <li>
                        Les nouvelles classes d'extension de sc&eacute;nario de test qui sont incluses seront plac&eacute;es dans le groupe de test et ex&eacute;cut&eacute;es par la m&ecirc;me occasion. Vous aurez &agrave; ajouter une directive <span class="new_code">SimpleTestOptions::ignore()</span> pour ces classes ou alors pensez &agrave; les ajouter avant la ligne <span class="new_code">GroupTest::addTestFile()</span>.
                    </li>
                </ol>
            </p>
        
        <p>
<a class="target" name="plus-haut">
<h2>Groupements de plus haut niveau</h2>
</a>
</p>
            <p>
                La technique ci-dessus place tous les sc&eacute;narios de test dans un unique et grand groupe. Sauf que pour des projets plus cons&eacute;quents, ce n'est probablement pas assez souple ; vous voudriez peut-&ecirc;tre grouper les tests tout &agrave; fait diff&eacute;remment.
            </p>
            <p>
                Pour obtenir un groupe de test plus souple nous pouvons sous classer <span class="new_code">GroupTest</span> et ensuite l'instancier au cas par cas...
<pre>
&lt;?php
    require_once('simpletest/unit_tester.php');
    require_once('simpletest/reporter.php');
    <strong>
    class FileGroupTest extends GroupTest {
        function FileGroupTest() {
            $this-&gt;GroupTest('All file tests');
            $this-&gt;addTestFile('file_test.php');
        }
    }</strong>
?&gt;
</pre>
                Ceci nomme le test dans le constructeur et ensuite ajoute &agrave; la fois nos sc&eacute;narios de test et un unique groupe en dessous. Bien s&ucirc;r nous pouvons ajouter plus d'un groupe &agrave; cet instant. Nous pouvons maintenant invoquer les tests &agrave; partir d'un autre fichier d'ex&eacute;cution...
<pre>
&lt;?php
    require_once('file_group_test.php');
    <strong>
    $test = &amp;new FileGroupTest();
    $test-&gt;run(new HtmlReporter());</strong>
?&gt;
</pre>
                ...ou alors nous pouvons les grouper dans un groupe de tests encore plus grand...
<pre>
&lt;?php
    require_once('file_group_test.php');
    <strong>
    $test = &amp;new BigGroupTest('Big group');
    $test-&gt;addTestCase(new FileGroupTest());
    $test-&gt;addTestCase(...);
    $test-&gt;run(new HtmlReporter());</strong>
?&gt;
</pre>
                Si nous souhaitons lancer le groupe de test original sans utiliser ses petits fichiers d'ex&eacute;cution, nous pouvons mettre le code du lanceur de test derri&egrave;re des barreaux quand nous cr&eacute;ons chaque groupe.
<pre>
&lt;?php
    class FileGroupTest extends GroupTest {
        function FileGroupTest() {
            $this-&gt;GroupTest('All file tests');
            $test-&gt;addTestFile('file_test.php');
        }
    }
    <strong>
    if (! defined('RUNNER')) {
        define('RUNNER', true);</strong>
        $test = &amp;new FileGroupTest();
        $test-&gt;run(new HtmlReporter());
    }
?&gt;
</pre>
                Cette approche exige aux barri&egrave;res d'&ecirc;tre activ&eacute;es &agrave; l'inclusion du fichier de groupe de test, mais c'est quand m&ecirc;me moins de tracas que beaucoup de fichiers de lancement &eacute;parpill&eacute;s. Reste &agrave; inclure des barreaux identiques au niveau sup&eacute;rieur afin de s'assurer que le <span class="new_code">run()</span> ne sera lanc&eacute; qu'une seule fois &agrave; partir du script de haut niveau qui l'a invoqu&eacute;.
<pre>
&lt;?php
    define('RUNNER', true);

    require_once('file_group_test.php');
    $test = &amp;new BigGroupTest('Big group');
    $test-&gt;addTestCase(new FileGroupTest());
    $test-&gt;addTestCase(...);
    $test-&gt;run(new HtmlReporter());
?&gt;
</pre>
                Comme les sc&eacute;narios de test normaux, un <span class="new_code">GroupTest</span> peut &ecirc;tre charg&eacute; avec la m&eacute;thode <span class="new_code">GroupTest::addTestFile()</span>.
<pre>	
&lt;?php	
    define('RUNNER', true);	
 	 	
    $test = &amp;new BigGroupTest('Big group');<strong>	
    $test-&gt;addTestFile('file_group_test.php');	
    $test-&gt;addTestFile(...);</strong>	
    $test-&gt;run(new HtmlReporter());	
?&gt;	
</pre>
            </p>
        
        <p>
<a class="target" name="heritage">
<h2>Int&eacute;grer des sc&eacute;narios de test h&eacute;rit&eacute;s</h2>
</a>
</p>
            <p>
                Si vous avez d&eacute;j&agrave; des tests unitaires pour votre code ou alors si vous &eacute;tendez des classes externes qui ont d&eacute;j&agrave; leurs propres tests, il y a peu de chances pour que ceux-ci soient d&eacute;j&agrave; au format SimpleTest. Heureusement il est possible d'incorporer ces sc&eacute;narios de test en provenance d'autres testeurs unitaires directement dans des groupes de test SimpleTest.
            </p>
            <p>
                Par exemple, supposons que nous ayons ce sc&eacute;nario de test pr&eacute;vu pour <a href="http://sourceforge.net/projects/phpunit">PhpUnit</a>dans le fichier <em>config_test.php</em>...
<pre>
<strong>class ConfigFileTest extends TestCase {
    function ConfigFileTest() {
        $this-&gt;TestCase('Config file test');
    }
    
    function testContents() {
        $config = new ConfigFile('test.conf');
        $this-&gt;assertRegexp('/me/', $config-&gt;getValue('username'));
    }
}</strong>
</pre>
                Le groupe de test peut le reconna&icirc;tre &agrave; partir du moment o&ugrave; nous mettons l'adaptateur appropri&eacute; avant d'ajouter le fichier de test...
<pre>
&lt;?php
    require_once('simpletest/unit_tester.php');
    require_once('simpletest/reporter.php');<strong>
    require_once('simpletest/adapters/phpunit_test_case.php');</strong>

    $test = &amp;new GroupTest('All file tests');<strong>
    $test-&gt;addTestFile('config_test.php');</strong>
    $test-&gt;run(new HtmlReporter());
?&gt;
</pre>
                Il n'y a que deux adaptateurs, l'autre est pour le paquet testeur unitaire de <a href="http://pear.php.net/manual/en/package.php.phpunit.php">PEAR</a>...
<pre>
&lt;?php
    require_once('simpletest/unit_tester.php');
    require_once('simpletest/reporter.php');<strong>
    require_once('simpletest/adapters/pear_test_case.php');</strong>

    $test = &amp;new GroupTest('All file tests');<strong>
    $test-&gt;addTestFile('some_pear_test_cases.php');</strong>
    $test-&gt;run(new HtmlReporter());
?&gt;
</pre>
                Les sc&eacute;narios de test de PEAR peuvent &ecirc;tre librement m&eacute;lang&eacute;s avec ceux de SimpleTest mais vous ne pouvez pas utiliser les assertions de SimpleTest au sein des versions h&eacute;rit&eacute;es des sc&eacute;narios de test. La raison ? Une simple v&eacute;rification que vous ne rendez pas par accident vos sc&eacute;narios de test compl&egrave;tement d&eacute;pendants de SimpleTest. Peut-&ecirc;tre que vous souhaitez publier votre biblioth&egrave;que sur PEAR par exemple : &ccedil;a voudrait dire la livrer avec des sc&eacute;narios de test compatibles avec PEAR::PhpUnit.
            </p>
        
    </div>
<div class="copyright">
            Copyright<br>Marcus Baker, Jason Sweat, Perrick Penet 2004
        </div>
</body>
</html>