Changeset 38571 for trunk/tests/phpunit/tests/actions.php

Timestamp:

09/08/2016 03:54:13 AM (9 years ago)

Author:

pento

Message:

Hooks: Add the new class WP_Hook, and modify hook handling to make use of it.

Filters and actions have been the basis of WordPress' plugin functionality since time immemorial, they've always been a reliable method for acting upon the current state of WordPress, and will continue to be so.

Over the years, however, edge cases have cropped up. Particularly when it comes to recursively executing hooks, or a hook adding and removing itself, the existing implementation struggled to keep up with more complex use cases.

And so, we introduce WP_Hook. By changing $wp_filter from an array of arrays, to an array of objects, we reduce the complexity of the hook handling code, as the processing code (see ::apply_filters()) only needs to be aware of itself, rather than the state of all hooks. At the same time, we're able te handle more complex use cases, as the object can more easily keep track of its own state than an array ever could.

Props jbrinley for the original architecture and design of this patch.
Props SergeyBiryukov, cheeserolls, Denis-de-Bernardy, leewillis77, wonderboymusic, nacin, jorbin, DrewAPicture, ocean90, dougwollison, khag7, pento, noplanman and aaroncampbell for their testing, suggestions, contributions, patch maintenance, cajoling and patience as we got through this.
Fixes #17817.

File:

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

trunk/tests/phpunit/tests/actions.php

@@ -113 +113 @@
         $argsvar2 = $a2->get_args();
         $this->assertEquals( array( $val1 ), array_pop( $argsvar2 ) );
+    }
+
+    /**
+     * Test that multiple callbacks receive the correct number of args even when the number
+     * is less than, or greater than previous hooks.
+     *
+     * @see https://core.trac.wordpress.org/ticket/17817#comment:72
+     * @ticket 17817
+     */
+    function test_action_args_3() {
+        $a1 = new MockAction();
+        $a2 = new MockAction();
+        $a3 = new MockAction();
+        $tag = rand_str();
+        $val1 = rand_str();
+        $val2 = rand_str();
+
+        // a1 accepts two arguments, a2 doesn't, a3 accepts two arguments
+        add_action( $tag, array( &$a1, 'action' ), 10, 2 );
+        add_action( $tag, array( &$a2, 'action' ) );
+        add_action( $tag, array( &$a3, 'action' ), 10, 2 );
+        // call the action with two arguments
+        do_action( $tag, $val1, $val2 );
+
+        $call_count = $a1->get_call_count();
+        // a1 should be called with both args
+        $this->assertEquals( 1, $call_count );
+        $argsvar1 = $a1->get_args();
+        $this->assertEquals( array( $val1, $val2 ), array_pop( $argsvar1 ) );
+
+        // a2 should be called with one only
+        $this->assertEquals( 1, $a2->get_call_count() );
+        $argsvar2 = $a2->get_args();
+        $this->assertEquals( array( $val1 ), array_pop( $argsvar2 ) );
+
+        // a3 should be called with both args
+        $this->assertEquals( 1, $a3->get_call_count() );
+        $argsvar3 = $a3->get_args();
+        $this->assertEquals( array( $val1, $val2 ), array_pop( $argsvar3 ) );
     }
 
