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