Ticket #6978: 6978.4.patch

src/bp-friends/bp-friends-cache.php

@@ -35 +35 @@
 add_action( 'friends_friendship_deleted',  'friends_clear_friend_object_cache' );
 
 /**
+ * Clear friendship caches on friendship changes.
+ *
+ * @since 2.7.0
+ *
+ * @param int $friendship_id     ID of the friendship that has changed.
+ * @param int $initiator_user_id ID of the first user.
+ * @param int $friend_user_id    ID of the second user.
+ * @return bool
+ */
+function bp_friends_clear_bp_friends_friendships_cache( $friendship_id, $initiator_user_id, $friend_user_id ) {
+        // Clear friendship ID cache for each user.
+        wp_cache_delete( $initiator_user_id, 'bp_friends_friendships_for_user' );
+        wp_cache_delete( $friend_user_id,    'bp_friends_friendships_for_user' );
+
+        // Clear the friendship object cache.
+        wp_cache_delete( $friendship_id, 'bp_friends_friendships' );
+}
+add_action( 'friends_friendship_requested', 'bp_friends_clear_bp_friends_friendships_cache', 10, 3 );
+add_action( 'friends_friendship_accepted',  'bp_friends_clear_bp_friends_friendships_cache', 10, 3 );
+add_action( 'friends_friendship_deleted',   'bp_friends_clear_bp_friends_friendships_cache', 10, 3 );
+
+/**
+ * Clear friendship caches on friendship changes.
+ *
+ * @since 2.7.0
+ *
+ * @param int                   $friendship_id The friendship ID.
+ * @param BP_Friends_Friendship $friendship Friendship object.
+ */
+function bp_friends_clear_bp_friends_friendships_cache_remove( $friendship_id, BP_Friends_Friendship $friendship ) {
+        // Clear friendship ID cache for each user.
+        wp_cache_delete( $friendship->initiator_user_id, 'bp_friends_friendships_for_user' );
+        wp_cache_delete( $friendship->friend_user_id,    'bp_friends_friendships_for_user' );
+
+        // Clear the friendship object cache.
+        wp_cache_delete( $friendship_id, 'bp_friends_friendships' );
+}
+add_action( 'friends_friendship_withdrawn', 'bp_friends_clear_bp_friends_friendships_cache_remove', 10, 2 );
+add_action( 'friends_friendship_rejected',  'bp_friends_clear_bp_friends_friendships_cache_remove', 10, 2 );
+
+/**
  * Clear the friend request cache for the user not initiating the friendship.
  *
  * @since 2.0.0

src/bp-friends/bp-friends-filters.php

@@ -28 +28 @@
         global $wpdb;
 
         // Stop if user isn't logged in.
-        if ( ! is_user_logged_in() ) {
+        if ( ! $user_id = bp_loggedin_user_id() ) {
                 return;
         }
 
-        $bp = buddypress();
+        $maybe_friend_ids = wp_parse_id_list( $user_ids_sql );
 
-        // Fetch whether or not the user is a friend of the current user.
-        $friend_status = $wpdb->get_results( $wpdb->prepare( "SELECT initiator_user_id, friend_user_id, is_confirmed FROM {$bp->friends->table_name} WHERE (initiator_user_id = %d AND friend_user_id IN ( {$user_ids_sql} ) ) OR (initiator_user_id IN ( {$user_ids_sql} ) AND friend_user_id = %d )", bp_loggedin_user_id(), bp_loggedin_user_id() ) );
-
-        // Keep track of members that have a friendship status with the current user.
-        $friend_user_ids = array();
-
-        // The "friend" is the user ID in the pair who is *not* the logged in user.
-        foreach ( (array) $friend_status as $fs ) {
-                $friend_id = bp_loggedin_user_id() == $fs->initiator_user_id ? $fs->friend_user_id : $fs->initiator_user_id;
-                $friend_user_ids[] = $friend_id;
-
-                if ( isset( $user_query->results[ $friend_id ] ) ) {
-                        if ( 0 == $fs->is_confirmed ) {
-                                $status = $fs->initiator_user_id == bp_loggedin_user_id() ? 'pending' : 'awaiting_response';
-                        } else {
-                                $status = 'is_friend';
-                        }
-
-                        $user_query->results[ $friend_id ]->is_friend         = $fs->is_confirmed;
-                        $user_query->results[ $friend_id ]->friendship_status = $status;
-                }
-        }
-
-        // The rest are not friends with the current user, so set status accordingly.
-        $not_friends = array_diff( $user_query->user_ids, $friend_user_ids );
-        foreach ( (array) $not_friends as $nf ) {
-                if ( bp_loggedin_user_id() == $nf ) {
-                        continue;
-                }
-
-                if ( isset( $user_query->results[ $nf ] ) ) {
-                        $user_query->results[ $nf ]->friendship_status = 'not_friends';
+        foreach ( $maybe_friend_ids as $friend_id ) {
+                $status = BP_Friends_Friendship::check_is_friend( $user_id, $friend_id );
+                $user_query->results[ $friend_id ]->friendship_status = $status;
+                if ( 'is_friend' == $status ) {
+                        $user_query->results[ $friend_id ]->is_friend = 1;
                 }
         }
 

src/bp-friends/classes/class-bp-friends-component.php

@@ -288 +288 @@
 
                 // Global groups.
                 wp_cache_add_global_groups( array(
-                        'bp_friends_requests'
+                        'bp_friends_requests',
+                        'bp_friends_friendships', // Individual friendship objects are cached here by ID.
+                        'bp_friends_friendships_for_user' // All friendship IDs for a single user.
                 ) );
 
                 parent::setup_cache_groups();

src/bp-friends/classes/class-bp-friends-friendship.php

@@ -122 +122 @@
 
                 $bp = buddypress();
 
-                if ( $friendship = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM {$bp->friends->table_name} WHERE id = %d", $this->id ) ) ) {
-                        $this->initiator_user_id = (int) $friendship->initiator_user_id;
-                        $this->friend_user_id    = (int) $friendship->friend_user_id;
-                        $this->is_confirmed      = (int) $friendship->is_confirmed;
-                        $this->is_limited        = (int) $friendship->is_limited;
-                        $this->date_created      = $friendship->date_created;
+                // Check cache for friendship data.
+                $friendship = wp_cache_get( $this->id, 'bp_friends_friendships' );
+
+                // Cache missed, so query the DB.
+                if ( false === $friendship ) {
+                        $friendship = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM {$bp->friends->table_name} WHERE id = %d", $this->id ) );
+
+                        wp_cache_set( $this->id, $friendship, 'bp_friends_friendships' );
+                }
+
+                // No friendship found so set the ID and bail.
+                if ( empty( $friendship ) || is_wp_error( $friendship ) ) {
+                        $this->id = 0;
+                        return;
                 }
 
-                if ( !empty( $this->populate_friend_details ) ) {
+                $this->initiator_user_id = (int) $friendship->initiator_user_id;
+                $this->friend_user_id    = (int) $friendship->friend_user_id;
+                $this->is_confirmed      = (int) $friendship->is_confirmed;
+                $this->is_limited        = (int) $friendship->is_limited;
+                $this->date_created      = $friendship->date_created;
+
+                if ( ! empty( $this->populate_friend_details ) ) {
                         if ( $this->friend_user_id == bp_displayed_user_id() ) {
                                 $this->friend = new BP_Core_User( $this->initiator_user_id );
                         } else {
@@ -206 +220 @@
         /** Static Methods ********************************************************/
 
         /**
+         * Get the friendships for a given user.
+         *
+         * @since 2.6.0
+         *
+         * @param int   $user_id              ID of the user whose friends are being retrieved.
+         * @param array $args {
+         *        Optional. Filter parameters.
+         *        @type int    $id                ID of specific friendship to retrieve.
+         *        @type int    $initiator_user_id ID of friendship initiator.
+         *        @type int    $friend_user_id    ID of specific friendship to retrieve.
+         *        @type int    $is_confirmed      Whether the friendship has been accepted.
+         *        @type int    $is_limited        Whether the friendship is limited.
+         *        @type string $order_by          Column name to order by.
+         *        @type string $sort_order        ASC or DESC. Default DESC.
+         * }
+         * @param string $operator            Optional. Operator to use in `wp_list_filter()`.
+         *
+         * @return array $friendships Array of friendship objects.
+         */
+        public static function get_friendships( $user_id, $args = array(), $operator = 'AND' ) {
+
+                if ( empty( $user_id ) ) {
+                        $user_id = bp_loggedin_user_id();
+                }
+
+                $r = bp_parse_args( $args, array(
+                        'id'                => null,
+                        'initiator_user_id' => null,
+                        'friend_user_id'    => null,
+                        'is_confirmed'      => null,
+                        'is_limited'        => null,
+                        'order_by'          => 'date_created',
+                        'sort_order'        => 'DESC',
+                        'page'              => null,
+                        'per_page'          => null
+                ), 'bp_get_user_friendships' );
+
+                // First, we get all friendships that involve the user.
+                $friendship_ids = wp_cache_get( $user_id, 'bp_friends_friendships_for_user' );
+                if ( false === $friendship_ids ) {
+                        $friendship_ids = self::get_friendship_ids_for_user( $user_id );
+                        wp_cache_set( $user_id, $friendship_ids, 'bp_friends_friendships_for_user' );
+                }
+
+                // Prime the membership cache.
+                $uncached_friendship_ids = bp_get_non_cached_ids( $friendship_ids, 'bp_friends_friendships' );
+                if ( ! empty( $uncached_friendship_ids ) ) {
+                        $uncached_friendships = self::get_friendships_by_id( $uncached_friendship_ids );
+
+                        foreach ( $uncached_friendships as $uncached_friendship ) {
+                                wp_cache_set( $uncached_friendship->id, $uncached_friendship, 'bp_friends_friendships' );
+                        }
+                }
+
+                // Assemble filter array.
+                $filters = wp_array_slice_assoc( $r, array( 'id', 'initiator_user_id', 'friend_user_id', 'is_confirmed', 'is_limited' ) );
+                foreach ( $filters as $filter_name => $filter_value ) {
+                        if ( is_null( $filter_value ) ) {
+                                unset( $filters[ $filter_name ] );
+                        }
+                }
+
+                // Populate friendship array from cache, and normalize.
+                $friendships = array();
+                $int_keys    = array( 'id', 'initiator_user_id', 'friend_user_id' );
+                $bool_keys   = array( 'is_confirmed', 'is_limited' );
+                foreach ( $friendship_ids as $friendship_id ) {
+                        // Create a limited BP_Friends_Friendship object (don't fetch the user details).
+                        $friendship = new BP_Friends_Friendship( $friendship_id, false, false );
+
+                        // Sanity check.
+                        if ( ! isset( $friendship->id ) ) {
+                                continue;
+                        }
+
+                        // Integer values.
+                        foreach ( $int_keys as $index ) {
+                                $friendship->{$index} = intval( $friendship->{$index} );
+                        }
+
+                        // Boolean values.
+                        foreach ( $bool_keys as $index ) {
+                                $friendship->{$index} = (bool) $friendship->{$index};
+                        }
+
+                        // We need to support the same operators as wp_list_filter().
+                        if ( 'OR' == $operator || 'NOT' == $operator ) {
+                                $matched = 0;
+
+                                foreach ( $filters as $filter_name => $filter_value ) {
+                                        if ( isset( $friendship->{$filter_name} ) && $filter_value == $friendship->{$filter_name} ) {
+                                                $matched++;
+                                        }
+                                }
+
+                                if ( ( 'OR' == $operator && $matched > 0 )
+                                  || ( 'NOT' == $operator && 0 == $matched ) ) {
+                                        $friendships[ $friendship->id ] = $friendship;
+                                }
+
+                        } else {
+                                /*
+                                 * This is the more typical 'AND' style of filter.
+                                 * If any of the filters miss, we move on.
+                                 */
+                                foreach ( $filters as $filter_name => $filter_value ) {
+                                        if ( ! isset( $friendship->{$filter_name} ) || $filter_value != $friendship->{$filter_name} ) {
+                                                continue 2;
+                                        }
+                                }
+                                $friendships[ $friendship->id ] = $friendship;
+                        }
+
+                }
+
+                // Sort the results on a column name.
+                if ( in_array( $r['order_by'], array( 'id', 'initiator_user_id', 'friend_user_id' ) ) ) {
+                        $friendships = bp_sort_by_key( $friendships, $r['order_by'], 'num', true );
+                }
+
+                // Adjust the sort direction of the results.
+                if ( 'ASC' === strtoupper( $r['sort_order'] ) ) {
+                        // `true` to preserve keys.
+                        $friendships = array_reverse( $friendships, true );
+                }
+
+                // Paginate the results.
+                if ( $r['per_page'] && $r['page'] ) {
+                        $start       = ( $r['page'] - 1 ) * ( $r['per_page'] );
+                        $friendships = array_slice( $friendships, $start, $r['per_page'] );
+                }
+
+                return $friendships;
+        }
+
+        /**
+         * Get all friendship IDs for a user.
+         *
+         * @since 2.7.0
+         *
+         * @param int $user_id ID of the user.
+         * @return array
+         */
+        public static function get_friendship_ids_for_user( $user_id ) {
+                global $wpdb;
+
+                $bp = buddypress();
+
+                $friendship_ids = $wpdb->get_col( $wpdb->prepare( "SELECT id FROM {$bp->friends->table_name} WHERE (initiator_user_id = %d OR friend_user_id = %d) ORDER BY date_created DESC", $user_id, $user_id ) );
+
+                return $friendship_ids;
+        }
+
+        /**
          * Get the IDs of a given user's friends.
          *
          * @since 1.0.0
@@ -221 +389 @@
         public static function get_friend_user_ids( $user_id, $friend_requests_only = false, $assoc_arr = false ) {
                 global $wpdb;
 
-                if ( !empty( $friend_requests_only ) ) {
-                        $oc_sql = 'AND is_confirmed = 0';
-                        $friend_sql = $wpdb->prepare( " WHERE friend_user_id = %d", $user_id );
+                if ( ! empty( $friend_requests_only ) ) {
+                        $args = array(
+                                'is_confirmed' => 0,
+                                'friend_user_id' => $user_id
+                        );
                 } else {
-                        $oc_sql = 'AND is_confirmed = 1';
-                        $friend_sql = $wpdb->prepare( " WHERE (initiator_user_id = %d OR friend_user_id = %d)", $user_id, $user_id );
+                        $args = array(
+                                'is_confirmed' => 1,
+                        );
                 }
 
-                $bp = buddypress();
-                $friends = $wpdb->get_results( "SELECT friend_user_id, initiator_user_id FROM {$bp->friends->table_name} {$friend_sql} {$oc_sql} ORDER BY date_created DESC" );
-                $fids = array();
+                $friendships = self::get_friendships( $user_id, $args );
 
-                for ( $i = 0, $count = count( $friends ); $i < $count; ++$i ) {
-                        if ( !empty( $assoc_arr ) ) {
-                                $fids[] = array( 'user_id' => ( $friends[$i]->friend_user_id == $user_id ) ? $friends[$i]->initiator_user_id : $friends[$i]->friend_user_id );
+                $fids = array();
+                foreach ( $friendships as $friendship ) {
+                        if ( ! empty( $assoc_arr ) ) {
+                                $fids[] = array( 'user_id' => ( $friendship->friend_user_id == $user_id ) ? $friendship->initiator_user_id : $friendship->friend_user_id );
                         } else {
-                                $fids[] = ( $friends[$i]->friend_user_id == $user_id ) ? $friends[$i]->initiator_user_id : $friends[$i]->friend_user_id;
+                                $fids[] = ( $friendship->friend_user_id == $user_id ) ? $friendship->initiator_user_id : $friendship->friend_user_id;
                         }
                 }
 
@@ -254 +424 @@
          * @return int|null The ID of the friendship object if found, otherwise null.
          */
         public static function get_friendship_id( $user_id, $friend_id ) {
-                global $wpdb;
-
-                $bp = buddypress();
+                $friendship_id = null;
 
-                $query = $wpdb->get_var( $wpdb->prepare( "SELECT id FROM {$bp->friends->table_name} WHERE ( initiator_user_id = %d AND friend_user_id = %d ) OR ( initiator_user_id = %d AND friend_user_id = %d ) AND is_confirmed = 1", $user_id, $friend_id, $friend_id, $user_id ) );
+                // Can't friend yourself.
+                if ( $user_id == $friend_id ) {
+                        return $friendship_id;
+                }
 
-                return is_numeric( $query ) ? (int) $query : $query;
+                /*
+                 * Find friendships where the possible_friend_userid is the
+                 * initiator or friend.
+                 */
+                $args = array(
+                        'initiator_user_id' => $friend_id,
+                        'friend_user_id'    => $friend_id
+                );
+                $result = self::get_friendships( $user_id, $args, 'OR' );
+                if ( $result ) {
+                        $friendship_id = current( $result )->id;
+                }
+                return $friendship_id;
         }
 
         /**
@@ -276 +459 @@
                 $friend_requests = wp_cache_get( $user_id, 'bp_friends_requests' );
 
                 if ( false === $friend_requests ) {
-                        global $wpdb;
-
-                        $bp = buddypress();
-
-                        $friend_requests = $wpdb->get_col( $wpdb->prepare( "SELECT initiator_user_id FROM {$bp->friends->table_name} WHERE friend_user_id = %d AND is_confirmed = 0", $user_id ) );
+                        //@TODO: this uses already cached data, so maybe `bp_friends_requests` should go away?
+                        $friend_requests = self::get_friend_user_ids( $user_id, true );
 
                         wp_cache_set( $user_id, $friend_requests, 'bp_friends_requests' );
                 }
@@ -306 +486 @@
         public static function total_friend_count( $user_id = 0 ) {
                 global $wpdb;
 
-                if ( empty( $user_id ) )
+                if ( empty( $user_id ) ) {
                         $user_id = ( bp_displayed_user_id() ) ? bp_displayed_user_id() : bp_loggedin_user_id();
-
-                $bp = buddypress();
+                }
 
                 /*
                  * This is stored in 'total_friend_count' usermeta.
                  * This function will recalculate, update and return.
                  */
 
