最新服务器上的版本，以后用这个
view | history | commit | commitdiff
wangzhenxin
2023-11-19 bc164b8bdbfbdf1d8229a5ced6b08d7cb8db7361
commit | author | age
2207d6 1 # Symfony
W 2
3
4 This module uses Symfony Crawler and HttpKernel to emulate requests and test response.
5
6 ## Demo Project
7
8 <https://github.com/Codeception/symfony-demo>
9
10 ## Config
11
12 ### Symfony 4.x
13
14 * app_path: 'src' - in Symfony 4 Kernel is located inside `src`
15 * environment: 'local' - environment used for load kernel
16 * kernel_class: 'App\Kernel' - kernel class name
17 * em_service: 'doctrine.orm.entity_manager' - use the stated EntityManager to pair with Doctrine Module.
18 * debug: true - turn on/off debug mode
19 * cache_router: 'false' - enable router caching between tests in order to [increase performance](http://lakion.com/blog/how-did-we-speed-up-sylius-behat-suite-with-blackfire)
20 * rebootable_client: 'true' - reboot client's kernel before each request
21
22 #### Example (`functional.suite.yml`) - Symfony 4 Directory Structure
23
24     modules:
25        enabled:
26           - Symfony:
27               app_path: 'src'
28               environment: 'test'
29
30
31 ### Symfony 3.x
32
33 * app_path: 'app' - specify custom path to your app dir, where the kernel interface is located.
34 * var_path: 'var' - specify custom path to your var dir, where bootstrap cache is located.
35 * environment: 'local' - environment used for load kernel
36 * kernel_class: 'AppKernel' - kernel class name
37 * em_service: 'doctrine.orm.entity_manager' - use the stated EntityManager to pair with Doctrine Module.
38 * debug: true - turn on/off debug mode
39 * cache_router: 'false' - enable router caching between tests in order to [increase performance](http://lakion.com/blog/how-did-we-speed-up-sylius-behat-suite-with-blackfire)
40 * rebootable_client: 'true' - reboot client's kernel before each request
41
42 #### Example (`functional.suite.yml`) - Symfony 3 Directory Structure
43
44     modules:
45        enabled:
46           - Symfony:
47               app_path: 'app/front'
48               var_path: 'var'
49               environment: 'local_test'
50
51
52 ### Symfony 2.x
53
54 * app_path: 'app' - specify custom path to your app dir, where bootstrap cache and kernel interface is located.
55 * environment: 'local' - environment used for load kernel
56 * kernel_class: 'AppKernel' - kernel class name
57 * debug: true - turn on/off debug mode
58 * em_service: 'doctrine.orm.entity_manager' - use the stated EntityManager to pair with Doctrine Module.
59 * cache_router: 'false' - enable router caching between tests in order to [increase performance](http://lakion.com/blog/how-did-we-speed-up-sylius-behat-suite-with-blackfire)
60 * rebootable_client: 'true' - reboot client's kernel before each request
61
62 ### Example (`functional.suite.yml`) - Symfony 2.x Directory Structure
63
64 ```
65    modules:
66        - Symfony:
67            app_path: 'app/front'
68            environment: 'local_test'
69 ```
70
71 ## Public Properties
72
73 * kernel - HttpKernel instance
74 * client - current Crawler instance
75
76 ## Parts
77
78 * services - allows to use Symfony DIC only with WebDriver or PhpBrowser modules.
79
80 Usage example:
81
82 ```yaml
83 actor: AcceptanceTester
84 modules:
85     enabled:
86         - Symfony:
87             part: SERVICES
88         - Doctrine2:
89             depends: Symfony
90         - WebDriver:
91             url: http://your-url.com
92             browser: phantomjs
93 ```
94
95
96 ## Actions
97
98 ### _findElements
99
100 *hidden API method, expected to be used from Helper classes*
101  
102 Locates element using available Codeception locator types:
103
104 * XPath
105 * CSS
106 * Strict Locator
107
108 Use it in Helpers or GroupObject or Extension classes:
109
110 ```php
111 <?php
112 $els = $this->getModule('Symfony')->_findElements('.items');
113 $els = $this->getModule('Symfony')->_findElements(['name' => 'username']);
114
115 $editLinks = $this->getModule('Symfony')->_findElements(['link' => 'Edit']);
116 // now you can iterate over $editLinks and check that all them have valid hrefs
117 ```
118
119 WebDriver module returns `Facebook\WebDriver\Remote\RemoteWebElement` instances
120 PhpBrowser and Framework modules return `Symfony\Component\DomCrawler\Crawler` instances
121
122  * `param` $locator
123  * `return` array of interactive elements
124
125
126 ### _getResponseContent
127
128 *hidden API method, expected to be used from Helper classes*
129  
130 Returns content of the last response
131 Use it in Helpers when you want to retrieve response of request performed by another module.
132
133 ```php
134 <?php
135 // in Helper class
136 public function seeResponseContains($text)
137 {
138    $this->assertContains($text, $this->getModule('Symfony')->_getResponseContent(), "response contains");
139 }
140 ?>
141 ```
142
143  * `return` string
144 @throws ModuleException
145
146
147 ### _loadPage
148
149 *hidden API method, expected to be used from Helper classes*
150  
151 Opens a page with arbitrary request parameters.
152 Useful for testing multi-step forms on a specific step.
153
154 ```php
155 <?php
156 // in Helper class
157 public function openCheckoutFormStep2($orderId) {
158     $this->getModule('Symfony')->_loadPage('POST', '/checkout/step2', ['order' => $orderId]);
159 }
160 ?>
161 ```
162
163  * `param` $method
164  * `param` $uri
165  * `param array` $parameters
166  * `param array` $files
167  * `param array` $server
168  * `param null` $content
169
170
171 ### _request
172
173 *hidden API method, expected to be used from Helper classes*
174  
175 Send custom request to a backend using method, uri, parameters, etc.
176 Use it in Helpers to create special request actions, like accessing API
177 Returns a string with response body.
178
179 ```php
180 <?php
181 // in Helper class
182 public function createUserByApi($name) {
183     $userData = $this->getModule('Symfony')->_request('POST', '/api/v1/users', ['name' => $name]);
184     $user = json_decode($userData);
185     return $user->id;
186 }
187 ?>
188 ```
189 Does not load the response into the module so you can't interact with response page (click, fill forms).
190 To load arbitrary page for interaction, use `_loadPage` method.
191
192  * `param` $method
193  * `param` $uri
194  * `param array` $parameters
195  * `param array` $files
196  * `param array` $server
197  * `param null` $content
198  * `return` mixed|Crawler
199 @throws ExternalUrlException
200 @see `_loadPage`
201
202
203 ### _savePageSource
204
205 *hidden API method, expected to be used from Helper classes*
206  
207 Saves page source of to a file
208
209 ```php
210 $this->getModule('Symfony')->_savePageSource(codecept_output_dir().'page.html');
211 ```
212  * `param` $filename
213
214
215 ### amHttpAuthenticated
216  
217 Authenticates user for HTTP_AUTH
218
219  * `param` $username
220  * `param` $password
221
222
223 ### amOnPage
224  
225 Opens the page for the given relative URI.
226
227 ``` php
228 <?php
229 // opens front page
230 $I->amOnPage('/');
231 // opens /register page
232 $I->amOnPage('/register');
233 ```
234
235  * `param string` $page
236
237
238 ### amOnRoute
239  
240 Opens web page using route name and parameters.
241
242 ``` php
243 <?php
244 $I->amOnRoute('posts.create');
245 $I->amOnRoute('posts.show', array('id' => 34));
246 ?>
247 ```
248
249  * `param` $routeName
250  * `param array` $params
251
252
253 ### attachFile
254  
255 Attaches a file relative to the Codeception `_data` directory to the given file upload field.
256
257 ``` php
258 <?php
259 // file is stored in 'tests/_data/prices.xls'
260 $I->attachFile('input[@type="file"]', 'prices.xls');
261 ?>
262 ```
263
264  * `param` $field
265  * `param` $filename
266
267
268 ### checkOption
269  
270 Ticks a checkbox. For radio buttons, use the `selectOption` method instead.
271
272 ``` php
273 <?php
274 $I->checkOption('#agree');
275 ?>
276 ```
277
278  * `param` $option
279
280
281 ### click
282  
283 Perform a click on a link or a button, given by a locator.
284 If a fuzzy locator is given, the page will be searched for a button, link, or image matching the locator string.
285 For buttons, the "value" attribute, "name" attribute, and inner text are searched.
286 For links, the link text is searched.
287 For images, the "alt" attribute and inner text of any parent links are searched.
288
289 The second parameter is a context (CSS or XPath locator) to narrow the search.
290
291 Note that if the locator matches a button of type `submit`, the form will be submitted.
292
293 ``` php
294 <?php
295 // simple link
296 $I->click('Logout');
297 // button of form
298 $I->click('Submit');
299 // CSS button
300 $I->click('#form input[type=submit]');
301 // XPath
302 $I->click('//form/*[@type=submit]');
303 // link in context
304 $I->click('Logout', '#nav');
305 // using strict locator
306 $I->click(['link' => 'Login']);
307 ?>
308 ```
309
310  * `param` $link
311  * `param` $context
312
313
314 ### deleteHeader
315  
316 Deletes the header with the passed name.  Subsequent requests
317 will not have the deleted header in its request.
318
319 Example:
320 ```php
321 <?php
322 $I->haveHttpHeader('X-Requested-With', 'Codeception');
323 $I->amOnPage('test-headers.php');
324 // ...
325 $I->deleteHeader('X-Requested-With');
326 $I->amOnPage('some-other-page.php');
327 ?>
328 ```
329
330  * `param string` $name the name of the header to delete.
331
332
333 ### dontSee
334  
335 Checks that the current page doesn't contain the text specified (case insensitive).
336 Give a locator as the second parameter to match a specific region.
337
338 ```php
339 <?php
340 $I->dontSee('Login');                         // I can suppose user is already logged in
341 $I->dontSee('Sign Up','h1');                  // I can suppose it's not a signup page
342 $I->dontSee('Sign Up','//body/h1');           // with XPath
343 $I->dontSee('Sign Up', ['css' => 'body h1']); // with strict CSS locator
344 ```
345
346 Note that the search is done after stripping all HTML tags from the body,
347 so `$I->dontSee('strong')` will fail on strings like:
348
349   - `<p>I am Stronger than thou</p>`
350   - `<script>document.createElement('strong');</script>`
351
352 But will ignore strings like:
353
354   - `<strong>Home</strong>`
355   - `<div class="strong">Home</strong>`
356   - `<!-- strong -->`
357
358 For checking the raw source code, use `seeInSource()`.
359
360  * `param string` $text
361  * `param string` $selector optional
362
363
364 ### dontSeeCheckboxIsChecked
365  
366 Check that the specified checkbox is unchecked.
367
368 ``` php
369 <?php
370 $I->dontSeeCheckboxIsChecked('#agree'); // I suppose user didn't agree to terms
371 $I->seeCheckboxIsChecked('#signup_form input[type=checkbox]'); // I suppose user didn't check the first checkbox in form.
372 ?>
373 ```
374
375  * `param` $checkbox
376
377
378 ### dontSeeCookie
379  
380 Checks that there isn't a cookie with the given name.
381 You can set additional cookie params like `domain`, `path` as array passed in last argument.
382
383  * `param` $cookie
384
385  * `param array` $params
386
387
388 ### dontSeeCurrentUrlEquals
389  
390 Checks that the current URL doesn't equal the given string.
391 Unlike `dontSeeInCurrentUrl`, this only matches the full URL.
392
393 ``` php
394 <?php
395 // current url is not root
396 $I->dontSeeCurrentUrlEquals('/');
397 ?>
398 ```
399
400  * `param string` $uri
401
402
403 ### dontSeeCurrentUrlMatches
404  
405 Checks that current url doesn't match the given regular expression.
406
407 ``` php
408 <?php
409 // to match root url
410 $I->dontSeeCurrentUrlMatches('~^/users/(\d+)~');
411 ?>
412 ```
413
414  * `param string` $uri
415
416
417 ### dontSeeElement
418  
419 Checks that the given element is invisible or not present on the page.
420 You can also specify expected attributes of this element.
421
422 ``` php
423 <?php
424 $I->dontSeeElement('.error');
425 $I->dontSeeElement('//form/input[1]');
426 $I->dontSeeElement('input', ['name' => 'login']);
427 $I->dontSeeElement('input', ['value' => '123456']);
428 ?>
429 ```
430
431  * `param` $selector
432  * `param array` $attributes
433
434
435 ### dontSeeEmailIsSent
436  
437 Checks that no email was sent. This is an alias for seeEmailIsSent(0).
438
439  * `[Part]` email
440
441
442 ### dontSeeInCurrentUrl
443  
444 Checks that the current URI doesn't contain the given string.
445
446 ``` php
447 <?php
448 $I->dontSeeInCurrentUrl('/users/');
449 ?>
450 ```
451
452  * `param string` $uri
453
454
455 ### dontSeeInField
456  
457 Checks that an input field or textarea doesn't contain the given value.
458 For fuzzy locators, the field is matched by label text, CSS and XPath.
459
460 ``` php
461 <?php
462 $I->dontSeeInField('Body','Type your comment here');
463 $I->dontSeeInField('form textarea[name=body]','Type your comment here');
464 $I->dontSeeInField('form input[type=hidden]','hidden_value');
465 $I->dontSeeInField('#searchform input','Search');
466 $I->dontSeeInField('//form/*[@name=search]','Search');
467 $I->dontSeeInField(['name' => 'search'], 'Search');
468 ?>
469 ```
470
471  * `param` $field
472  * `param` $value
473
474
475 ### dontSeeInFormFields
476  
477 Checks if the array of form parameters (name => value) are not set on the form matched with
478 the passed selector.
479
480 ``` php
481 <?php
482 $I->dontSeeInFormFields('form[name=myform]', [
483      'input1' => 'non-existent value',
484      'input2' => 'other non-existent value',
485 ]);
486 ?>
487 ```
488
489 To check that an element hasn't been assigned any one of many values, an array can be passed
490 as the value:
491
492 ``` php
493 <?php
494 $I->dontSeeInFormFields('.form-class', [
495      'fieldName' => [
496          'This value shouldn\'t be set',
497          'And this value shouldn\'t be set',
498      ],
499 ]);
500 ?>
501 ```
502
503 Additionally, checkbox values can be checked with a boolean.
504
505 ``` php
506 <?php
507 $I->dontSeeInFormFields('#form-id', [
508      'checkbox1' => true,        // fails if checked
509      'checkbox2' => false,       // fails if unchecked
510 ]);
511 ?>
512 ```
513
514  * `param` $formSelector
515  * `param` $params
516
517
518 ### dontSeeInSource
519  
520 Checks that the current page contains the given string in its
521 raw source code.
522
523 ```php
524 <?php
525 $I->dontSeeInSource('<h1>Green eggs &amp; ham</h1>');
526 ```
527
528  * `param`      $raw
529
530
531 ### dontSeeInTitle
532  
533 Checks that the page title does not contain the given string.
534
535  * `param` $title
536
537
538
539 ### dontSeeLink
540  
541 Checks that the page doesn't contain a link with the given string.
542 If the second parameter is given, only links with a matching "href" attribute will be checked.
543
544 ``` php
545 <?php
546 $I->dontSeeLink('Logout'); // I suppose user is not logged in
547 $I->dontSeeLink('Checkout now', '/store/cart.php');
548 ?>
549 ```
550
551  * `param string` $text
552  * `param string` $url optional
553
554
555 ### dontSeeOptionIsSelected
556  
557 Checks that the given option is not selected.
558
559 ``` php
560 <?php
561 $I->dontSeeOptionIsSelected('#form input[name=payment]', 'Visa');
562 ?>
563 ```
564
565  * `param` $selector
566  * `param` $optionText
567
568
569
570 ### dontSeeResponseCodeIs
571  
572 Checks that response code is equal to value provided.
573
574 ```php
575 <?php
576 $I->dontSeeResponseCodeIs(200);
577
578 // recommended \Codeception\Util\HttpCode
579 $I->dontSeeResponseCodeIs(\Codeception\Util\HttpCode::OK);
580 ```
581  * `param` $code
582
583
584 ### fillField
585  
586 Fills a text field or textarea with the given string.
587
588 ``` php
589 <?php
590 $I->fillField("//input[@type='text']", "Hello World!");
591 $I->fillField(['name' => 'email'], 'jon@mail.com');
592 ?>
593 ```
594
595  * `param` $field
596  * `param` $value
597
598
599 ### grabAttributeFrom
600  
601 Grabs the value of the given attribute value from the given element.
602 Fails if element is not found.
603
604 ``` php
605 <?php
606 $I->grabAttributeFrom('#tooltip', 'title');
607 ?>
608 ```
609
610  * `param` $cssOrXpath
611  * `param` $attribute
612
613
614
615 ### grabCookie
616  
617 Grabs a cookie value.
618 You can set additional cookie params like `domain`, `path` in array passed as last argument.
619
620  * `param` $cookie
621
622  * `param array` $params
623
624
625 ### grabFromCurrentUrl
626  
627 Executes the given regular expression against the current URI and returns the first capturing group.
628 If no parameters are provided, the full URI is returned.
629
630 ``` php
631 <?php
632 $user_id = $I->grabFromCurrentUrl('~^/user/(\d+)/~');
633 $uri = $I->grabFromCurrentUrl();
634 ?>
635 ```
636
637  * `param string` $uri optional
638
639
640
641 ### grabMultiple
642  
643 Grabs either the text content, or attribute values, of nodes
644 matched by $cssOrXpath and returns them as an array.
645
646 ```html
647 <a href="#first">First</a>
648 <a href="#second">Second</a>
649 <a href="#third">Third</a>
650 ```
651
652 ```php
653 <?php
654 // would return ['First', 'Second', 'Third']
655 $aLinkText = $I->grabMultiple('a');
656
657 // would return ['#first', '#second', '#third']
658 $aLinks = $I->grabMultiple('a', 'href');
659 ?>
660 ```
661
662  * `param` $cssOrXpath
663  * `param` $attribute
664  * `return` string[]
665
666
667 ### grabPageSource
668  
669 Grabs current page source code.
670
671 @throws ModuleException if no page was opened.
672
673  * `return` string Current page source code.
674
675
676 ### grabService
677  
678 Grabs a service from Symfony DIC container.
679 Recommended to use for unit testing.
680
681 ``` php
682 <?php
683 $em = $I->grabService('doctrine');
684 ?>
685 ```
686
687  * `param` $service
688  * `[Part]` services
689
690
691 ### grabServiceFromContainer
692  
693 Grabs a service from Symfony DIC container.
694 Recommended to use for unit testing.
695
696 ``` php
697 <?php
698 $em = $I->grabServiceFromContainer('doctrine');
699 ?>
700 ```
701
702  * `param` $service
703  * `[Part]` services
704 @deprecated Use grabService instead
705
706
707 ### grabTextFrom
708  
709 Finds and returns the text contents of the given element.
710 If a fuzzy locator is used, the element is found using CSS, XPath,
711 and by matching the full page source by regular expression.
712
713 ``` php
714 <?php
715 $heading = $I->grabTextFrom('h1');
716 $heading = $I->grabTextFrom('descendant-or-self::h1');
717 $value = $I->grabTextFrom('~<input value=(.*?)]~sgi'); // match with a regex
718 ?>
719 ```
720
721  * `param` $cssOrXPathOrRegex
722
723
724
725 ### grabValueFrom
726  
727  * `param` $field
728
729  * `return` array|mixed|null|string
730
731
732 ### haveHttpHeader
733  
734 Sets the HTTP header to the passed value - which is used on
735 subsequent HTTP requests through PhpBrowser.
736
737 Example:
738 ```php
739 <?php
740 $I->haveHttpHeader('X-Requested-With', 'Codeception');
741 $I->amOnPage('test-headers.php');
742 ?>
743 ```
744
745 To use special chars in Header Key use HTML Character Entities:
746 Example:
747 Header with underscore - 'Client_Id'
748 should be represented as - 'Client&#x0005F;Id' or 'Client&#95;Id'
749
750 ```php
751 <?php
752 $I->haveHttpHeader('Client&#95;Id', 'Codeception');
753 ?>
754 ```
755
756  * `param string` $name the name of the request header
757  * `param string` $value the value to set it to for subsequent
758        requests
759
760
761 ### invalidateCachedRouter
762  
763 Invalidate previously cached routes.
764
765
766 ### moveBack
767  
768 Moves back in history.
769
770  * `param int` $numberOfSteps (default value 1)
771
772
773 ### onReconfigure
774  
775 HOOK to be executed when config changes with `_reconfigure`.
776
777
778 ### persistService
779  
780 Get service $serviceName and add it to the lists of persistent services.
781 If $isPermanent then service becomes persistent between tests
782
783  * `param string`  $serviceName
784  * `param boolean` $isPermanent
785
786
787 ### rebootClientKernel
788  
789 Reboot client's kernel.
790 Can be used to manually reboot kernel when 'rebootable_client' => false
791
792 ``` php
793 <?php
794 ...
795 perform some requests
796 ...
797 $I->rebootClientKernel();
798 ...
799 perform other requests
800 ...
801
802 ?>
803 ```
804
805
806
807 ### resetCookie
808  
809 Unsets cookie with the given name.
810 You can set additional cookie params like `domain`, `path` in array passed as last argument.
811
812  * `param` $cookie
813
814  * `param array` $params
815
816
817 ### see
818  
819 Checks that the current page contains the given string (case insensitive).
820
821 You can specify a specific HTML element (via CSS or XPath) as the second
822 parameter to only search within that element.
823
824 ``` php
825 <?php
826 $I->see('Logout');                        // I can suppose user is logged in
827 $I->see('Sign Up', 'h1');                 // I can suppose it's a signup page
828 $I->see('Sign Up', '//body/h1');          // with XPath
829 $I->see('Sign Up', ['css' => 'body h1']); // with strict CSS locator
830 ```
831
832 Note that the search is done after stripping all HTML tags from the body,
833 so `$I->see('strong')` will return true for strings like:
834
835   - `<p>I am Stronger than thou</p>`
836   - `<script>document.createElement('strong');</script>`
837
838 But will *not* be true for strings like:
839
840   - `<strong>Home</strong>`
841   - `<div class="strong">Home</strong>`
842   - `<!-- strong -->`
843
844 For checking the raw source code, use `seeInSource()`.
845
846  * `param string` $text
847  * `param string` $selector optional
848
849
850 ### seeCheckboxIsChecked
851  
852 Checks that the specified checkbox is checked.
853
854 ``` php
855 <?php
856 $I->seeCheckboxIsChecked('#agree'); // I suppose user agreed to terms
857 $I->seeCheckboxIsChecked('#signup_form input[type=checkbox]'); // I suppose user agreed to terms, If there is only one checkbox in form.
858 $I->seeCheckboxIsChecked('//form/input[@type=checkbox and @name=agree]');
859 ?>
860 ```
861
862  * `param` $checkbox
863
864
865 ### seeCookie
866  
867 Checks that a cookie with the given name is set.
868 You can set additional cookie params like `domain`, `path` as array passed in last argument.
869
870 ``` php
871 <?php
872 $I->seeCookie('PHPSESSID');
873 ?>
874 ```
875
876  * `param` $cookie
877  * `param array` $params
878
879
880 ### seeCurrentRouteIs
881  
882 Checks that current url matches route.
883
884 ``` php
885 <?php
886 $I->seeCurrentRouteIs('posts.index');
887 $I->seeCurrentRouteIs('posts.show', array('id' => 8));
888 ?>
889 ```
890
891  * `param` $routeName
892  * `param array` $params
893
894
895 ### seeCurrentUrlEquals
896  
897 Checks that the current URL is equal to the given string.
898 Unlike `seeInCurrentUrl`, this only matches the full URL.
899
900 ``` php
901 <?php
902 // to match root url
903 $I->seeCurrentUrlEquals('/');
904 ?>
905 ```
906
907  * `param string` $uri
908
909
910 ### seeCurrentUrlMatches
911  
912 Checks that the current URL matches the given regular expression.
913
914 ``` php
915 <?php
916 // to match root url
917 $I->seeCurrentUrlMatches('~^/users/(\d+)~');
918 ?>
919 ```
920
921  * `param string` $uri
922
923
924 ### seeElement
925  
926 Checks that the given element exists on the page and is visible.
927 You can also specify expected attributes of this element.
928
929 ``` php
930 <?php
931 $I->seeElement('.error');
932 $I->seeElement('//form/input[1]');
933 $I->seeElement('input', ['name' => 'login']);
934 $I->seeElement('input', ['value' => '123456']);
935
936 // strict locator in first arg, attributes in second
937 $I->seeElement(['css' => 'form input'], ['name' => 'login']);
938 ?>
939 ```
940
941  * `param` $selector
942  * `param array` $attributes
943 @return
944
945
946 ### seeEmailIsSent
947  
948 Checks if the desired number of emails was sent.
949 If no argument is provided then at least one email must be sent to satisfy the check.
950
951 ``` php
952 <?php
953 $I->seeEmailIsSent(2);
954 ?>
955 ```
956
957  * `param null|int` $expectedCount
958
959
960 ### seeInCurrentRoute
961  
962 Checks that current url matches route.
963 Unlike seeCurrentRouteIs, this can matches without exact route parameters
964
965 ``` php
966 <?php
967 $I->seeCurrentRouteMatches('my_blog_pages');
968 ?>
969 ```
970
971  * `param` $routeName
972
973
974 ### seeInCurrentUrl
975  
976 Checks that current URI contains the given string.
977
978 ``` php
979 <?php
980 // to match: /home/dashboard
981 $I->seeInCurrentUrl('home');
982 // to match: /users/1
983 $I->seeInCurrentUrl('/users/');
984 ?>
985 ```
986
987  * `param string` $uri
988
989
990 ### seeInField
991  
992 Checks that the given input field or textarea *equals* (i.e. not just contains) the given value.
993 Fields are matched by label text, the "name" attribute, CSS, or XPath.
994
995 ``` php
996 <?php
997 $I->seeInField('Body','Type your comment here');
998 $I->seeInField('form textarea[name=body]','Type your comment here');
999 $I->seeInField('form input[type=hidden]','hidden_value');
1000 $I->seeInField('#searchform input','Search');
1001 $I->seeInField('//form/*[@name=search]','Search');
1002 $I->seeInField(['name' => 'search'], 'Search');
1003 ?>
1004 ```
1005
1006  * `param` $field
1007  * `param` $value
1008
1009
1010 ### seeInFormFields
1011  
1012 Checks if the array of form parameters (name => value) are set on the form matched with the
1013 passed selector.
1014
1015 ``` php
1016 <?php
1017 $I->seeInFormFields('form[name=myform]', [
1018      'input1' => 'value',
1019      'input2' => 'other value',
1020 ]);
1021 ?>
1022 ```
1023
1024 For multi-select elements, or to check values of multiple elements with the same name, an
1025 array may be passed:
1026
1027 ``` php
1028 <?php
1029 $I->seeInFormFields('.form-class', [
1030      'multiselect' => [
1031          'value1',
1032          'value2',
1033      ],
1034      'checkbox[]' => [
1035          'a checked value',
1036          'another checked value',
1037      ],
1038 ]);
1039 ?>
1040 ```
1041
1042 Additionally, checkbox values can be checked with a boolean.
1043
1044 ``` php
1045 <?php
1046 $I->seeInFormFields('#form-id', [
1047      'checkbox1' => true,        // passes if checked
1048      'checkbox2' => false,       // passes if unchecked
1049 ]);
1050 ?>
1051 ```
1052
1053 Pair this with submitForm for quick testing magic.
1054
1055 ``` php
1056 <?php
1057 $form = [
1058      'field1' => 'value',
1059      'field2' => 'another value',
1060      'checkbox1' => true,
1061      // ...
1062 ];
1063 $I->submitForm('//form[@id=my-form]', $form, 'submitButton');
1064 // $I->amOnPage('/path/to/form-page') may be needed
1065 $I->seeInFormFields('//form[@id=my-form]', $form);
1066 ?>
1067 ```
1068
1069  * `param` $formSelector
1070  * `param` $params
1071
1072
1073 ### seeInSource
1074  
1075 Checks that the current page contains the given string in its
1076 raw source code.
1077
1078 ``` php
1079 <?php
1080 $I->seeInSource('<h1>Green eggs &amp; ham</h1>');
1081 ```
1082
1083  * `param`      $raw
1084
1085
1086 ### seeInTitle
1087  
1088 Checks that the page title contains the given string.
1089
1090 ``` php
1091 <?php
1092 $I->seeInTitle('Blog - Post #1');
1093 ?>
1094 ```
1095
1096  * `param` $title
1097
1098
1099
1100 ### seeLink
1101  
1102 Checks that there's a link with the specified text.
1103 Give a full URL as the second parameter to match links with that exact URL.
1104
1105 ``` php
1106 <?php
1107 $I->seeLink('Logout'); // matches <a href="#">Logout</a>
1108 $I->seeLink('Logout','/logout'); // matches <a href="/logout">Logout</a>
1109 ?>
1110 ```
1111
1112  * `param string` $text
1113  * `param string` $url optional
1114
1115
1116 ### seeNumberOfElements
1117  
1118 Checks that there are a certain number of elements matched by the given locator on the page.
1119
1120 ``` php
1121 <?php
1122 $I->seeNumberOfElements('tr', 10);
1123 $I->seeNumberOfElements('tr', [0,10]); // between 0 and 10 elements
1124 ?>
1125 ```
1126  * `param` $selector
1127  * `param mixed` $expected int or int[]
1128
1129
1130 ### seeOptionIsSelected
1131  
1132 Checks that the given option is selected.
1133
1134 ``` php
1135 <?php
1136 $I->seeOptionIsSelected('#form input[name=payment]', 'Visa');
1137 ?>
1138 ```
1139
1140  * `param` $selector
1141  * `param` $optionText
1142
1143
1144
1145 ### seePageNotFound
1146  
1147 Asserts that current page has 404 response status code.
1148
1149
1150 ### seeResponseCodeIs
1151  
1152 Checks that response code is equal to value provided.
1153
1154 ```php
1155 <?php
1156 $I->seeResponseCodeIs(200);
1157
1158 // recommended \Codeception\Util\HttpCode
1159 $I->seeResponseCodeIs(\Codeception\Util\HttpCode::OK);
1160 ```
1161
1162  * `param` $code
1163
1164
1165 ### seeResponseCodeIsBetween
1166  
1167 Checks that response code is between a certain range. Between actually means [from <= CODE <= to]
1168
1169  * `param` $from
1170  * `param` $to
1171
1172
1173 ### seeResponseCodeIsClientError
1174  
1175 Checks that the response code is 4xx
1176
1177
1178 ### seeResponseCodeIsRedirection
1179  
1180 Checks that the response code 3xx
1181
1182
1183 ### seeResponseCodeIsServerError
1184  
1185 Checks that the response code is 5xx
1186
1187
1188 ### seeResponseCodeIsSuccessful
1189  
1190 Checks that the response code 2xx
1191
1192
1193 ### selectOption
1194  
1195 Selects an option in a select tag or in radio button group.
1196
1197 ``` php
1198 <?php
1199 $I->selectOption('form select[name=account]', 'Premium');
1200 $I->selectOption('form input[name=payment]', 'Monthly');
1201 $I->selectOption('//form/select[@name=account]', 'Monthly');
1202 ?>
1203 ```
1204
1205 Provide an array for the second argument to select multiple options:
1206
1207 ``` php
1208 <?php
1209 $I->selectOption('Which OS do you use?', array('Windows','Linux'));
1210 ?>
1211 ```
1212
1213 Or provide an associative array for the second argument to specifically define which selection method should be used:
1214
1215 ``` php
1216 <?php
1217 $I->selectOption('Which OS do you use?', array('text' => 'Windows')); // Only search by text 'Windows'
1218 $I->selectOption('Which OS do you use?', array('value' => 'windows')); // Only search by value 'windows'
1219 ?>
1220 ```
1221
1222  * `param` $select
1223  * `param` $option
1224
1225
1226 ### sendAjaxGetRequest
1227  
1228 If your page triggers an ajax request, you can perform it manually.
1229 This action sends a GET ajax request with specified params.
1230
1231 See ->sendAjaxPostRequest for examples.
1232
1233  * `param` $uri
1234  * `param` $params
1235
1236
1237 ### sendAjaxPostRequest
1238  
1239 If your page triggers an ajax request, you can perform it manually.
1240 This action sends a POST ajax request with specified params.
1241 Additional params can be passed as array.
1242
1243 Example:
1244
1245 Imagine that by clicking checkbox you trigger ajax request which updates user settings.
1246 We emulate that click by running this ajax request manually.
1247
1248 ``` php
1249 <?php
1250 $I->sendAjaxPostRequest('/updateSettings', array('notifications' => true)); // POST
1251 $I->sendAjaxGetRequest('/updateSettings', array('notifications' => true)); // GET
1252
1253 ```
1254
1255  * `param` $uri
1256  * `param` $params
1257
1258
1259 ### sendAjaxRequest
1260  
1261 If your page triggers an ajax request, you can perform it manually.
1262 This action sends an ajax request with specified method and params.
1263
1264 Example:
1265
1266 You need to perform an ajax request specifying the HTTP method.
1267
1268 ``` php
1269 <?php
1270 $I->sendAjaxRequest('PUT', '/posts/7', array('title' => 'new title'));
1271
1272 ```
1273
1274  * `param` $method
1275  * `param` $uri
1276  * `param` $params
1277
1278
1279 ### setCookie
1280  
1281 Sets a cookie with the given name and value.
1282 You can set additional cookie params like `domain`, `path`, `expires`, `secure` in array passed as last argument.
1283
1284 ``` php
1285 <?php
1286 $I->setCookie('PHPSESSID', 'el4ukv0kqbvoirg7nkp4dncpk3');
1287 ?>
1288 ```
1289
1290  * `param` $name
1291  * `param` $val
1292  * `param array` $params
1293
1294
1295
1296 ### submitForm
1297  
1298 Submits the given form on the page, with the given form
1299 values.  Pass the form field's values as an array in the second
1300 parameter.
1301
1302 Although this function can be used as a short-hand version of
1303 `fillField()`, `selectOption()`, `click()` etc. it has some important
1304 differences:
1305
1306  * Only field *names* may be used, not CSS/XPath selectors nor field labels
1307  * If a field is sent to this function that does *not* exist on the page,
1308    it will silently be added to the HTTP request.  This is helpful for testing
1309    some types of forms, but be aware that you will *not* get an exception
1310    like you would if you called `fillField()` or `selectOption()` with
1311    a missing field.
1312
1313 Fields that are not provided will be filled by their values from the page,
1314 or from any previous calls to `fillField()`, `selectOption()` etc.
1315 You don't need to click the 'Submit' button afterwards.
1316 This command itself triggers the request to form's action.
1317
1318 You can optionally specify which button's value to include
1319 in the request with the last parameter (as an alternative to
1320 explicitly setting its value in the second parameter), as
1321 button values are not otherwise included in the request.
1322
1323 Examples:
1324
1325 ``` php
1326 <?php
1327 $I->submitForm('#login', [
1328     'login' => 'davert',
1329     'password' => '123456'
1330 ]);
1331 // or
1332 $I->submitForm('#login', [
1333     'login' => 'davert',
1334     'password' => '123456'
1335 ], 'submitButtonName');
1336
1337 ```
1338
1339 For example, given this sample "Sign Up" form:
1340
1341 ``` html
1342 <form action="/sign_up">
1343     Login:
1344     <input type="text" name="user[login]" /><br/>
1345     Password:
1346     <input type="password" name="user[password]" /><br/>
1347     Do you agree to our terms?
1348     <input type="checkbox" name="user[agree]" /><br/>
1349     Select pricing plan:
1350     <select name="plan">
1351         <option value="1">Free</option>
1352         <option value="2" selected="selected">Paid</option>
1353     </select>
1354     <input type="submit" name="submitButton" value="Submit" />
1355 </form>
1356 ```
1357
1358 You could write the following to submit it:
1359
1360 ``` php
1361 <?php
1362 $I->submitForm(
1363     '#userForm',
1364     [
1365         'user' => [
1366             'login' => 'Davert',
1367             'password' => '123456',
1368             'agree' => true
1369         ]
1370     ],
1371     'submitButton'
1372 );
1373 ```
1374 Note that "2" will be the submitted value for the "plan" field, as it is
1375 the selected option.
1376
1377 You can also emulate a JavaScript submission by not specifying any
1378 buttons in the third parameter to submitForm.
1379
1380 ```php
1381 <?php
1382 $I->submitForm(
1383     '#userForm',
1384     [
1385         'user' => [
1386             'login' => 'Davert',
1387             'password' => '123456',
1388             'agree' => true
1389         ]
1390     ]
1391 );
1392 ```
1393
1394 This function works well when paired with `seeInFormFields()`
1395 for quickly testing CRUD interfaces and form validation logic.
1396
1397 ``` php
1398 <?php
1399 $form = [
1400      'field1' => 'value',
1401      'field2' => 'another value',
1402      'checkbox1' => true,
1403      // ...
1404 ];
1405 $I->submitForm('#my-form', $form, 'submitButton');
1406 // $I->amOnPage('/path/to/form-page') may be needed
1407 $I->seeInFormFields('#my-form', $form);
1408 ```
1409
1410 Parameter values can be set to arrays for multiple input fields
1411 of the same name, or multi-select combo boxes.  For checkboxes,
1412 you can use either the string value or boolean `true`/`false` which will
1413 be replaced by the checkbox's value in the DOM.
1414
1415 ``` php
1416 <?php
1417 $I->submitForm('#my-form', [
1418      'field1' => 'value',
1419      'checkbox' => [
1420          'value of first checkbox',
1421          'value of second checkbox',
1422      ],
1423      'otherCheckboxes' => [
1424          true,
1425          false,
1426          false
1427      ],
1428      'multiselect' => [
1429          'first option value',
1430          'second option value'
1431      ]
1432 ]);
1433 ```
1434
1435 Mixing string and boolean values for a checkbox's value is not supported
1436 and may produce unexpected results.
1437
1438 Field names ending in `[]` must be passed without the trailing square
1439 bracket characters, and must contain an array for its value.  This allows
1440 submitting multiple values with the same name, consider:
1441
1442 ```php
1443 <?php
1444 // This will NOT work correctly
1445 $I->submitForm('#my-form', [
1446     'field[]' => 'value',
1447     'field[]' => 'another value',  // 'field[]' is already a defined key
1448 ]);
1449 ```
1450
1451 The solution is to pass an array value:
1452
1453 ```php
1454 <?php
1455 // This way both values are submitted
1456 $I->submitForm('#my-form', [
1457     'field' => [
1458         'value',
1459         'another value',
1460     ]
1461 ]);
1462 ```
1463
1464  * `param` $selector
1465  * `param` $params
1466  * `param` $button
1467
1468
1469 ### switchToIframe
1470  
1471 Switch to iframe or frame on the page.
1472
1473 Example:
1474 ``` html
1475 <iframe name="another_frame" src="http://example.com">
1476 ```
1477
1478 ``` php
1479 <?php
1480 # switch to iframe
1481 $I->switchToIframe("another_frame");
1482 ```
1483
1484  * `param string` $name
1485
1486
1487 ### uncheckOption
1488  
1489 Unticks a checkbox.
1490
1491 ``` php
1492 <?php
1493 $I->uncheckOption('#notify');
1494 ?>
1495 ```
1496
1497  * `param` $option
1498
1499
1500 ### unpersistService
1501  
1502 Remove service $serviceName from the lists of persistent services.
1503
1504  * `param string` $serviceName
1505
1506 <p>&nbsp;</p><div class="alert alert-warning">Module reference is taken from the source code. <a href="https://github.com/Codeception/Codeception/tree/2.5/src/Codeception/Module/Symfony.php">Help us to improve documentation. Edit module reference</a></div>