722 lines
30 KiB
PHP
722 lines
30 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
// Load the API plugin's autoloader so its controller classes are available
|
|
require_once '/Users/rhuk/Projects/grav/grav-plugin-api/vendor/autoload.php';
|
|
|
|
use Codeception\Util\Fixtures;
|
|
use Grav\Common\Grav;
|
|
use Grav\Common\Page\Page;
|
|
use Grav\Common\Page\Pages;
|
|
use Grav\Common\Config\Config;
|
|
use Grav\Common\Data\Data;
|
|
use Grav\Common\Page\Interfaces\PageInterface;
|
|
use Grav\Common\User\Interfaces\UserInterface;
|
|
use Grav\Plugin\Api\Controllers\PagesController;
|
|
use Grav\Plugin\Api\Controllers\MediaController;
|
|
use Grav\Plugin\Api\Controllers\UsersController;
|
|
use Grav\Plugin\Api\Controllers\ConfigController;
|
|
use RocketTheme\Toolbox\Event\Event;
|
|
use RocketTheme\Toolbox\ResourceLocator\UniformResourceLocator;
|
|
|
|
/**
|
|
* Integration tests verifying that API controllers fire admin-compatible events.
|
|
*
|
|
* These tests use the real Grav framework to ensure events fire through the
|
|
* actual event dispatcher and that third-party plugins subscribing to
|
|
* onAdmin* events would be triggered correctly.
|
|
*/
|
|
class AdminEventsTest extends \PHPUnit\Framework\TestCase
|
|
{
|
|
protected Grav $grav;
|
|
protected Pages $pages;
|
|
protected string $tempDir;
|
|
|
|
/** @var array<int, array{name: string, event: Event}> */
|
|
protected array $capturedEvents = [];
|
|
|
|
protected function setUp(): void
|
|
{
|
|
parent::setUp();
|
|
|
|
$grav = Fixtures::get('grav');
|
|
$this->grav = $grav();
|
|
|
|
$this->tempDir = sys_get_temp_dir() . '/grav_api_events_test_' . uniqid();
|
|
@mkdir($this->tempDir . '/pages', 0775, true);
|
|
@mkdir($this->tempDir . '/cache/api/thumbnails', 0775, true);
|
|
@mkdir($this->tempDir . '/user/config', 0775, true);
|
|
|
|
$this->pages = $this->grav['pages'];
|
|
|
|
/** @var UniformResourceLocator $locator */
|
|
$locator = $this->grav['locator'];
|
|
$locator->addPath('page', '', $this->tempDir . '/pages', false);
|
|
$locator->addPath('cache', '', $this->tempDir . '/cache', false);
|
|
|
|
// Set up API plugin config
|
|
$this->grav['config']->set('plugins.api.route', '/api');
|
|
$this->grav['config']->set('plugins.api.version_prefix', 'v1');
|
|
$this->grav['config']->set('plugins.api.pagination.default_per_page', 20);
|
|
$this->grav['config']->set('plugins.api.pagination.max_per_page', 100);
|
|
$this->grav['config']->set('plugins.api.batch.max_items', 50);
|
|
|
|
$this->capturedEvents = [];
|
|
}
|
|
|
|
protected function tearDown(): void
|
|
{
|
|
$this->rmrf($this->tempDir);
|
|
parent::tearDown();
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// PagesController: create
|
|
// -------------------------------------------------------------------------
|
|
|
|
public function testCreatePageFiresOnAdminCreatePageFrontmatter(): void
|
|
{
|
|
$captured = [];
|
|
$this->grav['events']->addListener('onAdminCreatePageFrontmatter', function (Event $event) use (&$captured) {
|
|
$captured[] = $event;
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('POST', '/api/v1/pages', [
|
|
'route' => '/test-create',
|
|
'title' => 'Test Create',
|
|
'content' => 'Hello world',
|
|
]);
|
|
|
|
$response = $controller->create($request);
|
|
|
|
self::assertSame(201, $response->getStatusCode());
|
|
self::assertCount(1, $captured, 'onAdminCreatePageFrontmatter should fire once');
|
|
self::assertArrayHasKey('header', $captured[0]->toArray());
|
|
self::assertArrayHasKey('data', $captured[0]->toArray());
|
|
}
|
|
|
|
public function testCreatePageFiresOnAdminSaveBeforeSave(): void
|
|
{
|
|
$saveOrder = [];
|
|
$this->grav['events']->addListener('onAdminSave', function (Event $event) use (&$saveOrder) {
|
|
$saveOrder[] = 'onAdminSave';
|
|
// Verify object is a Page
|
|
self::assertInstanceOf(Page::class, $event['object']);
|
|
self::assertArrayHasKey('page', $event->toArray());
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('POST', '/api/v1/pages', [
|
|
'route' => '/test-save-order',
|
|
'title' => 'Save Order Test',
|
|
]);
|
|
|
|
$controller->create($request);
|
|
|
|
self::assertContains('onAdminSave', $saveOrder);
|
|
}
|
|
|
|
public function testCreatePageFiresOnAdminAfterSave(): void
|
|
{
|
|
$captured = [];
|
|
$this->grav['events']->addListener('onAdminAfterSave', function (Event $event) use (&$captured) {
|
|
$captured[] = $event;
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('POST', '/api/v1/pages', [
|
|
'route' => '/test-after-save',
|
|
'title' => 'After Save Test',
|
|
]);
|
|
|
|
$controller->create($request);
|
|
|
|
self::assertCount(1, $captured, 'onAdminAfterSave should fire once');
|
|
self::assertArrayHasKey('object', $captured[0]->toArray());
|
|
self::assertArrayHasKey('page', $captured[0]->toArray());
|
|
}
|
|
|
|
public function testCreatePageFrontmatterEventCanModifyHeader(): void
|
|
{
|
|
// The real Grav Event uses ArrayAccess. To modify a referenced array
|
|
// inside an event, the plugin pattern is to read, modify, write back.
|
|
$this->grav['events']->addListener('onAdminCreatePageFrontmatter', function (Event $event) {
|
|
$header = $event['header'];
|
|
$header['injected_by_plugin'] = true;
|
|
$event['header'] = $header;
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('POST', '/api/v1/pages', [
|
|
'route' => '/test-inject',
|
|
'title' => 'Inject Test',
|
|
]);
|
|
|
|
$controller->create($request);
|
|
|
|
// Verify the injected field made it into the saved page
|
|
$this->pages->reset();
|
|
$this->pages->init();
|
|
$page = $this->pages->find('/test-inject');
|
|
|
|
self::assertNotNull($page, 'Page should exist after creation');
|
|
self::assertTrue(
|
|
property_exists($page->header(), 'injected_by_plugin') && $page->header()->injected_by_plugin === true,
|
|
'onAdminCreatePageFrontmatter should be able to inject fields into the header'
|
|
);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// PagesController: update
|
|
// -------------------------------------------------------------------------
|
|
|
|
public function testUpdatePageFiresOnAdminSaveAndAfterSave(): void
|
|
{
|
|
// Create a page first
|
|
$this->createTestPage('/update-test', 'Update Test');
|
|
|
|
$saveEvents = [];
|
|
$afterSaveEvents = [];
|
|
|
|
$this->grav['events']->addListener('onAdminSave', function (Event $event) use (&$saveEvents) {
|
|
$saveEvents[] = $event;
|
|
});
|
|
$this->grav['events']->addListener('onAdminAfterSave', function (Event $event) use (&$afterSaveEvents) {
|
|
$afterSaveEvents[] = $event;
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('PATCH', '/api/v1/pages/update-test', [
|
|
'title' => 'Updated Title',
|
|
], ['route' => 'update-test']);
|
|
|
|
$response = $controller->update($request);
|
|
|
|
self::assertSame(200, $response->getStatusCode());
|
|
self::assertCount(1, $saveEvents, 'onAdminSave should fire once on update');
|
|
self::assertCount(1, $afterSaveEvents, 'onAdminAfterSave should fire once on update');
|
|
|
|
// Both events should have 'object' and 'page' keys
|
|
self::assertArrayHasKey('page', $saveEvents[0]->toArray());
|
|
self::assertArrayHasKey('page', $afterSaveEvents[0]->toArray());
|
|
}
|
|
|
|
public function testUpdatePageOnAdminSaveCanModifyPage(): void
|
|
{
|
|
$this->createTestPage('/modify-test', 'Modify Test');
|
|
|
|
$this->grav['events']->addListener('onAdminSave', function (Event $event) {
|
|
$page = $event['object'];
|
|
$header = (array) $page->header();
|
|
$header['modified_by_plugin'] = 'seo-magic';
|
|
$page->header((object) $header);
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('PATCH', '/api/v1/pages/modify-test', [
|
|
'title' => 'Modified',
|
|
], ['route' => 'modify-test']);
|
|
|
|
$controller->update($request);
|
|
|
|
// Re-read the page to verify
|
|
$this->pages->reset();
|
|
$this->pages->init();
|
|
$page = $this->pages->find('/modify-test');
|
|
|
|
self::assertNotNull($page);
|
|
self::assertSame('seo-magic', $page->header()->modified_by_plugin ?? null);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// PagesController: delete
|
|
// -------------------------------------------------------------------------
|
|
|
|
public function testDeletePageFiresOnAdminAfterDelete(): void
|
|
{
|
|
$this->createTestPage('/delete-test', 'Delete Test');
|
|
|
|
$captured = [];
|
|
$this->grav['events']->addListener('onAdminAfterDelete', function (Event $event) use (&$captured) {
|
|
$captured[] = $event;
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('DELETE', '/api/v1/pages/delete-test', [], ['route' => 'delete-test']);
|
|
|
|
$response = $controller->delete($request);
|
|
|
|
self::assertSame(204, $response->getStatusCode());
|
|
self::assertCount(1, $captured, 'onAdminAfterDelete should fire once');
|
|
self::assertArrayHasKey('object', $captured[0]->toArray());
|
|
self::assertArrayHasKey('page', $captured[0]->toArray());
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// PagesController: move
|
|
// -------------------------------------------------------------------------
|
|
|
|
public function testMovePageFiresOnAdminAfterSaveAs(): void
|
|
{
|
|
$this->createTestPage('/move-source', 'Move Source');
|
|
$this->createTestPage('/move-target', 'Move Target');
|
|
|
|
$captured = [];
|
|
$this->grav['events']->addListener('onAdminAfterSaveAs', function (Event $event) use (&$captured) {
|
|
$captured[] = $event;
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('POST', '/api/v1/pages/move-source/move', [
|
|
'parent' => '/move-target',
|
|
], ['route' => 'move-source']);
|
|
|
|
$controller->move($request);
|
|
|
|
self::assertCount(1, $captured, 'onAdminAfterSaveAs should fire once');
|
|
self::assertArrayHasKey('path', $captured[0]->toArray());
|
|
self::assertStringContainsString('move-source', $captured[0]['path']);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// MediaController: upload & delete
|
|
// -------------------------------------------------------------------------
|
|
|
|
public function testMediaUploadFiresOnAdminAfterAddMedia(): void
|
|
{
|
|
$this->createTestPage('/media-test', 'Media Test');
|
|
|
|
$captured = [];
|
|
$this->grav['events']->addListener('onAdminAfterAddMedia', function (Event $event) use (&$captured) {
|
|
$captured[] = $event;
|
|
});
|
|
|
|
$controller = $this->createMediaController();
|
|
|
|
// Create a temp file to upload
|
|
$tmpFile = $this->tempDir . '/upload.txt';
|
|
file_put_contents($tmpFile, 'test content');
|
|
|
|
$uploadedFile = $this->createUploadedFile($tmpFile, 'test-upload.txt', 'text/plain');
|
|
|
|
$request = $this->makeRequest('POST', '/api/v1/pages/media-test/media', [], ['route' => 'media-test']);
|
|
$request = $request->withUploadedFiles(['file' => $uploadedFile]);
|
|
|
|
$response = $controller->uploadPageMedia($request);
|
|
|
|
self::assertSame(201, $response->getStatusCode());
|
|
self::assertCount(1, $captured, 'onAdminAfterAddMedia should fire once');
|
|
self::assertArrayHasKey('object', $captured[0]->toArray());
|
|
self::assertArrayHasKey('page', $captured[0]->toArray());
|
|
}
|
|
|
|
public function testMediaDeleteFiresOnAdminAfterDelMedia(): void
|
|
{
|
|
$this->createTestPage('/media-del-test', 'Media Del Test');
|
|
|
|
// Put a file in the page directory
|
|
$pagePath = $this->tempDir . '/pages/media-del-test';
|
|
file_put_contents($pagePath . '/photo.txt', 'test');
|
|
|
|
$captured = [];
|
|
$this->grav['events']->addListener('onAdminAfterDelMedia', function (Event $event) use (&$captured) {
|
|
$captured[] = $event;
|
|
});
|
|
|
|
$controller = $this->createMediaController();
|
|
$request = $this->makeRequest('DELETE', '/api/v1/pages/media-del-test/media/photo.txt', [], [
|
|
'route' => 'media-del-test',
|
|
'filename' => 'photo.txt',
|
|
]);
|
|
|
|
$response = $controller->deletePageMedia($request);
|
|
|
|
self::assertSame(204, $response->getStatusCode());
|
|
self::assertCount(1, $captured, 'onAdminAfterDelMedia should fire once');
|
|
self::assertArrayHasKey('object', $captured[0]->toArray());
|
|
self::assertArrayHasKey('page', $captured[0]->toArray());
|
|
self::assertArrayHasKey('filename', $captured[0]->toArray());
|
|
self::assertSame('photo.txt', $captured[0]['filename']);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// UsersController: create & update
|
|
// -------------------------------------------------------------------------
|
|
|
|
public function testUserCreateFiresOnAdminSaveAndAfterSave(): void
|
|
{
|
|
$saveEvents = [];
|
|
$afterSaveEvents = [];
|
|
|
|
$this->grav['events']->addListener('onAdminSave', function (Event $event) use (&$saveEvents) {
|
|
$saveEvents[] = $event;
|
|
});
|
|
$this->grav['events']->addListener('onAdminAfterSave', function (Event $event) use (&$afterSaveEvents) {
|
|
$afterSaveEvents[] = $event;
|
|
});
|
|
|
|
$controller = $this->createUsersController();
|
|
$request = $this->makeRequest('POST', '/api/v1/users', [
|
|
'username' => 'testuser_' . uniqid(),
|
|
'password' => 'TestPass123!',
|
|
'email' => 'test@example.com',
|
|
]);
|
|
|
|
$response = $controller->create($request);
|
|
|
|
self::assertSame(201, $response->getStatusCode());
|
|
self::assertCount(1, $saveEvents, 'onAdminSave should fire once for user create');
|
|
self::assertCount(1, $afterSaveEvents, 'onAdminAfterSave should fire once for user create');
|
|
self::assertArrayHasKey('object', $saveEvents[0]->toArray());
|
|
}
|
|
|
|
public function testUserUpdateFiresOnAdminSaveAndAfterSave(): void
|
|
{
|
|
// Create user first
|
|
$username = 'updateuser_' . uniqid();
|
|
$accounts = $this->grav['accounts'];
|
|
$user = $accounts->load($username);
|
|
$user->set('email', 'before@example.com');
|
|
$user->set('fullname', 'Before');
|
|
$user->set('state', 'enabled');
|
|
$user->set('hashed_password', password_hash('test', PASSWORD_DEFAULT));
|
|
$user->save();
|
|
|
|
$saveEvents = [];
|
|
$afterSaveEvents = [];
|
|
|
|
$this->grav['events']->addListener('onAdminSave', function (Event $event) use (&$saveEvents) {
|
|
$saveEvents[] = $event;
|
|
});
|
|
$this->grav['events']->addListener('onAdminAfterSave', function (Event $event) use (&$afterSaveEvents) {
|
|
$afterSaveEvents[] = $event;
|
|
});
|
|
|
|
$controller = $this->createUsersController();
|
|
$request = $this->makeRequest('PATCH', '/api/v1/users/' . $username, [
|
|
'fullname' => 'After',
|
|
], ['username' => $username]);
|
|
|
|
$response = $controller->update($request);
|
|
|
|
self::assertSame(200, $response->getStatusCode());
|
|
self::assertCount(1, $saveEvents, 'onAdminSave should fire once for user update');
|
|
self::assertCount(1, $afterSaveEvents, 'onAdminAfterSave should fire once for user update');
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// ConfigController: update
|
|
// -------------------------------------------------------------------------
|
|
|
|
public function testConfigUpdateFiresOnAdminSaveAndAfterSave(): void
|
|
{
|
|
$saveEvents = [];
|
|
$afterSaveEvents = [];
|
|
|
|
$this->grav['events']->addListener('onAdminSave', function (Event $event) use (&$saveEvents) {
|
|
$saveEvents[] = $event;
|
|
});
|
|
$this->grav['events']->addListener('onAdminAfterSave', function (Event $event) use (&$afterSaveEvents) {
|
|
$afterSaveEvents[] = $event;
|
|
});
|
|
|
|
$controller = $this->createConfigController();
|
|
$request = $this->makeRequest('PATCH', '/api/v1/config/site', [
|
|
'title' => 'Updated Site Title',
|
|
], ['scope' => 'site']);
|
|
|
|
$response = $controller->update($request);
|
|
|
|
self::assertSame(200, $response->getStatusCode());
|
|
self::assertCount(1, $saveEvents, 'onAdminSave should fire once for config update');
|
|
self::assertCount(1, $afterSaveEvents, 'onAdminAfterSave should fire once for config update');
|
|
|
|
// Config saves wrap in Data object
|
|
self::assertInstanceOf(Data::class, $saveEvents[0]['object']);
|
|
}
|
|
|
|
public function testConfigOnAdminSaveCanModifyData(): void
|
|
{
|
|
// Plugins modify the Data object in-place via set().
|
|
// Since objects are passed by identity, changes are visible to the caller.
|
|
$this->grav['events']->addListener('onAdminSave', function (Event $event) {
|
|
$obj = $event['object'];
|
|
if ($obj instanceof Data) {
|
|
$obj->set('injected', 'by-plugin');
|
|
}
|
|
});
|
|
|
|
$controller = $this->createConfigController();
|
|
$request = $this->makeRequest('PATCH', '/api/v1/config/site', [
|
|
'title' => 'Config Modify Test',
|
|
], ['scope' => 'site']);
|
|
|
|
$response = $controller->update($request);
|
|
$body = json_decode((string) $response->getBody(), true);
|
|
|
|
self::assertSame(200, $response->getStatusCode());
|
|
|
|
// The Data object was modified in-place by the listener, and the
|
|
// controller calls $obj->toArray() after the event, so the injected
|
|
// value should appear in the response (inside the 'data' wrapper).
|
|
$data = $body['data'] ?? $body;
|
|
self::assertSame('by-plugin', $data['injected'] ?? null, 'Plugin should be able to inject config values via onAdminSave');
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Event ordering: admin events fire before API events
|
|
// -------------------------------------------------------------------------
|
|
|
|
public function testAdminEventsFireBeforeApiEvents(): void
|
|
{
|
|
$order = [];
|
|
|
|
$this->grav['events']->addListener('onAdminSave', function () use (&$order) {
|
|
$order[] = 'onAdminSave';
|
|
});
|
|
$this->grav['events']->addListener('onAdminAfterSave', function () use (&$order) {
|
|
$order[] = 'onAdminAfterSave';
|
|
});
|
|
$this->grav['events']->addListener('onApiPageCreated', function () use (&$order) {
|
|
$order[] = 'onApiPageCreated';
|
|
});
|
|
$this->grav['events']->addListener('onApiBeforePageCreate', function () use (&$order) {
|
|
$order[] = 'onApiBeforePageCreate';
|
|
});
|
|
$this->grav['events']->addListener('onAdminCreatePageFrontmatter', function () use (&$order) {
|
|
$order[] = 'onAdminCreatePageFrontmatter';
|
|
});
|
|
|
|
$controller = $this->createPagesController();
|
|
$request = $this->makeRequest('POST', '/api/v1/pages', [
|
|
'route' => '/order-test',
|
|
'title' => 'Order Test',
|
|
]);
|
|
|
|
$controller->create($request);
|
|
|
|
// Expected order:
|
|
// 1. onApiBeforePageCreate (API before event)
|
|
// 2. onAdminCreatePageFrontmatter (admin frontmatter injection)
|
|
// 3. onAdminSave (admin pre-save)
|
|
// 4. onAdminAfterSave (admin post-save)
|
|
// 5. onApiPageCreated (API after event)
|
|
self::assertSame([
|
|
'onApiBeforePageCreate',
|
|
'onAdminCreatePageFrontmatter',
|
|
'onAdminSave',
|
|
'onAdminAfterSave',
|
|
'onApiPageCreated',
|
|
], $order, 'Events should fire in the correct order');
|
|
}
|
|
|
|
// =========================================================================
|
|
// Helper methods
|
|
// =========================================================================
|
|
|
|
private function createPagesController(): PagesController
|
|
{
|
|
return new PagesController($this->grav, $this->grav['config']);
|
|
}
|
|
|
|
private function createMediaController(): MediaController
|
|
{
|
|
return new MediaController($this->grav, $this->grav['config']);
|
|
}
|
|
|
|
private function createUsersController(): UsersController
|
|
{
|
|
return new UsersController($this->grav, $this->grav['config']);
|
|
}
|
|
|
|
private function createConfigController(): ConfigController
|
|
{
|
|
return new ConfigController($this->grav, $this->grav['config']);
|
|
}
|
|
|
|
private function createTestPage(string $route, string $title, string $content = ''): void
|
|
{
|
|
$slug = ltrim($route, '/');
|
|
$dir = $this->tempDir . '/pages/' . $slug;
|
|
@mkdir($dir, 0775, true);
|
|
file_put_contents($dir . '/default.md', "---\ntitle: {$title}\n---\n{$content}");
|
|
$this->pages->reset();
|
|
$this->pages->init();
|
|
}
|
|
|
|
private function makeRequest(
|
|
string $method,
|
|
string $path,
|
|
array $body = [],
|
|
array $routeParams = [],
|
|
): \Psr\Http\Message\ServerRequestInterface {
|
|
$superAdmin = $this->createSuperAdmin();
|
|
|
|
return new class ($method, $path, $body, $routeParams, $superAdmin) implements \Psr\Http\Message\ServerRequestInterface {
|
|
private array $attributes;
|
|
private array $uploadedFiles = [];
|
|
|
|
public function __construct(
|
|
private readonly string $method,
|
|
private readonly string $path,
|
|
private readonly array $body,
|
|
array $routeParams,
|
|
object $user,
|
|
) {
|
|
$this->attributes = [
|
|
'api_user' => $user,
|
|
'json_body' => $body,
|
|
'route_params' => $routeParams,
|
|
];
|
|
}
|
|
|
|
public function getMethod(): string { return $this->method; }
|
|
public function getQueryParams(): array { return []; }
|
|
public function getServerParams(): array { return []; }
|
|
public function getAttribute(string $name, mixed $default = null): mixed { return $this->attributes[$name] ?? $default; }
|
|
public function getHeaderLine(string $name): string { return ''; }
|
|
public function getHeader(string $name): array { return []; }
|
|
public function hasHeader(string $name): bool { return false; }
|
|
public function getHeaders(): array { return []; }
|
|
public function getParsedBody(): mixed { return $this->body; }
|
|
public function getUploadedFiles(): array { return $this->uploadedFiles; }
|
|
|
|
public function withUploadedFiles(array $uploadedFiles): static {
|
|
$clone = clone $this;
|
|
$clone->uploadedFiles = $uploadedFiles;
|
|
return $clone;
|
|
}
|
|
|
|
public function withAttribute(string $name, mixed $value): static {
|
|
$clone = clone $this;
|
|
$clone->attributes[$name] = $value;
|
|
return $clone;
|
|
}
|
|
|
|
// Stubs for remaining PSR-7 methods
|
|
public function getUri(): \Psr\Http\Message\UriInterface {
|
|
$path = $this->path;
|
|
return new class($path) implements \Psr\Http\Message\UriInterface {
|
|
public function __construct(private string $p) {}
|
|
public function getScheme(): string { return 'https'; }
|
|
public function getAuthority(): string { return ''; }
|
|
public function getUserInfo(): string { return ''; }
|
|
public function getHost(): string { return 'localhost'; }
|
|
public function getPort(): ?int { return null; }
|
|
public function getPath(): string { return $this->p; }
|
|
public function getQuery(): string { return ''; }
|
|
public function getFragment(): string { return ''; }
|
|
public function withScheme(string $scheme): static { return clone $this; }
|
|
public function withUserInfo(string $user, ?string $password = null): static { return clone $this; }
|
|
public function withHost(string $host): static { return clone $this; }
|
|
public function withPort(?int $port): static { return clone $this; }
|
|
public function withPath(string $path): static { return clone $this; }
|
|
public function withQuery(string $query): static { return clone $this; }
|
|
public function withFragment(string $fragment): static { return clone $this; }
|
|
public function __toString(): string { return $this->p; }
|
|
};
|
|
}
|
|
public function getBody(): \Psr\Http\Message\StreamInterface {
|
|
$c = json_encode($this->body);
|
|
return new class($c) implements \Psr\Http\Message\StreamInterface {
|
|
public function __construct(private string $c) {}
|
|
public function __toString(): string { return $this->c; }
|
|
public function close(): void {}
|
|
public function detach() { return null; }
|
|
public function getSize(): ?int { return strlen($this->c); }
|
|
public function tell(): int { return 0; }
|
|
public function eof(): bool { return true; }
|
|
public function isSeekable(): bool { return false; }
|
|
public function seek(int $offset, int $whence = SEEK_SET): void {}
|
|
public function rewind(): void {}
|
|
public function isWritable(): bool { return false; }
|
|
public function write(string $string): int { return 0; }
|
|
public function isReadable(): bool { return true; }
|
|
public function read(int $length): string { return $this->c; }
|
|
public function getContents(): string { return $this->c; }
|
|
public function getMetadata(?string $key = null): mixed { return null; }
|
|
};
|
|
}
|
|
public function getRequestTarget(): string { return $this->path; }
|
|
public function withRequestTarget(string $requestTarget): static { return clone $this; }
|
|
public function withMethod(string $method): static { return clone $this; }
|
|
public function withUri(\Psr\Http\Message\UriInterface $uri, bool $preserveHost = false): static { return clone $this; }
|
|
public function getProtocolVersion(): string { return '1.1'; }
|
|
public function withProtocolVersion(string $version): static { return clone $this; }
|
|
public function withHeader(string $name, $value): static { return clone $this; }
|
|
public function withAddedHeader(string $name, $value): static { return clone $this; }
|
|
public function withoutHeader(string $name): static { return clone $this; }
|
|
public function withBody(\Psr\Http\Message\StreamInterface $body): static { return clone $this; }
|
|
public function getCookieParams(): array { return []; }
|
|
public function withCookieParams(array $cookies): static { return clone $this; }
|
|
public function withQueryParams(array $query): static { return clone $this; }
|
|
public function withParsedBody($data): static { return clone $this; }
|
|
public function getAttributes(): array { return $this->attributes; }
|
|
public function withoutAttribute(string $name): static {
|
|
$clone = clone $this;
|
|
unset($clone->attributes[$name]);
|
|
return $clone;
|
|
}
|
|
};
|
|
}
|
|
|
|
private function createSuperAdmin(): UserInterface
|
|
{
|
|
/** @var \Grav\Common\User\Interfaces\UserCollectionInterface $accounts */
|
|
$accounts = $this->grav['accounts'];
|
|
$user = $accounts->load('admin');
|
|
|
|
// If user doesn't exist, create it
|
|
if (!$user->exists()) {
|
|
$user->set('email', 'admin@test.com');
|
|
$user->set('fullname', 'Test Admin');
|
|
$user->set('state', 'enabled');
|
|
$user->set('access', [
|
|
'admin' => ['super' => true, 'login' => true],
|
|
'api' => ['access' => true, 'pages' => ['read' => true, 'write' => true], 'media' => ['read' => true, 'write' => true], 'users' => ['read' => true, 'write' => true], 'config' => ['read' => true, 'write' => true]],
|
|
]);
|
|
$user->save();
|
|
}
|
|
|
|
return $user;
|
|
}
|
|
|
|
private function createUploadedFile(string $tmpPath, string $clientName, string $mediaType): \Psr\Http\Message\UploadedFileInterface
|
|
{
|
|
$size = filesize($tmpPath);
|
|
return new class($tmpPath, $clientName, $mediaType, $size) implements \Psr\Http\Message\UploadedFileInterface {
|
|
private bool $moved = false;
|
|
public function __construct(
|
|
private readonly string $tmpPath,
|
|
private readonly string $clientName,
|
|
private readonly string $mediaType,
|
|
private readonly int $fileSize,
|
|
) {}
|
|
public function getStream(): \Psr\Http\Message\StreamInterface { throw new \RuntimeException('Not implemented'); }
|
|
public function moveTo(string $targetPath): void { copy($this->tmpPath, $targetPath); $this->moved = true; }
|
|
public function getSize(): int { return $this->fileSize; }
|
|
public function getError(): int { return UPLOAD_ERR_OK; }
|
|
public function getClientFilename(): string { return $this->clientName; }
|
|
public function getClientMediaType(): string { return $this->mediaType; }
|
|
};
|
|
}
|
|
|
|
private static function assertStringContains(string $needle, string $haystack, string $message = ''): void
|
|
{
|
|
self::assertStringContainsString($needle, $haystack, $message);
|
|
}
|
|
|
|
private function rmrf(string $dir): void
|
|
{
|
|
if (!is_dir($dir)) return;
|
|
foreach (scandir($dir) as $item) {
|
|
if ($item === '.' || $item === '..') continue;
|
|
$path = $dir . '/' . $item;
|
|
is_dir($path) ? $this->rmrf($path) : unlink($path);
|
|
}
|
|
rmdir($dir);
|
|
}
|
|
}
|