-                $count = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(id) FROM {$bp->friends->table_name} WHERE (initiator_user_id = %d OR friend_user_id = %d) AND is_confirmed = 1", $user_id, $user_id ) );
+                $args = array(
+                        'is_confirmed' => 1,
+                );
+                $friendships = self::get_friendships( $user_id, $args );
+                $count       = count( $friendships );
 
                 // Do not update meta if user has never had friends.
-                if ( empty( $count ) && !bp_get_user_meta( $user_id, 'total_friend_count', true ) )
+                if ( ! $count && ! bp_get_user_meta( $user_id, 'total_friend_count', true ) ) {
                         return 0;
+                }
 
                 bp_update_user_meta( $user_id, 'total_friend_count', (int) $count );
 
@@ -415 +599 @@
                         return false;
                 }
 
-                $bp = buddypress();
-
-                $result = $wpdb->get_results( $wpdb->prepare( "SELECT id, initiator_user_id, is_confirmed FROM {$bp->friends->table_name} WHERE (initiator_user_id = %d AND friend_user_id = %d) OR (initiator_user_id = %d AND friend_user_id = %d)", $initiator_userid, $possible_friend_userid, $possible_friend_userid, $initiator_userid ) );
+                // Can't friend yourself.
+                if ( $initiator_userid == $possible_friend_userid ) {
+                        return 'not_friends';
+                }
 
