Ticket #37923: 37923.14.diff

src/wp-admin/includes/ms.php

@@ -135 +135 @@
                         $wpdb->query( "DROP TABLE IF EXISTS `$table`" );
                 }
 
+                if ( is_site_meta_supported() ) {
+                        $blog_meta_ids = $wpdb->get_col( $wpdb->prepare( "SELECT meta_id FROM $wpdb->blogmeta WHERE blog_id = %d ", $blog_id ) );
+                        foreach ( $blog_meta_ids as $mid ) {
+                                delete_metadata_by_mid( 'blog', $mid );
+                        }
+                }
+
                 $wpdb->delete( $wpdb->blogs, array( 'blog_id' => $blog_id ) );
 
                 /**

src/wp-admin/includes/schema.php

@@ -267 +267 @@
   PRIMARY KEY  (blog_id),
   KEY db_version (db_version)
 ) $charset_collate;
+CREATE TABLE $wpdb->blogmeta (
+  meta_id bigint(20) unsigned NOT NULL auto_increment,
+  blog_id bigint(20) signed NOT NULL default '0',
+  meta_key varchar(255) default NULL,
+  meta_value longtext,
+  PRIMARY KEY  (meta_id),
+  KEY term_id (term_id),
+  KEY meta_key (meta_key($max_index_length))
+) $charset_collate;
 CREATE TABLE $wpdb->registration_log (
   ID bigint(20) NOT NULL auto_increment,
   email varchar(255) NOT NULL default '',

src/wp-admin/includes/upgrade.php

@@ -2133 +2133 @@
                         }
                 }
         }
+
+        // 4.9
+        if ( $wp_current_db_version < 40001 ) {
+                $network_id = get_main_network_id();
+                delete_network_option( $network_id, 'site_meta_supported' );
+                is_site_meta_supported();
+        }
 }
 
 //

src/wp-includes/class-wp-site-query.php

@@ -288 +288 @@
 
                 // Prime site network caches.
                 if ( $this->query_vars['update_site_cache'] ) {
-                        _prime_site_caches( $site_ids );
+                        _prime_site_caches( $site_ids, $this->query_vars['update_site_meta_cache'] );
                 }
 
                 // Fetch full site objects from the primed cache.

src/wp-includes/functions.php

@@ -4704 +4704 @@
 }
 
 /**
+ * Determines whether site meta is enabled.
+ *
+ * This function checks whether the 'blogmeta' database table exists. The result is saved as
+ * a setting for the main network, making it essentially a global setting. Subsequent requests
+ * will refer to this setting instead of running the query. The $force parameter can be used
+ * to bypass the setting, and reset it accordingly, however this is not recommended.
+ *
+ * The 'is_site_meta_supported' filter can be used to bypass the database checks completely.
+ *
+ * @since 4.9.0
+ *
+ * @global wpdb $wpdb WordPress database abstraction object.
+ *
+ * @return bool True if site meta is supported, false otherwise.
+ */
+function is_site_meta_supported() {
+        global $wpdb;
+
+        if ( ! is_multisite() ) {
+                return false;
+        }
+
+        $network_id = get_main_network_id();
+
+        if ( false === ( $supported = get_network_option( $network_id, 'site_meta_supported', false ) ) ) {
+                $supported = $wpdb->get_var( "SHOW TABLES LIKE '{$wpdb->blogmeta}'" ) ? 1 : 0;
+
+                update_network_option( $network_id, 'site_meta_supported', $supported );
+        }
+
+        return (bool) $supported;
+}
+
+/**
  * gmt_offset modification for smart timezone handling.
  *
  * Overrides the gmt_offset option if we have a timezone_string available.

src/wp-includes/load.php

@@ -567 +567 @@
         }
 
         if ( function_exists( 'wp_cache_add_global_groups' ) ) {
-                wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'blog-lookup', 'blog-details', 'site-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites' ) );
+                wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'blog-lookup', 'blog-details', 'site-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites', 'blog_meta' ) );
                 wp_cache_add_non_persistent_groups( array( 'counts', 'plugins' ) );
         }
 }

src/wp-includes/ms-blogs.php

@@ -474 +474 @@
         wp_cache_delete( $domain_path_key, 'blog-id-cache' );
         wp_cache_delete( 'current_blog_' . $blog->domain, 'site-options' );
         wp_cache_delete( 'current_blog_' . $blog->domain . $blog->path, 'site-options' );
+        wp_cache_delete( $blog_id, 'blog_meta' );
 
         /**
          * Fires immediately after a site has been removed from the object cache.
@@ -585 +586 @@
  *
  * @param array $sites Array of site objects.
  */
