php/chandizhida_backend_v2.git

wangzhenxin

2023-11-19 bc164b8bdbfbdf1d8229a5ced6b08d7cb8db7361

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