chore: completing partial tests

Author: vardumper

clover.xml

@@ -0,0 +1,76 @@
+<?php
+
+use Html\Trait\ClassResolverTrait;
+use Html\Delegator\HTMLDocumentDelegator;
+use Html\Delegator\HTMLElementDelegator;
+
+class TestClassResolverExtra
+{
+    use ClassResolverTrait;
+
+    public function callGetClassesExtendingClass(string $base): array
+    {
+        return $this->getClassesExtendingClass($base);
+    }
+
+    public function callGetClassesImplementingInterface(string $interface): array
+    {
+        return $this->getClassesImplementingInterface($interface);
+    }
+
+    public function callGetElementByQualifiedName(string $name): ?string
+    {
+        return $this->getElementByQualifiedName($name);
+    }
+
+    public function callGetDelegatorFromElement(\DOM\Element $element): ?HTMLElementDelegator
+    {
+        return $this->getDelegatorFromElement($element);
+    }
+}
+
+// Simple classes for testing inheritance/interface discovery
+class BaseForResolverTest {}
+class SubForResolverTest extends BaseForResolverTest {}
+interface InterfaceForResolver {}
+class ImplementsResolverTest implements InterfaceForResolver {}
+
+// Test element delegator with Element attribute
+#[\Html\Mapping\Element('x-foo')]
+class TestElementDelegator extends HTMLElementDelegator {
+    public static string $QUALIFIED_NAME = 'x-foo';
+}
+
+test('getClassesExtendingClass finds subclasses', function () {
+    $resolver = new TestClassResolverExtra();
+
+    $result = $resolver->callGetClassesExtendingClass(BaseForResolverTest::class);
+
+    expect(in_array(SubForResolverTest::class, $result))->toBeTrue();
+});
+
+test('getClassesImplementingInterface finds implementations', function () {
+    $resolver = new TestClassResolverExtra();
+
+    $result = $resolver->callGetClassesImplementingInterface(InterfaceForResolver::class);
+
+    expect(in_array(ImplementsResolverTest::class, $result))->toBeTrue();
+});
+
+test('getElementByQualifiedName finds class by attribute', function () {
+    $resolver = new TestClassResolverExtra();
+
+    $class = $resolver->callGetElementByQualifiedName('x-foo');
+
+    expect($class)->toBe(TestElementDelegator::class);
+});
+
+test('getDelegatorFromElement returns instance of the configured class', function () {
+    $doc = HTMLDocumentDelegator::createEmpty();
+    $element = $doc->delegated->createElement('x-foo');
+
+    $resolver = new TestClassResolverExtra();
+    $delegator = $resolver->callGetDelegatorFromElement($element);
+
+    expect($delegator)->toBeInstanceOf(TestElementDelegator::class);
+});

tests/Trait/ClassResolverTraitExtraTest.php

@@ -0,0 +1,72 @@
+<?php
+
+use Html\Trait\ClassResolverTrait;
+
+class TestClassResolverPrivate
+{
+    use ClassResolverTrait;
+
+    public function callLoadAllPhpFiles(string $dir): void
+    {
+        $this->loadAllPhpFiles($dir);
+    }
+
+    public function callFindComposerRoot(string $start): ?string
+    {
+        return $this->findComposerRoot($start);
+    }
+
+    public function callGetPackageRoot(): string
+    {
+        return $this->getPackageRoot();
+    }
+}
+
+test('loadAllPhpFiles requires php files and loads classes', function () {
+    $tmp = sys_get_temp_dir() . '/ehd_test_' . uniqid();
+    mkdir($tmp . '/src', 0777, true);
+    $file = $tmp . '/src/TestLoadedClass.php';
+    file_put_contents($file, "<?php\nclass TempLoadedClass {}\n");
+
+    $t = new TestClassResolverPrivate();
+
+    expect(class_exists('TempLoadedClass'))->toBeFalse();
+    $t->callLoadAllPhpFiles($tmp . '/src');
+    expect(class_exists('TempLoadedClass'))->toBeTrue();
+
+    // cleanup
+    @unlink($file);
+    @rmdir($tmp . '/src');
+    @rmdir($tmp);
+});
+
+test('findComposerRoot returns autoload path when composer.json and vendor/autoload.php exist', function () {
+    $tmp = sys_get_temp_dir() . '/ehd_test_comp_' . uniqid();
+    mkdir($tmp . '/nested/dir', 0777, true);
+    file_put_contents($tmp . '/composer.json', '{}');
+    mkdir($tmp . '/vendor', 0777, true);
+    file_put_contents($tmp . '/vendor/autoload.php', "<?php\n// autoload\n");
+
+    $t = new TestClassResolverPrivate();
+
+    $found = $t->callFindComposerRoot($tmp . '/nested/dir');
+
+    expect($found)->toBe($tmp . '/vendor/autoload.php');
+
+    // cleanup
+    @unlink($tmp . '/vendor/autoload.php');
+    @rmdir($tmp . '/vendor');
+    @unlink($tmp . '/composer.json');
+    @rmdir($tmp . '/nested/dir');
+    @rmdir($tmp . '/nested');
+    @rmdir($tmp);
+});
+
+test('getPackageRoot returns string and points to package root', function () {
+    $t = new TestClassResolverPrivate();
+
+    $pkg = $t->callGetPackageRoot();
+
+    expect(is_string($pkg))->toBeTrue();
+    expect(is_dir($pkg))->toBeTrue();
+});

