PageRenderTime 59ms CodeModel.GetById 34ms RepoModel.GetById 0ms app.codeStats 0ms

/tests/integration/Storage/Adapter/GetSetCest.php

http://github.com/phalcon/cphalcon
PHP | 426 lines | 389 code | 15 blank | 22 comment | 1 complexity | 69696ba2e7ff288cbe7c4bccf2448793 MD5 | raw file
Possible License(s): BSD-3-Clause
  1. <?php
  2. /**
  3. * This file is part of the Phalcon Framework.
  4. *
  5. * (c) Phalcon Team <team@phalcon.io>
  6. *
  7. * For the full copyright and license information, please view the LICENSE.txt
  8. * file that was distributed with this source code.
  9. */
  10. declare(strict_types=1);
  11. namespace Phalcon\Tests\Integration\Storage\Adapter;
  12. use Codeception\Example;
  13. use IntegrationTester;
  14. use Phalcon\Storage\Adapter\Apcu;
  15. use Phalcon\Storage\Adapter\Libmemcached;
  16. use Phalcon\Storage\Adapter\Memory;
  17. use Phalcon\Storage\Adapter\Redis;
  18. use Phalcon\Storage\Adapter\Stream;
  19. use Phalcon\Storage\SerializerFactory;
  20. use stdClass;
  21. use function array_merge;
  22. use function getOptionsLibmemcached;
  23. use function getOptionsRedis;
  24. use function outputDir;
  25. use function sprintf;
  26. use function uniqid;
  27. class GetSetCest
  28. {
  29. /**
  30. * Tests Phalcon\Storage\Adapter\* :: get()/set()
  31. *
  32. * @dataProvider getExamples
  33. *
  34. * @author Phalcon Team <team@phalcon.io>
  35. * @since 2020-09-09
  36. */
  37. public function storageAdapterGetSet(IntegrationTester $I, Example $example)
  38. {
  39. $className = $example[0];
  40. $label = $example[1];
  41. $extension = $example[2];
  42. $class = $example[3];
  43. $options = $example[4];
  44. $value = $example[5];
  45. $I->wantToTest(
  46. sprintf(
  47. 'Storage\Adapter\%s - get()/set() - %s',
  48. $className,
  49. $label
  50. )
  51. );
  52. if (!empty($extension)) {
  53. $I->checkExtensionIsLoaded($extension);
  54. }
  55. $serializer = new SerializerFactory();
  56. $adapter = new $class($serializer, $options);
  57. $key = uniqid('k-');
  58. $result = $adapter->set($key, $value);
  59. $I->assertTrue($result);
  60. $result = $adapter->has($key);
  61. $I->assertTrue($result);
  62. /**
  63. * This will issue delete
  64. */
  65. $result = $adapter->set($key, $value, 0);
  66. $I->assertTrue($result);
  67. $result = $adapter->has($key);
  68. $I->assertFalse($result);
  69. }
  70. /**
  71. * @return array[]
  72. */
  73. private function getExamples(): array
  74. {
  75. return [
  76. [
  77. 'Apcu',
  78. 'null',
  79. 'apcu',
  80. Apcu::class,
  81. [],
  82. null,
  83. ],
  84. [
  85. 'Apcu',
  86. 'true',
  87. 'apcu',
  88. Apcu::class,
  89. [],
  90. true,
  91. ],
  92. [
  93. 'Apcu',
  94. 'false',
  95. 'apcu',
  96. Apcu::class,
  97. [],
  98. false,
  99. ],
  100. [
  101. 'Apcu',
  102. 'integer',
  103. 'apcu',
  104. Apcu::class,
  105. [],
  106. 123456,
  107. ],
  108. [
  109. 'Apcu',
  110. 'float',
  111. 'apcu',
  112. Apcu::class,
  113. [],
  114. 123.456,
  115. ],
  116. [
  117. 'Apcu',
  118. 'string',
  119. 'apcu',
  120. Apcu::class,
  121. [],
  122. uniqid(),
  123. ],
  124. [
  125. 'Apcu',
  126. 'object',
  127. 'apcu',
  128. Apcu::class,
  129. [],
  130. new stdClass(),
  131. ],
  132. [
  133. 'Libmemcached',
  134. 'null',
  135. 'memcached',
  136. Libmemcached::class,
  137. getOptionsLibmemcached(),
  138. null,
  139. ],
  140. [
  141. 'Libmemcached',
  142. 'true',
  143. 'memcached',
  144. Libmemcached::class,
  145. getOptionsLibmemcached(),
  146. true,
  147. ],
  148. [
  149. 'Libmemcached',
  150. 'false',
  151. 'memcached',
  152. Libmemcached::class,
  153. getOptionsLibmemcached(),
  154. false,
  155. ],
  156. [
  157. 'Libmemcached',
  158. 'integer',
  159. 'memcached',
  160. Libmemcached::class,
  161. getOptionsLibmemcached(),
  162. 123456,
  163. ],
  164. [
  165. 'Libmemcached',
  166. 'float',
  167. 'memcached',
  168. Libmemcached::class,
  169. getOptionsLibmemcached(),
  170. 123.456,
  171. ],
  172. [
  173. 'Libmemcached',
  174. 'string',
  175. 'memcached',
  176. Libmemcached::class,
  177. getOptionsLibmemcached(),
  178. uniqid(),
  179. ],
  180. [
  181. 'Libmemcached',
  182. 'object',
  183. 'memcached',
  184. Libmemcached::class,
  185. getOptionsLibmemcached(),
  186. new stdClass(),
  187. ],
  188. [
  189. 'Libmemcached',
  190. 'custom serializer',
  191. 'memcached',
  192. Libmemcached::class,
  193. array_merge(
  194. getOptionsLibmemcached(),
  195. [
  196. 'defaultSerializer' => 'Base64',
  197. ]
  198. ),
  199. uniqid(),
  200. ],
  201. [
  202. 'Memory',
  203. 'null',
  204. '',
  205. Memory::class,
  206. [],
  207. null,
  208. ],
  209. [
  210. 'Memory',
  211. 'true',
  212. '',
  213. Memory::class,
  214. [],
  215. true,
  216. ],
  217. [
  218. 'Memory',
  219. 'false',
  220. '',
  221. Memory::class,
  222. [],
  223. false,
  224. ],
  225. [
  226. 'Memory',
  227. 'integer',
  228. '',
  229. Memory::class,
  230. [],
  231. 123456,
  232. ],
  233. [
  234. 'Memory',
  235. 'float',
  236. '',
  237. Memory::class,
  238. [],
  239. 123.456,
  240. ],
  241. [
  242. 'Memory',
  243. 'string',
  244. '',
  245. Memory::class,
  246. [],
  247. uniqid(),
  248. ],
  249. [
  250. 'Memory',
  251. 'object',
  252. '',
  253. Memory::class,
  254. [],
  255. new stdClass(),
  256. ],
  257. [
  258. 'Redis',
  259. 'null',
  260. 'redis',
  261. Redis::class,
  262. getOptionsRedis(),
  263. null,
  264. ],
  265. [
  266. 'Redis',
  267. 'true',
  268. 'redis',
  269. Redis::class,
  270. getOptionsRedis(),
  271. true,
  272. ],
  273. [
  274. 'Redis',
  275. 'false',
  276. 'redis',
  277. Redis::class,
  278. getOptionsRedis(),
  279. false,
  280. ],
  281. [
  282. 'Redis',
  283. 'integer',
  284. 'redis',
  285. Redis::class,
  286. getOptionsRedis(),
  287. 123456,
  288. ],
  289. [
  290. 'Redis',
  291. 'float',
  292. 'redis',
  293. Redis::class,
  294. getOptionsRedis(),
  295. 123.456,
  296. ],
  297. [
  298. 'Redis',
  299. 'string',
  300. 'redis',
  301. Redis::class,
  302. getOptionsRedis(),
  303. uniqid(),
  304. ],
  305. [
  306. 'Redis',
  307. 'object',
  308. 'redis',
  309. Redis::class,
  310. getOptionsRedis(),
  311. new stdClass(),
  312. ],
  313. [
  314. 'Redis',
  315. 'custom serializer',
  316. 'redis',
  317. Redis::class,
  318. array_merge(
  319. getOptionsRedis(),
  320. [
  321. 'defaultSerializer' => 'Base64',
  322. ]
  323. ),
  324. uniqid(),
  325. ],
  326. [
  327. 'Redis',
  328. 'persistent',
  329. 'redis',
  330. Redis::class,
  331. array_merge(
  332. getOptionsRedis(),
  333. [
  334. 'persistent' => true,
  335. ]
  336. ),
  337. uniqid(),
  338. ],
  339. [
  340. 'Stream',
  341. 'null',
  342. '',
  343. Stream::class,
  344. [
  345. 'storageDir' => outputDir(),
  346. ],
  347. null,
  348. ],
  349. [
  350. 'Stream',
  351. 'true',
  352. '',
  353. Stream::class,
  354. [
  355. 'storageDir' => outputDir(),
  356. ],
  357. true,
  358. ],
  359. [
  360. 'Stream',
  361. 'false',
  362. '',
  363. Stream::class,
  364. [
  365. 'storageDir' => outputDir(),
  366. ],
  367. false,
  368. ],
  369. [
  370. 'Stream',
  371. 'integer',
  372. '',
  373. Stream::class,
  374. [
  375. 'storageDir' => outputDir(),
  376. ],
  377. 123456,
  378. ],
  379. [
  380. 'Stream',
  381. 'float',
  382. '',
  383. Stream::class,
  384. [
  385. 'storageDir' => outputDir(),
  386. ],
  387. 123.456,
  388. ],
  389. [
  390. 'Stream',
  391. 'string',
  392. '',
  393. Stream::class,
  394. [
  395. 'storageDir' => outputDir(),
  396. ],
  397. uniqid(),
  398. ],
  399. [
  400. 'Stream',
  401. 'object',
  402. '',
  403. Stream::class,
  404. [
  405. 'storageDir' => outputDir(),
  406. ],
  407. new stdClass(),
  408. ],
  409. ];
  410. }
  411. }