Loosen-IT/WP-LIT-MCP
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 7 Wiki Activity
Files
b511ef63482bb46ac95e1bbe7ceea7b8aa1645eb
WP-LIT-MCP/tests/Unit/Integrations/Divi/Design/VariableBookTest.php
T

286 lines
13 KiB
PHP
Raw Blame History

<?php
declare(strict_types=1);
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
use InvalidArgumentException;
use LIT\MCP\Integrations\Divi\Design\VariableBook;
use PHPUnit\Framework\TestCase;
use stdClass;
final class VariableBookTest extends TestCase
{
/** @return array<string, mixed> One stored variable (formats §2). */
public static function variable(
string $type,
string $id,
string $label,
string $value,
string $order = '1',
string $status = 'active'
): array {
return [
'id' => $id, 'label' => $label, 'value' => $value, 'order' => $order, 'status' => $status,
'lastUpdated' => '2026-09-27T22:21:39.000Z', 'variableType' => $type,
];
}
/** @return array<string, array<string, array<string, mixed>>> The stored shape (et_divi_global_variables). */
public static function stored(): array
{
return [
'numbers' => [
'gvid-f6yq6mayfy' => self::variable('numbers', 'gvid-f6yq6mayfy', 'Eckenradius', '8px', '1'),
'gvid-5dec72fwsc' => self::variable('numbers', 'gvid-5dec72fwsc', 'Abstand Karte', '2rem', '2'),
'gvid-old0000001' => self::variable('numbers', 'gvid-old0000001', 'Alt', '1px', '', 'archived'),
],
'strings' => [
'gvid-7uckqqhmrh' => self::variable('strings', 'gvid-7uckqqhmrh', 'Slogan', 'Handwerk', '1'),
'gvid-dup0000001' => self::variable('strings', 'gvid-dup0000001', 'Eckenradius', 'Text', '2'),
],
'fonts' => [
'gvid-d4a5bsz2gt' => self::variable('fonts', 'gvid-d4a5bsz2gt', 'Akzentschrift', 'Merriweather'),
],
'gradients' => [
'gvid-grad000001' => self::variable(
'gradients',
'gvid-grad000001',
'Verlauf',
'linear-gradient(red, blue)'
),
],
];
}
/** @return array<string, mixed> The shape of GlobalData::get_global_variables() (formats §2, verified in DDEV). */
public static function fromGetter(): array
{
$actions = ['editLabel' => true, 'editValue' => true, 'reorder' => true, 'remove' => true];
$stored = self::stored();
$withActions = static fn (array $group): array => array_map(
static fn (array $entry): array => $entry + ['allowedActions' => $actions],
$group
);
return [
'numbers' => (object) $withActions($stored['numbers']),
'strings' => (object) $withActions($stored['strings']),
'images' => new stdClass(),
'links' => new stdClass(),
'colors' => (object) ['gcid-x1' => ['id' => 'gcid-x1', 'label' => 'Farbe', 'value' => '#fff']],
'fonts' => (object) ([
'--et_global_heading_font' => ['id' => '--et_global_heading_font', 'label' => 'Überschrift',
'value' => 'Open Sans', 'status' => 'active', 'allowedActions' => $actions],
'--et_global_body_font' => ['id' => '--et_global_body_font', 'label' => 'Fließtext',
'value' => 'Open Sans', 'status' => 'active', 'allowedActions' => $actions],
] + $withActions($stored['fonts'])),
'gradients' => (object) $withActions($stored['gradients']),
];
}
public function testStoredShapeIsKeptAsItIs(): void
{
self::assertSame(self::stored(), VariableBook::fromDivi(self::stored())->data());
}
public function testGetterShapeEqualsTheStoredShape(): void
{
$fromGetter = VariableBook::fromDivi(self::fromGetter());
$fromStored = VariableBook::fromDivi(self::stored());
self::assertSame($fromStored->data(), $fromGetter->data());
self::assertSame($fromStored->rev(), $fromGetter->rev());
self::assertNull($fromGetter->typeOf('--et_global_body_font'));
self::assertNull($fromGetter->typeOf('gcid-x1'));
self::assertArrayNotHasKey('colors', $fromGetter->data());
self::assertArrayNotHasKey('images', $fromGetter->data(), 'empty groups are dropped');
self::assertArrayNotHasKey('allowedActions', $fromGetter->entry('numbers', 'gvid-f6yq6mayfy') ?? []);
}
public function testGradientsPassThroughUnchanged(): void
{
$book = VariableBook::fromDivi(self::stored());
self::assertSame('linear-gradient(red, blue)', $book->entry('gradients', 'gvid-grad000001')['value']);
self::assertSame('gradients', $book->typeOf('gvid-grad000001'));
self::assertSame(
'gradients',
$book->with('gradients', 'gvid-grad000001', ['label' => 'Verlauf 2', 'value' => 'x'])
->entry('gradients', 'gvid-grad000001')['variableType']
);
}
public function testMissingKeysAreFilledAndIdAndTypeComeFromTheSlot(): void
{
$book = VariableBook::fromDivi([
'numbers' => ['gvid-x1' => ['id' => 'other', 'label' => 'A', 'value' => 8, 'order' => null,
'variableType' => 'strings', 'extra' => 'dropped']],
'strings' => ['kein-gvid' => ['label' => 'B', 'value' => 'x']],
]);
self::assertSame([
'id' => 'gvid-x1', 'label' => 'A', 'value' => '8', 'order' => '', 'status' => 'active',
'lastUpdated' => '', 'variableType' => 'numbers',
], $book->entry('numbers', 'gvid-x1'));
self::assertArrayNotHasKey('strings', $book->data());
}
public function testRevIsStableAndChangesWithTheContent(): void
{
$book = VariableBook::fromDivi(self::stored());
$reversed = VariableBook::fromDivi(array_map(
static fn (array $group): array => array_reverse($group, true),
array_reverse(self::stored(), true)
));
self::assertMatchesRegularExpression('/^[0-9a-f]{12}$/', $book->rev());
self::assertSame($book->rev(), $reversed->rev());
self::assertNotSame(
$book->rev(),
$book->with('numbers', 'gvid-f6yq6mayfy', ['label' => 'X', 'value' => '9px'])->rev()
);
}
public function testRealDiviFixtureAndItsGetterShapeAreTheSame(): void
{
$json = (string) file_get_contents(dirname(__DIR__, 4) . '/Fixtures/divi/stage4/global-variables.json');
$fixture = json_decode($json, true);
$stored = VariableBook::fromDivi($fixture['stored']);
$read = VariableBook::fromDivi($fixture['get_global_variables']);
self::assertSame($stored->rev(), $read->rev());
self::assertSame(['numbers', 'strings', 'images', 'links', 'fonts'], array_keys($read->data()));
self::assertSame('8px', $read->entry('numbers', 'gvid-f6yq6mayfy')['value']);
self::assertNull($read->typeOf('--et_global_heading_font'));
}
public function testFindByIdAndLabel(): void
{
$book = VariableBook::fromDivi(self::stored());
self::assertSame(['type' => 'numbers', 'id' => 'gvid-f6yq6mayfy'], $book->find('gvid-f6yq6mayfy'));
self::assertSame(['type' => 'strings', 'id' => 'gvid-7uckqqhmrh'], $book->find(' SLOGAN '));
self::assertSame(['type' => 'fonts', 'id' => 'gvid-d4a5bsz2gt'], $book->find('Akzentschrift', 'fonts'));
self::assertNull($book->find('Akzentschrift', 'numbers'));
self::assertNull($book->find('gvid-d4a5bsz2gt', 'numbers'));
self::assertNull($book->find('Fehlt'));
self::assertNull($book->find(''));
}
public function testAmbiguousLabelListsTheIdsAndAnArgumentTypeResolvesIt(): void
{
$book = VariableBook::fromDivi(self::stored());
self::assertSame(['type' => 'numbers', 'id' => 'gvid-f6yq6mayfy'], $book->find('Eckenradius', 'numbers'));
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage(
'Name der globalen Variable "Eckenradius" ist mehrdeutig; bitte die ID angeben: '
. 'gvid-f6yq6mayfy, gvid-dup0000001.'
);
$book->find('Eckenradius');
}
public function testWithIsImmutableAndKeepsTheTypeOrder(): void
{
$book = VariableBook::fromDivi(self::stored());
$added = $book->with('images', 'gvid-img0000001', ['label' => 'Bild', 'value' => '12', 'order' => '1']);
self::assertCount(3, $book->data()['numbers']);
self::assertSame(['numbers', 'strings', 'images', 'fonts', 'gradients'], array_keys($added->data()));
self::assertSame('images', $added->entry('images', 'gvid-img0000001')['variableType']);
self::assertSame('active', $added->entry('images', 'gvid-img0000001')['status']);
self::assertNull($book->entry('images', 'gvid-img0000001'));
}
public function testWithRejectsTypesDiviDoesNotStore(): void
{
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Unbekannter Variablentyp "colors".');
VariableBook::fromDivi([])->with('colors', 'gvid-x1', ['label' => 'A', 'value' => '#fff']);
}
public function testNextOrderIsTheHighestOrderPlusOne(): void
{
$book = VariableBook::fromDivi(self::stored());
self::assertSame('3', $book->nextOrder('numbers'), 'the archived entry with order "" does not count');
self::assertSame('2', $book->nextOrder('fonts'));
self::assertSame('1', $book->nextOrder('images'));
self::assertSame('1', $book->nextOrder('colors'));
self::assertSame('11', $book->with('links', 'gvid-l1', ['label' => 'L', 'value' => '/', 'order' => '10'])
->nextOrder('links'));
}
public function testRestoredFromKeepsCurrentOnlyVariablesArchived(): void
{
$current = VariableBook::fromDivi(self::stored())
->with('numbers', 'gvid-new0000001', ['label' => 'Neu', 'value' => '4px', 'order' => '3'])
->with('images', 'gvid-img0000001', ['label' => 'Bild', 'value' => '12', 'order' => '1'])
->with('strings', 'gvid-7uckqqhmrh', ['label' => 'Slogan neu', 'value' => 'Geändert', 'order' => '1']);
$snapshot = VariableBook::fromDivi(self::stored());
$restored = $current->restoredFrom($snapshot);
self::assertSame('Slogan', $restored->entry('strings', 'gvid-7uckqqhmrh')['label'], 'snapshot wins');
self::assertSame(
['label' => 'Neu', 'value' => '4px', 'order' => '', 'status' => 'archived'],
array_intersect_key(
$restored->entry('numbers', 'gvid-new0000001') ?? [],
array_flip(['status', 'order', 'label', 'value'])
)
);
self::assertSame('archived', $restored->entry('images', 'gvid-img0000001')['status']);
self::assertSame('', $restored->entry('images', 'gvid-img0000001')['order']);
self::assertSame('archived', $restored->entry('numbers', 'gvid-old0000001')['status']);
// Every ID of the current inventory survives, as Divi demands.
foreach ($current->data() as $type => $entries) {
foreach (array_keys($entries) as $id) {
self::assertNotNull($restored->entry($type, (string) $id), $id);
}
}
self::assertSame($snapshot->rev(), $snapshot->restoredFrom($snapshot)->rev());
}
public function testRestoredArchivedEntryLosesItsOrder(): void
{
$current = VariableBook::fromDivi(self::stored())
->with('fonts', 'gvid-gone000001', [
'label' => 'Weg', 'value' => 'Lato', 'order' => '7', 'status' => 'archived',
]);
$restored = $current->restoredFrom(VariableBook::fromDivi(self::stored()));
self::assertSame(['archived', ''], [
$restored->entry('fonts', 'gvid-gone000001')['status'],
$restored->entry('fonts', 'gvid-gone000001')['order'],
]);
}
public function testOnlyHereListsTheActiveVariablesARestoreWouldArchive(): void
{
$current = VariableBook::fromDivi(self::stored())
->with('numbers', 'gvid-new0000001', ['label' => 'Neu', 'value' => '4px'])
->with('fonts', 'gvid-gone000001', ['label' => 'Weg', 'value' => 'Lato', 'status' => 'archived']);
self::assertSame(
[['type' => 'numbers', 'id' => 'gvid-new0000001', 'label' => 'Neu']],
$current->onlyHere(VariableBook::fromDivi(self::stored()))
);
self::assertSame([], $current->onlyHere($current));
}
public function testNewIdHasTheBuilderFormat(): void
{
self::assertMatchesRegularExpression('/^gvid-[0-9a-z]{10}$/', VariableBook::newId());
self::assertNotSame(VariableBook::newId(), VariableBook::newId());
self::assertSame(
'gvid-zzzzzzzzzz',
VariableBook::newId(static fn (int $length): string => str_repeat('z', $length))
);
self::assertMatchesRegularExpression('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', VariableBook::now());
}
}
Reference in New Issue View Git Blame Copy Permalink