const SOURCE_NAME = 'test/source';

const SOURCE_LABEL = array(

'label' => 'Test source',

);

/**

public static function wpSetUpBeforeClass() {

register_block_type(

'test/block',

array(

'attributes' => array(

'myAttribute' => array(

'type' => 'string',

),

),

'render_callback' => function ( $attributes ) {

if ( isset( $attributes['myAttribute'] ) ) {

return '<p>' . esc_html( $attributes['myAttribute'] ) . '</p>';

}

},

)

);

}

/**

public function set_up() {

parent::set_up();

add_filter(

'block_bindings_supported_attributes_test/block',

function ( $supported_attributes ) {

$supported_attributes[] = 'myAttribute';

return $supported_attributes;

}

);

add_filter(

'block_bindings_supported_attributes_core/image',

function ( $supported_attributes ) {

$supported_attributes[] = 'caption';

return $supported_attributes;

}

);

}

/**

public function tear_down() {

foreach ( get_all_registered_block_bindings_sources() as $source_name => $source_properties ) {

if ( str_starts_with( $source_name, 'test/' ) ) {

unregister_block_bindings_source( $source_name );

}

}

parent::tear_down();

}

/**

public static function wpTearDownAfterClass() {

unregister_block_type( 'test/block' );

}

public function data_update_block_with_value_from_source() {

return array(

'paragraph block' => array(

'content',

<<<HTML

,

'<p class="wp-block-paragraph">test source value</p>',

),

'button block' => array(

'text',

<<<HTML

,

'<div class="wp-block-button"><a class="wp-block-button__link wp-element-button">test source value</a></div>',

),

'test block' => array(

'myAttribute',

<<<HTML

,

'<p>test source value</p>',

),

);

}

/**

public function test_update_block_with_value_from_source( $bound_attribute, $block_content, $expected_result ) {

$get_value_callback = function () {

return 'test source value';

};

register_block_bindings_source(

self::SOURCE_NAME,

array(

'label' => self::SOURCE_LABEL,

'get_value_callback' => $get_value_callback,

)

);

$parsed_blocks = parse_blocks( $block_content );

$parsed_blocks[0]['attrs']['metadata'] = array(

'bindings' => array(

$bound_attribute => array(

'source' => self::SOURCE_NAME,

),

),

);

$block = new WP_Block( $parsed_blocks[0] );

$result = $block->render();

$this->assertSame(

'test source value',

$block->attributes[ $bound_attribute ],

"The '{$bound_attribute}' attribute should be updated with the value returned by the source."

);

$this->assertSame(

$expected_result,

trim( $result ),

'The block content should be updated with the value returned by the source.'

);

}

public function data_different_get_value_callbacks() {

return array(

'pass arguments to source' => array(

function ( $source_args, $block_instance, $attribute_name ) {

$value = $source_args['key'];

return "The attribute name is '$attribute_name' and its binding has argument 'key' with value '$value'.";

},

"<p class=\"wp-block-paragraph\">The attribute name is 'content' and its binding has argument 'key' with value 'test'.</p>",

),

'symbols and numbers should be rendered correctly' => array(

function () {

return '$12.50';

},

'<p class="wp-block-paragraph">$12.50</p>',

),

);

}

/**

public function test_different_get_value_callbacks( $get_value_callback, $expected ) {

register_block_bindings_source(

self::SOURCE_NAME,

array(

'label' => self::SOURCE_LABEL,

'get_value_callback' => $get_value_callback,

)

);

$block_content = <<<HTML

HTML;

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block( $parsed_blocks[0] );

$result = $block->render();

$this->assertSame(

$expected,

trim( $result ),

'The block content should be updated with the value returned by the source.'

);

}

/**

public function test_unsafe_html_from_source_is_sanitized() {

register_block_bindings_source(

self::SOURCE_NAME,

array(

'label' => self::SOURCE_LABEL,

'get_value_callback' => function () {

return '<script>alert("Unsafe HTML")</script>';

},

)

);

$block_content = <<<HTML

HTML;

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block( $parsed_blocks[0] );

$result = $block->render();

$processor = new WP_HTML_Tag_Processor( $result );

$this->assertFalse( $processor->next_tag( 'SCRIPT' ), 'The SCRIPT element should be removed.' );

}

/**

public function test_passing_uses_context_to_source() {

$get_value_callback = function ( $source_args, $block_instance ) {

$this->assertArrayNotHasKey(

'forbiddenSourceContext',

$block_instance->context,

"Only context that was made available through the source's uses_context property should be accessible."

);

$value = $block_instance->context['sourceContext'];

return "Value: $value";

};

register_block_bindings_source(

self::SOURCE_NAME,

array(

'label' => self::SOURCE_LABEL,

'get_value_callback' => $get_value_callback,

'uses_context' => array( 'sourceContext' ),

)

);

$block_content = <<<HTML

HTML;

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block(

$parsed_blocks[0],

array(

'sourceContext' => 'source context value',

'forbiddenSourceContext' => 'forbidden donut',

)

);

$result = $block->render();

$this->assertSame(

'Value: source context value',

$block->attributes['myAttribute'],

"The 'myAttribute' should be updated with the value of the source context."

);

$this->assertSame(

'<p>Value: source context value</p>',

trim( $result ),

'The block content should be updated with the value of the source context.'

);

}

/**

public function test_update_block_with_value_from_source_image_placeholder() {

$get_value_callback = function ( $source_args, $block_instance, $attribute_name ) {

if ( 'url' === $attribute_name ) {

return 'https://example.com/image.jpg';

}

if ( 'caption' === $attribute_name ) {

return 'Example Image';

}

};

register_block_bindings_source(

self::SOURCE_NAME,

array(

'label' => self::SOURCE_LABEL,

'get_value_callback' => $get_value_callback,

)

);

$block_content = <<<HTML

HTML;

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block( $parsed_blocks[0] );

$result = $block->render();

$this->assertSame(

'https://example.com/image.jpg',

$block->attributes['url'],

"The 'url' attribute should be updated with the value returned by the source."

);

$this->assertSame(

'Example Image',

$block->attributes['caption'],

"The 'caption' attribute should be updated with the value returned by the source."

);

$this->assertSame(

'<figure class="wp-block-image"><img src="https://example.com/image.jpg" alt=""/><figcaption class="wp-element-caption">Example Image</figcaption></figure>',

trim( $result ),

'The block content should be updated with the value returned by the source.'

);

}

/**

public function test_update_icon_block_with_value_from_source() {

register_block_bindings_source(

self::SOURCE_NAME,

array(

'label' => self::SOURCE_LABEL,

'get_value_callback' => function () {

return 'core/arrow-right';

},

)

);

$block_content = <<<HTML

HTML;

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block( $parsed_blocks[0] );

$block->render();

$this->assertSame(

'core/arrow-right',

$block->attributes['icon'],

"The 'icon' attribute should be updated with the value returned by the source."

);

}

/**

public function test_default_binding_for_pattern_overrides() {

$block_content = <<<HTML

HTML;

$expected_content = 'This is the content value';

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block( $parsed_blocks[0], array( 'pattern/overrides' => array( 'Test' => array( 'myAttribute' => $expected_content ) ) ) );

$result = $block->render();

$this->assertSame(

"<p>$expected_content</p>",

trim( $result ),

'The `__default` attribute should be replaced with the real attribute prior to the callback.'

);

$expected_bindings_metadata = array(

'myAttribute' => array( 'source' => 'core/pattern-overrides' ),

);

$this->assertSame(

$expected_bindings_metadata,

$block->attributes['metadata']['bindings'],

'The __default binding should be updated with the individual binding attributes in the block metadata.'

);

}

/**

public function test_filter_block_bindings_source_value() {

register_block_bindings_source(

self::SOURCE_NAME,

array(

'label' => self::SOURCE_LABEL,

'get_value_callback' => function () {

return '';

},

)

);

$filter_value = function ( $value, $source_name, $source_args, $block_instance, $attribute_name ) {

if ( self::SOURCE_NAME !== $source_name ) {

return $value;

}

return "Filtered value: {$source_args['test_key']}. Block instance: {$block_instance->name}. Attribute name: {$attribute_name}.";

};

add_filter( 'block_bindings_source_value', $filter_value, 10, 5 );

$block_content = <<<HTML

HTML;

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block( $parsed_blocks[0] );

$result = $block->render();

remove_filter( 'block_bindings_source_value', $filter_value );

$this->assertSame(

'<p class="wp-block-paragraph">Filtered value: test_arg. Block instance: core/paragraph. Attribute name: content.</p>',

trim( $result ),

'The block content should show the filtered value.'

);

}

/**

private function render_list_item_with_source_value( $source_value, $block_content ) {

register_block_bindings_source(

self::SOURCE_NAME,

array(

'label' => self::SOURCE_LABEL,

'get_value_callback' => function () use ( $source_value ) {

return $source_value;

},

)

);

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block( $parsed_blocks[0] );

return trim( $block->render() );

}

/**

public function test_update_list_item_with_plain_text_value_from_source() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( 'test source value', $block_content );

$this->assertSame(

'<li>test source value</li>',

$result,

'The list item content should be replaced by the source text.'

);

}

/**

public function test_update_list_item_with_raw_nested_list_markup_without_inner_block_replaces_markup() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( 'Bound text', $block_content );

$this->assertSame(

'<li>Bound text</li>',

$result,

'Raw nested list markup should be replaced with the rest of the list item content.'

);

}

/**

public function test_update_list_item_source_image_renders_after_kses() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value(

'Bound <img class="wp-image-42" src="https://example.com/inline-image.jpg" alt="Inline image" />',

$block_content

);

$this->assertEqualHTML(

'<li>Bound <img class="wp-image-42" src="https://example.com/inline-image.jpg" alt="Inline image"></li>',

$result,

'<body>',

'The source image should render in the list item content after sanitization.'

);

}

/**

public function test_update_list_item_unsafe_source_markup_is_sanitized() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value(

'Bound <img src="https://example.com/inline-image.jpg" alt="Inline image" onerror="alert(1)" /><script>alert("Unsafe HTML")</script>',

$block_content

);

$this->assertStringNotContainsString(

'<script',

$result,

'Script tags should be stripped from list item source content.'

);

$this->assertStringNotContainsString(

'onerror',

$result,

'Event handler attributes should be stripped from list item source content.'

);

$processor = new WP_HTML_Tag_Processor( $result );

$this->assertTrue( $processor->next_tag( 'IMG' ), 'Safe image markup should remain after sanitization.' );

$this->assertSame( 'https://example.com/inline-image.jpg', $processor->get_attribute( 'src' ), 'The image src should be preserved.' );

$this->assertSame( 'Inline image', $processor->get_attribute( 'alt' ), 'The image alt should be preserved.' );

$processor = new WP_HTML_Tag_Processor( $result );

$this->assertFalse( $processor->next_tag( 'SCRIPT' ), 'The SCRIPT element should be removed.' );

}

/**

public function test_update_list_item_original_inline_image_is_replaced_by_source_text() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( 'Bound text', $block_content );

$this->assertSame(

'<li>Bound text</li>',

$result,

'The original inline image should be replaced with the rest of the list item content.'

);

$this->assertStringNotContainsString(

'original-image.jpg',

$result,

'The original inline image source should not remain after binding replacement.'

);

$this->assertStringNotContainsString(

'Original inline image',

$result,

'The original inline image alt text should not remain after binding replacement.'

);

}

/**

public function test_update_list_item_with_nested_list_preserves_nested_list() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( 'Bound list item', $block_content );

$normalized = preg_replace( '/>\s+</', '><', trim( $result ) );

$this->assertStringNotContainsString(

'Default content',

$result,

'The original list item content should be replaced by the source value.'

);

$this->assertMatchesRegularExpression(

'#<li>Bound list item\s*<ul class="wp-block-list"><li>Nested child</li></ul></li>#',

$normalized,

'The list item should render the source text and preserve nested list inner blocks.'

);

}

/**

public function test_update_list_item_with_raw_list_markup_before_nested_list_replaces_raw_markup() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( 'Bound list item', $block_content );

$normalized = preg_replace( '/>\s+</', '><', trim( $result ) );

$this->assertStringNotContainsString(

'Raw list markup should be replaced',

$result,

'Raw list markup before the nested block should be replaced by the source value.'

);

$this->assertMatchesRegularExpression(

'#<li>Bound list item\s*<ul class="wp-block-list"><li>Nested child should remain</li></ul></li>#',

$normalized,

'The list item should preserve only the delimiter-backed nested list inner block.'

);

}

/**

public function test_update_list_item_with_empty_value_preserves_nested_list() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( '', $block_content );

$normalized = preg_replace( '/>\s+</', '><', trim( $result ) );

$this->assertStringNotContainsString(

'Default content',

$result,

'An empty source value should clear the original list item content.'

);

$this->assertMatchesRegularExpression(

'#<li>\s*<ul class="wp-block-list"><li>Nested child</li></ul></li>#',

$normalized,

'An empty source value should still preserve nested list inner blocks.'

);

}

/**

public function test_update_list_item_with_nested_ordered_list_preserves_nested_list() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( 'Bound list item', $block_content );

$normalized = preg_replace( '/>\s+</', '><', trim( $result ) );

$this->assertStringNotContainsString(

'Default content',

$result,

'The original list item content should be replaced by the source value.'

);

$this->assertMatchesRegularExpression(

'#<li>Bound list item\s*<ol class="wp-block-list"><li>Nested ordered child</li></ol></li>#',

$normalized,

'The list item should render the source text and preserve the nested ordered list.'

);

}

/**

public function test_update_list_item_with_deeply_nested_list_preserves_all_levels() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( 'Bound list item', $block_content );

$this->assertStringNotContainsString(

'Level one default',

$result,

'Only the bound list item content should be replaced.'

);

$this->assertStringContainsString(

'Level two',

$result,

'The first nested level should be preserved.'

);

$this->assertStringContainsString(

'Level three',

$result,

'The second nested level should be preserved.'

);

}

/**

public function test_update_list_item_preserves_non_list_inner_block() {

$block_content = <<<HTML

HTML;

$result = $this->render_list_item_with_source_value( 'Bound list item', $block_content );

$this->assertStringNotContainsString(

'Default content',

$result,

'The original list item content should be replaced by the source value.'

);

$this->assertStringContainsString(

'Bound list item',

$result,

'The source value should be rendered as the list item content.'

);

$this->assertStringContainsString(

'wp-block-button',

$result,

'The nested button inner block should be preserved.'

);

$this->assertStringContainsString(

'Keep this button',

$result,

'The nested button inner block content should be preserved.'

);

}

/**

public function test_default_binding_for_list_item_pattern_overrides() {

$list_item_name = 'Editable List Item';

$block_content = <<<HTML

HTML;

$expected_content = 'Pattern <em>override</em>';

$parsed_blocks = parse_blocks( $block_content );

$block = new WP_Block(

$parsed_blocks[0],

array(

'pattern/overrides' => array(

$list_item_name => array( 'content' => $expected_content ),

),

)

);

$result = $block->render();

$normalized = preg_replace( '/>\s+</', '><', trim( $result ) );

$this->assertStringNotContainsString(

'Default content',

$result,

'The original list item content should be replaced by the pattern override.'

);

$this->assertStringContainsString(

'<li>Nested child</li>',

$normalized,

'Nested list inner blocks should remain in the rendered output.'

);

$this->assertMatchesRegularExpression(

'#<li>Pattern <em>override</em><ul class="wp-block-list"><li>Nested child</li></ul></li>#',

$normalized,

'The list item should render the pattern override before its nested list.'

);

$expected_bindings_metadata = array(

'content' => array( 'source' => 'core/pattern-overrides' ),

);

$this->assertSame(

$expected_bindings_metadata,

$block->inner_blocks[0]->attributes['metadata']['bindings'],

'The __default binding should be updated with the list item content binding metadata.'

);

}