Changeset 61176 for trunk/tests/phpunit/tests/dependencies/scripts.php

Timestamp:

11/07/2025 06:11:24 AM (9 months ago)

Author:

westonruter

Message:

Script Loader: Guard against exponential recursion during calculation of loading strategy and fetchpriority.

This addresses a performance issue in the recursive WP_Scripts::get_highest_fetchpriority_with_dependents() and WP_Scripts::filter_eligible_strategies() methods for redundant processing of shared dependencies in complex dependency graphs. To fix this, a $stored_results param is introduced which is passed by reference; this variable contains a cache of the calculated results for all scripts handles, so that subsequent calls for the same handle can return the cached value instead of re-computing it.

Developed in ​https://github.com/WordPress/wordpress-develop/pull/10459

Follow-up to [60704], [60931], [56033].

Props ciobanucatalin, b1ink0, westonruter, mukesh27.
See #61734, #12009.
Fixes #64194.

File:

• trunk/tests/phpunit/tests/dependencies/scripts.php (modified) (2 diffs)

trunk/tests/phpunit/tests/dependencies/scripts.php

@@ -1437 +1437 @@
 
         /**
+         * Tests that `WP_Scripts::get_highest_fetchpriority_with_dependents()` correctly reuses cached results.
+         *
+         * @ticket 64194
+         *
+         * @covers WP_Scripts::get_highest_fetchpriority_with_dependents
+         */
+        public function test_highest_fetchpriority_with_dependents_uses_cached_result() {
+                $wp_scripts = new WP_Scripts();
+                $wp_scripts->add( 'd', 'https://example.com/d.js' );
+                $wp_scripts->add_data( 'd', 'fetchpriority', 'low' );
+
+                /*
+                 * Simulate a pre-existing `$stored_results` cache entry for `d`.
+                 * If the caching logic works, the function should use this "high" value
+                 * instead of recalculating based on the actual (lower) value.
+                 */
+                $stored_results = array( 'd' => 'high' );
+
+                // Access the private method using reflection.
+                $method = new ReflectionMethod( WP_Scripts::class, 'get_highest_fetchpriority_with_dependents' );
+                if ( PHP_VERSION_ID < 80100 ) {
+                        $method->setAccessible( true );
+                }
+
+                // Pass `$stored_results` BY REFERENCE.
+                $result = $method->invokeArgs( $wp_scripts, array( 'd', array(), &$stored_results ) );
+
+                $this->assertSame(
+                        'high',
+                        $result,
+                        'Expected "high" indicates that the cached `$stored_results` entry for D was used instead of recalculating.'
+                );
+        }
+
+        /**
          * Tests that printing a script without enqueueing has the same output as when it is enqueued.
          *
@@ -1533 +1568 @@
                 $expected = str_replace( "'", '"', $expected );
                 $this->assertSame( $expected, $output, 'Scripts registered with no strategy assigned, and who have no dependencies, should have no loading strategy attributes printed.' );
+        }
+
+        /**
+         * Tests that `WP_Scripts::filter_eligible_strategies()` correctly reuses cached results.
+         *
+         * @ticket 64194
+         *
+         * @covers WP_Scripts::filter_eligible_strategies
+         */
+        public function test_filter_eligible_strategies_uses_cached_result() {
+                $wp_scripts = new WP_Scripts();
+                $wp_scripts->add( 'd', 'https://example.com/d.js' );
+                $wp_scripts->add_data( 'd', 'strategy', 'defer' );
+
+                /*
+                 * Simulate a cached result in `$stored_results` for D.
+                 * If caching logic is functioning properly, this cached value
+                 * should be returned immediately without recomputing.
+                 */
+                $stored_results = array( 'd' => array( 'async' ) );
+
+                // Access the private method via reflection.
+                $method = new ReflectionMethod( WP_Scripts::class, 'filter_eligible_strategies' );
+                if ( PHP_VERSION_ID < 80100 ) {
+                        $method->setAccessible( true );
+                }
+
+                // Invoke the method with `$stored_results` passed by reference.
+                $result = $method->invokeArgs( $wp_scripts, array( 'd', null, array(), &$stored_results ) );
+
+                $this->assertSame(
+                        array( 'async' ),
+                        $result,
+                        'Expected cached `$stored_results` value for D to be reused instead of recomputed.'
+                );
         }