-                if ( ! empty( $result ) ) {
-                        if ( 0 == (int) $result[0]->is_confirmed ) {
-                                $status = $initiator_userid == $result[0]->initiator_user_id ? 'pending' : 'awaiting_response';
+                /*
+                 * Find friendships where the possible_friend_userid is the
+                 * initiator or friend.
+                 */
+                $args = array(
+                        'initiator_user_id' => $possible_friend_userid,
+                        'friend_user_id'    => $possible_friend_userid
+                );
+                $result = self::get_friendships( $initiator_userid, $args, 'OR' );
+
+                if ( $result ) {
+                        $friendship = current( $result );
+                        if ( ! $friendship->is_confirmed ) {
+                                $status = $initiator_userid == $friendship->initiator_user_id ? 'pending' : 'awaiting_response';
                         } else {
                                 $status = 'is_friend';
                         }
@@ -699 +895 @@
         }
 
         /**
+         * Get friendship objects by ID (or an array of IDs).
+         *
+         * @since 2.7.0
+         *
+         * @param int|string|array $friendship_ids Single friendship ID or comma-separated/array list of friendship IDs.
+         * @return array
+         */
+        public static function get_friendships_by_id( $friendship_ids ) {
+                global $wpdb;
+
+                $bp = buddypress();
+
+                $friendship_ids = implode( ',', wp_parse_id_list( $friendship_ids ) );
+                return $wpdb->get_results( "SELECT * FROM {$bp->friends->table_name} WHERE id IN ({$friendship_ids})" );
+        }
+
+        /**
          * Get the friend user IDs for a given friendship.
          *
          * @since 1.0.0
@@ -707 +920 @@
          * @return object friend_user_id and initiator_user_id.
          */
         public static function get_user_ids_for_friendship( $friendship_id ) {
-                global $wpdb;
 
-                $bp = buddypress();
+                $friendship = new BP_Friends_Friendship( $friendship_id, false, false );
+
+                if ( empty( $friendship->id ) ) {
+                        return null;
+                }
+
+                $retval = new StdClass;
+                $retval->friend_user_id = $friendship->friend_user_id;
+                $retval->initiator_user_id = $friendship->initiator_user_id;
 
-                return $wpdb->get_row( $wpdb->prepare( "SELECT friend_user_id, initiator_user_id FROM {$bp->friends->table_name} WHERE id = %d", $friendship_id ) );
+                return $retval;
         }
 
         /**
@@ -726 +946 @@
 
                 $bp = buddypress();
 
-                // Get friends of $user_id.
-                $friend_ids = BP_Friends_Friendship::get_friend_user_ids( $user_id );
+                // Get all friendships, of any status, for the user.
+                $friendships    = self::get_friendships( $user_id );
+                $friend_ids     = array();
+                $friendship_ids = array();
+                foreach ( $friendships as $friendship ) {
+                        $friendship_ids[] = $friendship->id;
+                        if ( $friendship->is_confirmed ) {
+                                $friend_ids[] = ( $friendship->friend_user_id == $user_id ) ? $friendship->initiator_user_id : $friendship->friend_user_id;
+                        }
+                }
 
-                // Delete all friendships related to $user_id.
-                $wpdb->query( $wpdb->prepare( "DELETE FROM {$bp->friends->table_name} WHERE friend_user_id = %d OR initiator_user_id = %d", $user_id, $user_id ) );
+                // Delete the friendships from the database.
+                if ( $friendship_ids ) {
+                        $friendship_ids_sql = implode( ',', wp_parse_id_list( $friendship_ids ) );
+                        $wpdb->query( "DELETE FROM {$bp->friends->table_name} WHERE id IN ({$friendship_ids_sql})" );
+                }
 
                 // Delete friend request notifications for members who have a
                 // notification from this user.
@@ -738 +969 @@
                         $wpdb->query( $wpdb->prepare( "DELETE FROM {$bp->notifications->table_name} WHERE component_name = 'friends' AND ( component_action = 'friendship_request' OR component_action = 'friendship_accepted' ) AND item_id = %d", $user_id ) );
                 }
 
-                // Loop through friend_ids and update their counts.
+                // Clean up the friendships cache.
+                foreach ( $friendship_ids as $friendship_id ) {
+                        wp_cache_delete( $friendship_id, 'bp_friends_friendships' );
+                }
+
+                // Loop through friend_ids to scrub user caches and update total count metas.
                 foreach ( (array) $friend_ids as $friend_id ) {
+                        // Delete cached friendships.
+                        wp_cache_delete( $friend_id, 'bp_friends_friendships_for_user' );
                         BP_Friends_Friendship::total_friend_count( $friend_id );
                 }
+
+                // Delete cached friendships.
+                wp_cache_delete( $user_id, 'bp_friends_friendships_for_user' );
         }
 }

tests/phpunit/testcases/friends/functions.php

@@ -267 +267 @@
                 $this->filter_fired = current_filter();
                 return $value;
         }
+
+        /**
+         * @group friendship_caching
+         */
+        public function test_friends_check_friendship_should_hit_user_cache() {
+                global $wpdb;
+                $now = time();
+                $u1 = $this->factory->user->create( array(
+                        'last_activity' => date( 'Y-m-d H:i:s', $now ),
+                ) );
+                $u2 = $this->factory->user->create( array(
+                        'last_activity' => date( 'Y-m-d H:i:s', $now - 100 ),
+                ) );
+                $u3 = $this->factory->user->create( array(
+                        'last_activity' => date( 'Y-m-d H:i:s', $now - 200 ),
+                ) );
+
+                friends_add_friend( $u1, $u2, true );
+                friends_add_friend( $u1, $u3, false );
+
+                friends_check_friendship_status( $u1, $u2 );
+                $first_query_count = $wpdb->num_queries;
+
+                friends_check_friendship_status( $u1, $u3 );
+
+                $this->assertEquals( $first_query_count, $wpdb->num_queries );
+        }
+
+        /**
+         * @group friendship_caching
+         */
+        public function test_friends_check_friendship_should_hit_friendship_object_cache() {
+                global $wpdb;
+                $now = time();
+                $u1 = $this->factory->user->create( array(
+                        'last_activity' => date( 'Y-m-d H:i:s', $now ),
+                ) );
+                $u2 = $this->factory->user->create( array(
+                        'last_activity' => date( 'Y-m-d H:i:s', $now - 100 ),
+                ) );
+
+                friends_add_friend( $u1, $u2, true );
+
+                friends_check_friendship_status( $u1, $u2 );
+                $first_query_count = $wpdb->num_queries;
+
+                /*
+                 * We expect this to generate one query to find $u2's friendships,
+                 * but the friendship object itself should come from cache.
+                 */
+                friends_check_friendship_status( $u2, $u1 );
+
+                $this->assertEquals( $first_query_count + 1, $wpdb->num_queries );
+        }
 }