@wordpress/e2e-tests 9.5.1-next.v.202602271551.0 → 9.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/e2e-tests",
-	"version": "9.5.1-next.v.202602271551.0+464abe399",
+	"version": "9.5.1",
 	"description": "Test plugins and mu-plugins for E2E tests in WordPress.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -24,8 +24,8 @@
 		"npm": ">=8.19.2"
 	},
 	"dependencies": {
-		"@wordpress/interactivity": "^6.40.1-next.v.202602271551.0+464abe399",
-		"@wordpress/interactivity-router": "^2.40.1-next.v.202602271551.0+464abe399"
+		"@wordpress/interactivity": "^6.40.1",
+		"@wordpress/interactivity-router": "^2.40.1"
 	},
 	"peerDependencies": {
 		"jest": ">=29",
@@ -36,5 +36,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "95aa7055a5757219e2d96a91efc69f7dd1b2d4c3"
+	"gitHead": "adb6623c9f32490cfc73c7ac7f122578c1f10c65"
 }

package/plugins/block-bindings.php

@@ -172,7 +172,7 @@ function gutenberg_test_block_bindings_registration() {
 			'type'         => 'number',
 			'show_in_rest' => true,
 			'single'       => true,
-			'default'      => 5.5,
+			'default'      => 0.5,
 		)
 	);
 	register_meta(
@@ -183,7 +183,7 @@ function gutenberg_test_block_bindings_registration() {
 			'type'         => 'integer',
 			'show_in_rest' => true,
 			'single'       => true,
-			'default'      => 5,
+			'default'      => 3,
 		)
 	);
 	register_meta(

package/plugins/connectors-capability-restriction.php

@@ -0,0 +1,112 @@
+<?php
+/**
+ * Plugin Name: Gutenberg Test Connectors Capability Restriction
+ * Plugin URI: https://github.com/WordPress/gutenberg
+ * Author: Gutenberg Team
+ *
+ * @package gutenberg-test-connectors-capability-restriction
+ */
+
+add_action(
+	'init',
+	static function () {
+		register_setting(
+			'general',
+			'gutenberg_test_cap_restriction',
+			array(
+				'type'         => 'string',
+				'default'      => '',
+				'show_in_rest' => true,
+			)
+		);
+	}
+);
+
+register_activation_hook(
+	__FILE__,
+	static function () {
+		delete_option( 'gutenberg_test_cap_restriction' );
+	}
+);
+
+register_deactivation_hook(
+	__FILE__,
+	static function () {
+		delete_option( 'gutenberg_test_cap_restriction' );
+	}
+);
+
+add_action(
+	'wp_connectors_init',
+	static function ( WP_Connector_Registry $registry ) {
+		$registry->register(
+			'test_install_required_connector',
+			array(
+				'name'           => 'Test Install Required Connector',
+				'description'    => 'A connector backed by a plugin that is not installed.',
+				'type'           => 'ai_provider',
+				'plugin'         => array(
+					'file'      => 'gutenberg-test-connectors-never-installed/plugin.php',
+					'is_active' => '__return_false',
+				),
+				'authentication' => array(
+					'method'       => 'api_key',
+					'setting_name' => 'gutenberg_test_install_required_connector_api_key',
+				),
+			)
+		);
+
+		$registry->register(
+			'test_activate_required_connector',
+			array(
+				'name'           => 'Test Activate Required Connector',
+				'description'    => 'A connector backed by an installed inactive plugin.',
+				'type'           => 'ai_provider',
+				'plugin'         => array(
+					'file'      => 'hello/hello.php',
+					'is_active' => '__return_false',
+				),
+				'authentication' => array(
+					'method'       => 'api_key',
+					'setting_name' => 'gutenberg_test_activate_required_connector_api_key',
+				),
+			)
+		);
+	}
+);
+
+add_filter(
+	'map_meta_cap',
+	static function ( $caps, $cap ) {
+		$restriction = get_option( 'gutenberg_test_cap_restriction', '' );
+
+		if ( empty( $restriction ) ) {
+			return $caps;
+		}
+
+		$blocked_caps = array();
+
+		switch ( $restriction ) {
+			case 'no_install':
+				$blocked_caps = array( 'install_plugins', 'upload_plugins' );
+				break;
+			case 'no_activate':
+				$blocked_caps = array( 'activate_plugins' );
+				break;
+			case 'no_install_activate':
+				$blocked_caps = array( 'install_plugins', 'upload_plugins', 'activate_plugins' );
+				break;
+			case 'disallow_file_mods':
+				$blocked_caps = array( 'install_plugins', 'upload_plugins', 'delete_plugins', 'update_plugins' );
+				break;
+		}
+
+		if ( in_array( $cap, $blocked_caps, true ) ) {
+			return array( 'do_not_allow' );
+		}
+
+		return $caps;
+	},
+	10,
+	2
+);

package/plugins/connectors-empty-state.php

@@ -0,0 +1,19 @@
+<?php
+/**
+ * Plugin Name: Gutenberg Test Connectors Empty State
+ * Plugin URI: https://github.com/WordPress/gutenberg
+ * Author: Gutenberg Team
+ *
+ * Removes the default connector data so the Connectors page renders its empty state.
+ *
+ * @package gutenberg-test-connectors-empty-state
+ */
+
+// Remove the Gutenberg filter that provides default connector data.
+add_action(
+	'init',
+	static function () {
+		remove_filter( 'script_module_data_options-connectors-wp-admin', '_gutenberg_get_connector_script_module_data' );
+	},
+	PHP_INT_MAX
+);

package/plugins/connectors-js-extensibility/index.mjs

@@ -0,0 +1,55 @@
+/**
+ * Script module that demonstrates client-side connector registration.
+ *
+ * The server registers test_custom_service with its name and description.
+ * This module calls registerConnector() with the same slug to add a render
+ * function. The store merges both registrations, so the final connector
+ * combines the render function from JS with the metadata from PHP.
+ */
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+import {
+	__experimentalRegisterConnector as registerConnector,
+	__experimentalConnectorItem as ConnectorItem,
+} from '@wordpress/connectors';
+
+const h = window.React.createElement;
+
+// Register the render function for the connector.
+registerConnector( 'test_custom_service', {
+	render: ( props ) =>
+		h(
+			ConnectorItem,
+			{
+				className: 'connector-item--test_custom_service',
+				name: props.name,
+				description: props.description,
+				logo: props.logo,
+			},
+			h(
+				'p',
+				{ className: 'test-custom-service-content' },
+				'Custom rendered content for testing.'
+			)
+		),
+} );
+
+// Registers a custom render for an api_key connector to verify that a
+// subsequent default registration for the same slug does not replace it.
+registerConnector( 'test_api_key_with_custom_render', {
+	render: ( props ) =>
+		h(
+			ConnectorItem,
+			{
+				className: 'connector-item--test_api_key_with_custom_render',
+				name: props.name,
+				description: props.description,
+				logo: props.logo,
+			},
+			h(
+				'p',
+				{ className: 'test-api-key-with-custom-render-content' },
+				'Custom render survived registerDefaultConnectors().'
+			)
+		),
+} );

package/plugins/connectors-js-extensibility.php

@@ -0,0 +1,84 @@
+<?php
+/**
+ * Plugin Name: Gutenberg Test Connectors JS Extensibility
+ * Plugin URI: https://github.com/WordPress/gutenberg
+ * Author: Gutenberg Team
+ *
+ * Registers three connectors on the server:
+ *
+ * 1. test_custom_service — also registered client-side via a script module using
+ *    the merging strategy (two registerConnector calls with the same slug: one
+ *    providing the render function, the other metadata).
+ * 2. test_server_only_service — server-only, with no client-side render function,
+ *    so it should not display a card in the UI.
+ * 3. test_api_key_with_custom_render — an api_key connector whose JS render
+ *    is registered before the default registrations run, used to verify that
+ *    a subsequent default registration does not replace an existing render.
+ *
+ * @package gutenberg-test-connectors-js-extensibility
+ */
+
+// Register two custom-type connectors for E2E testing.
+add_action(
+	'wp_connectors_init',
+	static function ( WP_Connector_Registry $registry ) {
+		$registry->register(
+			'test_custom_service',
+			array(
+				'name'           => 'Test Custom Service',
+				'description'    => 'A custom service for E2E testing.',
+				'type'           => 'custom_service',
+				'authentication' => array(
+					'method' => 'none',
+				),
+			)
+		);
+
+		$registry->register(
+			'test_server_only_service',
+			array(
+				'name'           => 'Test Server Only Service',
+				'description'    => 'A server-only service with no JS render.',
+				'type'           => 'custom_service',
+				'authentication' => array(
+					'method' => 'none',
+				),
+			)
+		);
+
+		$registry->register(
+			'test_api_key_with_custom_render',
+			array(
+				'name'           => 'Test API Key With Custom Render',
+				'description'    => 'An api_key connector with a JS-registered custom render.',
+				'type'           => 'ai_provider',
+				'authentication' => array(
+					'method'      => 'api_key',
+					'settingName' => 'test_api_key_with_custom_render_key',
+				),
+			)
+		);
+	}
+);
+
+// Enqueue the script module on the connectors page.
+add_action(
+	'admin_enqueue_scripts',
+	static function () {
+		if ( ! isset( $_GET['page'] ) || 'options-connectors-wp-admin' !== $_GET['page'] ) {
+			return;
+		}
+
+		wp_register_script_module(
+			'gutenberg-test-connectors-js-extensibility',
+			plugins_url( 'connectors-js-extensibility/index.mjs', __FILE__ ),
+			array(
+				array(
+					'id'     => '@wordpress/connectors',
+					'import' => 'static',
+				),
+			)
+		);
+		wp_enqueue_script_module( 'gutenberg-test-connectors-js-extensibility' );
+	}
+);

package/plugins/connectors-test-provider.php

@@ -0,0 +1,126 @@
+<?php
+/**
+ * Plugin Name: Gutenberg Test Connectors Provider
+ * Plugin URI: https://github.com/WordPress/gutenberg
+ * Author: Gutenberg Team
+ *
+ * Registers a naive AI provider with hardcoded API key validation
+ * for E2E testing of the Connectors page setup flow.
+ *
+ * The valid API key is: test-api-key-123
+ *
+ * @package gutenberg-test-connectors-provider
+ */
+
+// phpcs:disable Generic.Files.OneObjectStructurePerFile.MultipleFound
+// phpcs:disable WordPress.Files.FileName
+// phpcs:disable WordPress.NamingConventions.ValidVariableName.VariableNotSnakeCase
+// phpcs:disable VariableAnalysis.CodeAnalysis.VariableAnalysis.UnusedVariable
+
+use WordPress\AiClient\AiClient;
+use WordPress\AiClient\Providers\AbstractProvider;
+use WordPress\AiClient\Providers\Contracts\ModelMetadataDirectoryInterface;
+use WordPress\AiClient\Providers\Contracts\ProviderAvailabilityInterface;
+use WordPress\AiClient\Providers\DTO\ProviderMetadata;
+use WordPress\AiClient\Providers\Enums\ProviderTypeEnum;
+use WordPress\AiClient\Providers\Http\Contracts\RequestAuthenticationInterface;
+use WordPress\AiClient\Providers\Http\Contracts\WithRequestAuthenticationInterface;
+use WordPress\AiClient\Providers\Http\DTO\ApiKeyRequestAuthentication;
+use WordPress\AiClient\Providers\Http\Enums\RequestAuthenticationMethod;
+use WordPress\AiClient\Providers\Models\Contracts\ModelInterface;
+use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
+
+/**
+ * Availability checker that validates against a hardcoded API key.
+ */
+class Gutenberg_Test_Provider_Availability implements ProviderAvailabilityInterface, WithRequestAuthenticationInterface {
+
+	const VALID_API_KEY = 'test-api-key-123';
+
+	/**
+	 * @var RequestAuthenticationInterface|null
+	 */
+	private $authentication = null;
+
+	public function isConfigured(): bool {
+		if ( ! $this->authentication instanceof ApiKeyRequestAuthentication ) {
+			return false;
+		}
+		return $this->authentication->getApiKey() === self::VALID_API_KEY;
+	}
+
+	public function setRequestAuthentication( RequestAuthenticationInterface $authentication ): void {
+		$this->authentication = $authentication;
+	}
+
+	public function getRequestAuthentication(): RequestAuthenticationInterface {
+		return $this->authentication;
+	}
+}
+
+/**
+ * Empty model metadata directory (no models needed for testing).
+ */
+class Gutenberg_Test_Provider_Model_Directory implements ModelMetadataDirectoryInterface {
+
+	public function listModelMetadata(): array {
+		return array();
+	}
+
+	public function hasModelMetadata( string $modelId ): bool {
+		return false;
+	}
+
+	public function getModelMetadata( string $modelId ): ModelMetadata {
+		throw new \WordPress\AiClient\Common\Exception\InvalidArgumentException(
+			sprintf( 'Model not found: %s', $modelId )
+		);
+	}
+}
+
+/**
+ * Minimal AI provider for E2E testing.
+ */
+class Gutenberg_Test_Provider extends AbstractProvider {
+
+	protected static function createProviderMetadata(): ProviderMetadata {
+		return new ProviderMetadata(
+			'test_provider',
+			'Test Provider',
+			ProviderTypeEnum::from( ProviderTypeEnum::CLOUD ),
+			null,
+			RequestAuthenticationMethod::from( RequestAuthenticationMethod::API_KEY ),
+			'A test AI provider for E2E testing.'
+		);
+	}
+
+	protected static function createProviderAvailability(): ProviderAvailabilityInterface {
+		return new Gutenberg_Test_Provider_Availability();
+	}
+
+	protected static function createModelMetadataDirectory(): ModelMetadataDirectoryInterface {
+		return new Gutenberg_Test_Provider_Model_Directory();
+	}
+
+	protected static function createModel( ModelMetadata $modelMetadata, ProviderMetadata $providerMetadata ): ModelInterface {
+		throw new \WordPress\AiClient\Common\Exception\InvalidArgumentException( 'Test provider does not support models.' );
+	}
+}
+
+// Register the provider in the AiClient registry so it is auto-discovered by the WP_Connector_Registry.
+add_action(
+	'init',
+	static function () {
+		if ( ! class_exists( '\WordPress\AiClient\AiClient' ) ) {
+			return;
+		}
+		AiClient::defaultRegistry()->registerProvider( Gutenberg_Test_Provider::class );
+	}
+);
+
+register_deactivation_hook(
+	__FILE__,
+	static function () {
+		delete_option( 'connectors_ai_test_provider_api_key' );
+	}
+);

package/plugins/interactive-blocks/directive-bind/render.php

@@ -66,6 +66,9 @@
 		'emptyString' => '{ "value": "" }',
 		'anyString'   => '{ "value": "any" }',
 		'number'      => '{ "value": 10 }',
+		'auto'        => '{ "value": "auto" }',
+		'manual'      => '{ "value": "manual" }',
+		'hint'        => '{ "value": "hint" }',
 	);
 	?>
 
