"dms/phpunit-arraysubset-asserts": "^0.3.1",
"mikey179/vfsstream": "^1.6",
"mockery/mockery": "^1.3",
+ "php-mock/php-mock-mockery": "^1.5",
"php-mock/php-mock-phpunit": "^2.10",
"phpmd/phpmd": "^2.15",
"phpstan/phpstan": "^2.0",
"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
"This file is @generated automatically"
],
- "content-hash": "b77bf714197f04022a5feb001bf07852",
+ "content-hash": "32af97f73ec49df2a6cfe98f11bc1d60",
"packages": [
{
"name": "asika/simple-console",
],
"time": "2024-02-10T21:37:25+00:00"
},
+ {
+ "name": "php-mock/php-mock-mockery",
+ "version": "1.5.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-mock/php-mock-mockery.git",
+ "reference": "291994acdc26daf1e3c659cfbe58b01eeb180b7f"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-mock/php-mock-mockery/zipball/291994acdc26daf1e3c659cfbe58b01eeb180b7f",
+ "reference": "291994acdc26daf1e3c659cfbe58b01eeb180b7f",
+ "shasum": ""
+ },
+ "require": {
+ "mockery/mockery": "^1",
+ "php": ">=5.6",
+ "php-mock/php-mock-integration": "^2.2.1 || ^3.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4|^5|^8"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "phpmock\\mockery\\": "classes/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "WTFPL"
+ ],
+ "authors": [
+ {
+ "name": "Markus Malkusch",
+ "email": "markus@malkusch.de",
+ "homepage": "http://markus.malkusch.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Mock built-in PHP functions (e.g. time()) with Mockery. This package relies on PHP's namespace fallback policy. No further extension is needed.",
+ "homepage": "https://github.com/php-mock/php-mock-mockery",
+ "keywords": [
+ "BDD",
+ "TDD",
+ "function",
+ "mock",
+ "mockery",
+ "stub",
+ "test",
+ "test double",
+ "testing"
+ ],
+ "support": {
+ "issues": "https://github.com/php-mock/php-mock-mockery/issues",
+ "source": "https://github.com/php-mock/php-mock-mockery/tree/1.5.0"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/michalbundyra",
+ "type": "github"
+ }
+ ],
+ "time": "2025-03-08T19:46:20+00:00"
+ },
{
"name": "php-mock/php-mock-phpunit",
"version": "2.10.0",
use Friendica\Core\L10n;
use Friendica\Core\Lock\Capability\ICanLock;
use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Network\HTTPException\NotFoundException;
use Friendica\Util\Profiler;
use Psr\Log\LoggerInterface;
use Friendica\Network\HTTPException;
private function isAllowed(array $request): bool
{
- return empty(!$request['key']) && $request['key'] == $this->config->get('system', 'stats_key');
+ return !empty($request['key']) && $request['key'] == $this->config->get('system', 'stats_key');
}
+ /**
+ * @throws NotFoundException In case the rquest isn't allowed
+ */
protected function content(array $request = []): string
{
if (!$this->isAllowed($request)) {
];
}
- $this->jsonExit($data);
+ $this->response->setType('json', 'application/json; charset=utf-8');
+ $this->response->addContent(json_encode($data, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT));
}
}
--- /dev/null
+<?php
+
+// Copyright (C) 2010-2024, the Friendica project
+// SPDX-FileCopyrightText: 2010-2024 the Friendica project
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+namespace Friendica\Test;
+
+use Friendica\Core\Cache\Capability\ICanCacheInMemory;
+use Friendica\Core\Lock\Capability\ICanLock;
+
+abstract class CacheLockTestCase extends LockTestCase
+{
+ abstract protected function getCache(): ICanCacheInMemory;
+
+ abstract protected function getInstance(): ICanLock;
+
+ /**
+ * Test if the getStats() result is identically to the getCacheStats()
+ */
+ public function testGetStats()
+ {
+ self::assertSame(array_keys($this->getCache()->getStats()), array_keys($this->instance->getCacheStats()));
+ }
+}
namespace Friendica\Test;
+use Friendica\Core\Cache\Capability\ICanCache;
+use Friendica\Core\Cache\Capability\ICanCacheInMemory;
use Friendica\Core\Lock\Capability\ICanLock;
-use Friendica\Test\MockedTestCase;
+use Friendica\Core\Lock\Type\CacheLock;
abstract class LockTestCase extends MockedTestCase
{
/**
- * @var int Start time of the mock (used for time operations)
+ * Start time of the mock (used for time operations)
*/
- protected $startTime = 1417011228;
+ protected int $startTime = 1417011228;
+ protected ICanLock $instance;
- /**
- * @var ICanLock
- */
- protected $instance;
+ abstract protected function getInstance(): ICanLock;
- abstract protected function getInstance();
protected function setUp(): void
{
self::assertFalse($this->instance->isLocked('wrongLock'));
self::assertFalse($this->instance->release('wrongLock'));
}
+
+
}
self::markTestSkipped("Array Cache doesn't support TTL");
return true;
}
+
+ /**
+ * @small
+ */
+ public function testGetStats()
+ {
+ self::assertEmpty($this->cache->getStats());
+ }
}
--- /dev/null
+<?php
+
+// Copyright (C) 2010-2024, the Friendica project
+// SPDX-FileCopyrightText: 2010-2024 the Friendica project
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+namespace Core\Cache;
+
+use Friendica\Core\Cache\Type\ArrayCache;
+use Friendica\Core\Cache\Type\ProfilerCacheDecorator;
+use Friendica\Core\Config\Capability\IManageConfigValues;
+use Friendica\Test\MemoryCacheTestCase;
+use Friendica\Util\Profiler;
+
+class ProfilerCacheDecoratorTest extends MemoryCacheTestCase
+{
+ protected function getInstance()
+ {
+ $config = \Mockery::mock(IManageConfigValues::class);
+ $config->shouldReceive('get')->with('system', 'profiler')->once()->andReturn(false);
+ $config->shouldReceive('get')->with('rendertime', 'callstack')->once()->andReturn(false);
+
+ $this->cache = new ProfilerCacheDecorator(new ArrayCache('localhost'), new Profiler($config));
+ return $this->cache;
+ }
+
+ protected function tearDown(): void
+ {
+ $this->cache->clear(false);
+ parent::tearDown();
+ }
+
+ /**
+ * @doesNotPerformAssertions
+ */
+ public function testTTL()
+ {
+ // Array Cache doesn't support TTL
+ self::markTestSkipped("Array Cache doesn't support TTL");
+ return true;
+ }
+
+ /**
+ * @small
+ */
+ public function testGetStats()
+ {
+ self::assertEmpty($this->cache->getStats());
+ }
+
+ public function testGetName()
+ {
+ self::assertStringEndsWith(' (with profiler)', $this->instance->getName());
+ }
+}
namespace Friendica\Test\src\Core\Lock;
+use Friendica\Core\Cache\Capability\ICanCacheInMemory;
use Friendica\Core\Cache\Type\APCuCache;
+use Friendica\Core\Lock\Capability\ICanLock;
use Friendica\Core\Lock\Type\CacheLock;
-use Friendica\Test\LockTestCase;
+use Friendica\Test\CacheLockTestCase;
/**
* @group APCU
*/
-class APCuCacheLockTest extends LockTestCase
+class APCuCacheLockTest extends CacheLockTestCase
{
+ private APCuCache $cache;
+ private ICanLock $lock;
+
protected function setUp(): void
{
if (!APCuCache::isAvailable()) {
static::markTestSkipped('APCu is not available');
}
+ $this->cache = new APCuCache('localhost');
+ $this->lock = new CacheLock($this->cache);
+
parent::setUp();
}
- protected function getInstance()
+ protected function getInstance(): CacheLock
+ {
+ return $this->lock;
+ }
+
+ protected function getCache(): ICanCacheInMemory
{
- return new CacheLock(new APCuCache('localhost'));
+ return $this->cache;
}
}
namespace Friendica\Test\src\Core\Lock;
+use Friendica\Core\Cache\Capability\ICanCacheInMemory;
use Friendica\Core\Cache\Type\ArrayCache;
use Friendica\Core\Lock\Type\CacheLock;
-use Friendica\Test\LockTestCase;
+use Friendica\Test\CacheLockTestCase;
-class ArrayCacheLockTest extends LockTestCase
+class ArrayCacheLockTest extends CacheLockTestCase
{
- protected function getInstance()
+ private CacheLock $lock;
+ private ArrayCache $cache;
+
+ protected function setUp(): void
+ {
+ $this->cache = new ArrayCache('localhost');
+ $this->lock = new CacheLock($this->cache);
+
+ parent::setUp();
+ }
+
+ protected function getInstance(): CacheLock
+ {
+ return $this->lock;
+ }
+
+ protected function getCache(): ICanCacheInMemory
{
- return new CacheLock(new ArrayCache('localhost'));
+ return $this->cache;
}
/**
namespace Friendica\Test\src\Core\Lock;
+use Friendica\Core\Lock\Capability\ICanLock;
use Friendica\Core\Lock\Type\DatabaseLock;
use Friendica\Test\LockTestCase;
use Friendica\Test\Util\CreateDatabaseTrait;
parent::setUp();
}
- protected function getInstance()
+ protected function getInstance(): ICanLock
{
return new DatabaseLock($this->getDbInstance(), $this->pid);
}
namespace Friendica\Test\src\Core\Lock;
use Exception;
+use Friendica\Core\Cache\Capability\ICanCacheInMemory;
use Friendica\Core\Cache\Type\MemcacheCache;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Lock\Type\CacheLock;
-use Friendica\Test\LockTestCase;
+use Friendica\Test\CacheLockTestCase;
use Mockery;
/**
* @requires extension Memcache
* @group MEMCACHE
*/
-class MemcacheCacheLockTest extends LockTestCase
+class MemcacheCacheLockTest extends CacheLockTestCase
{
- protected function getInstance()
+ private CacheLock $lock;
+ private MemcacheCache $cache;
+
+ protected function setUp(): void
{
$configMock = Mockery::mock(IManageConfigValues::class);
->with('system', 'memcache_port')
->andReturn($port);
- $lock = null;
-
try {
- $cache = new MemcacheCache($host, $configMock);
- $lock = new CacheLock($cache);
+ $this->cache = new MemcacheCache($host, $configMock);
+ $this->lock = new CacheLock($this->cache);
} catch (Exception $e) {
static::markTestSkipped('Memcache is not available');
}
- return $lock;
+ parent::setUp();
+ }
+
+ protected function getInstance(): CacheLock
+ {
+ return $this->lock;
+ }
+
+ protected function getCache(): ICanCacheInMemory
+ {
+ return $this->cache;
}
/**
namespace Friendica\Test\src\Core\Lock;
use Exception;
+use Friendica\Core\Cache\Capability\ICanCacheInMemory;
use Friendica\Core\Cache\Type\MemcachedCache;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Test\CacheLockTestCase;
use Friendica\Test\LockTestCase;
use Mockery;
use Psr\Log\NullLogger;
* @requires extension memcached
* @group MEMCACHED
*/
-class MemcachedCacheLockTest extends LockTestCase
+class MemcachedCacheLockTest extends CacheLockTestCase
{
- protected function getInstance()
+ private MemcachedCache $cache;
+ private CacheLock $lock;
+
+ protected function setUp(): void
{
$configMock = Mockery::mock(IManageConfigValues::class);
$logger = new NullLogger();
- $lock = null;
-
try {
- $cache = new MemcachedCache($host, $configMock, $logger);
- $lock = new CacheLock($cache);
+ $this->cache = new MemcachedCache($host, $configMock, $logger);
+ $this->lock = new CacheLock($this->cache);
} catch (Exception $e) {
static::markTestSkipped('Memcached is not available');
}
- return $lock;
+ parent::setUp();
+ }
+
+ protected function getInstance(): CacheLock
+ {
+ return $this->lock;
+ }
+
+ protected function getCache(): ICanCacheInMemory
+ {
+ return $this->cache;
}
/**
namespace Friendica\Test\src\Core\Lock;
use Exception;
+use Friendica\Core\Cache\Capability\ICanCacheInMemory;
use Friendica\Core\Cache\Type\RedisCache;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Test\CacheLockTestCase;
use Friendica\Test\LockTestCase;
use Mockery;
* @requires extension redis
* @group REDIS
*/
-class RedisCacheLockTest extends LockTestCase
+class RedisCacheLockTest extends CacheLockTestCase
{
- protected function getInstance()
+ protected function setUp(): void
{
$configMock = Mockery::mock(IManageConfigValues::class);
->with('system', 'redis_password')
->andReturn(null);
- $lock = null;
-
try {
- $cache = new RedisCache($host, $configMock);
- $lock = new CacheLock($cache);
+ $this->cache = new RedisCache($host, $configMock);
+ $this->lock = new CacheLock($this->cache);
} catch (Exception $e) {
static::markTestSkipped('Redis is not available. Error: ' . $e->getMessage());
}
- return $lock;
+ parent::setUp();
+ }
+
+ protected function getInstance(): CAcheLock
+ {
+ return $this->lock;
+ }
+
+ protected function getCache(): ICanCacheInMemory
+ {
+ return $this->cache;
}
}
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Config\Model\ReadOnlyFileConfig;
use Friendica\Core\Config\ValueObject\Cache;
+use Friendica\Core\Lock\Capability\ICanLock;
use Friendica\Core\Lock\Type\SemaphoreLock;
use Friendica\Core\System;
use Friendica\DI;
parent::setUp();
}
- protected function getInstance()
+ protected function getInstance(): ICanLock
{
return new SemaphoreLock();
}
--- /dev/null
+<?php
+
+// Copyright (C) 2010-2024, the Friendica project
+// SPDX-FileCopyrightText: 2010-2024 the Friendica project
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+namespace Friendica\Test\src\Module;
+
+use Friendica\Capabilities\ICanCreateResponses;
+use Friendica\Core\Cache\Capability\ICanCache;
+use Friendica\Core\Cache\Type\ArrayCache;
+use Friendica\Core\Cache\Type\DatabaseCache;
+use Friendica\Core\Config\Capability\IManageConfigValues;
+use Friendica\Core\Lock\Capability\ICanLock;
+use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Core\Lock\Type\DatabaseLock;
+use Friendica\DI;
+use Friendica\Module\Special\HTTPException;
+use Friendica\Module\StatsCaching;
+use Friendica\Test\FixtureTestCase;
+use Mockery\MockInterface;
+use phpmock\mockery\PHPMockery;
+
+class StatsCachingTest extends FixtureTestCase
+{
+ /** @var MockInterface|HTTPException */
+ protected $httpExceptionMock;
+
+ protected ICanCache $cache;
+ protected ICanLock $lock;
+
+ /** @var MockInterface|IManageConfigValues */
+ protected $config;
+
+ protected function setUp(): void
+ {
+ parent::setUp();
+
+ $this->httpExceptionMock = \Mockery::mock(HTTPException::class);
+ $this->config = \Mockery::mock(IManageConfigValues::class);
+ $this->cache = new ArrayCache('localhost');
+ $this->lock = new CacheLock($this->cache);
+ }
+
+ public function testStatsCachingNotAllowed()
+ {
+ $this->httpExceptionMock->shouldReceive('content')->andReturn('failed')->once();
+
+ $response = (new StatsCaching(DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), [], $this->config, $this->cache, $this->lock, []))
+ ->run($this->httpExceptionMock);
+
+ self::assertEquals('404', $response->getStatusCode());
+ self::assertEquals('Page not found', $response->getReasonPhrase());
+ self::assertEquals('failed', $response->getBody());
+ }
+
+ public function testStatsCachingWitMinimumCache()
+ {
+ $request = [
+ 'key' => '12345',
+ ];
+ $this->config->shouldReceive('get')->with('system', 'stats_key')->twice()->andReturn('12345');
+ PHPMockery::mock("Friendica\\Module", "function_exists")->with('opcache_get_status')->once()->andReturn(false);
+
+ $response = (new StatsCaching(DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), [], $this->config, $this->cache, $this->lock, []))
+ ->run($this->httpExceptionMock, $request);
+
+ self::assertJson($response->getBody());
+ self::assertEquals(['Content-type' => ['application/json; charset=utf-8'], ICanCreateResponses::X_HEADER => ['json']], $response->getHeaders());
+
+ $json = json_decode($response->getBody(), true);
+
+ self::assertEquals([
+ 'type' => 'array',
+ 'stats' => [],
+ ], $json['cache']);
+ self::assertEquals([
+ 'type' => 'array',
+ 'stats' => [],
+ ], $json['lock']);
+ }
+
+ public function testStatsCachingWithDatabase()
+ {
+ $request = [
+ 'key' => '12345',
+ ];
+ $this->config->shouldReceive('get')->with('system', 'stats_key')->twice()->andReturn('12345');
+
+ $this->cache = new DatabaseCache('localhost', DI::dba());
+ $this->lock = new DatabaseLock(DI::dba());
+ PHPMockery::mock("Friendica\\Module", "function_exists")->with('opcache_get_status')->once()->andReturn(false);
+
+ $response = (new StatsCaching(DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), [], $this->config, $this->cache, $this->lock, []))
+ ->run($this->httpExceptionMock, $request);
+
+ self::assertJson($response->getBody());
+ self::assertEquals(['Content-type' => ['application/json; charset=utf-8'], ICanCreateResponses::X_HEADER => ['json']], $response->getHeaders());
+
+ $json = json_decode($response->getBody(), true);
+
+ self::assertEquals(['enabled' => false], $json['opcache']);
+ self::assertEquals(['type' => 'database'], $json['cache']);
+ self::assertEquals(['type' => 'database'], $json['lock']);
+ }
+
+ public function testStatsCachingWithCache()
+ {
+ $request = [
+ 'key' => '12345',
+ ];
+ $this->config->shouldReceive('get')->with('system', 'stats_key')->twice()->andReturn('12345');
+
+ $this->cache = new DatabaseCache('localhost', DI::dba());
+ $this->lock = new DatabaseLock(DI::dba());
+ PHPMockery::mock("Friendica\\Module", "function_exists")->with('opcache_get_status')->once()->andReturn(false);
+
+ $response = (new StatsCaching(DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), [], $this->config, $this->cache, $this->lock, []))
+ ->run($this->httpExceptionMock, $request);
+
+ self::assertJson($response->getBody());
+ self::assertEquals(['Content-type' => ['application/json; charset=utf-8'], ICanCreateResponses::X_HEADER => ['json']], $response->getHeaders());
+
+ $json = json_decode($response->getBody(), true);
+
+ self::assertEquals(['enabled' => false], $json['opcache']);
+ self::assertEquals(['type' => 'database'], $json['cache']);
+ self::assertEquals(['type' => 'database'], $json['lock']);
+ }
+
+ public function testStatsCachingWithOpcacheAndNull()
+ {
+ $request = [
+ 'key' => '12345',
+ ];
+ $this->config->shouldReceive('get')->with('system', 'stats_key')->twice()->andReturn('12345');
+
+ $this->cache = new DatabaseCache('localhost', DI::dba());
+ $this->lock = new DatabaseLock(DI::dba());
+ PHPMockery::mock("Friendica\\Module", "function_exists")->with('opcache_get_status')->once()->andReturn(true);
+ PHPMockery::mock("Friendica\\Module", "opcache_get_status")->with(false)->once()->andReturn(false);
+
+ $response = (new StatsCaching(DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), [], $this->config, $this->cache, $this->lock, []))
+ ->run($this->httpExceptionMock, $request);
+
+ self::assertJson($response->getBody());
+ self::assertEquals(['Content-type' => ['application/json; charset=utf-8'], ICanCreateResponses::X_HEADER => ['json']], $response->getHeaders());
+
+ $json = json_decode($response->getBody(), true);
+
+ print_r($json);
+
+ self::assertEquals([
+ 'enabled' => false,
+ 'hit_rate' => null,
+ 'used_memory' => null,
+ 'free_memory' => null,
+ 'num_cached_scripts' => null,
+ ], $json['opcache']);
+ self::assertEquals(['type' => 'database'], $json['cache']);
+ self::assertEquals(['type' => 'database'], $json['lock']);
+ }
+
+ public function testStatsCachingWithOpcacheAndValues()
+ {
+ $request = [
+ 'key' => '12345',
+ ];
+ $this->config->shouldReceive('get')->with('system', 'stats_key')->twice()->andReturn('12345');
+
+ $this->cache = new DatabaseCache('localhost', DI::dba());
+ $this->lock = new DatabaseLock(DI::dba());
+ PHPMockery::mock("Friendica\\Module", "function_exists")->with('opcache_get_status')->once()->andReturn(true);
+ PHPMockery::mock("Friendica\\Module", "opcache_get_status")->with(false)->once()->andReturn([
+ 'opcache_enabled' => true,
+ 'opcache_statistics' => [
+ 'opcache_hit_rate' => 1,
+ 'num_cached_scripts' => 2,
+ ],
+ 'memory_usage' => [
+ 'used_memory' => 3,
+ 'free_memory' => 4,
+ ]
+ ]);
+
+ $response = (new StatsCaching(DI::l10n(), DI::baseUrl(), DI::args(), DI::logger(), DI::profiler(), DI::apiResponse(), [], $this->config, $this->cache, $this->lock, []))
+ ->run($this->httpExceptionMock, $request);
+
+ self::assertJson($response->getBody());
+ self::assertEquals(['Content-type' => ['application/json; charset=utf-8'], ICanCreateResponses::X_HEADER => ['json']], $response->getHeaders());
+
+ $json = json_decode($response->getBody(), true);
+
+ self::assertEquals([
+ 'enabled' => true,
+ 'hit_rate' => 1,
+ 'used_memory' => 3,
+ 'free_memory' => 4,
+ 'num_cached_scripts' => 2,
+ ], $json['opcache']);
+ self::assertEquals(['type' => 'database'], $json['cache']);
+ self::assertEquals(['type' => 'database'], $json['lock']);
+ }
+}
projects / friendica.git / commitdiff