feat: enhance JSHandle and JavaScriptSerializer with additional functionality and tests

Author: MrPunyapal

src/Playwright/JSHandle.php

@@ -65,6 +65,12 @@ public function dispose(): void
      */
     public function toString(): string
     {
-        return $this->jsonValue();
+        $value = $this->jsonValue();
+
+        if (is_string($value)) {
+            return $value;
+        }
+
+        return (string) $value;
     }
 }

src/Playwright/Page.php

@@ -26,7 +26,9 @@ public function __construct(
         public string $guid,
         public string $frameGuid,
         public string $url = '',
-    ) {}
+    ) {
+        //
+    }
 
     /**
      * Get the current URL of the page.
@@ -555,7 +557,8 @@ public function evaluateHandle(string $pageFunction, mixed $arg = null): JSHandl
             'arg' => JavaScriptSerializer::serializeArgument($arg),
         ];
 
-        $response = $this->sendMessage('evaluateExpressionHandle', $params);        /** @var array{method?: string|null, params: array{type?: string|null, guid?: string}} $message */
+        $response = $this->sendMessage('evaluateExpressionHandle', $params);
+
         foreach ($response as $message) {
             if (
                 isset($message['method'], $message['params']['type'], $message['params']['guid'])

src/Support/JavaScriptSerializer.php

@@ -5,7 +5,6 @@
 namespace Pest\Browser\Support;
 
 use DateTimeImmutable;
-use stdClass;
 
 /**
  * Handles serialization and deserialization of JavaScript values.
@@ -85,7 +84,6 @@ public static function serializeValue(mixed $value): array
             return ['o' => $result];
         }
 
-        // Fallback for unsupported types
         return ['s' => (string) $value];
     }
 

tests/Browser/Playwright/JSHandle/EvaluateTest.php

@@ -3,47 +3,38 @@
 declare(strict_types=1);
 
 use Pest\Browser\Playwright\JSHandle;
-use Pest\Browser\Support\JavaScriptSerializer;
 
 it('can evaluate basic expressions on a JSHandle', function (): void {
     $page = page('/test/frame-tests');
 
-    // Create a JSHandle for a DOM element
     $handle = $page->evaluateHandle('document.querySelector("#test-content")');
     expect($handle)->toBeInstanceOf(JSHandle::class);
 
-    // Evaluate a simple property access on the handle
     $textContent = $handle->evaluate('node => node.textContent');
     expect($textContent)->toContain('This is the main content for testing');
 });
 
 it('can evaluate expressions that modify a JSHandle element', function (): void {
     $page = page('/test/frame-tests');
 
-    // Create a JSHandle for an input element
     $handle = $page->evaluateHandle('document.querySelector("#test-input")');
     expect($handle)->toBeInstanceOf(JSHandle::class);
 
-    // Set the value of the input
     $handle->evaluate('input => { input.value = "test value"; return true; }');
 
-    // Verify the value was changed
     $value = $page->inputValue('#test-input');
     expect($value)->toBe('test value');
 });
 
 it('can pass arguments when evaluating expressions on a JSHandle', function (): void {
     $page = page('/test/frame-tests');
 
-    // Create a JSHandle
     $handle = $page->evaluateHandle('document.querySelector("#test-content")');
     expect($handle)->toBeInstanceOf(JSHandle::class);
 
-    // Pass a simple string argument
     $result = $handle->evaluate('(node, text) => { node.textContent = text; return node.textContent; }', 'Updated content');
     expect($result)->toBe('Updated content');
 
-    // Verify the content was actually changed in the page
     $content = $page->textContent('#test-content');
     expect($content)->toBe('Updated content');
 });
@@ -54,16 +45,81 @@
     $handle = $page->evaluateHandle('document.querySelector("h1")');
     expect($handle)->toBeInstanceOf(JSHandle::class);
 
-    // Return a string
     $text = $handle->evaluate('h1 => h1.textContent');
     expect($text)->toBeString();
     expect($text)->toContain('PESTPHP');
 
-    // Return a boolean
     $hasChildren = $handle->evaluate('h1 => h1.hasChildNodes()');
     expect($hasChildren)->toBeTrue();
 
-    // Return a number
     $childCount = $handle->evaluate('h1 => h1.childNodes.length');
     expect($childCount)->toBeGreaterThan(0);
 });
+
+it('can get JSON value from JSHandle with objects', function (): void {
+    $page = page('/test/frame-tests');
+
+    $handle = $page->evaluateHandle('({name: "test", value: 42, active: true})');
+    expect($handle)->toBeInstanceOf(JSHandle::class);
+
+    $jsonValue = $handle->jsonValue();
+    expect($jsonValue)->toBeArray();
+    expect($jsonValue)->toHaveKey('name');
+    expect($jsonValue)->toHaveKey('value');
+    expect($jsonValue['name'])->toBe('test');
+    expect($jsonValue['value'])->toBe(42);
+    expect($jsonValue['active'])->toBeTrue();
+});
+
+it('can get JSON value from JSHandle with different data types', function (): void {
+    $page = page('/test/frame-tests');
+
+    $arrayHandle = $page->evaluateHandle('[1, 2, "test"]');
+    expect($arrayHandle->jsonValue())->toBe([1, 2, 'test']);
+
+    $numberHandle = $page->evaluateHandle('42');
+    expect($numberHandle->jsonValue())->toBe(42);
+});
+
+it('can get JSON value from JSHandle for DOM elements', function (): void {
+    $page = page('/test/frame-tests');
+
+    $handle = $page->evaluateHandle('document.querySelector("#test-content")');
+    expect($handle)->toBeInstanceOf(JSHandle::class);
+
+    $jsonValue = $handle->jsonValue();
+    expect($jsonValue)->toBeString();
+    expect($jsonValue)->toContain('ref:');
+});
+
+it('can convert JSHandle to string representation', function (): void {
+    $page = page('/test/frame-tests');
+
+    $stringHandle = $page->evaluateHandle('"hello world"');
+    expect($stringHandle->toString())->toBe('hello world');
+
+    $numberHandle = $page->evaluateHandle('42');
+    expect($numberHandle->toString())->toBe('42');
+});
+
+it('can dispose JSHandle', function (): void {
+    $page = page('/test/frame-tests');
+
+    $handle = $page->evaluateHandle('document.querySelector("#test-content")');
+    expect($handle)->toBeInstanceOf(JSHandle::class);
+
+    $handle->dispose();
+    expect(true)->toBeTrue();
+});
+
+it('can evaluate complex expressions with various argument types', function (): void {
+    $page = page('/test/frame-tests');
+
+    $handle = $page->evaluateHandle('document');
+    expect($handle)->toBeInstanceOf(JSHandle::class);
+
+    expect($handle->evaluate('(doc, arg) => arg === null', null))->toBeTrue();
+    expect($handle->evaluate('(doc, num) => num * 2', 21))->toBe(42);
+    expect($handle->evaluate('(doc, arr) => arr.length', [1, 2, 3]))->toBe(3);
+    expect($handle->evaluate('(doc, obj) => obj.name + ":" + obj.value', ['name' => 'test', 'value' => 123]))->toBe('test:123');
+});

tests/Unit/Playwright/JSHandleTest.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+use Pest\Browser\Playwright\JSHandle;
+
+test('constructs JSHandle with guid correctly', function (): void {
+    $guid = 'test-guid-12345';
+    $handle = new JSHandle($guid);
+
+    expect($handle->guid)->toBe($guid);
+});
+
+test('has correct class properties', function (): void {
+    $guid = 'test-guid';
+    $handle = new JSHandle($guid);
+
+    expect($handle)->toBeInstanceOf(JSHandle::class);
+    expect(property_exists($handle, 'guid'))->toBeTrue();
+});
+
+test('can be created with different guid formats', function (): void {
+    $guidFormats = [
+        'simple-guid',
+        'uuid-v4-format-12345',
+        'handle-with-numbers-123',
+        'CamelCaseGuid',
+        'guid_with_underscores',
+    ];
+
+    foreach ($guidFormats as $guid) {
+        $handle = new JSHandle($guid);
+        expect($handle->guid)->toBe($guid);
+        expect($handle)->toBeInstanceOf(JSHandle::class);
+    }
+});
+
+test('has unique guid for different instances', function (): void {
+    $handle1 = new JSHandle('guid-1');
+    $handle2 = new JSHandle('guid-2');
+
+    expect($handle1->guid)->not()->toBe($handle2->guid);
+    expect($handle1)->not()->toBe($handle2);
+});

tests/Unit/Support/JavaScriptSerializerTest.php

@@ -4,43 +4,19 @@
 
 use Pest\Browser\Support\JavaScriptSerializer;
 
-it('serializes null values correctly', function (): void {
-    $value = null;
-    $result = JavaScriptSerializer::serializeValue($value);
-
-    expect($result)->toBe(['v' => 'null']);
-});
-
-it('serializes boolean values correctly', function (): void {
-    $true = JavaScriptSerializer::serializeValue(true);
-    $false = JavaScriptSerializer::serializeValue(false);
-
-    expect($true)->toBe(['b' => true]);
-    expect($false)->toBe(['b' => false]);
-});
-
-it('serializes numeric values correctly', function (): void {
-    $int = JavaScriptSerializer::serializeValue(42);
-    $float = JavaScriptSerializer::serializeValue(3.14);
-
-    expect($int)->toBe(['n' => 42]);
-    expect($float)->toBe(['n' => 3.14]);
+it('serializes primitive values correctly', function (): void {
+    expect(JavaScriptSerializer::serializeValue(null))->toBe(['v' => 'null']);
+    expect(JavaScriptSerializer::serializeValue(true))->toBe(['b' => true]);
+    expect(JavaScriptSerializer::serializeValue(false))->toBe(['b' => false]);
+    expect(JavaScriptSerializer::serializeValue(42))->toBe(['n' => 42]);
+    expect(JavaScriptSerializer::serializeValue(3.14))->toBe(['n' => 3.14]);
+    expect(JavaScriptSerializer::serializeValue('hello'))->toBe(['s' => 'hello']);
 });
 
 it('serializes special numeric values correctly', function (): void {
-    $nan = JavaScriptSerializer::serializeValue(NAN);
-    $infinity = JavaScriptSerializer::serializeValue(INF);
-    $negInfinity = JavaScriptSerializer::serializeValue(-INF);
-
-    expect($nan)->toBe(['v' => 'NaN']);
-    expect($infinity)->toBe(['v' => 'Infinity']);
-    expect($negInfinity)->toBe(['v' => '-Infinity']);
-});
-
-it('serializes strings correctly', function (): void {
-    $string = JavaScriptSerializer::serializeValue('hello world');
-
-    expect($string)->toBe(['s' => 'hello world']);
+    expect(JavaScriptSerializer::serializeValue(NAN))->toBe(['v' => 'NaN']);
+    expect(JavaScriptSerializer::serializeValue(INF))->toBe(['v' => 'Infinity']);
+    expect(JavaScriptSerializer::serializeValue(-INF))->toBe(['v' => '-Infinity']);
 });
 
 it('serializes arrays correctly', function (): void {
@@ -59,7 +35,6 @@
     expect($assoc)->toHaveKey('o');
     expect($assoc['o'])->toBeArray();
 
-    // Check for the name key-value pair
     $hasName = false;
     $hasAge = false;
 
@@ -86,7 +61,6 @@
     expect($result)->toHaveKey('o');
     expect($result['o'])->toBeArray();
 
-    // Check for the needed properties
     $hasName = false;
     $hasActive = false;
 
@@ -222,3 +196,34 @@
     expect($result['user']['name'])->toBe('Alice');
     expect($result['user']['hobbies'])->toBe(['reading', 'coding']);
 });
+
+it('serializes DateTimeImmutable objects correctly', function (): void {
+    $date = new DateTimeImmutable('2023-01-01T12:00:00Z');
+    $result = JavaScriptSerializer::serializeValue($date);
+
+    expect($result)->toHaveKey('d');
+    expect($result['d'])->toBe('2023-01-01T12:00:00+00:00');
+});
+
+it('parses DateTimeImmutable values correctly', function (): void {
+    $dateValue = ['d' => '2023-01-01T12:00:00+00:00'];
+    $result = JavaScriptSerializer::parseValue($dateValue);
+
+    expect($result)->toBeInstanceOf(DateTimeImmutable::class);
+    expect($result->format('Y-m-d\TH:i:s\Z'))->toBe('2023-01-01T12:00:00Z');
+});
+
+it('serializes big integers correctly', function (): void {
+    $bigInt = 9007199254740993;
+    $result = JavaScriptSerializer::serializeValue($bigInt);
+
+    expect($result)->toHaveKey('bi');
+    expect($result['bi'])->toBe('9007199254740993');
+});
+
+it('parses big integer values correctly', function (): void {
+    $bigIntValue = ['bi' => '9007199254740993'];
+    $result = JavaScriptSerializer::parseValue($bigIntValue);
+
+    expect($result)->toBe('9007199254740993');
+});