-function update_site_cache( $sites ) {
+function update_site_cache( $sites, $update_meta_cache = true ) {
         if ( ! $sites ) {
                 return;
         }
-
+        $site_ids = array();
         foreach ( $sites as $site ) {
+                $site_ids[] = $site->blog_id;
                 wp_cache_add( $site->blog_id, $site, 'sites' );
                 wp_cache_add( $site->blog_id . 'short', $site, 'blog-details' );
         }
+
+        if ( $update_meta_cache ) {
+                update_sitemeta_cache( $site_ids );
+        }
+}
+
+/**
+ * Updates metadata cache for list of site IDs.
+ *
+ * Performs SQL query to retrieve all metadata for the sites matching `$site_ids` and stores them in the cache.
+ * Subsequent calls to `get_site_meta()` will not need to query the database.
+ *
+ * @since 4.9.0
+ *
+ * @param array $site_ids List of site IDs.
+ * @return array|false Returns false if there is nothing to update. Returns an array of metadata on success.
+ */
+function update_sitemeta_cache( $site_ids ) {
+        if ( ! is_site_meta_supported() ) {
+                return false;
+        }
+
+        return update_meta_cache( 'blog', $site_ids );
 }
 
 /**
@@ -658 +683 @@
         return $query->query( $args );
 }
 
+
 /**
  * Retrieve option value for a given blog id based on name of option.
  *
@@ -796 +822 @@
         return $return;
 }
 
+
+
+/**
+ * Add meta data field to a site.
+ *
+ * Site meta data is called "Custom Fields" on the Administration Screen.
+ *
+ * @since 4.9.0
+ *
+ * @param int    $site_id    Site ID.
+ * @param string $meta_key   Metadata name.
+ * @param mixed  $meta_value Metadata value. Must be serializable if non-scalar.
+ * @param bool   $unique     Optional. Whether the same key should not be added.
+ *                           Default false.
+ * @return int|false Meta ID on success, false on failure.
+ */
+function add_site_meta( $site_id, $meta_key, $meta_value, $unique = false ) {
+        // Bail if site meta table is not installed.
+        if ( ! is_site_meta_supported() ) {
+                return false;
+        }
+
+        $added = add_metadata( 'blog', $site_id, $meta_key, $meta_value, $unique );
+
+        // Bust site query cache.
+        if ( $added ) {
+                // @todo use clean_blog_cache here
+                wp_cache_set( 'last_changed', microtime(), 'sites' );
+        }
+
+        return $added;
+}
+
+/**
+ * Remove metadata matching criteria from a site.
+ *
+ * You can match based on the key, or key and value. Removing based on key and
+ * value, will keep from removing duplicate metadata with the same key. It also
+ * allows removing all metadata matching key, if needed.
+ *
+ * @since 4.9.0
+ *
+ * @param int    $site_id    Site ID.
+ * @param string $meta_key   Metadata name.
+ * @param mixed  $meta_value Optional. Metadata value. Must be serializable if
+ *                           non-scalar. Default empty.
+ * @return bool True on success, false on failure.
+ */
+function delete_site_meta( $site_id, $meta_key, $meta_value = '' ) {
+        // Bail if site meta table is not installed.
+        if ( ! is_site_meta_supported() ) {
+                return false;
+        }
+
+        $deleted = delete_metadata( 'blog', $site_id, $meta_key, $meta_value );
+
+        // Bust site query cache.
+        if ( $deleted ) {
+                // @todo use clean_blog_cache here
+                wp_cache_set( 'last_changed', microtime(), 'sites' );
+        }
+
+        return $deleted;
+}
+
+/**
+ * Retrieve site meta field for a site.
+ *
+ * @since 4.9.0
+ *
+ * @param int    $site_id Site ID.
+ * @param string $key     Optional. The meta key to retrieve. By default, returns
+ *                        data for all keys. Default empty.
+ * @param bool   $single  Optional. Whether to return a single value. Default false.
+ * @return mixed Will be an array if $single is false. Will be value of meta data
+ *               field if $single is true.
+ */
+function get_site_meta( $site_id, $key = '', $single = false ) {
+        // Bail if site meta table is not installed.
+        if ( ! is_site_meta_supported() ) {
+                return false;
+        }
+
+        return get_metadata( 'blog', $site_id, $key, $single );
+}
+
+/**
+ * Update site meta field based on site ID.
+ *
+ * Use the $prev_value parameter to differentiate between meta fields with the
+ * same key and site ID.
+ *
+ * If the meta field for the site does not exist, it will be added.
+ *
+ * @since 4.9.0
+ *
+ * @param int    $site_id    Site ID.
+ * @param string $meta_key   Metadata key.
+ * @param mixed  $meta_value Metadata value. Must be serializable if non-scalar.
+ * @param mixed  $prev_value Optional. Previous value to check before removing.
+ *                           Default empty.
+ * @return int|bool Meta ID if the key didn't exist, true on successful update,
+ *                  false on failure.
+ */
+function update_site_meta( $site_id, $meta_key, $meta_value, $prev_value = '' ) {
+        // Bail if site meta table is not installed.
+        if ( ! is_site_meta_supported() ) {
+                return false;
+        }
+
+        $updated = update_metadata( 'blog', $site_id, $meta_key, $meta_value, $prev_value );
+
+        // Bust site query cache.
+        if ( $updated ) {
+                // @todo use clean_blog_cache here
+                wp_cache_set( 'last_changed', microtime(), 'sites' );
+        }
+
+        return $updated;
+}
+
+/**
+ * Delete everything from site meta matching meta key.
+ *
+ * @since 4.9.0
+ *
+ * @param string $meta_key Metadata key to search for when deleting.
+ * @return bool Whether the site meta key was deleted from the database.
+ */
+function delete_site_meta_by_key( $meta_key ) {
+        // Bail if site meta table is not installed.
+        if ( ! is_site_meta_supported() ) {
+                return false;
+        }
+
+        $deleted = delete_metadata( 'blog', null, $meta_key, '', true );
+
+        // Bust site query cache.
+        if ( $deleted ) {
+                // @todo use clean_blog_cache here
+                wp_cache_set( 'last_changed', microtime(), 'sites' );
+        }
+
+        return $deleted;
+}
+
 /**
  * Switch the current blog.
  *
@@ -869 +1041 @@
                         if ( is_array( $global_groups ) ) {
                                 wp_cache_add_global_groups( $global_groups );
                         } else {
-                                wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites', 'site-details' ) );
+                                wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites', 'site-details', 'blog_meta' ) );
                         }
                         wp_cache_add_non_persistent_groups( array( 'counts', 'plugins' ) );
                 }
@@ -937 +1109 @@
                         if ( is_array( $global_groups ) ) {
                                 wp_cache_add_global_groups( $global_groups );
                         } else {
-                                wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites', 'site-details' ) );
+                                wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites', 'site-details', 'blog_meta' ) );
                         }
                         wp_cache_add_non_persistent_groups( array( 'counts', 'plugins' ) );
                 }

src/wp-includes/version.php

@@ -11 +11 @@
  *
  * @global int $wp_db_version
  */
-$wp_db_version = 38590;
+$wp_db_version = 40001;
 
 /**
  * Holds the TinyMCE version

src/wp-includes/wp-db.php

@@ -400 +400 @@
         public $blogs;
 
         /**
+         * Multisite Blog Metadata table
+         *
+         * @since 4.9.0
+         * @var string
+         */
+        public $blogmeta;
+
+        /**
          * Multisite Blog Versions table
          *
          * @since 3.0.0

src/wp-settings.php

@@ -95 +95 @@
 // Load early WordPress files.
 require( ABSPATH . WPINC . '/compat.php' );
 require( ABSPATH . WPINC . '/class-wp-list-util.php' );
+require( ABSPATH . WPINC . '/formatting.php' );
+require( ABSPATH . WPINC . '/meta.php' );
 require( ABSPATH . WPINC . '/functions.php' );
 require( ABSPATH . WPINC . '/class-wp-matchesmapregex.php' );
 require( ABSPATH . WPINC . '/class-wp.php' );
@@ -143 +145 @@
 // Load most of WordPress.
 require( ABSPATH . WPINC . '/class-wp-walker.php' );
 require( ABSPATH . WPINC . '/class-wp-ajax-response.php' );
-require( ABSPATH . WPINC . '/formatting.php' );
 require( ABSPATH . WPINC . '/capabilities.php' );
 require( ABSPATH . WPINC . '/class-wp-roles.php' );
 require( ABSPATH . WPINC . '/class-wp-role.php' );
@@ -158 +159 @@
 require( ABSPATH . WPINC . '/class-wp-user-query.php' );
 require( ABSPATH . WPINC . '/class-wp-session-tokens.php' );
 require( ABSPATH . WPINC . '/class-wp-user-meta-session-tokens.php' );
-require( ABSPATH . WPINC . '/meta.php' );
 require( ABSPATH . WPINC . '/class-wp-meta-query.php' );
 require( ABSPATH . WPINC . '/class-wp-metadata-lazyloader.php' );
 require( ABSPATH . WPINC . '/general-template.php' );

tests/phpunit/includes/testcase.php

@@ -328 +328 @@
                         $wp_object_cache->__remoteset();
                 }
                 wp_cache_flush();
-                wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites', 'site-details' ) );
+                wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites', 'site-details', 'blog_meta' ) );
                 wp_cache_add_non_persistent_groups( array( 'comment', 'counts', 'plugins' ) );
         }
 

tests/phpunit/tests/multisite/siteMeta.php

@@ +1 @@
+<?php
+
+if ( is_multisite() ) :
+
+/**
+ * @group ms-site
+ * @group multisite
+ * @group meta
+ * @ticket 37923
+ */
+class Tests_Multisite_Site_Meta extends WP_UnitTestCase {
+        protected static $site_id;
+        protected static $site_id2;
+        protected static $flag_was_set;
+
+        public static function wpSetUpBeforeClass( $factory ) {
+                self::$site_id = $factory->blog->create( array( 'domain' => 'wordpress.org', 'path' => '/' ) );
+                self::$site_id2 = $factory->blog->create( array( 'domain' => 'wordpress.org', 'path' => '/foo/' ) );
+
+                // Populate the main network flag as necessary.
+                self::$flag_was_set = true;
+                if ( false === get_network_option( get_main_network_id(), 'site_meta_supported', false ) ) {
+                        self::$flag_was_set = false;
+                        is_site_meta_supported();
+                }
+        }
+
+        public static function wpTearDownAfterClass() {
+                // Delete the possibly previously populated main network flag.
+                if ( ! self::$flag_was_set ) {
+                        delete_network_option( get_main_network_id(), 'site_meta_supported' );
+                }
+
+                wpmu_delete_blog( self::$site_id, true );
+                wpmu_delete_blog( self::$site_id2, true );
+
+                wp_update_network_site_counts();
+        }
+
+        public function test_is_site_meta_supported() {
+                remove_all_filters( 'is_site_meta_supported' );
+
+                $setting = get_network_option( get_main_network_id(), 'site_meta_supported' );
+                if ( $setting ) {
+                        $this->assertTrue( is_site_meta_supported() );
+                } else {
+                        $this->assertFalse( is_site_meta_supported() );
+                }
+        }
+
+        public function test_is_site_meta_supported_with_filter() {
+                add_filter( 'is_site_meta_supported', '__return_false' );
+
+                $this->assertFalse( is_site_meta_supported() );
+        }
+
+        public function test_add() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
+        }
+
+        public function test_add_unique() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
+                $this->assertFalse( add_site_meta( self::$site_id, 'foo', 'bar', true ) );
+        }
+
+        public function test_delete() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+
+                $this->assertTrue( delete_site_meta( self::$site_id, 'foo' ) );
+        }
+
+        public function test_delete_with_invalid_meta_key_should_return_false() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                $this->assertFalse( delete_site_meta( self::$site_id, 'foo' ) );
+        }
+
+        public function test_delete_should_respect_meta_value() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+                add_site_meta( self::$site_id, 'foo', 'baz' );
+
+                $this->assertTrue( delete_site_meta( self::$site_id, 'foo', 'bar' ) );
+
+                $metas = get_site_meta( self::$site_id, 'foo', false );
+                $this->assertSame( array( 'baz' ), $metas );
+        }
+
+        public function test_get_with_no_key_should_fetch_all_keys() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+                add_site_meta( self::$site_id, 'foo1', 'baz' );
+
+                $found = get_site_meta( self::$site_id );
+                $expected = array(
+                        'foo' => array( 'bar' ),
+                        'foo1' => array( 'baz' ),
+                );
+
+                $this->assertEqualSets( $expected, $found );
+        }
+
+        public function test_get_with_key_should_fetch_all_for_key() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+                add_site_meta( self::$site_id, 'foo', 'baz' );
+                add_site_meta( self::$site_id, 'foo1', 'baz' );
+
+                $found = get_site_meta( self::$site_id, 'foo' );
+                $expected = array( 'bar', 'baz' );
+
+                $this->assertEqualSets( $expected, $found );
+        }
+
+        public function test_get_should_respect_single_true() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+                add_site_meta( self::$site_id, 'foo', 'baz' );
+
+                $found = get_site_meta( self::$site_id, 'foo', true );
+                $this->assertEquals( 'bar', $found );
+        }
+
+        public function test_update_should_pass_to_add_when_no_value_exists_for_key() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                $actual = update_site_meta( self::$site_id, 'foo', 'bar' );
+                $this->assertInternalType( 'int', $actual );
+                $this->assertNotEmpty( $actual );
+
+                $meta = get_site_meta( self::$site_id, 'foo', true );
+                $this->assertSame( 'bar', $meta );
+        }
+
+        public function test_update_should_return_true_when_updating_existing_value_for_key() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+
+                $actual = update_site_meta( self::$site_id, 'foo', 'baz' );
+                $this->assertTrue( $actual );
+
+                $meta = get_site_meta( self::$site_id, 'foo', true );
+                $this->assertSame( 'baz', $meta );
+        }
+
+        public function test_delete_by_key() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                add_site_meta( self::$site_id, 'unique_delete_by_key', 'value', true );
+                add_site_meta( self::$site_id2, 'unique_delete_by_key', 'value', true );
+
+                $this->assertEquals( 'value', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
+                $this->assertEquals( 'value', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
+
+                $this->assertTrue( delete_site_meta_by_key( 'unique_delete_by_key' ) );
+
+                $this->assertEquals( '', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
+                $this->assertEquals( '', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
+        }
+
+        public function test_site_meta_should_be_deleted_when_site_is_deleted() {
+                if ( ! is_site_meta_supported() ) {
+                        $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
+                }
+
+                $site_id = self::factory()->blog->create( array( 'domain' => 'foo.org', 'path' => '/' ) );
+
+                add_site_meta( $site_id, 'foo', 'bar' );
+                add_site_meta( $site_id, 'foo1', 'bar' );
+
+                $this->assertSame( 'bar', get_site_meta( $site_id, 'foo', true ) );
+                $this->assertSame( 'bar', get_site_meta( $site_id, 'foo1', true ) );
+
+                wpmu_delete_blog( $site_id, true );
+
+                $this->assertSame( '', get_site_meta( $site_id, 'foo', true ) );
+                $this->assertSame( '', get_site_meta( $site_id, 'foo1', true ) );
+        }
+}
+
+endif;
+<?php
+
+if ( is_multisite() ) :
+/**
+ * @group ms-site
+ * @group multisite
+ * @group meta
+ * @ticket 37923
+ */
+class Tests_Multisite_Site_Meta extends WP_UnitTestCase {
+        protected static $site_id;
+        protected static $site_id2;
+
+    function setUp() {
+        global $wpdb;
+        parent::setUp();
+        $this->suppress = $wpdb->suppress_errors();
+
+        update_site_option( 'site_meta_supported', 1 );
+    }
+
+    function tearDown() {
+        global $wpdb;
+
+        update_site_option( 'site_meta_supported', 0 );
+        $wpdb->suppress_errors( $this->suppress );
+
+        parent::tearDown();
+    }
+
+        public static function wpSetUpBeforeClass( $factory ) {
+                self::$site_id = $factory->blog->create( array( 'domain' => 'wordpress.org', 'path' => '/' ) );
+                self::$site_id2 = $factory->blog->create( array( 'domain' => 'wordpress.org', 'path' => '/foo/' ) );
+        }
+
+        public static function wpTearDownAfterClass() {
+                wpmu_delete_blog( self::$site_id, true );
+                wpmu_delete_blog( self::$site_id2, true );
+
+                wp_update_network_site_counts();
+        delete_site_option( 'site_meta_supported');
+        }
+
+        public function test_add() {
+                $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
+        }
+
+        public function test_add_unique() {
+                $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
+                $this->assertFalse( add_site_meta( self::$site_id, 'foo', 'bar', true ) );
+        }
+
+        public function test_delete() {
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+
+                $this->assertTrue( delete_site_meta( self::$site_id, 'foo' ) );
+        }
+
+        public function test_delete_with_invalid_meta_key_should_return_false() {
+                $this->assertFalse( delete_site_meta( self::$site_id, 'foo' ) );
+        }
+
+        public function test_delete_should_respect_meta_value() {
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+                add_site_meta( self::$site_id, 'foo', 'baz' );
+
+                $this->assertTrue( delete_site_meta( self::$site_id, 'foo', 'bar' ) );
+
+                $metas = get_site_meta( self::$site_id, 'foo', false );
+                $this->assertSame( array( 'baz' ), $metas );
+        }
+
+        public function test_get_with_no_key_should_fetch_all_keys() {
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+                add_site_meta( self::$site_id, 'foo1', 'baz' );
+
+                $found = get_site_meta( self::$site_id );
+                $expected = array(
+                        'foo' => array( 'bar' ),
+                        'foo1' => array( 'baz' ),
+                );
+
+                $this->assertEqualSets( $expected, $found );
+        }
+
+        public function test_get_with_key_should_fetch_all_for_key() {
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+                add_site_meta( self::$site_id, 'foo', 'baz' );
+                add_site_meta( self::$site_id, 'foo1', 'baz' );
+
+                $found = get_site_meta( self::$site_id, 'foo' );
+                $expected = array( 'bar', 'baz' );
+
+                $this->assertEqualSets( $expected, $found );
+        }
+
+        public function test_get_should_respect_single_true() {
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+                add_site_meta( self::$site_id, 'foo', 'baz' );
+
+                $found = get_site_meta( self::$site_id, 'foo', true );
+                $this->assertEquals( 'bar', $found );
+        }
+
+        public function test_update_should_pass_to_add_when_no_value_exists_for_key() {
+                $actual = update_site_meta( self::$site_id, 'foo', 'bar' );
+                $this->assertInternalType( 'int', $actual );
+                $this->assertNotEmpty( $actual );
+
+                $meta = get_site_meta( self::$site_id, 'foo', true );
+                $this->assertSame( 'bar', $meta );
+        }
+
+        public function test_update_should_return_true_when_updating_existing_value_for_key() {
+                add_site_meta( self::$site_id, 'foo', 'bar' );
+
+                $actual = update_site_meta( self::$site_id, 'foo', 'baz' );
+                $this->assertTrue( $actual );
+
+                $meta = get_site_meta( self::$site_id, 'foo', true );
+                $this->assertSame( 'baz', $meta );
+        }
+
+        public function test_delete_by_key() {
+                add_site_meta( self::$site_id, 'unique_delete_by_key', 'value', true );
+                add_site_meta( self::$site_id2, 'unique_delete_by_key', 'value', true );
+
+                $this->assertEquals( 'value', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
+                $this->assertEquals( 'value', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
+
+                $this->assertTrue( delete_site_meta_by_key( 'unique_delete_by_key' ) );
+
+                $this->assertEquals( '', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
+                $this->assertEquals( '', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
+        }
+
+        public function test_site_meta_should_be_deleted_when_site_is_deleted() {
+                $site_id = self::factory()->blog->create( array( 'domain' => 'foo.org', 'path' => '/' ) );
+
+                add_site_meta( $site_id, 'foo', 'bar' );
+                add_site_meta( $site_id, 'foo1', 'bar' );
+
+                $this->assertSame( 'bar', get_site_meta( $site_id, 'foo', true ) );
+                $this->assertSame( 'bar', get_site_meta( $site_id, 'foo1', true ) );
+
+                wpmu_delete_blog( $site_id, true );
+
+                $this->assertSame( '', get_site_meta( $site_id, 'foo', true ) );
+                $this->assertSame( '', get_site_meta( $site_id, 'foo1', true ) );
+        }
+
+        public function test_disabled_site_meta_by_filter(){
+        $site_id = self::factory()->blog->create( array( 'domain' => 'foo.org', 'path' => '/' ) );
+        add_filter( 'pre_site_option_site_meta_supported', '__return_null' );
+
+            $this->assertSame( null, get_site_option('site_meta_supported') );
+            $this->assertSame( false, add_site_meta( $site_id, 'wibble', 'test1' ) );
+            $this->assertSame( false, update_site_meta( $site_id, 'wibble', 'test2' ) );
+        $this->assertSame( false, get_site_meta( $site_id, 'wibble' ) );
+            $this->assertSame( false, delete_site_meta( $site_id, 'wibble' ) );
+
+        remove_filter( 'pre_site_option_site_meta_supported', '__return_null' );
+    }
+}
+
+endif;