Issues (1237)

Security Analysis    not enabled

This project does not seem to handle request data directly as such no vulnerable execution paths were found.

  Cross-Site Scripting
Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.
  File Exposure
File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.
  File Manipulation
File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.
  Object Injection
Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.
  Code Injection
Code Injection enables an attacker to execute arbitrary code on the server.
  Response Splitting
Response Splitting can be used to send arbitrary responses.
  File Inclusion
File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.
  Command Injection
Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.
  SQL Injection
SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.
  XPath Injection
XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.
  LDAP Injection
LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.
  Header Injection
  Other Vulnerability
This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.
  Regex Injection
Regex Injection enables an attacker to execute arbitrary code in your PHP process.
  XML Injection
XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.
  Variable Injection
Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.
Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

tests/unit/UnitTester.php (2 issues)

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

1
<?php //[STAMP] c8568e8eab4a240544c36ae031f88bd8
2
3
// This class was automatically generated by build task
4
// You should not change it manually as it will be overwritten on next build
5
// @codingStandardsIgnoreFile
6
7
8
use Codeception\Module\Asserts;
9
use Codeception\Module\UnitHelper;
10
11
/**
12
 * Inherited Methods
13
 * @method void wantToTest($text)
14
 * @method void wantTo($text)
15
 * @method void execute($callable)
16
 * @method void expectTo($prediction)
17
 * @method void expect($prediction)
18
 * @method void amGoingTo($argumentation)
19
 * @method void am($role)
20
 * @method void lookForwardTo($achieveValue)
21
 * @method void comment($description)
22
 * @method void haveFriend($name, $actorClass = null)
23
 *
24
 * @SuppressWarnings(PHPMD)
25
*/
26
class UnitTester extends \Codeception\Actor
0 ignored issues
show
Comprehensibility Best Practice introduced by
The type UnitTester has been defined more than once; this definition is ignored, only the first definition in tests/_support/UnitTester.php (L19-26) is considered.

This check looks for classes that have been defined more than once.

If you can, we would recommend to use standard object-oriented programming techniques. For example, to avoid multiple types, it might make sense to create a common interface, and then multiple, different implementations for that interface.

This also has the side-effect of providing you with better IDE auto-completion, static analysis and also better OPCode caching from PHP.