@@ -90,6 +93,10 @@
 			data-wp-bind--disabled="context.value"
 			data-wp-bind--aria-disabled="context.value"
 		>
+		<div
+			data-testid="popover"
+			data-wp-bind--popover="context.value"
+		></div>
 		<button
 			data-testid="toggle value"
 			data-wp-on--click="actions.toggleValue"

package/plugins/interactive-blocks/router-race-condition/block.json

@@ -0,0 +1,15 @@
+{
+	"$schema": "https://schemas.wp.org/trunk/block.json",
+	"apiVersion": 3,
+	"name": "test/router-race-condition",
+	"title": "E2E Interactivity tests - router race condition",
+	"category": "text",
+	"icon": "heart",
+	"description": "",
+	"supports": {
+		"interactivity": true
+	},
+	"textdomain": "e2e-interactivity",
+	"viewScriptModule": "file:./view.js",
+	"render": "file:./render.php"
+}

package/plugins/interactive-blocks/router-race-condition/render.php

@@ -0,0 +1,26 @@
+<?php
+/**
+ * HTML for testing the router hydration race condition.
+ *
+ * @package gutenberg-test-interactive-blocks
+ *
+ * @phpcs:disable VariableAnalysis.CodeAnalysis.VariableAnalysis.UndefinedVariable
+ */
+?>
+<div
+	data-wp-interactive="router-race-condition"
+	data-wp-router-region="router-race-condition/buttons"
+	data-wp-context='{ "counter": 0 }'
+>
+	<button
+		data-testid="context-counter"
+		data-wp-text="context.counter"
+		data-wp-on--click="actions.increment"
+	>0</button>
+
+	<button
+		data-testid="global-counter"
+		data-wp-text="state.counter"
+		data-wp-on--click="actions.incrementGlobal"
+	>0</button>
+</div>