tests/Trait/ClassResolverTraitPrivateTest.php

@@ -0,0 +1,76 @@
+<?php
+
+use Html\Trait\DelegatorTrait;
+use BadMethodCallException;
+use InvalidArgumentException;
+
+class DummyDelegated {
+    public string $fooProp = 'bar';
+
+    public function sum(int $a, int $b): int {
+        return $a + $b;
+    }
+
+    public function methodTakesObject(\stdClass $obj): string {
+        return $obj->name ?? 'none';
+    }
+
+    public function typeStrict(int $x): int {
+        return $x * 2;
+    }
+}
+
+class TestDelegator
+{
+    use DelegatorTrait;
+
+    public object $delegated;
+
+    public function __construct()
+    {
+        $this->delegated = new DummyDelegated();
+    }
+}
+
+test('__call delegates method calls and returns result', function () {
+    $t = new TestDelegator();
+
+    $result = $t->sum(2, 3);
+
+    expect($result)->toBe(5);
+});
+
+test('__call replaces delegator arg with delegated object when passed', function () {
+    $t = new TestDelegator();
+
+    $other = new TestDelegator();
+    $other->delegated = new \stdClass();
+    $other->delegated->name = 'abc';
+
+    $res = $t->methodTakesObject($other);
+
+    expect($res)->toBe('abc');
+});
+
+test('__call throws BadMethodCallException when call fails due to type error', function () {
+    $t = new TestDelegator();
+
+    expect(fn () => $t->typeStrict('not-int'))
+        ->toThrow(BadMethodCallException::class);
+});
+
+test('__get returns delegated property value and throws when missing', function () {
+    $t = new TestDelegator();
+
+    expect($t->fooProp)->toBe('bar');
+    expect(fn () => $t->missingProp)->toThrow(InvalidArgumentException::class);
+});
+
+test('__set sets delegated property and throws when missing', function () {
+    $t = new TestDelegator();
+
+    $t->fooProp = 'changed';
+    expect($t->fooProp)->toBe('changed');
+
+    expect(fn () => ($t->unknown = 'x'))->toThrow(InvalidArgumentException::class);
+});

tests/Trait/DelegatorTraitTest.php

@@ -0,0 +1,35 @@
+<?php
+
+use Html\Trait\GeneratorResolverTrait;
+use Html\Trait\ClassResolverTrait;
+use Html\Mapping\TemplateGenerator;
+use Html\Interface\TemplateGeneratorInterface;
+
+#[TemplateGenerator('testgen')]
+class TestGeneratorImplementation implements TemplateGeneratorInterface {
+    public function getExtension(): string { return 'x'; }
+    public function getNamePattern(): string { return 'x'; }
+    public function canRenderElements(): bool { return false; }
+    public function canRenderDocuments(): bool { return false; }
+    public function isTemplated(): bool { return false; }
+    public function render($elementOrDocument): ?string { return null; }
+}
+
+class TestGeneratorResolver {
+    use GeneratorResolverTrait;
+    use ClassResolverTrait; // supplies getClassesImplementingInterface used by GeneratorResolver
+
+    public function callGetGenerators(array $names): array
+    {
+        return $this->getGenerators($names);
+    }
+}
+
+test('getGenerators returns instances of annotated generators by name', function () {
+    $r = new TestGeneratorResolver();
+
+    $result = $r->callGetGenerators(['testgen']);
+
+    expect(array_key_exists('testgen', $result))->toBeTrue();
+    expect($result['testgen'])->toBeInstanceOf(TestGeneratorImplementation::class);
+});

tests/Trait/GeneratorResolverTraitTest.php

@@ -0,0 +1,45 @@
+<?php
+
+use Html\Trait\NativePropertiesTrait;
+
+class TestNativeProperties {
+    use NativePropertiesTrait;
+
+    // define properties that trait expects to exist
+    public ?string $textContent = null;
+    public string $innerHTML = '';
+    public string $nodeValue = '';
+    public string $substitutedNodeValue = '';
+}
+
+test('textContent setter and getter', function () {
+    $t = new TestNativeProperties();
+
+    $t->setTextContent('hello');
+
+    expect($t->getTextContent())->toBe('hello');
+});
+
+test('innerHTML setter and getter', function () {
+    $t = new TestNativeProperties();
+
+    $t->setInnerHTML('<b>bold</b>');
+
+    expect($t->getInnerHTML())->toBe('<b>bold</b>');
+});
+
+test('nodeValue setter and getter', function () {
+    $t = new TestNativeProperties();
+
+    $t->setNodeValue('node');
+
+    expect($t->getNodeValue())->toBe('node');
+});
+
+test('substitutedNodeValue setter and getter', function () {
+    $t = new TestNativeProperties();
+
+    $t->setSubstitutedNodeValue('sub');
+
+    expect($t->getSubstitutedNodeValue())->toBe('sub');
+});