Loading history...
There is one abstract method getScenario in this class; you could implement it, or declare this class as abstract.
Loading history...
27
{
28
   
29
    /**
30
     * [!] Method is generated. Documentation taken from corresponding module.
31
     *
32
     * Checks that two variables are equal.
33
     *
34
     * @param        $expected
35
     * @param        $actual
36
     * @param string $message
37
     *
38
     * @return mixed
39
     * @see \Codeception\Module\Asserts::assertEquals()
40
     */
41
    public function assertEquals($expected, $actual, $message = null) {
42
        return $this->scenario->runStep(new \Codeception\Step\Action('assertEquals', func_get_args()));
43
    }
44
45
 
46
    /**
47
     * [!] Method is generated. Documentation taken from corresponding module.
48
     *
49
     * Checks that two variables are not equal
50
     *
51
     * @param        $expected
52
     * @param        $actual
53
     * @param string $message
54
     * @see \Codeception\Module\Asserts::assertNotEquals()
55
     */
56
    public function assertNotEquals($expected, $actual, $message = null) {
57
        return $this->scenario->runStep(new \Codeception\Step\Action('assertNotEquals', func_get_args()));
58
    }
59
60
 
61
    /**
62
     * [!] Method is generated. Documentation taken from corresponding module.
63
     *
64
     * Checks that two variables are same
65
     *
66
     * @param        $expected
67
     * @param        $actual
68
     * @param string $message
69
     *
70
     * @return mixed
71
     * @see \Codeception\Module\Asserts::assertSame()
72
     */
73
    public function assertSame($expected, $actual, $message = null) {
74
        return $this->scenario->runStep(new \Codeception\Step\Action('assertSame', func_get_args()));
75
    }
76
77
 
78
    /**
79
     * [!] Method is generated. Documentation taken from corresponding module.
80
     *
81
     * Checks that two variables are not same
82
     *
83
     * @param        $expected
84
     * @param        $actual
85
     * @param string $message
86
     * @see \Codeception\Module\Asserts::assertNotSame()
87
     */
88
    public function assertNotSame($expected, $actual, $message = null) {
89
        return $this->scenario->runStep(new \Codeception\Step\Action('assertNotSame', func_get_args()));
90
    }
91
92
 
93
    /**
94
     * [!] Method is generated. Documentation taken from corresponding module.
95
     *
96
     * Checks that expected is greater than actual
97
     *
98
     * @param        $expected
99
     * @param        $actual
100
     * @param string $message
101
     * @see \Codeception\Module\Asserts::assertGreaterThan()
102
     */
103
    public function assertGreaterThan($expected, $actual, $message = null) {
104
        return $this->scenario->runStep(new \Codeception\Step\Action('assertGreaterThan', func_get_args()));
105
    }
106
107
 
108
    /**
109
     * [!] Method is generated. Documentation taken from corresponding module.
110
     *
111
     * @deprecated
112
     * @see \Codeception\Module\Asserts::assertGreaterThen()
113
     */
114
    public function assertGreaterThen($expected, $actual, $message = null) {
115
        return $this->scenario->runStep(new \Codeception\Step\Action('assertGreaterThen', func_get_args()));
116
    }
117
118
 
119
    /**
120
     * [!] Method is generated. Documentation taken from corresponding module.
121
     *
122
     * Checks that expected is greater or equal than actual
123
     *
124
     * @param        $expected
125
     * @param        $actual
126
     * @param string $message
127
     * @see \Codeception\Module\Asserts::assertGreaterThanOrEqual()
128
     */
129
    public function assertGreaterThanOrEqual($expected, $actual, $message = null) {
130
        return $this->scenario->runStep(new \Codeception\Step\Action('assertGreaterThanOrEqual', func_get_args()));
131
    }
132
133
 
134
    /**
135
     * [!] Method is generated. Documentation taken from corresponding module.
136
     *
137
     * @deprecated
138
     * @see \Codeception\Module\Asserts::assertGreaterThenOrEqual()
139
     */
140
    public function assertGreaterThenOrEqual($expected, $actual, $message = null) {
141
        return $this->scenario->runStep(new \Codeception\Step\Action('assertGreaterThenOrEqual', func_get_args()));
142
    }
143
144
 
145
    /**
146
     * [!] Method is generated. Documentation taken from corresponding module.
147
     *
148
     * Checks that expected is less than actual
149
     *
150
     * @param        $expected
151
     * @param        $actual
152
     * @param string $message
153
     * @see \Codeception\Module\Asserts::assertLessThan()
154
     */
155
    public function assertLessThan($expected, $actual, $message = null) {
156
        return $this->scenario->runStep(new \Codeception\Step\Action('assertLessThan', func_get_args()));
157
    }
158
159
 
160
    /**
161
     * [!] Method is generated. Documentation taken from corresponding module.
162
     *
163
     * Checks that expected is less or equal than actual
164
     *
165
     * @param        $expected
166
     * @param        $actual
167
     * @param string $message
168
     * @see \Codeception\Module\Asserts::assertLessThanOrEqual()
169
     */
170
    public function assertLessThanOrEqual($expected, $actual, $message = null) {
171
        return $this->scenario->runStep(new \Codeception\Step\Action('assertLessThanOrEqual', func_get_args()));
172
    }
173
174
 
175
    /**
176
     * [!] Method is generated. Documentation taken from corresponding module.
177
     *
178
     * Checks that haystack contains needle
179
     *
180
     * @param        $needle
181
     * @param        $haystack
182
     * @param string $message
183
     * @see \Codeception\Module\Asserts::assertContains()
184
     */
185
    public function assertContains($needle, $haystack, $message = null) {
186
        return $this->scenario->runStep(new \Codeception\Step\Action('assertContains', func_get_args()));
187
    }
188
189
 
190
    /**
191
     * [!] Method is generated. Documentation taken from corresponding module.
192
     *
193
     * Checks that haystack doesn't contain needle.
194
     *
195
     * @param        $needle
196
     * @param        $haystack
197
     * @param string $message
198
     * @see \Codeception\Module\Asserts::assertNotContains()
199
     */
200
    public function assertNotContains($needle, $haystack, $message = null) {
201
        return $this->scenario->runStep(new \Codeception\Step\Action('assertNotContains', func_get_args()));
202
    }
203
204
 
205
    /**
206
     * [!] Method is generated. Documentation taken from corresponding module.
207
     *
208
     * Checks that variable is empty.
209
     *
210
     * @param        $actual
211
     * @param string $message
212
     * @see \Codeception\Module\Asserts::assertEmpty()
213
     */
214
    public function assertEmpty($actual, $message = null) {
215
        return $this->scenario->runStep(new \Codeception\Step\Action('assertEmpty', func_get_args()));
216
    }
217
218
 
219
    /**
220
     * [!] Method is generated. Documentation taken from corresponding module.
221
     *
222
     * Checks that variable is not empty.
223
     *
224
     * @param        $actual
225
     * @param string $message
226
     * @see \Codeception\Module\Asserts::assertNotEmpty()
227
     */
228
    public function assertNotEmpty($actual, $message = null) {
229
        return $this->scenario->runStep(new \Codeception\Step\Action('assertNotEmpty', func_get_args()));
230
    }
231
232
 
233
    /**
234
     * [!] Method is generated. Documentation taken from corresponding module.
235
     *
236
     * Checks that variable is NULL
237
     *
238
     * @param        $actual
239
     * @param string $message
240
     * @see \Codeception\Module\Asserts::assertNull()
241
     */
242
    public function assertNull($actual, $message = null) {
243
        return $this->scenario->runStep(new \Codeception\Step\Action('assertNull', func_get_args()));
244
    }
245
246
 
247
    /**
248
     * [!] Method is generated. Documentation taken from corresponding module.
249
     *
250
     * Checks that variable is not NULL
251
     *
252
     * @param        $actual
253
     * @param string $message
254
     * @see \Codeception\Module\Asserts::assertNotNull()
255
     */
256
    public function assertNotNull($actual, $message = null) {
257
        return $this->scenario->runStep(new \Codeception\Step\Action('assertNotNull', func_get_args()));
258
    }
259
260
 
261
    /**
262
     * [!] Method is generated. Documentation taken from corresponding module.
263
     *
264
     * Checks that condition is positive.
265
     *
266
     * @param        $condition
267
     * @param string $message
268
     * @see \Codeception\Module\Asserts::assertTrue()
269
     */
270
    public function assertTrue($condition, $message = null) {
271
        return $this->scenario->runStep(new \Codeception\Step\Action('assertTrue', func_get_args()));
272
    }
273
274
 
275
    /**
276
     * [!] Method is generated. Documentation taken from corresponding module.
277
     *
278
     * Checks that condition is negative.
279
     *
280
     * @param        $condition
281
     * @param string $message
282
     * @see \Codeception\Module\Asserts::assertFalse()
283
     */
284
    public function assertFalse($condition, $message = null) {
285
        return $this->scenario->runStep(new \Codeception\Step\Action('assertFalse', func_get_args()));
286
    }
287
288
 
289
    /**
290
     * [!] Method is generated. Documentation taken from corresponding module.
291
     *
292
     * Fails the test with message.
293
     *
294
     * @param $message
295
     * @see \Codeception\Module\Asserts::fail()
296
     */
297
    public function fail($message) {
298
        return $this->scenario->runStep(new \Codeception\Step\Action('fail', func_get_args()));
299
    }
300
}
301