package/plugins/interactive-blocks/router-race-condition/view.asset.php

@@ -0,0 +1,9 @@
+<?php return array(
+	'dependencies' => array(
+		'@wordpress/interactivity',
+		array(
+			'id'     => '@wordpress/interactivity-router',
+			'import' => 'static',
+		),
+	),
+);

package/plugins/interactive-blocks/router-race-condition/view.js

@@ -0,0 +1,20 @@
+/**
+ * WordPress dependencies
+ */
+import { store, getContext } from '@wordpress/interactivity';
+import '@wordpress/interactivity-router';
+
+const { state } = store( 'router-race-condition', {
+	state: {
+		counter: 0,
+	},
+	actions: {
+		increment() {
+			const context = getContext();
+			context.counter += 1;
+		},
+		incrementGlobal() {
+			state.counter += 1;
+		},
+	},
+} );

package/plugins/interactive-blocks/router-regions/render.php

@@ -164,6 +164,9 @@
 	</p>
 </div>
 
+<a data-testid="hash-link" href="#hash-link-target">Go to anchor</a>
+<div id="hash-link-target" data-testid="hash-link-target"></div>
+
 <div id="regions-with-attach-to" data-testid="regions-with-attach-to">
 	<?php
 	/*

package/plugins/meta-box-rtc-compatible.php

@@ -0,0 +1,31 @@
+<?php
+/**
+ * Plugin Name: Gutenberg Test Plugin, RTC Compatible Meta Box
+ * Plugin URI: https://github.com/WordPress/gutenberg
+ * Author: Gutenberg Team
+ *
+ * @package gutenberg-test-rtc-compatible-meta-box
+ */
+
+/**
+ * Renders the RTC-compatible test meta box.
+ */
+function gutenberg_test_rtc_compatible_meta_box_render() {
+	echo 'RTC Compatible Meta Box';
+}
+
+/**
+ * Registers a meta box marked as compatible with real-time collaboration.
+ */
+function gutenberg_test_rtc_compatible_meta_box_add() {
+	add_meta_box(
+		'gutenberg-test-rtc-compatible-meta-box',
+		'RTC Compatible Test Meta Box',
+		'gutenberg_test_rtc_compatible_meta_box_render',
+		'post',
+		'normal',
+		'high',
+		array( '__rtc_compatible_meta_box' => true )
+	);
+}
+add_action( 'add_meta_boxes', 'gutenberg_test_rtc_compatible_meta_box_add' );

