]> git.mxchange.org Git - friendica.git/blob - tests/Util/DBAMockTrait.php
Reduce the usage of the "proxifyUrl" function
[friendica.git] / tests / Util / DBAMockTrait.php
1 <?php
2 /**
3  * @copyright Copyright (C) 2010-2021, the Friendica project
4  *
5  * @license GNU AGPL version 3 or any later version
6  *
7  * This program is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU Affero General Public License as
9  * published by the Free Software Foundation, either version 3 of the
10  * License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Affero General Public License for more details.
16  *
17  * You should have received a copy of the GNU Affero General Public License
18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
19  *
20  */
21
22 namespace Friendica\Test\Util;
23
24 use Friendica\Database\DBA;
25 use Mockery\MockInterface;
26
27 class DBAStub
28 {
29         public static $connected = true;
30 }
31
32 /**
33  * Trait to mock the DBA connection status
34  */
35 trait DBAMockTrait
36 {
37         /**
38          * @var MockInterface The mocking interface of Friendica\Database\DBA
39          */
40         private $dbaMock;
41
42         private function checkMock()
43         {
44                 if (!isset($this->dbaMock)) {
45                         $this->dbaMock = \Mockery::namedMock(DBA::class, DBAStub::class);
46                 }
47         }
48
49         /**
50          * Mocking DBA::connect()
51          *
52          * @param bool $return True, if the connect was successful, otherwise false
53          * @param null|int $times How often the method will get used
54          */
55         public function mockConnect($return = true, $times = null)
56         {
57                 $this->checkMock();
58
59                 $this->dbaMock
60                         ->shouldReceive('connect')
61                         ->times($times)
62                         ->andReturn($return);
63         }
64
65         /**
66          * Mocking DBA::connected()
67          *
68          * @param bool $return True, if the DB is connected, otherwise false
69          * @param null|int $times How often the method will get used
70          */
71         public function mockConnected($return = true, $times = null)
72         {
73                 $this->checkMock();
74
75                 $this->dbaMock
76                         ->shouldReceive('connected')
77                         ->times($times)
78                         ->andReturn($return);
79         }
80
81         /**
82          * Mocking DBA::fetchFirst()
83          *
84          * @param string   $arg    The argument of fetchFirst
85          * @param bool     $return True, if the DB is connected, otherwise false
86          * @param null|int $times  How often the method will get used
87          */
88         public function mockFetchFirst(string $arg, bool $return = true, int $times = null)
89         {
90                 $this->checkMock();
91
92                 $this->dbaMock
93                         ->shouldReceive('fetchFirst')
94                         ->with($arg)
95                         ->times($times)
96                         ->andReturn($return);
97         }
98
99         /**
100          * Mocking each DBA::fetch() call of an statement
101          *
102          * @param array $stmt The result statement (array)
103          * @param null|int $times How often the method will get used
104          */
105         public function mockFetchLoop($stmt = [], $times = null)
106         {
107                 $this->checkMock();
108
109                 foreach ($stmt as $item) {
110                         $this->dbaMock
111                                 ->shouldReceive('fetch')
112                                 ->times($times)
113                                 ->andReturn($item);
114                 }
115
116                 // The last mock call of a fetch (=> breaking the loop)
117                 $this->dbaMock
118                         ->shouldReceive('fetch')
119                         ->times($times)
120                         ->andReturn(false);
121         }
122
123         /**
124          * Mocking DBA::close()
125          *
126          * @param array $return The return per fetch
127          * @param null|int $times How often the method will get used
128          */
129         public function mockDbaClose($return = [], $times = null)
130         {
131                 $this->checkMock();
132
133                 $this->dbaMock
134                         ->shouldReceive('close')
135                         ->times($times)
136                         ->andReturn($return);
137         }
138
139         /**
140          * Mocking DBA::select()
141          *
142          * @param string   $tableName The name of the table
143          * @param array    $select    The Select Array (Default is [])
144          * @param array    $where     The Where Array (Default is [])
145          * @param object   $return    The array to return (Default is [])
146          * @param null|int $times     How often the method will get used
147          */
148         public function mockSelect(string $tableName, array $select = [], array $where = [], $return = null, int $times = null)
149         {
150                 $this->checkMock();
151
152                 $this->dbaMock
153                         ->shouldReceive('select')
154                         ->with($tableName, $select, $where)
155                         ->times($times)
156                         ->andReturn($return);
157         }
158
159         /**
160          * Mocking DBA::delete()
161          *
162          * @param string   $tableName The name of the table
163          * @param array    $where     The Where Array (Default is [])
164          * @param bool     $return    The array to return (Default is true)
165          * @param null|int $times     How often the method will get used
166          */
167         public function mockDBADelete(string $tableName, array $where = [], bool $return = true, int $times = null)
168         {
169                 $this->checkMock();
170
171                 $this->dbaMock
172                         ->shouldReceive('delete')
173                         ->with($tableName, $where)
174                         ->times($times)
175                         ->andReturn($return);
176         }
177
178         /**
179          * Mocking DBA::update()
180          *
181          * @param string   $expTableName  The name of the table
182          * @param array    $expFields     The Fields Array
183          * @param array    $expCondition  The Condition Array
184          * @param array    $expOld_fields The Old Fieldnames (Default is [])
185          * @param bool     $return        true if the update was successful
186          * @param null|int $times         How often the method will get used
187          */
188         public function mockDBAUpdate(string $expTableName, array $expFields, array $expCondition, array $expOld_fields = [], bool $return = true, int $times = null)
189         {
190                 $this->checkMock();
191
192                 $closure = function ($tableName, $fields, $condition, $old_fields = []) use ($expTableName, $expFields, $expCondition, $expOld_fields) {
193                         return
194                                 $tableName == $expTableName &&
195                                 $fields == $expFields &&
196                                 $condition == $expCondition &&
197                                 $old_fields == $expOld_fields;
198                 };
199
200                 $this->dbaMock
201                         ->shouldReceive('update')
202                         ->withArgs($closure)
203                         ->times($times)
204                         ->andReturn($return);
205         }
206
207         /**
208          * Mocking DBA::insert()
209          *
210          * @param string   $expTableName    The name of the table
211          * @param array    $expParam        The Parameters Array
212          * @param bool     $expOnDuplUpdate Update on a duplicated entry
213          * @param bool     $return          True if the insert was successful
214          * @param null|int $times           How often the method will get used
215          */
216         public function mockDBAInsert(string $expTableName, array $expParam, bool $expOnDuplUpdate = false, bool $return = true, int $times = null)
217         {
218                 $this->checkMock();
219
220                 $closure = function ($tableName, $param, $on_duplicate_update = false) use ($expTableName, $expParam, $expOnDuplUpdate) {
221                         return $tableName            == $expTableName
222                                 && $param                == $expParam
223                                 && $on_duplicate_update  == $expOnDuplUpdate;
224
225                 };
226
227                 $this->dbaMock
228                         ->shouldReceive('insert')
229                         ->withArgs($closure)
230                         ->times($times)
231                         ->andReturn($return);
232         }
233
234         /**
235          * Mocking DBA::selectFirst()
236          *
237          * @param string   $expTableName The name of the table
238          * @param array    $expSelect    The Select Array (Default is [])
239          * @param array    $expWhere     The Where Array (Default is [])
240          * @param array    $return       The array to return (Default is [])
241          * @param null|int $times        How often the method will get used
242          */
243         public function mockSelectFirst(string $expTableName, array $expSelect = [], array $expWhere = [], array $return = [], int $times = null)
244         {
245                 $this->checkMock();
246
247                 $closure = function ($tableName, $select = [], $where = []) use ($expTableName, $expSelect, $expWhere) {
248                         return $tableName === $expTableName
249                                 && $select === $expSelect
250                                 && $where === $expWhere;
251                 };
252
253                 $this->dbaMock
254                         ->shouldReceive('selectFirst')
255                         ->withArgs($closure)
256                         ->times($times)
257                         ->andReturn($return);
258         }
259
260         /**
261          * Mocking DBA::isResult()
262          *
263          * @param object $record The record to test
264          * @param bool $return True, if the DB is connected, otherwise false
265          * @param null|int $times How often the method will get used
266          */
267         public function mockIsResult($record, $return = true, $times = null)
268         {
269                 $this->checkMock();
270
271                 $this->dbaMock
272                         ->shouldReceive('isResult')
273                         ->with($record)
274                         ->times($times)
275                         ->andReturn($return);
276         }
277
278         /**
279          * Mocking DBA::isResult()
280          *
281          * @param object $record The record to test
282          * @param array $return The array to return
283          * @param null|int $times How often the method will get used
284          */
285         public function mockToArray($record = null, $return = [], $times = null)
286         {
287                 $this->checkMock();
288
289                 $this->dbaMock
290                         ->shouldReceive('toArray')
291                         ->with($record)
292                         ->times($times)
293                         ->andReturn($return);
294         }
295
296         /**
297          * Mocking DBA::p()
298          *
299          * @param string $sql The SQL statement
300          * @param object $return The object to return
301          * @param null|int $times How often the method will get used
302          */
303         public function mockP($sql = null, $return = null, $times = null)
304         {
305                 $this->checkMock();
306
307                 if (!isset($sql)) {
308                         $this->dbaMock
309                                 ->shouldReceive('p')
310                                 ->times($times)
311                                 ->andReturn($return);
312                 } else {
313                         $this->dbaMock
314                                 ->shouldReceive('p')
315                                 ->with($sql)
316                                 ->times($times)
317                                 ->andReturn($return);
318                 }
319         }
320
321         /**
322          * Mocking DBA::lock()
323          *
324          * @param string   $table  The table to lock
325          * @param bool     $return True, if the lock is set successful
326          * @param null|int $times  How often the method will get used
327          */
328         public function mockDbaLock(string $table, bool $return = true, int $times = null)
329         {
330                 $this->checkMock();
331
332                 $this->dbaMock
333                         ->shouldReceive('lock')
334                         ->with($table)
335                         ->times($times)
336                         ->andReturn($return);
337         }
338
339         /**
340          * Mocking DBA::unlock()
341          *
342          * @param bool $return True, if the lock is set successful
343          * @param null|int $times How often the method will get used
344          */
345         public function mockDbaUnlock( $return = true, $times = null)
346         {
347                 $this->checkMock();
348
349                 $this->dbaMock
350                         ->shouldReceive('unlock')
351                         ->times($times)
352                         ->andReturn($return);
353         }
354 }