@@ -259 +298 @@
 
     /**
+     * @ticket 17817
+     */
+    function test_action_recursion() {
+        $tag = rand_str();
+        $a = new MockAction();
+        $b = new MockAction();
+
+        add_action( $tag, array( $a, 'action' ), 11, 1 );
+        add_action( $tag, array( $b, 'action' ), 13, 1 );
+        add_action( $tag, array( $this, 'action_that_causes_recursion' ), 12, 1 );
+        do_action( $tag, $tag );
+
+        $this->assertEquals( 2, $a->get_call_count(), 'recursive actions should call all callbacks with earlier priority' );
+        $this->assertEquals( 2, $b->get_call_count(), 'recursive actions should call callbacks with later priority' );
+    }
+
+    function action_that_causes_recursion( $tag ) {
+        static $recursing = false;
+        if ( ! $recursing ) {
+            $recursing = true;
+            do_action( $tag, $tag );
+        }
+        $recursing = false;
+    }
+
+    /**
+     * @ticket 9968
+     * @ticket 17817
+     */
+    function test_action_callback_manipulation_while_running() {
+        $tag = rand_str();
+        $a = new MockAction();
+        $b = new MockAction();
+        $c = new MockAction();
+        $d = new MockAction();
+        $e = new MockAction();
+
+        add_action( $tag, array( $a, 'action' ), 11, 2 );
+        add_action( $tag, array( $this, 'action_that_manipulates_a_running_hook' ), 12, 2 );
+        add_action( $tag, array( $b, 'action' ), 12, 2 );
+
+        do_action( $tag, $tag, array( $a, $b, $c, $d, $e ) );
+        do_action( $tag, $tag, array( $a, $b, $c, $d, $e ) );
+
+        $this->assertEquals( 2, $a->get_call_count(), 'callbacks should run unless otherwise instructed' );
+        $this->assertEquals( 1, $b->get_call_count(), 'callback removed by same priority callback should still get called' );
+        $this->assertEquals( 1, $c->get_call_count(), 'callback added by same priority callback should not get called' );
+        $this->assertEquals( 2, $d->get_call_count(), 'callback added by earlier priority callback should get called' );
+        $this->assertEquals( 1, $e->get_call_count(), 'callback added by later priority callback should not get called' );
+    }
+
+    function action_that_manipulates_a_running_hook( $tag, $mocks ) {
+        remove_action( $tag, array( $mocks[ 1 ], 'action' ), 12, 2 );
+        add_action( $tag, array( $mocks[ 2 ], 'action' ), 12, 2 );
+        add_action( $tag, array( $mocks[ 3 ], 'action' ), 13, 2 );
+        add_action( $tag, array( $mocks[ 4 ], 'action' ), 10, 2 );
+    }
+
+    /**
+     * @ticket 17817
+     *
+     * This specificaly addresses the concern raised at
+     * https://core.trac.wordpress.org/ticket/17817#comment:52
+     */
+    function test_remove_anonymous_callback() {
+        $tag = rand_str();
+        $a = new MockAction();
+        add_action( $tag, array( $a, 'action' ), 12, 1 );
+        $this->assertTrue( has_action( $tag ) );
+
+        $hook = $GLOBALS['wp_filter'][ $tag ];
+
+        // From http://wordpress.stackexchange.com/a/57088/6445
+        foreach ( $hook as $priority => $filter ) {
+            foreach ( $filter as $identifier => $function ) {
+                if ( is_array( $function )
+                    && is_a( $function['function'][ 0 ], 'MockAction' )
+                    && 'action' === $function['function'][ 1 ]
+                ) {
+                    remove_filter(
+                        $tag,
+                        array( $function['function'][ 0 ], 'action' ),
+                        $priority
+                    );
+                }
+            }
+        }
+
+        $this->assertFalse( has_action( $tag ) );
+    }
+
+
+    /**
+     * Test the ArrayAccess methods of WP_Hook
+     *
+     * @ticket 17817
+     */
+    function test_array_access_of_wp_filter_global() {
+        global $wp_filter;
+        $tag = rand_str();
+
+        add_action( $tag, '__return_null', 11, 1 );
+
+        $this->assertTrue( isset( $wp_filter[ $tag ][ 11 ] ) );
+        $this->assertArrayHasKey( '__return_null', $wp_filter[ $tag ][ 11 ] );
+
+        unset( $wp_filter[ $tag ][ 11 ] );
+        $this->assertFalse( has_action( $tag, '__return_null' ) );
+
+        $wp_filter[ $tag ][ 11 ] = array( '__return_null' => array( 'function' => '__return_null', 'accepted_args' => 1 ) );
+        $this->assertEquals( 11, has_action( $tag, '__return_null' ) );
+    }
+
+    /**
      * Make sure current_action() behaves as current_filter()
      *