package/plugins/server-side-rendered-block.php

@@ -87,6 +87,14 @@ add_action(
 			)
 		);
 
+		// Add binding support for the auto-register-with-controls block.
+		add_filter(
+			'block_bindings_supported_attributes_test/auto-register-with-controls',
+			static function () {
+				return array( 'title', 'count', 'spacing', 'showEmojis', 'emoji' );
+			}
+		);
+
 		// PHP-only block with auto-generated controls from various attribute types
 		register_block_type(
 			'test/auto-register-with-controls',

package/plugins/sync-connection-error-filter/index.js

@@ -0,0 +1,83 @@
+( function () {
+	const { createElement: el } = wp.element;
+	const { useSelect } = wp.data;
+	const {
+		Modal,
+		Button,
+		__experimentalVStack: VStack,
+		__experimentalHStack: HStack,
+	} = wp.components;
+	const { __ } = wp.i18n;
+	const { registerPlugin } = wp.plugins;
+
+	const { unlock } =
+		wp.privateApis.__dangerousOptInToUnstableAPIsOnlyForCoreModules(
+			'I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.',
+			'@wordpress/core-data'
+		);
+
+	function CustomConnectionLimitModal() {
+		const connectionStatus = useSelect( function ( select ) {
+			return unlock( select( 'core' ) ).getSyncConnectionStatus() || null;
+		}, [] );
+
+		const error =
+			connectionStatus &&
+			connectionStatus.status === 'disconnected' &&
+			connectionStatus.error
+				? connectionStatus.error
+				: null;
+
+		if ( ! error || error.code !== 'connection-limit-exceeded' ) {
+			return null;
+		}
+
+		return el(
+			Modal,
+			{
+				title: __( 'Collaboration limit reached' ),
+				isDismissible: false,
+				onRequestClose() {},
+				shouldCloseOnClickOutside: false,
+				shouldCloseOnEsc: false,
+				size: 'medium',
+			},
+			el(
+				VStack,
+				{ spacing: 6 },
+				el(
+					'p',
+					null,
+					'Consider upgrading your hosting plan to increase the collaboration limits.'
+				),
+				el(
+					HStack,
+					{ justify: 'right' },
+					el(
+						Button,
+						{
+							variant: 'tertiary',
+							isDestructive: true,
+							href: 'edit.php',
+							__next40pxDefaultSize: true,
+						},
+						__( 'Back to Posts' )
+					),
+					el(
+						Button,
+						{
+							variant: 'primary',
+							href: 'https://example.com/upgrade',
+							__next40pxDefaultSize: true,
+						},
+						__( 'Upgrade Plan' )
+					)
+				)
+			)
+		);
+	}
+
+	registerPlugin( 'custom-sync-connection-error', {
+		render: CustomConnectionLimitModal,
+	} );
+} )();

package/plugins/sync-connection-error-filter.php

@@ -0,0 +1,48 @@
+<?php
+/**
+ * Plugin Name: Gutenberg Test Plugin, Sync Connection Error Filter
+ * Plugin URI: https://github.com/WordPress/gutenberg
+ * Author: Gutenberg Team
+ *
+ * @package gutenberg-test-sync-connection-error-filter
+ */
+
+/**
+ * Registers the editor.isSyncConnectionErrorHandled filter and custom modal.
+ */
+function enqueue_sync_connection_error_filter_scripts() {
+	// Register the filter early on wp-hooks so it's available before the
+	// editor modal renders. Plugins return true for error codes they handle.
+	wp_add_inline_script(
+		'wp-hooks',
+		"wp.hooks.addFilter(
+			'editor.isSyncConnectionErrorHandled',
+			'gutenberg-test/custom-sync-error',
+			function( isHandled, errorCode ) {
+				if ( errorCode === 'connection-limit-exceeded' ) {
+					return true;
+				}
+				return isHandled;
+			}
+		);"
+	);
+
+	// Enqueue the custom modal component that replaces the default UI
+	// for connection-limit-exceeded errors.
+	wp_enqueue_script(
+		'gutenberg-test-sync-connection-error-filter',
+		plugins_url( 'sync-connection-error-filter/index.js', __FILE__ ),
+		array(
+			'wp-components',
+			'wp-data',
+			'wp-element',
+			'wp-i18n',
+			'wp-plugins',
+			'wp-private-apis',
+		),
+		filemtime( plugin_dir_path( __FILE__ ) . 'sync-connection-error-filter/index.js' ),
+		true
+	);
+}
+
+add_action( 'enqueue_block_editor_assets', 'enqueue_sync_connection_error_filter_scripts' );