diff --git a/lib/compat/wordpress-6.2/script-loader.php b/lib/compat/wordpress-6.2/script-loader.php
index e08bfa6e46ca8e..f3fde930383bc2 100644
--- a/lib/compat/wordpress-6.2/script-loader.php
+++ b/lib/compat/wordpress-6.2/script-loader.php
@@ -127,6 +127,30 @@ function gutenberg_resolve_assets_override() {
 
 	$scripts = ob_get_clean();
 
+	/*
+	 * Generate web font @font-face styles for the site editor iframe.
+	 * Use the registered font families for printing.
+	 */
+	if ( class_exists( 'WP_Web_Fonts' ) ) {
+		$wp_webfonts = wp_webfonts();
+		$registered  = $wp_webfonts->get_registered_font_families();
+		if ( ! empty( $registered ) ) {
+			$queue = $wp_webfonts->queue;
+			$done  = $wp_webfonts->done;
+
+			$wp_webfonts->done  = array();
+			$wp_webfonts->queue = $registered;
+
+			ob_start();
+			$wp_webfonts->do_items();
+			$styles .= ob_get_clean();
+
+			// Reset the Web Fonts API.
+			$wp_webfonts->done  = $done;
+			$wp_webfonts->queue = $queue;
+		}
+	}
+
 	return array(
 		'styles'  => $styles,
 		'scripts' => $scripts,
diff --git a/lib/experimental/class-wp-web-fonts.php b/lib/experimental/class-wp-web-fonts.php
new file mode 100644
index 00000000000000..15df7ecf47e5c5
--- /dev/null
+++ b/lib/experimental/class-wp-web-fonts.php
@@ -0,0 +1,744 @@
+<?php
+/**
+ * Web Fonts API class.
+ *
+ * @package    WordPress
+ * @subpackage WebFonts
+ * @since      X.X.X
+ */
+
+if ( class_exists( 'WP_Web_Fonts' ) ) {
+	return;
+}
+
+/**
+ * Class WP_Web_Fonts
+ *
+ * @since X.X.X
+ */
+class WP_Web_Fonts extends WP_Webfonts {
+
+	/**
+	 * An array of registered providers.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var array
+	 */
+	private $providers = array();
+
+	/**
+	 * The flipped $to_do array of web font handles.
+	 *
+	 * Used for a faster lookup of the web font handles.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var string[]
+	 */
+	private $to_do_keyed_handles;
+
+	/**
+	 * Provider instance store, keyed by provider ID.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var array
+	 */
+	private $provider_instances = array();
+
+	/**
+	 * Variation property defaults.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var array
+	 */
+	private $variation_property_defaults = array(
+		'provider'     => 'local',
+		'font-family'  => '',
+		'font-style'   => 'normal',
+		'font-weight'  => '400',
+		'font-display' => 'fallback',
+	);
+
+	/**
+	 * Constructor.
+	 *
+	 * @since X.X.X
+	 */
+	public function __construct() {
+		/**
+		 * Filters the web font variation's property defaults.
+		 *
+		 * @since X.X.X
+		 *
+		 * @param array $defaults {
+		 *     An array of required web font properties and defaults.
+		 *
+		 *     @type string $provider     The provider ID. Default 'local'.
+		 *     @type string $font-family  The font-family property. Default empty string.
+		 *     @type string $font-style   The font-style property. Default 'normal'.
+		 *     @type string $font-weight  The font-weight property. Default '400'.
+		 *     @type string $font-display The font-display property. Default 'fallback'.
+		 * }
+		 */
+		$this->variation_property_defaults = apply_filters( 'wp_webfont_variation_defaults', $this->variation_property_defaults );
+
+		/**
+		 * Fires when the WP_Webfonts instance is initialized.
+		 *
+		 * @since X.X.X
+		 *
+		 * @param WP_Web_Fonts $wp_webfonts WP_Web_Fonts instance (passed by reference).
+		 */
+		do_action_ref_array( 'wp_default_webfonts', array( &$this ) );
+	}
+
+	/**
+	 * Get the list of registered providers.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return array $providers {
+	 *     An associative array of registered providers, keyed by their unique ID.
+	 *
+	 *     @type string $provider_id => array {
+	 *         An associate array of provider's class name and fonts.
+	 *
+	 *         @type string $class   Fully qualified name of the provider's class.
+	 *         @type string[] $fonts An array of enqueued font handles for this provider.
+	 *     }
+	 * }
+	 */
+	public function get_providers() {
+		return $this->providers;
+	}
+
+	/**
+	 * Register a provider.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $provider_id The provider's unique ID.
+	 * @param string $class       The provider class name.
+	 * @return bool True if successfully registered, else false.
+	 */
+	public function register_provider( $provider_id, $class ) {
+		if ( empty( $provider_id ) || empty( $class ) || ! class_exists( $class ) ) {
+			return false;
+		}
+
+		$this->providers[ $provider_id ] = array(
+			'class' => $class,
+			'fonts' => array(),
+		);
+		return true;
+	}
+
+	/**
+	 * Get the list of all registered font family handles.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string[]
+	 */
+	public function get_registered_font_families() {
+		$font_families = array();
+		foreach ( $this->registered as $handle => $obj ) {
+			if ( $obj->extra['is_font_family'] ) {
+				$font_families[] = $handle;
+			}
+		}
+		return $font_families;
+	}
+
+	/**
+	 * Get the list of all registered font families and their variations.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string[]
+	 */
+	public function get_registered() {
+		return array_keys( $this->registered );
+	}
+
+	/**
+	 * Get the list of enqueued font families and their variations.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return array[]
+	 */
+	public function get_enqueued() {
+		return $this->queue;
+	}
+
+	/**
+	 * Registers a font family.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family Font family name to register.
+	 * @return string|null Font family handle when registration successes. Null on failure.
+	 */
+	public function add_font_family( $font_family ) {
+		$font_family_handle = WP_Webfonts_Utils::convert_font_family_into_handle( $font_family );
+		if ( ! $font_family_handle ) {
+			return null;
+		}
+
+		if ( isset( $this->registered[ $font_family_handle ] ) ) {
+			return $font_family_handle;
+		}
+
+		$registered = $this->add( $font_family_handle, false );
+		if ( ! $registered ) {
+			return null;
+		}
+
+		$this->add_data( $font_family_handle, 'font-properties', array( 'font-family' => $font_family ) );
+		$this->add_data( $font_family_handle, 'is_font_family', true );
+
+		return $font_family_handle;
+	}
+
+	/**
+	 * Removes a font family and all registered variations.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family to remove.
+	 */
+	public function remove_font_family( $font_family_handle ) {
+		if ( ! isset( $this->registered[ $font_family_handle ] ) ) {
+			return;
+		}
+
+		$variations = $this->registered[ $font_family_handle ]->deps;
+
+		foreach ( $variations as $variation ) {
+			$this->remove( $variation );
+		}
+
+		$this->remove( $font_family_handle );
+	}
+
+	/**
+	 * Add a variation to an existing family or register family if none exists.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param array  $variation          An array of variation properties to add.
+	 * @param string $variation_handle   Optional. The variation's handle. When none is provided, the
+	 *                                   handle will be dynamically generated.
+	 *                                   Default empty string.
+	 * @return string|null Variation handle on success. Else null.
+	 */
+	public function add_variation( $font_family_handle, array $variation, $variation_handle = '' ) {
+		if ( ! WP_Webfonts_Utils::is_defined( $font_family_handle ) ) {
+			trigger_error( 'Font family handle must be a non-empty string.' );
+			return null;
+		}
+
+		// When there is a variation handle, check it.
+		if ( '' !== $variation_handle && ! WP_Webfonts_Utils::is_defined( $variation_handle ) ) {
+			trigger_error( 'Variant handle must be a non-empty string.' );
+			return null;
+		}
+
+		// Register the font family when it does not yet exist.
+		if ( ! isset( $this->registered[ $font_family_handle ] ) ) {
+			if ( ! $this->add_font_family( $font_family_handle ) ) {
+				return null;
+			}
+		}
+
+		$variation = $this->validate_variation( $variation );
+
+		// Variation validation failed.
+		if ( ! $variation ) {
+			return null;
+		}
+
+		// When there's no variation handle, attempt to create one.
+		if ( '' === $variation_handle ) {
+			$variation_handle = WP_Webfonts_Utils::convert_variation_into_handle( $font_family_handle, $variation );
+			if ( is_null( $variation_handle ) ) {
+				return null;
+			}
+		}
+
+		// Bail out if the variant is already registered.
+		if ( $this->is_variation_registered( $font_family_handle, $variation_handle ) ) {
+			return $variation_handle;
+		}
+
+		$variation_src = array_key_exists( 'src', $variation ) ? $variation['src'] : false;
+		$result        = $this->add( $variation_handle, $variation_src );
+
+		// Bail out if the registration failed.
+		if ( ! $result ) {
+			return null;
+		}
+
+		$this->add_data( $variation_handle, 'font-properties', $variation );
+		$this->add_data( $variation_handle, 'is_font_family', false );
+
+		// Add the font variation as a dependency to the registered font family.
+		$this->add_dependency( $font_family_handle, $variation_handle );
+
+		$this->providers[ $variation['provider'] ]['fonts'][] = $variation_handle;
+
+		return $variation_handle;
+	}
+
+	/**
+	 * Removes a variation.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family for this variation.
+	 * @param string $variation_handle   The variation's handle to remove.
+	 */
+	public function remove_variation( $font_family_handle, $variation_handle ) {
+		if ( isset( $this->registered[ $variation_handle ] ) ) {
+			$this->remove( $variation_handle );
+		}
+
+		if ( ! $this->is_variation_registered( $font_family_handle, $variation_handle ) ) {
+			return;
+		}
+
+		// Remove the variation as a dependency from its font family.
+		$this->registered[ $font_family_handle ]->deps = array_values(
+			array_diff(
+				$this->registered[ $font_family_handle ]->deps,
+				array( $variation_handle )
+			)
+		);
+	}
+
+	/**
+	 * Checks if the variation is registered.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param string $variation_handle   Variation's handle.
+	 * @return bool True when registered to the given font family. Else false.
+	 */
+	private function is_variation_registered( $font_family_handle, $variation_handle ) {
+		if ( ! isset( $this->registered[ $font_family_handle ] ) ) {
+			return false;
+		}
+
+		return in_array( $variation_handle, $this->registered[ $font_family_handle ]->deps, true );
+	}
+
+	/**
+	 * Adds a variation as a dependency to the given font family.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param string $variation_handle   The variation's handle.
+	 */
+	private function add_dependency( $font_family_handle, $variation_handle ) {
+		$this->registered[ $font_family_handle ]->deps[] = $variation_handle;
+	}
+
+	/**
+	 * Validates and sanitizes a variation.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $variation  Variation properties to add.
+	 * @return false|array Validated variation on success. Else, false.
+	 */
+	private function validate_variation( $variation ) {
+		$variation = wp_parse_args( $variation, $this->variation_property_defaults );
+
+		// Check the font-family.
+		if ( empty( $variation['font-family'] ) || ! is_string( $variation['font-family'] ) ) {
+			trigger_error( 'Webfont font-family must be a non-empty string.' );
+			return false;
+		}
+
+		// Local fonts need a "src".
+		if ( 'local' === $variation['provider'] ) {
+			// Make sure that local fonts have 'src' defined.
+			if ( empty( $variation['src'] ) || ( ! is_string( $variation['src'] ) && ! is_array( $variation['src'] ) ) ) {
+				trigger_error( 'Webfont src must be a non-empty string or an array of strings.' );
+				return false;
+			}
+		} elseif ( ! isset( $this->providers[ $variation['provider'] ] ) ) {
+			trigger_error( sprintf( 'The provider "%s" is not registered', $variation['provider'] ) );
+			return false;
+		} elseif ( ! class_exists( $this->providers[ $variation['provider'] ]['class'] ) ) {
+			trigger_error( sprintf( 'The provider class "%s" does not exist', $variation['provider'] ) );
+			return false;
+		}
+
+		// Validate the 'src' property.
+		if ( ! empty( $variation['src'] ) ) {
+			foreach ( (array) $variation['src'] as $src ) {
+				if ( empty( $src ) || ! is_string( $src ) ) {
+					trigger_error( 'Each webfont src must be a non-empty string.' );
+					return false;
+				}
+			}
+		}
+
+		// Check the font-weight.
+		if ( ! is_string( $variation['font-weight'] ) && ! is_int( $variation['font-weight'] ) ) {
+			trigger_error( 'Webfont font-weight must be a properly formatted string or integer.' );
+			return false;
+		}
+
+		// Check the font-display.
+		if ( ! in_array( $variation['font-display'], array( 'auto', 'block', 'fallback', 'swap', 'optional' ), true ) ) {
+			$variation['font-display'] = 'fallback';
+		}
+
+		$valid_props = array(
+			'ascent-override',
+			'descent-override',
+			'font-display',
+			'font-family',
+			'font-stretch',
+			'font-style',
+			'font-weight',
+			'font-variant',
+			'font-feature-settings',
+			'font-variation-settings',
+			'line-gap-override',
+			'size-adjust',
+			'src',
+			'unicode-range',
+
+			// Exceptions.
+			'provider',
+		);
+
+		foreach ( $variation as $prop => $value ) {
+			if ( ! in_array( $prop, $valid_props, true ) ) {
+				unset( $variation[ $prop ] );
+			}
+		}
+
+		return $variation;
+	}
+
+	/**
+	 * Processes the items and dependencies.
+	 *
+	 * Processes the items passed to it or the queue, and their dependencies.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string|string[]|bool $handles Optional. Items to be processed: queue (false),
+	 *                                      single item (string), or multiple items (array of strings).
+	 *                                      Default false.
+	 * @param int|false            $group   Optional. Group level: level (int), no group (false).
+	 *
+	 * @return array|string[] Array of web font handles that have been processed.
+	 *                        An empty array if none were processed.
+	 */
+	public function do_items( $handles = false, $group = false ) {
+		$handles = $this->prepare_handles_for_printing( $handles );
+
+		if ( empty( $handles ) ) {
+			return $this->done;
+		}
+
+		$this->all_deps( $handles );
+		if ( empty( $this->to_do ) ) {
+			return $this->done;
+		}
+
+		$this->to_do_keyed_handles = array_flip( $this->to_do );
+
+		foreach ( $this->get_providers() as $provider_id => $provider ) {
+			// Alert and skip if the provider class does not exist.
+			if ( ! class_exists( $provider['class'] ) ) {
+				/* translators: %s is the provider name. */
+				trigger_error(
+					sprintf(
+						'Class "%s" not found for "%s" web font provider',
+						$provider['class'],
+						$provider_id
+					)
+				);
+				continue;
+			}
+
+			$this->do_item( $provider_id, $group );
+		}
+
+		$this->process_font_families_after_printing( $handles );
+
+		return $this->done;
+	}
+
+	/**
+	 * Prepares the given handles for printing.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string|string[]|bool $handles Optional. Handles to prepare.
+	 *                                      Default false.
+	 * @return array Array of handles.
+	 */
+	private function prepare_handles_for_printing( $handles = false ) {
+		if ( false !== $handles ) {
+			$handles = $this->validate_handles( $handles );
+			// Bail out when invalid.
+			if ( empty( $handles ) ) {
+				return array();
+			}
+		}
+
+		// Use the enqueued queue.
+		if ( empty( $handles ) ) {
+			if ( empty( $this->queue ) ) {
+				return array();
+			}
+			$handles = $this->queue;
+		}
+
+		return $handles;
+	}
+
+	/**
+	 * Validates handle(s) to ensure each is a non-empty string.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string|string[] $handles Handles to prepare.
+	 * @return string[]|null Array of handles on success. Else null.
+	 */
+	private function validate_handles( $handles ) {
+		// Validate each element is a non-empty string handle.
+		$handles = array_filter( (array) $handles, array( WP_Webfonts_Utils::class, 'is_defined' ) );
+
+		if ( empty( $handles ) ) {
+			trigger_error( 'Handles must be a non-empty string or array of non-empty strings' );
+			return null;
+		}
+
+		return $handles;
+	}
+
+	/**
+	 * Invokes each provider to process and print its styles.
+	 *
+	 * @since X.X.X
+	 *
+	 * @see WP_Dependencies::do_item()
+	 *
+	 * @param string    $provider_id The provider to process.
+	 * @param int|false $group       Not used.
+	 * @return bool
+	 */
+	public function do_item( $provider_id, $group = false ) { // phpcs:ignore VariableAnalysis.CodeAnalysis.VariableAnalysis.UnusedVariable
+		// Bail out if the provider is not registered.
+		if ( ! isset( $this->providers[ $provider_id ] ) ) {
+			return false;
+		}
+
+		$font_handles = $this->get_enqueued_fonts_for_provider( $provider_id );
+		if ( empty( $font_handles ) ) {
+			return false;
+		}
+
+		$properties_by_font = $this->get_font_properties_for_provider( $font_handles );
+		if ( empty( $properties_by_font ) ) {
+			return false;
+		}
+
+		// Invoke provider to print its styles.
+		$provider = $this->get_provider_instance( $provider_id );
+		$provider->set_webfonts( $properties_by_font );
+		$provider->print_styles();
+
+		// Clean up.
+		$this->update_queues_for_printed_fonts( $font_handles );
+
+		return true;
+	}
+
+	/**
+	 * Retrieves a list of enqueued web font variations for a provider.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $provider_id The provider to process.
+	 * @return array[] Webfonts organized by providers.
+	 */
+	private function get_enqueued_fonts_for_provider( $provider_id ) {
+		$providers = $this->get_providers();
+
+		if ( empty( $providers[ $provider_id ] ) ) {
+			return array();
+		}
+
+		return array_intersect(
+			$providers[ $provider_id ]['fonts'],
+			$this->to_do
+		);
+	}
+
+	/**
+	 * Gets a list of font properties for each of the given font handles.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_handles Font handles to get properties.
+	 * @return array A list of fonts with each font's properties.
+	 */
+	private function get_font_properties_for_provider( array $font_handles ) {
+		$font_properties = array();
+
+		foreach ( $font_handles as $font_handle ) {
+			$properties = $this->get_data( $font_handle, 'font-properties' );
+			if ( ! $properties ) {
+				continue;
+			}
+			$font_properties[ $font_handle ] = $properties;
+		}
+
+		return $font_properties;
+	}
+
+	/**
+	 * Gets the instance of the provider from the WP_Webfonts::$provider_instance store.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $provider_id The provider to get.
+	 * @return object Instance of the provider.
+	 */
+	private function get_provider_instance( $provider_id ) {
+		if ( ! isset( $this->provider_instances[ $provider_id ] ) ) {
+			$this->provider_instances[ $provider_id ] = new $this->providers[ $provider_id ]['class']();
+		}
+		return $this->provider_instances[ $provider_id ];
+	}
+
+	/**
+	 * Update queues for the given printed fonts.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_handles Font handles to get properties.
+	 */
+	private function update_queues_for_printed_fonts( array $font_handles ) {
+		foreach ( $font_handles as $font_handle ) {
+			$this->set_as_done( $font_handle );
+			$this->remove_from_to_do_queues( $font_handle );
+		}
+	}
+
+	/**
+	 * Processes the font families after printing the variations.
+	 *
+	 * For each queued font family:
+	 *
+	 * a. if any of their variations were printed, the font family is added to the `done` list.
+	 * b. removes each from the to_do queues.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $handles Handles to process.
+	 */
+	private function process_font_families_after_printing( array $handles ) {
+		foreach ( $handles as $handle ) {
+			if (
+				! $this->get_data( $handle, 'is_font_family' ) ||
+				! isset( $this->to_do_keyed_handles[ $handle ] )
+			) {
+				continue;
+			}
+			$font_family = $this->registered[ $handle ];
+
+			// Add the font family to `done` list if any of its variations were printed.
+			if ( ! empty( $font_family->deps ) ) {
+				$processed = array_intersect( $font_family->deps, $this->done );
+				if ( ! empty( $processed ) ) {
+					$this->set_as_done( $handle );
+				}
+			}
+
+			$this->remove_from_to_do_queues( $handle );
+		}
+	}
+
+	/**
+	 * Removes the handle from the `to_do` and `to_do_keyed_handles` lists.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $handle Handle to remove.
+	 */
+	private function remove_from_to_do_queues( $handle ) {
+		unset(
+			$this->to_do[ $this->to_do_keyed_handles[ $handle ] ],
+			$this->to_do_keyed_handles[ $handle ]
+		);
+	}
+
+	/**
+	 * Sets the given handle to done by adding it to the `done` list.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $handle Handle to set as done.
+	 */
+	private function set_as_done( $handle ) {
+		if ( ! is_array( $this->done ) ) {
+			$this->done = array();
+		}
+		$this->done[] = $handle;
+	}
+
+	/**
+	 * Converts the font family and its variations into theme.json structural format.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family_handle Font family to convert.
+	 * @return array Webfonts in theme.json structural format.
+	 */
+	public function to_theme_json( $font_family_handle ) {
+		if ( ! isset( $this->registered[ $font_family_handle ] ) ) {
+			return array();
+		}
+
+		$font_family_name  = $this->registered[ $font_family_handle ]->extra['font-properties']['font-family'];
+		$theme_json_format = array(
+			'fontFamily' => str_contains( $font_family_name, ' ' ) ? "'{$font_family_name}'" : $font_family_name,
+			'name'       => $font_family_name,
+			'slug'       => $font_family_handle,
+			'fontFace'   => array(),
+		);
+
+		foreach ( $this->registered[ $font_family_handle ]->deps as $variation_handle ) {
+			if ( ! isset( $this->registered[ $variation_handle ] ) ) {
+				continue;
+			}
+
+			$variation_obj        = $this->registered[ $variation_handle ];
+			$variation_properties = array( 'origin' => 'gutenberg_wp_webfonts_api' );
+			foreach ( $variation_obj->extra['font-properties'] as $property_name => $property_value ) {
+				$property_in_camelcase                          = lcfirst( str_replace( '-', '', ucwords( $property_name, '-' ) ) );
+				$variation_properties[ $property_in_camelcase ] = $property_value;
+			}
+			$theme_json_format['fontFace'][ $variation_obj->handle ] = $variation_properties;
+		}
+
+		return $theme_json_format;
+	}
+}
diff --git a/lib/experimental/class-wp-webfonts-provider-local.php b/lib/experimental/class-wp-webfonts-provider-local.php
index 9af27fa7c436a7..3950ebcd624c39 100644
--- a/lib/experimental/class-wp-webfonts-provider-local.php
+++ b/lib/experimental/class-wp-webfonts-provider-local.php
@@ -35,6 +35,21 @@ class WP_Webfonts_Provider_Local extends WP_Webfonts_Provider {
 	 */
 	protected $id = 'local';
 
+	/**
+	 * Constructor.
+	 *
+	 * @since 6.1.0
+	 */
+	public function __construct() {
+		if (
+			function_exists( 'is_admin' ) && ! is_admin()
+			&&
+			function_exists( 'current_theme_supports' ) && ! current_theme_supports( 'html5', 'style' )
+		) {
+			$this->style_tag_atts = array( 'type' => 'text/css' );
+		}
+	}
+
 	/**
 	 * Gets the `@font-face` CSS styles for locally-hosted font files.
 	 *
@@ -81,7 +96,7 @@ class WP_Webfonts_Provider_Local extends WP_Webfonts_Provider {
 	 * }
 	 * </code>
 	 *
-	 * @since 6.0.0
+	 * @since X.X.X
 	 *
 	 * @return string The `@font-face` CSS.
 	 */
@@ -183,7 +198,8 @@ private function order_src( array $webfont ) {
 	private function build_font_face_css( array $webfont ) {
 		$css = '';
 
-		// Wrap font-family in quotes if it contains spaces.
+		// Wrap font-family in quotes if it contains spaces
+		// and is not already wrapped in quotes.
 		if (
 			str_contains( $webfont['font-family'], ' ' ) &&
 			! str_contains( $webfont['font-family'], '"' ) &&
diff --git a/lib/experimental/class-wp-webfonts-provider.php b/lib/experimental/class-wp-webfonts-provider.php
index a49b8a324b7f5f..8fcbd76a76d3cf 100644
--- a/lib/experimental/class-wp-webfonts-provider.php
+++ b/lib/experimental/class-wp-webfonts-provider.php
@@ -6,7 +6,7 @@
  *
  * @package    WordPress
  * @subpackage WebFonts
- * @since      6.0.0
+ * @since      X.X.X
  */
 
 if ( class_exists( 'WP_Webfonts_Provider' ) ) {
@@ -30,26 +30,46 @@
  * into styles (in a performant way for the provider service
  * it manages).
  *
- * @since 6.0.0
+ * @since X.X.X
  */
 abstract class WP_Webfonts_Provider {
 
+	/**
+	 * The provider's unique ID.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var string
+	 */
+	protected $id = '';
+
 	/**
 	 * Webfonts to be processed.
 	 *
-	 * @since 6.0.0
+	 * @since X.X.X
 	 *
 	 * @var array[]
 	 */
 	protected $webfonts = array();
 
+	/**
+	 * Array of Font-face style tag's attribute(s)
+	 * where the key is the attribute name and the
+	 * value is its value.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var string[]
+	 */
+	protected $style_tag_atts = array();
+
 	/**
 	 * Sets this provider's webfonts property.
 	 *
 	 * The API's Controller passes this provider's webfonts
 	 * for processing here in the provider.
 	 *
-	 * @since 6.0.0
+	 * @since X.X.X
 	 *
 	 * @param array[] $webfonts Registered webfonts.
 	 */
@@ -57,6 +77,18 @@ public function set_webfonts( array $webfonts ) {
 		$this->webfonts = $webfonts;
 	}
 
+	/**
+	 * Prints the generated styles.
+	 *
+	 * @since X.X.X
+	 */
+	public function print_styles() {
+		printf(
+			$this->get_style_element(),
+			$this->get_css()
+		);
+	}
+
 	/**
 	 * Gets the `@font-face` CSS for the provider's webfonts.
 	 *
@@ -64,9 +96,37 @@ public function set_webfonts( array $webfonts ) {
 	 * needed `@font-face` CSS for all of its webfonts. Specifics of how
 	 * this processing is done is contained in each provider.
 	 *
-	 * @since 6.0.0
+	 * @since X.X.X
 	 *
 	 * @return string The `@font-face` CSS.
 	 */
 	abstract public function get_css();
+
+	/**
+	 * Gets the `<style>` element for wrapping the `@font-face` CSS.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string The style element.
+	 */
+	protected function get_style_element() {
+		$attributes = $this->generate_style_element_attributes();
+
+		return "<style id='wp-webfonts-{$this->id}'{$attributes}>\n%s\n</style>\n";
+	}
+
+	/**
+	 * Gets the defined <style> element's attributes.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string A string of attribute=value when defined, else, empty string.
+	 */
+	private function generate_style_element_attributes() {
+		$attributes = '';
+		foreach ( $this->style_tag_atts as $name => $value ) {
+			$attributes .= " {$name}='{$value}'";
+		}
+		return $attributes;
+	}
 }
diff --git a/lib/experimental/class-wp-webfonts-utils.php b/lib/experimental/class-wp-webfonts-utils.php
new file mode 100644
index 00000000000000..3c086a974ab9d0
--- /dev/null
+++ b/lib/experimental/class-wp-webfonts-utils.php
@@ -0,0 +1,122 @@
+<?php
+/**
+ * Webfont API's utility helpers.
+ *
+ * @package    WordPress
+ * @subpackage WebFonts
+ * @since      X.X.X
+ */
+
+if ( class_exists( 'WP_Webfonts_Utils' ) ) {
+	return;
+}
+
+/**
+ * Utility helpers for the Webfonts API.
+ *
+ * @since X.X.X
+ */
+class WP_Webfonts_Utils {
+
+	/**
+	 * Converts the given font family into a handle.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family Font family to convert into a handle.
+	 * @return string|null The font family handle on success. Else, null.
+	 */
+	public static function convert_font_family_into_handle( $font_family ) {
+		if ( ! self::is_defined( $font_family ) ) {
+			return null;
+		}
+
+		// If the font-family is a comma-separated list (example: "Inter, sans-serif" ), use just the first font.
+		if ( str_contains( $font_family, ',' ) ) {
+			$font_family = explode( ',', $font_family )[0];
+		}
+
+		return sanitize_title( $font_family );
+	}
+
+	/**
+	 * Converts the given variation and its font-family into a handle.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $font_family The font family's handle for this variation.
+	 * @param array  $variation   An array of variation properties.
+	 * @return string|null The variation handle.
+	 */
+	public static function convert_variation_into_handle( $font_family, array $variation ) {
+		$handle = '';
+		foreach ( array( 'font-weight', 'font-style' ) as $property ) {
+			if ( ! array_key_exists( $property, $variation ) || ! static::is_defined( $variation[ $property ] ) ) {
+				continue;
+			}
+
+			$handle .= ' ' . $variation[ $property ];
+		}
+
+		if ( '' === $handle ) {
+			trigger_error( 'Variant handle could not be determined as font-weight and/or font-style are require' );
+			return null;
+		}
+
+		return sanitize_title( $font_family . $handle );
+	}
+
+	/**
+	 * Gets the font family from the variation.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $variation An array of variation properties to search.
+	 * @return string|null The font family if defined. Else, null.
+	 */
+	public static function get_font_family_from_variation( array $variation ) {
+		return static::search_for_font_family( $variation );
+	}
+
+	/**
+	 * Checks if the given input is defined, i.e. meaning is a non-empty string.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $input The input to check.
+	 * @return bool True when non-empty string. Else false.
+	 */
+	public static function is_defined( $input ) {
+		return ( is_string( $input ) && ! empty( $input ) );
+	}
+
+	/**
+	 * Searches the variation array to extract the font family.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $haystack An array of variation properties to search.
+	 * @return string|null The font family when found. Else, null.
+	 */
+	private static function search_for_font_family( array $haystack ) {
+		if ( array_key_exists( 'fontFamily', $haystack ) ) {
+			$key = 'fontFamily';
+		} elseif ( array_key_exists( 'font-family', $haystack ) ) {
+			$key = 'font-family';
+		} else {
+			trigger_error( 'Font family not found.' );
+			return null;
+		}
+
+		if ( static::is_defined( $haystack[ $key ] ) ) {
+			// If the font-family is a comma-separated list (example: "Inter, sans-serif" ), use just the first font.
+			if ( strpos( $haystack[ $key ], ',' ) !== false ) {
+				return explode( ',', $haystack[ $key ] )[0];
+			}
+			return $haystack[ $key ];
+		}
+
+		trigger_error( 'Font family not defined in the variation.' );
+		return null;
+	}
+}
diff --git a/lib/experimental/class-wp-webfonts.php b/lib/experimental/class-wp-webfonts.php
index 0c0cb06a27ffb3..fd00d39cfc5bf8 100644
--- a/lib/experimental/class-wp-webfonts.php
+++ b/lib/experimental/class-wp-webfonts.php
@@ -1,10 +1,15 @@
 <?php
 /**
- * Webfonts API class.
+ * Webfonts API class: backwards-compatibility (BC) layer for all
+ * deprecated publicly exposed methods and functionality.
  *
- * @package    WordPress
+ * This class/file will NOT be backported to Core. Rather for sites
+ * using the previous API, it exists to prevent breakages, giving
+ * developers time to upgrade their code.
+ *
+ * @since      X.X.X
  * @subpackage WebFonts
- * @since      6.0.0
+ * @package    WordPress
  */
 
 if ( class_exists( 'WP_Webfonts' ) ) {
@@ -14,411 +19,277 @@
 /**
  * Class WP_Webfonts
  *
- * @since 6.0.0
+ * BACKPORT NOTE: Do not backport this file to Core.
+ * This class exists to give extenders guidance and time to upgrade their code
+ * to use the new Web Fonts API.
  */
-class WP_Webfonts {
+class WP_Webfonts extends WP_Dependencies {
 
 	/**
-	 * An array of registered webfonts.
-	 *
-	 * @since 6.0.0
+	 * Gets the font slug.
 	 *
-	 * @var array[]
-	 */
-	private $registered_webfonts = array();
-
-	/**
-	 * An array of enqueued webfonts.
+	 * @since X.X.X
+	 * @deprecated Use WP_Webfonts_Utils::convert_font_family_into_handle() or WP_Webfonts_Utils::get_font_family_from_variation().
 	 *
-	 * @var array[]
-	 */
-	private $enqueued_webfonts = array();
-
-	/**
-	 * An array of registered providers.
-	 *
-	 * @since 6.0.0
-	 *
-	 * @var array
+	 * @param array|string $to_convert The value to convert into a slug. Expected as the web font's array
+	 *                                 or a font-family as a string.
+	 * @return string|false The font slug on success, or false if the font-family cannot be determined.
 	 */
-	private $providers = array();
+	public static function get_font_slug( $to_convert ) {
+		$message = is_array( $to_convert )
+			? 'Use WP_Webfonts_Utils::get l_font_family_from_variation() to get the font family from an array and then WP_Webfonts_Utils::convert_font_family_into_handle() to convert the font-family name into a handle'
+			: 'Use WP_Webfonts_Utils::convert_font_family_into_handle() to convert the font-family name into a handle';
+		_deprecated_function( __METHOD__, 'X.X.X', $message );
 
-	/**
-	 * Stylesheet handle.
-	 *
-	 * @since 6.0.0
-	 *
-	 * @var string
-	 */
-	private $stylesheet_handle = '';
+		return static::_get_font_slug( $to_convert );
+	}
 
 	/**
-	 * Init.
+	 * Initializes the API.
 	 *
 	 * @since 6.0.0
+	 * @deprecated X.X.X Use wp_webfonts().
 	 */
-	public function init() {
-		// Register default providers.
-		$this->register_provider( 'local', 'WP_Webfonts_Provider_Local' );
-
-		// Register callback to generate and enqueue styles.
-		if ( did_action( 'wp_enqueue_scripts' ) ) {
-			$this->stylesheet_handle = 'webfonts-footer';
-			$hook                    = 'wp_print_footer_scripts';
-		} else {
-			$this->stylesheet_handle = 'webfonts';
-			$hook                    = 'wp_enqueue_scripts';
-		}
-		add_action( $hook, array( $this, 'generate_and_enqueue_styles' ) );
-
-		// Enqueue webfonts in the block editor.
-		add_action( 'admin_init', array( $this, 'generate_and_enqueue_editor_styles' ) );
+	public static function init() {
+		_deprecated_function( __METHOD__, 'X.X.X', 'wp_webfonts()' );
 	}
 
 	/**
-	 * Get the list of registered fonts.
+	 * Gets the list of registered fonts.
 	 *
 	 * @since 6.0.0
+	 * @deprecated X.X.X Use wp_webfonts()->get_registered().
 	 *
 	 * @return array[]
 	 */
 	public function get_registered_webfonts() {
-		return $this->registered_webfonts;
+		_deprecated_function( __METHOD__, 'X.X.X', 'wp_webfonts()->get_registered()' );
+
+		return $this->_get_registered_webfonts();
 	}
 
 	/**
-	 * Get the list of enqueued fonts.
+	 * Gets the list of enqueued fonts.
+	 *
+	 * @since 6.0.0
+	 * @deprecated X.X.X Use wp_webfonts()->get_enqueued().
 	 *
 	 * @return array[]
 	 */
 	public function get_enqueued_webfonts() {
-		return $this->enqueued_webfonts;
-	}
+		_deprecated_function( __METHOD__, 'X.X.X', 'wp_webfonts()->get_enqueued()' );
 
-	/**
-	 * Get the list of all fonts.
-	 *
-	 * @return array[]
-	 */
-	public function get_all_webfonts() {
-		return array_merge( $this->get_registered_webfonts(), $this->get_enqueued_webfonts() );
+		return $this->queue;
 	}
 
 	/**
-	 * Get the list of providers.
+	 * Gets the list of all fonts.
 	 *
 	 * @since 6.0.0
+	 * @deprecated X.X.X Use wp_webfonts()->get_registered().
 	 *
-	 * @return WP_Webfonts_Provider[] All registered providers, each keyed by their unique ID.
+	 * @return array[]
 	 */
-	public function get_providers() {
-		return $this->providers;
+	public function get_all_webfonts() {
+		_deprecated_function( __METHOD__, 'X.X.X', 'wp_webfonts()->get_registered()' );
+
+		return $this->_get_registered_webfonts();
 	}
 
 	/**
-	 * Register a webfont.
+	 * Registers a webfont.
 	 *
 	 * @since 6.0.0
+	 * @deprecated X.X.X Use wp_register_webfonts().
 	 *
-	 * @param array $webfont Webfont to be registered.
+	 * @param array  $webfont             Web font to register.
+	 * @param string $font_family_handle  Optional. Font family handle for the given variation.
+	 *                                    Default empty string.
+	 * @param string $variation_handle    Optional. Handle for the variation to register.
+	 * @param bool   $silence_deprecation Optional. Silences the deprecation notice. For internal use.
 	 * @return string|false The font family slug if successfully registered, else false.
 	 */
-	public function register_webfont( array $webfont ) {
-		$webfont = $this->validate_webfont( $webfont );
-
-		// If not valid, bail out.
-		if ( ! $webfont ) {
-			return false;
+	public function register_webfont( array $webfont, $font_family_handle = '', $variation_handle = '', $silence_deprecation = false ) {
+		if ( ! $silence_deprecation ) {
+			_deprecated_function( __METHOD__, 'X.X.X', 'wp_register_webfonts()' );
 		}
 
-		$slug = $this->get_font_slug( $webfont );
+		// When font family's handle is not passed, attempt to get it from the variation.
+		if ( ! WP_Webfonts_Utils::is_defined( $font_family_handle ) ) {
+			$font_family = WP_Webfonts_Utils::get_font_family_from_variation( $webfont );
+			if ( $font_family ) {
+				$font_family_handle = WP_Webfonts_Utils::convert_font_family_into_handle( $font_family );
+			}
+		}
 
-		// Initialize a new font-family collection.
-		if ( ! isset( $this->registered_webfonts[ $slug ] ) ) {
-			$this->registered_webfonts[ $slug ] = array();
+		if ( empty( $font_family_handle ) ) {
+			return false;
 		}
 
-		$this->registered_webfonts[ $slug ][] = $webfont;
-		return $slug;
+		return $this->add_variation( $font_family_handle, $webfont, $variation_handle )
+			? $font_family_handle
+			: false;
 	}
 
 	/**
 	 * Enqueue a font-family that has been already registered.
 	 *
+	 * @since 6.0.0
+	 * @deprecated X.X.X Use wp_enqueue_webfonts().
+	 *
 	 * @param string $font_family_name The font family name to be enqueued.
 	 * @return bool True if successfully enqueued, else false.
 	 */
 	public function enqueue_webfont( $font_family_name ) {
-		$slug = $this->get_font_slug( $font_family_name );
-
-		if ( isset( $this->enqueued_webfonts[ $slug ] ) ) {
-			return true;
-		}
-
-		if ( ! isset( $this->registered_webfonts[ $slug ] ) ) {
-			/* translators: %s unique slug to identify the font family of the webfont */
-			_doing_it_wrong( __METHOD__, sprintf( __( 'The "%s" font family is not registered.', 'gutenberg' ), $slug ), '6.0.0' );
-
-			return false;
-		}
+		_deprecated_function( __METHOD__, 'X.X.X', 'wp_enqueue_webfonts()' );
 
-		$this->enqueued_webfonts[ $slug ] = $this->registered_webfonts[ $slug ];
-		unset( $this->registered_webfonts[ $slug ] );
+		wp_enqueue_webfonts( array( $font_family_name ) );
 		return true;
 	}
 
 	/**
-	 * Get the font slug.
-	 *
-	 * @since 6.0.0
+	 * Migrates deprecated webfonts structure into new API data structure,
+	 * i.e. variations grouped by their font-family.
 	 *
-	 * @param array|string $to_convert The value to convert into a slug. Expected as the web font's array
-	 *                                 or a font-family as a string.
-	 * @return string|false The font slug on success, or false if the font-family cannot be determined.
+	 * @param array $webfonts Array of webfonts to migrate.
+	 * @return array
 	 */
-	public static function get_font_slug( $to_convert ) {
-		if ( is_array( $to_convert ) ) {
-			if ( isset( $to_convert['slug'] ) ) {
-				return $to_convert['slug'];
-			} elseif ( isset( $to_convert['font-family'] ) ) {
-				$to_convert = $to_convert['font-family'];
-			} elseif ( isset( $to_convert['fontFamily'] ) ) {
-				$to_convert = $to_convert['fontFamily'];
-			} else {
-				_doing_it_wrong( __METHOD__, __( 'Could not determine the font family name.', 'gutenberg' ), '6.0.0' );
-				return false;
+	public function migrate_deprecated_structure( array $webfonts ) {
+		$message = 'A deprecated web fonts array structure passed to wp_register_webfonts(). ' .
+			'Variations must be grouped and keyed by their font family.';
+		trigger_error( $message, E_USER_DEPRECATED );
+
+		$new_webfonts = array();
+		foreach ( $webfonts as $webfont ) {
+			$font_family = WP_Webfonts_Utils::get_font_family_from_variation( $webfont );
+			if ( ! $font_family ) {
+				continue;
+			}
+
+			if ( ! isset( $new_webfonts[ $font_family ] ) ) {
+				$new_webfonts[ $font_family ] = array();
 			}
-		}
 
-		// If the font-family is a comma-separated list (example: "Inter, sans-serif" ), use just the first font.
-		if ( strpos( $to_convert, ',' ) !== false ) {
-			$to_convert = explode( ',', $to_convert )[0];
+			$new_webfonts[ $font_family ][] = $webfont;
 		}
 
-		return sanitize_title( $to_convert );
+		return $new_webfonts;
 	}
 
 	/**
-	 * Validate a webfont.
+	 * Determines if the given webfonts array is the deprecated array structure.
 	 *
-	 * @since 6.0.0
-	 *
-	 * @param array $webfont The webfont arguments.
-	 *
-	 * @return array|false The validated webfont arguments, or false if the webfont is invalid.
+	 * @param array $webfonts Array of webfonts to check.
+	 * @return bool True when deprecated structure, else false.
 	 */
-	public function validate_webfont( $webfont ) {
-		$webfont = wp_parse_args(
-			$webfont,
-			array(
-				'provider'     => 'local',
-				'font-family'  => '',
-				'font-style'   => 'normal',
-				'font-weight'  => '400',
-				'font-display' => 'fallback',
-			)
-		);
-
-		// Check the font-family.
-		if ( empty( $webfont['font-family'] ) || ! is_string( $webfont['font-family'] ) ) {
-			trigger_error( __( 'Webfont font family must be a non-empty string.', 'gutenberg' ) );
-			return false;
-		}
-
-		// Local fonts need a "src".
-		if ( 'local' === $webfont['provider'] ) {
-			// Make sure that local fonts have 'src' defined.
-			if ( empty( $webfont['src'] ) || ( ! is_string( $webfont['src'] ) && ! is_array( $webfont['src'] ) ) ) {
-				trigger_error( __( 'Webfont src must be a non-empty string or an array of strings.', 'gutenberg' ) );
-				return false;
-			}
-		}
-
-		// Validate the 'src' property.
-		if ( ! empty( $webfont['src'] ) ) {
-			foreach ( (array) $webfont['src'] as $src ) {
-				if ( empty( $src ) || ! is_string( $src ) ) {
-					trigger_error( __( 'Each webfont src must be a non-empty string.', 'gutenberg' ) );
-					return false;
-				}
-			}
-		}
-
-		// Check the font-weight.
-		if ( ! is_string( $webfont['font-weight'] ) && ! is_int( $webfont['font-weight'] ) ) {
-			trigger_error( __( 'Webfont font weight must be a properly formatted string or integer.', 'gutenberg' ) );
-			return false;
+	public function is_deprecated_structure( array $webfonts ) {
+		// Checks the first key to determine if it's empty or non-string.
+		foreach ( $webfonts as $font_family => $variations ) {
+			return ! WP_Webfonts_Utils::is_defined( $font_family );
 		}
+	}
 
-		// Check the font-display.
-		if ( ! in_array( $webfont['font-display'], array( 'auto', 'block', 'fallback', 'swap', 'optional' ), true ) ) {
-			$webfont['font-display'] = 'fallback';
-		}
+	/**
+	 * Handle the deprecated web fonts structure.
+	 *
+	 * @param array  $webfont Web font for extracting font family.
+	 * @param string $message Deprecation message to throw.
+	 * @return string|null The font family slug if successfully registered. Else null.
+	 */
+	protected function extract_font_family_from_deprecated_webfonts_structure( array $webfont, $message ) {
+		trigger_error( $message, E_USER_DEPRECATED );
 
-		$valid_props = array(
-			'ascent-override',
-			'descent-override',
-			'font-display',
-			'font-family',
-			'font-stretch',
-			'font-style',
-			'font-weight',
-			'font-variant',
-			'font-feature-settings',
-			'font-variation-settings',
-			'line-gap-override',
-			'size-adjust',
-			'src',
-			'unicode-range',
-
-			// Exceptions.
-			'provider',
-		);
-
-		foreach ( $webfont as $prop => $value ) {
-			if ( ! in_array( $prop, $valid_props, true ) ) {
-				unset( $webfont[ $prop ] );
-			}
+		$font_family = WP_Webfonts_Utils::get_font_family_from_variation( $webfont );
+		if ( ! $font_family ) {
+			return null;
 		}
 
-		return $webfont;
+		return WP_Webfonts_Utils::convert_font_family_into_handle( $font_family );
 	}
 
 	/**
-	 * Register a provider.
+	 * Gets the font slug.
 	 *
-	 * @since 6.0.0
+	 * Helper function for reuse without the deprecation.
 	 *
-	 * @param string $provider The provider name.
-	 * @param string $class    The provider class name.
-	 * @return bool True if successfully registered, else false.
+	 * @param array|string $to_convert The value to convert into a slug. Expected as the web font's array
+	 *                                 or a font-family as a string.
+	 * @return string|false The font slug on success, or false if the font-family cannot be determined.
 	 */
-	public function register_provider( $provider, $class ) {
-		if ( empty( $provider ) || empty( $class ) ) {
-			return false;
-		}
-		$this->providers[ $provider ] = $class;
-		return true;
+	private static function _get_font_slug( $to_convert ) {
+		$font_family_name = is_array( $to_convert ) ? WP_Webfonts_Utils::get_font_family_from_variation( $to_convert ) : $to_convert;
+		return ! empty( $font_family_name )
+			? WP_Webfonts_Utils::convert_font_family_into_handle( $font_family_name )
+			: false;
 	}
 
 	/**
-	 * Generate and enqueue webfonts styles.
+	 * Gets the registered webfonts in the original web font property structure keyed by each handle.
 	 *
-	 * @since 6.0.0
+	 * @return array[]
 	 */
-	public function generate_and_enqueue_styles() {
-		// Generate the styles.
-		$webfonts = $this->get_webfonts_by_provider( $this->get_enqueued_webfonts() );
-		$styles   = $this->generate_styles( $webfonts );
-
-		// Bail out if there are no styles to enqueue.
-		if ( '' === $styles ) {
-			return;
-		}
+	private function _get_registered_webfonts() {
+		$font_families = array();
+		$registered    = array();
 
-		// Enqueue the stylesheet.
-		wp_register_style( $this->stylesheet_handle, '' );
-		wp_enqueue_style( $this->stylesheet_handle );
+		// Find the registered font families.
+		foreach ( $this->registered as $handle => $obj ) {
+			if ( ! $obj->extra['is_font_family'] ) {
+				continue;
+			}
 
-		// Add the styles to the stylesheet.
-		wp_add_inline_style( $this->stylesheet_handle, $styles );
-	}
+			if ( ! isset( $registered[ $handle ] ) ) {
+				$registered[ $handle ] = array();
+			}
 
-	/**
-	 * Generate and enqueue editor styles.
-	 *
-	 * @since 6.0.0
-	 */
-	public function generate_and_enqueue_editor_styles() {
-		// Generate the styles.
-		$webfonts = $this->get_webfonts_by_provider( $this->get_all_webfonts() );
-		$styles   = $this->generate_styles( $webfonts );
-
-		// Bail out if there are no styles to enqueue.
-		if ( '' === $styles ) {
-			return;
+			$font_families[ $handle ] = $obj->deps;
+		}
+
+		// Build the return array structure.
+		foreach ( $font_families as $font_family_handle => $variations ) {
+			foreach ( $variations as $variation_handle ) {
+				$variation_obj = $this->registered[ $variation_handle ];
+
+				$registered[ $font_family_handle ][ $variation_handle ] = $variation_obj->extra['font-properties'];
+			}
 		}
 
-		wp_enqueue_style( 'wp-block-library' );
-		wp_add_inline_style( 'wp-block-library', $styles );
+		return $registered;
 	}
 
 	/**
-	 * Generate styles for webfonts.
-	 *
-	 * @since 6.0.0
+	 * Gets the enqueued webfonts in the original web font property structure keyed by each handle.
 	 *
-	 * @param array[] $webfonts_by_provider Webfonts organized by provider.
-	 * @return string $styles Generated styles.
+	 * @return array[]
 	 */
-	private function generate_styles( array $webfonts_by_provider ) {
-		$styles    = '';
-		$providers = $this->get_providers();
-
-		/*
-		 * Loop through each of the providers to get the CSS for their respective webfonts
-		 * to incrementally generate the collective styles for all of them.
-		 */
-		foreach ( $providers as $provider_id => $provider_class ) {
-
-			// Bail out if the provider class does not exist.
-			if ( ! class_exists( $provider_class ) ) {
-				/* translators: %s is the provider name. */
-				trigger_error( sprintf( __( 'Webfont provider "%s" is not registered.', 'gutenberg' ), $provider_id ) );
+	private function _get_enqueued_webfonts() {
+		$enqueued = array();
+		foreach ( $this->queue as $handle ) {
+			// Skip if not registered.
+			if ( ! isset( $this->registered[ $handle ] ) ) {
 				continue;
 			}
 
-			$provider_webfonts = isset( $webfonts_by_provider[ $provider_id ] )
-				? $webfonts_by_provider[ $provider_id ]
-				: array();
-
-			// If there are no registered webfonts for this provider, skip it.
-			if ( empty( $provider_webfonts ) ) {
+			// Skip if already found.
+			if ( isset( $enqueued[ $handle ] ) ) {
 				continue;
 			}
 
-			/*
-			 * Process the webfonts by first passing them to the provider via `set_webfonts()`
-			 * and then getting the CSS from the provider.
-			 */
-			$provider = new $provider_class();
-			$provider->set_webfonts( $provider_webfonts );
-			$styles .= $provider->get_css();
-		}
-
-		return $styles;
-	}
+			$obj = $this->registered[ $handle ];
 
+			// If a variation, add it.
+			if ( ! $obj->extra['is_font_family'] ) {
+				$enqueued[ $handle ] = $obj->extra['font-properties'];
+				continue;
+			}
 
-	/**
-	 * Reorganizes webfonts grouped by font-family into grouped by provider.
-	 *
-	 * @param array[] $font_families Font families and each of their webfonts.
-	 * @return array[] Webfonts organized by providers.
-	 */
-	private function get_webfonts_by_provider( array $font_families ) {
-		$providers            = $this->get_providers();
-		$webfonts_by_provider = array();
-
-		foreach ( $font_families as $webfonts ) {
-			foreach ( $webfonts as $webfont ) {
-				$provider = $webfont['provider'];
-
-				// Skip if the provider is not registered.
-				if ( ! isset( $providers[ $provider ] ) ) {
-					/* translators: %s is the provider name. */
-					trigger_error( sprintf( __( 'Webfont provider "%s" is not registered.', 'gutenberg' ), $provider ) );
-					continue;
-				}
-
-				// Initialize a new provider collection.
-				if ( ! isset( $webfonts_by_provider[ $provider ] ) ) {
-					$webfonts_by_provider[ $provider ] = array();
-				}
-				$webfonts_by_provider[ $provider ][] = $webfont;
+			// If font-family, add all of its variations.
+			foreach ( $obj->deps as $variation_handle ) {
+				$obj                           = $this->registered[ $variation_handle ];
+				$enqueued[ $variation_handle ] = $obj->extra['font-properties'];
 			}
 		}
 
-		return $webfonts_by_provider;
+		return $enqueued;
 	}
 }
diff --git a/lib/experimental/register-webfonts-from-theme-json.php b/lib/experimental/register-webfonts-from-theme-json.php
index f0a37677eb0637..4b49f6e0534fa3 100644
--- a/lib/experimental/register-webfonts-from-theme-json.php
+++ b/lib/experimental/register-webfonts-from-theme-json.php
@@ -5,173 +5,174 @@
  * @package gutenberg
  */
 
-/**
- * Register webfonts defined in theme.json.
- */
-function gutenberg_register_webfonts_from_theme_json() {
-	// Get settings.
-	$settings = WP_Theme_JSON_Resolver_Gutenberg::get_merged_data()->get_settings();
-
-	// If in the editor, add webfonts defined in variations.
-	if ( is_admin() || ( defined( 'REST_REQUEST' ) && REST_REQUEST ) ) {
-		$variations = WP_Theme_JSON_Resolver_Gutenberg::get_style_variations();
-
-		foreach ( $variations as $variation ) {
-
-			// Sanity check: Skip if fontFamilies are not defined in the variation.
-			if (
-				empty( $variation['settings'] ) ||
-				empty( $variation['settings']['typography'] ) ||
-				empty( $variation['settings']['typography']['fontFamilies'] )
-			) {
-				continue;
-			}
+if ( ! function_exists( 'gutenberg_register_webfonts_from_theme_json' ) ) {
+	/**
+	 * Register webfonts defined in theme.json.
+	 */
+	function gutenberg_register_webfonts_from_theme_json() {
+		// Get settings.
+		$settings = WP_Theme_JSON_Resolver_Gutenberg::get_merged_data()->get_settings();
+
+		// If in the editor, add webfonts defined in variations.
+		if ( is_admin() || ( defined( 'REST_REQUEST' ) && REST_REQUEST ) ) {
+			$variations = WP_Theme_JSON_Resolver_Gutenberg::get_style_variations();
+
+			foreach ( $variations as $variation ) {
+
+				// Sanity check: Skip if fontFamilies are not defined in the variation.
+				if (
+					empty( $variation['settings'] ) ||
+					empty( $variation['settings']['typography'] ) ||
+					empty( $variation['settings']['typography']['fontFamilies'] )
+				) {
+					continue;
+				}
 
-			// Merge the variation settings with the global settings.
-			$settings['typography']                          = empty( $settings['typography'] ) ? array() : $settings['typography'];
-			$settings['typography']['fontFamilies']          = empty( $settings['typography']['fontFamilies'] ) ? array() : $settings['typography']['fontFamilies'];
-			$settings['typography']['fontFamilies']['theme'] = empty( $settings['typography']['fontFamilies'] ) ? array() : $settings['typography']['fontFamilies']['theme'];
-			$settings['typography']['fontFamilies']['theme'] = array_merge( $settings['typography']['fontFamilies']['theme'], $variation['settings']['typography']['fontFamilies']['theme'] );
+				// Merge the variation settings with the global settings.
+				$settings['typography']                          = empty( $settings['typography'] ) ? array() : $settings['typography'];
+				$settings['typography']['fontFamilies']          = empty( $settings['typography']['fontFamilies'] ) ? array() : $settings['typography']['fontFamilies'];
+				$settings['typography']['fontFamilies']['theme'] = empty( $settings['typography']['fontFamilies'] ) ? array() : $settings['typography']['fontFamilies']['theme'];
+				$settings['typography']['fontFamilies']['theme'] = array_merge( $settings['typography']['fontFamilies']['theme'], $variation['settings']['typography']['fontFamilies']['theme'] );
 
-			// Make sure there are no duplicates.
-			$settings['typography']['fontFamilies'] = array_unique( $settings['typography']['fontFamilies'] );
+				// Make sure there are no duplicates.
+				$settings['typography']['fontFamilies'] = array_unique( $settings['typography']['fontFamilies'] );
+			}
 		}
-	}
-
-	// Bail out early if there are no settings for webfonts.
-	if ( empty( $settings['typography'] ) || empty( $settings['typography']['fontFamilies'] ) ) {
-		return;
-	}
-
-	$webfonts = array();
 
-	// Look for fontFamilies.
-	foreach ( $settings['typography']['fontFamilies'] as $font_families ) {
-		foreach ( $font_families as $font_family ) {
+		// Bail out early if there are no settings for webfonts.
+		if ( empty( $settings['typography'] ) || empty( $settings['typography']['fontFamilies'] ) ) {
+			return;
+		}
 
-			// Skip if fontFace is not defined.
-			if ( empty( $font_family['fontFace'] ) ) {
-				continue;
-			}
+		$webfonts = array();
+		$handles  = array();
 
-			$font_family['fontFace'] = (array) $font_family['fontFace'];
+		// Look for fontFamilies.
+		foreach ( $settings['typography']['fontFamilies'] as $font_families ) {
+			foreach ( $font_families as $font_family ) {
 
-			foreach ( $font_family['fontFace'] as $font_face ) {
-				// Skip if the webfont was registered through the Webfonts API.
-				if ( isset( $font_face['origin'] ) && 'gutenberg_wp_webfonts_api' === $font_face['origin'] ) {
+				// Skip if fontFace is not defined.
+				if ( empty( $font_family['fontFace'] ) ) {
 					continue;
 				}
 
-				// Check if webfonts have a "src" param, and if they do account for the use of "file:./".
-				if ( ! empty( $font_face['src'] ) ) {
-					$font_face['src'] = (array) $font_face['src'];
+				$font_family['fontFace'] = (array) $font_family['fontFace'];
+
+				foreach ( $font_family['fontFace'] as $font_face ) {
+					// Skip if the webfont was registered through the Webfonts API.
+					if ( isset( $font_face['origin'] ) && 'gutenberg_wp_webfonts_api' === $font_face['origin'] ) {
+						continue;
+					}
+
+					// Check if webfonts have a "src" param, and if they do account for the use of "file:./".
+					if ( ! empty( $font_face['src'] ) ) {
+						$font_face['src'] = (array) $font_face['src'];
 
-					foreach ( $font_face['src'] as $src_key => $url ) {
-						// Tweak the URL to be relative to the theme root.
-						if ( ! str_starts_with( $url, 'file:./' ) ) {
-							continue;
+						foreach ( $font_face['src'] as $src_key => $url ) {
+							// Tweak the URL to be relative to the theme root.
+							if ( ! str_starts_with( $url, 'file:./' ) ) {
+								continue;
+							}
+							$font_face['src'][ $src_key ] = get_theme_file_uri( str_replace( 'file:./', '', $url ) );
 						}
-						$font_face['src'][ $src_key ] = get_theme_file_uri( str_replace( 'file:./', '', $url ) );
 					}
-				}
 
-				// Convert keys to kebab-case.
-				foreach ( $font_face as $property => $value ) {
-					$kebab_case               = _wp_to_kebab_case( $property );
-					$font_face[ $kebab_case ] = $value;
-					if ( $kebab_case !== $property ) {
-						unset( $font_face[ $property ] );
+					// Convert keys to kebab-case.
+					foreach ( $font_face as $property => $value ) {
+						$kebab_case               = _wp_to_kebab_case( $property );
+						$font_face[ $kebab_case ] = $value;
+						if ( $kebab_case !== $property ) {
+							unset( $font_face[ $property ] );
+						}
+					}
+
+					$font_family_handle = WP_Webfonts_Utils::get_font_family_from_variation( $font_face );
+					if ( empty( $font_family_handle ) && isset( $font_family['slug'] ) ) {
+						$font_family_handle = $font_family['slug'];
+					}
+					if ( ! empty( $font_family_handle ) ) {
+						$font_family_handle = WP_Webfonts_Utils::convert_font_family_into_handle( $font_family_handle );
+					}
+					if ( empty( $font_family_handle ) ) {
+						_doing_it_wrong( __FUNCTION__, __( 'Font family not defined in the variation or "slug".', 'gutenberg' ), '6.1.0' );
+					}
+
+					$handles[] = $font_family_handle;
+					if ( ! array_key_exists( $font_family_handle, $webfonts ) ) {
+						$webfonts[ $font_family_handle ] = array();
 					}
-				}
 
-				$webfonts[] = $font_face;
+					$webfonts[ $font_family_handle ][] = $font_face;
+				}
 			}
 		}
-	}
-	foreach ( $webfonts as $webfont ) {
-		wp_webfonts()->register_webfont( $webfont );
-	}
-	foreach ( $webfonts as $webfont ) {
-		wp_webfonts()->enqueue_webfont( $webfont['font-family'] );
-	}
-}
 
-/**
- * Add missing fonts data to the global styles.
- *
- * @param array $data The global styles.
- * @return array The global styles with missing fonts data.
- */
-function gutenberg_add_registered_webfonts_to_theme_json( $data ) {
-	$font_families_registered = wp_webfonts()->get_all_webfonts();
-	$font_families_from_theme = array();
-	if ( ! empty( $data['settings'] ) && ! empty( $data['settings']['typography'] ) && ! empty( $data['settings']['typography']['fontFamilies'] ) ) {
-		$font_families_from_theme = $data['settings']['typography']['fontFamilies'];
+		wp_register_webfonts( $webfonts );
+		wp_enqueue_webfonts( $handles );
 	}
+}
 
+if ( ! function_exists( 'gutenberg_add_registered_webfonts_to_theme_json' ) ) {
 	/**
-	 * Helper to get an array of the font-families.
+	 * Add missing fonts data to the global styles.
 	 *
-	 * @param array $families_data The font-families data.
-	 * @return array The font-families array.
+	 * @param array $data The global styles.
+	 * @return array The global styles with missing fonts data.
 	 */
-	$get_families = static function( $families_data ) {
-		$families = array();
-		foreach ( $families_data as $family ) {
-			$families[] = WP_Webfonts::get_font_slug( $family );
-		}
-
-		// Micro-optimization: Use array_flip( array_flip( $array ) )
-		// instead of array_unique( $array ) because it's faster.
-		// The result is the same.
-		return array_flip( array_flip( $families ) );
-	};
+	function gutenberg_add_registered_webfonts_to_theme_json( $data ) {
+		$font_families_registered = wp_webfonts()->get_registered_font_families();
+		$font_families_from_theme = ! empty( $data['settings']['typography']['fontFamilies'] )
+			? $data['settings']['typography']['fontFamilies']
+			: array();
+
+		/**
+		 * Helper to get an array of the font-families.
+		 *
+		 * @param array $families_data The font-families data.
+		 * @return array The font-families array.
+		 */
+		$get_families = static function ( $families_data ) {
+			$families = array();
+			foreach ( $families_data as $family ) {
+				$font_family = WP_Webfonts_Utils::get_font_family_from_variation( $family );
+				$handle      = WP_Webfonts_Utils::convert_font_family_into_handle( $font_family );
+				if ( ! empty( $handle ) ) {
+					$families[ $handle ] = true;
+				}
+			}
 
-	// Diff the arrays to find the missing fonts.
-	$to_add = array_diff(
-		array_keys( $font_families_registered ),
-		$get_families( $font_families_from_theme )
-	);
+			return ! empty( $families ) ? array_keys( $families ) : array();
+		};
 
-	// Bail out early if there are no missing fonts.
-	if ( empty( $to_add ) ) {
-		return $data;
-	}
+		// Find missing fonts that are not in the theme's theme.json.
+		$to_add = array();
+		if ( ! empty( $font_families_registered ) ) {
+			$to_add = array_diff( $font_families_registered, $get_families( $font_families_from_theme ) );
+		}
 
-	// Make sure the path to settings.typography.fontFamilies.theme exists
-	// before adding missing fonts.
-	if ( empty( $data['settings'] ) ) {
-		$data['settings'] = array();
-	}
-	if ( empty( $data['settings']['typography'] ) ) {
-		$data['settings']['typography'] = array();
-	}
-	if ( empty( $data['settings']['typography']['fontFamilies'] ) ) {
-		$data['settings']['typography']['fontFamilies'] = array();
-	}
+		// Bail out early if there are no missing fonts.
+		if ( empty( $to_add ) ) {
+			return $data;
+		}
 
-	foreach ( $to_add as $slug ) {
-		$font_faces_for_family = $font_families_registered[ $slug ];
-		$family_name           = $font_faces_for_family[0]['font-family'];
-		$font_faces            = array();
+		// Make sure the path to settings.typography.fontFamilies.theme exists
+		// before adding missing fonts.
+		if ( empty( $data['settings'] ) ) {
+			$data['settings'] = array();
+		}
+		if ( empty( $data['settings']['typography'] ) ) {
+			$data['settings']['typography'] = array();
+		}
+		if ( empty( $data['settings']['typography']['fontFamilies'] ) ) {
+			$data['settings']['typography']['fontFamilies'] = array();
+		}
 
-		foreach ( $font_faces_for_family as $font_face ) {
-			$camel_cased = array( 'origin' => 'gutenberg_wp_webfonts_api' );
-			foreach ( $font_face as $key => $value ) {
-				$camel_cased[ lcfirst( str_replace( '-', '', ucwords( $key, '-' ) ) ) ] = $value;
-			}
-			$font_faces[] = $camel_cased;
+		foreach ( $to_add as $font_family_handle ) {
+			$data['settings']['typography']['fontFamilies'][] = wp_webfonts()->to_theme_json( $font_family_handle );
 		}
 
-		$data['settings']['typography']['fontFamilies'][] = array(
-			'fontFamily' => str_contains( $family_name, ' ' ) ? "'{$family_name}'" : $family_name,
-			'name'       => $family_name,
-			'slug'       => $slug,
-			'fontFace'   => $font_faces,
-		);
+		return $data;
 	}
-
-	return $data;
 }
 
 // `gutenberg_register_webfonts_from_theme_json()` calls `WP_Theme_JSON_Resolver_Gutenberg::get_merged_data()`, which instantiates `WP_Theme_JSON_Gutenberg()`;
diff --git a/lib/experimental/webfonts-deprecations.php b/lib/experimental/webfonts-deprecations.php
new file mode 100644
index 00000000000000..bd50b0f476d96a
--- /dev/null
+++ b/lib/experimental/webfonts-deprecations.php
@@ -0,0 +1,100 @@
+<?php
+/**
+ * Deprecated functions provided here to give extenders time to change
+ * their plugins/themes before this API is introduced into Core.
+ *
+ * BACKPORT NOTE: Do not backport these deprecated functions to Core.
+ *
+ * @since      X.X.X
+ * @subpackage WebFonts
+ * @package    WordPress
+ */
+
+if ( ! function_exists( 'wp_enqueue_webfont' ) ) {
+	/**
+	 * Enqueue a single font family that has been registered beforehand.
+	 *
+	 * Example of how to enqueue Source Serif Pro font:
+	 *
+	 * <code>
+	 * wp_enqueue_webfont( 'Source Serif Pro' );
+	 * </code>
+	 *
+	 * Font families should be enqueued from the `init` hook or later.
+	 *
+	 * @since 6.0.0
+	 * @deprecated X.X.X Use wp_enqueue_webfonts().
+	 *
+	 * @param string $font_family_name The font family name to be enqueued.
+	 * @return bool True if successfully enqueued, else false.
+	 */
+	function wp_enqueue_webfont( $font_family_name ) {
+		_deprecated_function( __FUNCTION__, 'X.X.X', 'wp_enqueue_webfonts()' );
+
+		wp_enqueue_webfonts( array( $font_family_name ) );
+		return true;
+	}
+}
+
+if ( ! function_exists( 'wp_register_webfont' ) ) {
+	/**
+	 * Registers a single webfont.
+	 *
+	 * Example of how to register Source Serif Pro font with font-weight range of 200-900:
+	 *
+	 * If the font file is contained within the theme:
+	 *
+	 * <code>
+	 * wp_register_webfont(
+	 *      array(
+	 *          'provider'    => 'local',
+	 *          'font-family' => 'Source Serif Pro',
+	 *          'font-weight' => '200 900',
+	 *          'font-style'  => 'normal',
+	 *          'src'         => get_theme_file_uri( 'assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2' ),
+	 *      )
+	 * );
+	 * </code>
+	 *
+	 * @since 6.0.0
+	 * @deprecated X.X.X Use wp_register_webfonts().
+	 *
+	 * @param array $webfont Webfont to be registered.
+	 * @return string|false The font family slug if successfully registered, else false.
+	 */
+	function wp_register_webfont( array $webfont ) {
+		_deprecated_function( __FUNCTION__, 'X.X.X', 'wp_register_webfonts()' );
+
+		return wp_webfonts()->register_webfont( $webfont, '', '', false );
+	}
+}
+
+if ( ! function_exists( 'wp_get_webfont_providers' ) ) {
+	/**
+	 * Gets all registered providers.
+	 *
+	 * Return an array of providers, each keyed by their unique
+	 * ID (i.e. the `$id` property in the provider's object) with
+	 * an instance of the provider (object):
+	 *     ID => provider instance
+	 *
+	 * Each provider contains the business logic for how to
+	 * process its specific font service (i.e. local or remote)
+	 * and how to generate the `@font-face` styles for its service.
+	 *
+	 * @since X.X.X
+	 * @deprecated X.X.X Use wp_webfonts()->get_providers().
+	 *
+	 * @return string[] All registered providers, each keyed by their unique ID.
+	 */
+	function wp_get_webfont_providers() {
+		_deprecated_function( __FUNCTION__, 'X.X.X', 'wp_webfonts()->get_providers()' );
+
+		$providers = array();
+		foreach ( wp_webfonts()->get_providers() as $id => $config ) {
+			$providers[ $id ] = $config['class'];
+		}
+
+		return $providers;
+	}
+}
diff --git a/lib/experimental/webfonts.php b/lib/experimental/webfonts.php
index 201101d1d7093e..c4ccc1640d9c83 100644
--- a/lib/experimental/webfonts.php
+++ b/lib/experimental/webfonts.php
@@ -4,23 +4,25 @@
  *
  * @package    WordPress
  * @subpackage WebFonts
- * @since      6.0.0
+ * @since      X.X.X
  */
 
 if ( ! function_exists( 'wp_webfonts' ) ) {
 	/**
-	 * Instantiates the webfonts controller, if not already set, and returns it.
+	 * Initialize $wp_webfonts if it has not been set.
 	 *
-	 * @since 6.0.0
+	 * @since X.X.X
+	 *
+	 * @global WP_Web_Fonts $wp_webfonts
 	 *
-	 * @return WP_Webfonts Instance of the controller.
+	 * @return WP_Web_Fonts WP_Web_Fonts instance.
 	 */
 	function wp_webfonts() {
 		global $wp_webfonts;
 
-		if ( ! $wp_webfonts instanceof WP_Webfonts ) {
-			$wp_webfonts = new WP_Webfonts();
-			$wp_webfonts->init();
+		if ( ! ( $wp_webfonts instanceof WP_Web_Fonts ) ) {
+			$wp_webfonts = new WP_Web_Fonts();
+			$wp_webfonts->register_provider( 'local', 'WP_Webfonts_Provider_Local' );
 		}
 
 		return $wp_webfonts;
@@ -29,132 +31,111 @@ function wp_webfonts() {
 
 if ( ! function_exists( 'wp_register_webfonts' ) ) {
 	/**
-	 * Registers a collection of webfonts.
-	 *
-	 * Example of how to register Source Serif Pro font with font-weight range of 200-900
-	 * and font-style of normal and italic:
-	 *
-	 * If the font files are contained within the theme:
-	 * <code>
-	 * wp_register_webfonts(
-	 *      array(
-	 *          array(
-	 *              'provider'    => 'local',
-	 *              'font-family' => 'Source Serif Pro',
-	 *              'font-weight' => '200 900',
-	 *              'font-style'  => 'normal',
-	 *              'src'         => get_theme_file_uri( 'assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2' ),
-	 *          ),
-	 *          array(
-	 *              'provider'    => 'local',
-	 *              'font-family' => 'Source Serif Pro',
-	 *              'font-weight' => '200 900',
-	 *              'font-style'  => 'italic',
-	 *              'src'         => get_theme_file_uri( 'assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2' ),
-	 *          ),
-	 *      )
-	 * );
-	 * </code>
-	 *
-	 * Webfonts should be registered in the `after_setup_theme` hook.
-	 *
-	 * @since 6.0.0
-	 *
-	 * @param array[] $webfonts Webfonts to be registered.
-	 *                        This contains an array of webfonts to be registered.
-	 *                        Each webfont is an array.
-	 * @return string[] The font family slug of the registered webfonts.
+	 * Registers one or more font-families and each of their variations.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array[] $webfonts {
+	 *     Web fonts to be registered, grouped by each font-family.
+	 *
+	 *     @type string $font-family => array[] $variations {
+	 *          An array of web font variations for this font-family.
+	 *          Each variation has the following structure.
+	 *
+	 *          @type array $variation {
+	 *              @type string $provider     The provider ID. Default 'local'.
+	 *              @type string $font-style   The font-style property. Default 'normal'.
+	 *              @type string $font-weight  The font-weight property. Default '400'.
+	 *              @type string $font-display The font-display property. Default 'fallback'.
+	 *         }
+	 *     }
+	 * }
+	 * @return string[] Array of registered font family handles.
 	 */
 	function wp_register_webfonts( array $webfonts ) {
-		$registered_webfont_slugs = array();
+		$registered  = array();
+		$wp_webfonts = wp_webfonts();
 
-		foreach ( $webfonts as $webfont ) {
-			$slug = wp_register_webfont( $webfont );
+		// BACKPORT NOTE: Do not backport this code block to Core.
+		if ( $wp_webfonts->is_deprecated_structure( $webfonts ) ) {
+			$webfonts = $wp_webfonts->migrate_deprecated_structure( $webfonts );
+		}
+		// BACKPORT NOTE: end of code block.
 
-			if ( is_string( $slug ) ) {
-				$registered_webfont_slugs[ $slug ] = true;
+		foreach ( $webfonts as $font_family => $variations ) {
+			$font_family_handle = $wp_webfonts->add_font_family( $font_family );
+			if ( ! $font_family_handle ) {
+				continue;
 			}
+
+			// Register each of the variations for this font family.
+			foreach ( $variations as $variation_handle => $variation ) {
+				if ( ! WP_Webfonts_Utils::is_defined( $variation_handle ) ) {
+					$variation_handle = '';
+				}
+
+				$wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+			}
+
+			$registered[] = $font_family_handle;
 		}
 
-		return array_keys( $registered_webfont_slugs );
+		return $registered;
 	}
 }
 
-if ( ! function_exists( 'wp_register_webfont' ) ) {
+if ( ! function_exists( 'wp_enqueue_webfonts' ) ) {
 	/**
-	 * Registers a single webfont.
+	 * Enqueues one or more font family and all of its variations.
 	 *
-	 * Example of how to register Source Serif Pro font with font-weight range of 200-900:
+	 * @since X.X.X
 	 *
-	 * If the font file is contained within the theme:
-	 *
-	 * <code>
-	 * wp_register_webfont(
-	 *      array(
-	 *          'provider'    => 'local',
-	 *          'font-family' => 'Source Serif Pro',
-	 *          'font-weight' => '200 900',
-	 *          'font-style'  => 'normal',
-	 *          'src'         => get_theme_file_uri( 'assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2' ),
-	 *      )
-	 * );
-	 * </code>
-	 *
-	 * @since 6.0.0
-	 *
-	 * @param array $webfont Webfont to be registered.
-	 * @return string|false The font family slug if successfully registered, else false.
+	 * @param string[] $font_families Font family(ies) to enqueue.
 	 */
-	function wp_register_webfont( array $webfont ) {
-		return wp_webfonts()->register_webfont( $webfont );
+	function wp_enqueue_webfonts( array $font_families ) {
+		$handles = array_map( array( WP_Webfonts_Utils::class, 'convert_font_family_into_handle' ), $font_families );
+
+		wp_webfonts()->enqueue( $handles );
 	}
 }
 
-if ( ! function_exists( 'wp_enqueue_webfonts' ) ) {
+if ( ! function_exists( 'wp_enqueue_webfont_variations' ) ) {
 	/**
-	 * Enqueues a collection of font families.
-	 *
-	 * Example of how to enqueue Source Serif Pro and Roboto font families, both registered beforehand.
-	 *
-	 * <code>
-	 * wp_enqueue_webfonts(
-	 *  'Roboto',
-	 *  'Sans Serif Pro'
-	 * );
-	 * </code>
+	 * Enqueues a specific set of web font variations.
 	 *
-	 * Font families should be enqueued from the `init` hook or later.
-	 *
-	 * @since 6.0.0
+	 * @since X.X.X
 	 *
-	 * @param string[] $webfonts Font families to be enqueued.
+	 * @param string|string[] $variation_handles Variation handle (string) or handles (array of strings).
 	 */
-	function wp_enqueue_webfonts( array $webfonts ) {
-		foreach ( $webfonts as $webfont ) {
-			wp_enqueue_webfont( $webfont );
-		}
+	function wp_enqueue_webfont_variations( $variation_handles ) {
+		wp_webfonts()->enqueue( $variation_handles );
 	}
 }
 
-if ( ! function_exists( 'wp_enqueue_webfont' ) ) {
+if ( ! function_exists( 'wp_deregister_font_family' ) ) {
 	/**
-	 * Enqueue a single font family that has been registered beforehand.
-	 *
-	 * Example of how to enqueue Source Serif Pro font:
+	 * Deregisters a font family and all of its registered variations.
 	 *
-	 * <code>
-	 * wp_enqueue_webfont( 'Source Serif Pro' );
-	 * </code>
+	 * @since X.X.X
 	 *
-	 * Font families should be enqueued from the `init` hook or later.
+	 * @param string $font_family_handle The font family to remove.
+	 */
+	function wp_deregister_font_family( $font_family_handle ) {
+		wp_webfonts()->remove_font_family( $font_family_handle );
+	}
+}
+
+if ( ! function_exists( 'wp_deregister_webfont_variation' ) ) {
+	/**
+	 * Deregisters a font variation.
 	 *
-	 * @since 6.0.0
+	 * @since X.X.X
 	 *
-	 * @param string $font_family_name The font family name to be enqueued.
-	 * @return bool True if successfully enqueued, else false.
+	 * @param string $font_family_handle The font family for this variation.
+	 * @param string $variation_handle   The variation's handle to remove.
 	 */
-	function wp_enqueue_webfont( $font_family_name ) {
-		return wp_webfonts()->enqueue_webfont( $font_family_name );
+	function wp_deregister_webfont_variation( $font_family_handle, $variation_handle ) {
+		wp_webfonts()->remove_variation( $font_family_handle, $variation_handle );
 	}
 }
 
@@ -189,28 +170,40 @@ function wp_register_webfont_provider( $name, $classname ) {
 	}
 }
 
-if ( ! function_exists( 'wp_get_webfont_providers' ) ) {
+if ( ! function_exists( 'wp_print_webfonts' ) ) {
 	/**
-	 * Gets all registered providers.
-	 *
-	 * Return an array of providers, each keyed by their unique
-	 * ID (i.e. the `$id` property in the provider's object) with
-	 * an instance of the provider (object):
-	 *     ID => provider instance
-	 *
-	 * Each provider contains the business logic for how to
-	 * process its specific font service (i.e. local or remote)
-	 * and how to generate the `@font-face` styles for its service.
+	 * Invokes each provider to process and print its styles.
 	 *
-	 * @since 6.0.0
+	 * @since X.X.X
 	 *
-	 * @return WP_Webfonts_Provider[] All registered providers, each keyed by their unique ID.
+	 * @param string|string[]|false $handles Optional. Items to be processed: queue (false),
+	 *                                       single item (string), or multiple items (array of strings).
+	 *                                       Default false.
+	 * @return array|string[] Array of web font handles that have been processed.
+	 *                        An empty array if none were processed.
 	 */
-	function wp_get_webfont_providers() {
-		return wp_webfonts()->get_providers();
+	function wp_print_webfonts( $handles = false ) {
+		global $wp_webfonts;
+
+		if ( empty( $handles ) ) {
+			$handles = false;
+		}
+
+		_wp_scripts_maybe_doing_it_wrong( __FUNCTION__ );
+
+		if ( ! ( $wp_webfonts instanceof WP_Web_Fonts ) ) {
+			if ( ! $handles ) {
+				return array(); // No need to instantiate if nothing is there.
+			}
+		}
+
+		return wp_webfonts()->do_items( $handles );
 	}
 }
 
+add_action( 'admin_print_styles', 'wp_print_webfonts', 50 );
+add_action( 'wp_head', 'wp_print_webfonts', 50 );
+
 /**
  * Add webfonts mime types.
  */
diff --git a/lib/load.php b/lib/load.php
index b700ec3f2a11d1..21b9e7acbc6b97 100644
--- a/lib/load.php
+++ b/lib/load.php
@@ -89,19 +89,25 @@ function gutenberg_is_experiment_enabled( $name ) {
 // Experimental features.
 remove_action( 'plugins_loaded', '_wp_theme_json_webfonts_handler' ); // Turns off WP 6.0's stopgap handler for Webfonts API.
 require __DIR__ . '/experimental/block-editor-settings-mobile.php';
-require __DIR__ . '/experimental/register-webfonts-from-theme-json.php';
 if ( ! class_exists( 'WP_HTML_Tag_Processor' ) ) {
 	require __DIR__ . '/experimental/html/index.php';
 }
 require __DIR__ . '/experimental/class-wp-theme-json-resolver-gutenberg.php';
-require __DIR__ . '/experimental/class-wp-webfonts.php';
-require __DIR__ . '/experimental/class-wp-webfonts-provider.php';
-require __DIR__ . '/experimental/class-wp-webfonts-provider-local.php';
-require __DIR__ . '/experimental/webfonts.php';
+require __DIR__ . '/experimental/blocks.php';
 require __DIR__ . '/experimental/navigation-theme-opt-in.php';
 require __DIR__ . '/experimental/navigation-page.php';
 require __DIR__ . '/experimental/kses.php';
 
+// Web Fonts API.
+require __DIR__ . '/experimental/webfonts-deprecations.php'; // Temporary deprecated functions.
+require __DIR__ . '/experimental/class-wp-webfonts.php'; // Temporary deprecated class.
+require __DIR__ . '/experimental/class-wp-webfonts-utils.php';
+require __DIR__ . '/experimental/register-webfonts-from-theme-json.php';
+require __DIR__ . '/experimental/class-wp-web-fonts.php';
+require __DIR__ . '/experimental/class-wp-webfonts-provider.php';
+require __DIR__ . '/experimental/class-wp-webfonts-provider-local.php';
+require __DIR__ . '/experimental/webfonts.php';
+
 // Plugin specific code.
 require __DIR__ . '/class-wp-theme-json-gutenberg.php';
 require __DIR__ . '/blocks.php';
diff --git a/phpunit/class-wp-webfonts-test.php b/phpunit/class-wp-webfonts-test.php
deleted file mode 100644
index 45732c6a265b4c..00000000000000
--- a/phpunit/class-wp-webfonts-test.php
+++ /dev/null
@@ -1,453 +0,0 @@
-<?php
-
-/**
- * @group  webfonts
- * @covers WP_Webfonts_Test
- */
-class WP_Webfonts_Test extends WP_UnitTestCase {
-	/**
-	 * WP_Webfonts instance reference
-	 *
-	 * @var WP_Webfonts
-	 */
-	private $old_wp_webfonts;
-
-	public function set_up() {
-		parent::set_up();
-
-		global $wp_webfonts;
-		$this->old_wp_webfonts = $wp_webfonts;
-
-		$wp_webfonts = null;
-	}
-
-	public function tear_down() {
-		global $wp_webfonts;
-
-		$wp_webfonts = $this->old_wp_webfonts;
-		parent::tear_down();
-	}
-
-	/**
-	 * Test wp_register_webfonts() bulk register webfonts.
-	 *
-	 * @covers wp_register_webfonts
-	 * @covers WP_Webfonts::register_font
-	 * @covers WP_Webfonts::get_registered_fonts
-	 * @covers WP_Webfonts::get_enqueued_fonts
-	 */
-	public function test_wp_register_webfonts() {
-		$font_family_name = 'Source Serif Pro';
-
-		$fonts = array(
-			array(
-				'provider'     => 'local',
-				'font-family'  => $font_family_name,
-				'font-style'   => 'normal',
-				'font-weight'  => '200 900',
-				'font-stretch' => 'normal',
-				'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-				'font-display' => 'fallback',
-			),
-			array(
-				'provider'     => 'local',
-				'font-family'  => $font_family_name,
-				'font-style'   => 'italic',
-				'font-weight'  => '200 900',
-				'font-stretch' => 'normal',
-				'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
-				'font-display' => 'fallback',
-			),
-		);
-
-		$expected = array(
-			wp_webfonts()->get_font_slug( $font_family_name ) => $fonts,
-		);
-
-		wp_register_webfonts( $fonts );
-		$this->assertEquals( $expected, wp_webfonts()->get_registered_webfonts() );
-		$this->assertEquals( array(), wp_webfonts()->get_enqueued_webfonts() );
-	}
-
-	/**
-	 * Test wp_register_webfont() register a single webfont.
-	 *
-	 * @covers wp_register_webfont
-	 * @covers WP_Webfonts::register_font
-	 * @covers WP_Webfonts::get_registered_fonts
-	 * @covers WP_Webfonts::get_enqueued_fonts
-	 */
-	public function test_wp_register_webfont() {
-		$font_family_name = 'Source Serif Pro';
-
-		$font = array(
-			'provider'     => 'local',
-			'font-family'  => $font_family_name,
-			'font-style'   => 'normal',
-			'font-weight'  => '200 900',
-			'font-stretch' => 'normal',
-			'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-			'font-display' => 'fallback',
-		);
-
-		$expected = array(
-			wp_webfonts()->get_font_slug( $font_family_name ) => array( $font ),
-		);
-
-		wp_register_webfont( $font );
-		$this->assertEquals( $expected, wp_webfonts()->get_registered_webfonts() );
-		$this->assertEquals( array(), wp_webfonts()->get_enqueued_webfonts() );
-	}
-
-	/**
-	 * Test wp_register_webfont() does not enqueue the webfont on registration.
-	 *
-	 * @covers wp_register_webfont
-	 * @covers WP_Webfonts::register_font
-	 * @covers WP_Webfonts::get_registered_fonts
-	 * @covers WP_Webfonts::get_enqueued_fonts
-	 */
-	public function test_wp_register_webfont_does_not_enqueue_on_registration() {
-		$font_family_name = 'Source Serif Pro';
-
-		$font = array(
-			'provider'     => 'local',
-			'font-family'  => $font_family_name,
-			'font-style'   => 'normal',
-			'font-weight'  => '200 900',
-			'font-stretch' => 'normal',
-			'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-			'font-display' => 'fallback',
-		);
-
-		$expected = array(
-			wp_webfonts()->get_font_slug( $font_family_name ) => array( $font ),
-		);
-
-		wp_register_webfont( $font );
-		$this->assertEquals( $expected, wp_webfonts()->get_registered_webfonts() );
-		$this->assertEquals( array(), wp_webfonts()->get_enqueued_webfonts() );
-	}
-
-	/**
-	 * Test wp_enqueue_webfonts() bulk enqueue webfonts.
-	 *
-	 * @covers wp_enqueue_webfonts
-	 * @covers WP_Webfonts::enqueue_font
-	 * @covers WP_Webfonts::get_enqueued_fonts
-	 * @covers WP_Webfonts::get_registered_fonts
-	 */
-	public function test_wp_enqueue_webfonts() {
-		$source_serif_pro = array(
-			'provider'     => 'local',
-			'font-family'  => 'Source Serif Pro',
-			'font-style'   => 'normal',
-			'font-weight'  => '200 900',
-			'font-stretch' => 'normal',
-			'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-			'font-display' => 'fallback',
-		);
-
-		wp_register_webfont( $source_serif_pro );
-
-		$roboto = array(
-			'provider'     => 'local',
-			'font-family'  => 'Roboto',
-			'font-style'   => 'normal',
-			'font-weight'  => '400',
-			'font-stretch' => 'normal',
-			'src'          => 'https://example.com/assets/fonts/roboto/Roboto.ttf.woff2',
-			'font-display' => 'fallback',
-		);
-
-		wp_register_webfont( $roboto );
-
-		$expected = array(
-			wp_webfonts()->get_font_slug( $source_serif_pro['font-family'] ) => array( $source_serif_pro ),
-			wp_webfonts()->get_font_slug( $roboto['font-family'] ) => array( $roboto ),
-		);
-
-		wp_enqueue_webfonts(
-			array(
-				$source_serif_pro['font-family'],
-				$roboto['font-family'],
-			)
-		);
-
-		$this->assertEquals( $expected, wp_webfonts()->get_enqueued_webfonts() );
-		$this->assertEquals( array(), wp_webfonts()->get_registered_webfonts() );
-	}
-
-	/**
-	 * Test wp_enqueue_font() enqueues a registered webfont.
-	 *
-	 * @covers wp_enqueue_webfont
-	 * @covers WP_Webfonts::enqueued_font
-	 * @covers WP_Webfonts::get_enqueued_fonts
-	 * @covers WP_Webfonts::get_registered_fonts
-	 */
-	public function test_wp_enqueue_webfont_enqueues_registered_webfont() {
-		$font_family_name = 'Source Serif Pro';
-
-		$font = array(
-			'provider'     => 'local',
-			'font-family'  => $font_family_name,
-			'font-style'   => 'normal',
-			'font-weight'  => '200 900',
-			'font-stretch' => 'normal',
-			'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-			'font-display' => 'fallback',
-		);
-
-		$expected = array(
-			wp_webfonts()->get_font_slug( $font_family_name ) => array( $font ),
-		);
-
-		wp_register_webfont( $font );
-		wp_enqueue_webfont( $font_family_name );
-
-		$this->assertEquals( array(), wp_webfonts()->get_registered_webfonts() );
-		$this->assertEquals( $expected, wp_webfonts()->get_enqueued_webfonts() );
-	}
-
-	/**
-	 * Test wp_enqueue_font() does not enqueue a webfont that was not registered.
-	 *
-	 * @covers wp_enqueue_webfont
-	 * @covers WP_Webfonts::enqueued_font
-	 * @covers WP_Webfonts::get_enqueued_fonts
-	 * @covers WP_Webfonts::get_registered_fonts
-	 *
-	 * @expectedIncorrectUsage WP_Webfonts::enqueue_webfont
-	 */
-	public function test_wp_enqueue_webfont_does_not_enqueue_unregistered_webfont() {
-		$font_family_name = 'Source Serif Pro';
-
-		wp_enqueue_webfont( $font_family_name );
-
-		$this->assertSame( array(), wp_webfonts()->get_registered_webfonts(), 'WP_Webfonts::get_registered_webfonts should return an empty array' );
-		$this->assertSame( array(), wp_webfonts()->get_enqueued_webfonts(), 'WP_Webfonts::get_enqueued_webfonts should return an empty array' );
-	}
-
-	/**
-	 * @covers wp_register_webfont
-	 * @covers WP_Webfonts::register_provider
-	 * @covers WP_Webfonts::get_providers
-	 */
-	public function test_get_providers() {
-		wp_register_webfont_provider( 'test-provider', 'Test_Provider' );
-		$this->assertEquals(
-			array(
-				'local'         => 'WP_Webfonts_Provider_Local',
-				'test-provider' => 'Test_Provider',
-			),
-			wp_get_webfont_providers()
-		);
-	}
-
-	/**
-	 * @dataProvider data_get_font_slug_when_cannot_determine_fontfamily
-	 * @covers       WP_Webfonts::get_font_slug
-	 *
-	 * @expectedIncorrectUsage WP_Webfonts::get_font_slug
-	 */
-	public function test_get_font_slug_when_cannot_determine_fontfamily( $to_convert ) {
-		$this->assertFalse( wp_webfonts()->get_font_slug( $to_convert ) );
-	}
-
-	/**
-	 * Data provider.
-	 *
-	 * @return array[]
-	 */
-	public function data_get_font_slug_when_cannot_determine_fontfamily() {
-		return array(
-			'empty array'                     => array( array() ),
-			'array without a font-family key' => array(
-				array(
-					'provider'     => 'local',
-					'font-style'   => 'normal',
-					'font-weight'  => '200 900',
-					'font-display' => 'fallback',
-					'font-stretch' => 'normal',
-					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-				),
-			),
-			"array with 'font family' key"    => array(
-				array( 'font family' => 'Source Serif Pro' ),
-			),
-			"array with 'Font-Family' key"    => array(
-				array( 'Font-Family' => 'Source Serif Pro' ),
-			),
-			"array with 'FontFamily' key"     => array(
-				array( 'FontFamily' => 'Source Serif Pro' ),
-			),
-		);
-	}
-
-	/**
-	 * @dataProvider data_get_font_slug
-	 * @covers       WP_Webfonts::get_font_slug
-	 */
-	public function test_get_font_slug( $to_convert, $expected ) {
-		$this->assertSame( $expected, wp_webfonts()->get_font_slug( $to_convert ) );
-	}
-
-	/**
-	 * Data provider.
-	 *
-	 * @return array[]
-	 */
-	public function data_get_font_slug() {
-		return array(
-			"array using 'fontFamily' format"  => array(
-				'to_convert' => array( 'fontFamily' => 'Source Serif Pro' ),
-				'expected'   => 'source-serif-pro',
-			),
-			"array using 'font-family' format" => array(
-				'to_convert' => array( 'font-family' => 'Source Serif Pro' ),
-				'expected'   => 'source-serif-pro',
-			),
-			'string with font family name'     => array(
-				'to_convert' => 'Source Serif Pro',
-				'expected'   => 'source-serif-pro',
-			),
-			'empty string'                     => array(
-				'to_convert' => '',
-				'expected'   => '',
-			),
-		);
-	}
-
-	/**
-	 * @covers WP_Webfonts::validate_webfont
-	 */
-	public function test_validate_webfont() {
-		$this->expectNotice();
-
-		// Test empty array.
-		$this->assertFalse( wp_webfonts()->validate_webfont( array() ) );
-
-		$font = array(
-			'font-family' => 'Test Font 1',
-			'src'         => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-		);
-
-		// Test missing provider fallback to local.
-		$this->assertEquals( 'local', wp_webfonts()->validate_webfont( $font )['provider'] );
-
-		// Test missing font-weight fallback to 400.
-		$this->assertEquals( '400', wp_webfonts()->validate_webfont( $font )['font-weight'] );
-
-		// Test missing font-style fallback to normal.
-		$this->assertEquals( 'normal', wp_webfonts()->validate_webfont( $font )['font-style'] );
-
-		// Test missing font-display fallback to fallback.
-		$this->assertEquals( 'fallback', wp_webfonts()->validate_webfont( $font )['font-display'] );
-
-		// Test local font with missing "src".
-		$this->assertFalse( wp_webfonts()->validate_webfont( array( 'font-family' => 'Test Font 2' ) ) );
-
-		// Test valid src URL, without a protocol.
-		$font['src'] = '//example.com/SourceSerif4Variable-Roman.ttf.woff2';
-		$this->assertEquals( wp_webfonts()->validate_webfont( $font )['src'], $font['src'] );
-
-		// Test font-weight.
-		$font_weights = array( 100, '100', '100 900', 'normal' );
-		foreach ( $font_weights as $value ) {
-			$font['font-weight'] = $value;
-			$this->assertEquals( wp_webfonts()->validate_webfont( $font )['font-weight'], $value );
-		}
-
-		// Test that invalid keys get removed from the font.
-		$font['invalid-key'] = 'invalid';
-		$this->assertArrayNotHasKey( 'invalid-key', wp_webfonts()->validate_webfont( $font ) );
-	}
-
-	/**
-	 * Test generate_and_enqueue_styles outputs only enqueued webfonts.
-	 *
-	 * @covers WP_Webfonts::generate_and_enqueue_styles
-	 */
-	public function test_generate_and_enqueue_styles() {
-		wp_register_webfonts(
-			array(
-				array(
-					'provider'     => 'local',
-					'font-family'  => 'Roboto',
-					'font-style'   => 'normal',
-					'font-weight'  => '400',
-					'font-stretch' => 'normal',
-					'src'          => 'https://example.com/assets/fonts/roboto/Roboto-Regular.ttf',
-					'font-display' => 'fallback',
-				),
-				array(
-					'provider'     => 'local',
-					'font-family'  => 'Source Serif Pro',
-					'font-style'   => 'normal',
-					'font-weight'  => '200 900',
-					'font-stretch' => 'normal',
-					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-					'font-display' => 'fallback',
-				),
-			)
-		);
-
-		wp_enqueue_webfont( 'Source Serif Pro' );
-
-		wp_webfonts()->generate_and_enqueue_styles();
-
-		$expected = <<<EOF
-@font-face{font-family:"Source Serif Pro";font-style:normal;font-weight:200 900;font-display:fallback;font-stretch:normal;src:local("Source Serif Pro"), url('https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2') format('woff2');}
-EOF;
-
-		$this->assertStringContainsString(
-			$expected,
-			get_echo( 'wp_print_styles' )
-		);
-	}
-
-	/**
-	 * Test generate_and_enqueue_editor_styles outputs registered and enqueued webfonts.
-	 * Both are necessary so the editor correctly loads webfonts picked while in the editor.
-	 *
-	 * @covers WP_Webfonts::generate_and_enqueue_editor_styles
-	 */
-	public function test_generate_and_enqueue_editor_styles() {
-		wp_register_webfonts(
-			array(
-				array(
-					'provider'     => 'local',
-					'font-family'  => 'Roboto',
-					'font-style'   => 'normal',
-					'font-weight'  => '400',
-					'font-stretch' => 'normal',
-					'src'          => 'https://example.com/assets/fonts/roboto/Roboto-Regular.ttf',
-					'font-display' => 'fallback',
-				),
-				array(
-					'provider'     => 'local',
-					'font-family'  => 'Source Serif Pro',
-					'font-style'   => 'normal',
-					'font-weight'  => '200 900',
-					'font-stretch' => 'normal',
-					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
-					'font-display' => 'fallback',
-				),
-			)
-		);
-
-		wp_enqueue_webfont( 'Source Serif Pro' );
-
-		wp_webfonts()->generate_and_enqueue_editor_styles();
-
-		$expected = <<<EOF
-@font-face{font-family:Roboto;font-style:normal;font-weight:400;font-display:fallback;font-stretch:normal;src:local(Roboto), url('https://example.com/assets/fonts/roboto/Roboto-Regular.ttf') format('truetype');}@font-face{font-family:"Source Serif Pro";font-style:normal;font-weight:200 900;font-display:fallback;font-stretch:normal;src:local("Source Serif Pro"), url('https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2') format('woff2');}
-EOF;
-
-		$this->assertStringContainsString(
-			$expected,
-			get_echo( 'wp_print_styles' )
-		);
-	}
-}
diff --git a/phpunit/fixtures/mock-provider.php b/phpunit/fixtures/mock-provider.php
new file mode 100644
index 00000000000000..91475837e0e916
--- /dev/null
+++ b/phpunit/fixtures/mock-provider.php
@@ -0,0 +1,27 @@
+<?php
+
+class Mock_Provider extends WP_Webfonts_Provider {
+	/**
+	 * The provider's unique ID.
+	 *
+	 * @var string
+	 */
+	protected $id = 'mock';
+
+	public function get_css() {
+		$handles = array_keys( $this->webfonts );
+		return implode( '; ', $handles );
+		return sprintf( $this->css, implode( '; ', $handles ) );
+	}
+
+	/**
+	 * Gets the `<style>` element for wrapping the `@font-face` CSS.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string The style element.
+	 */
+	protected function get_style_element() {
+		return '<mock id="wp-webfonts-mock" attr="some-attr">%s</mock>\n';
+	}
+}
diff --git a/phpunit/multisite.xml b/phpunit/multisite.xml
index 494c9a4610d07b..7a6117948547d3 100644
--- a/phpunit/multisite.xml
+++ b/phpunit/multisite.xml
@@ -5,6 +5,7 @@
 		convertErrorsToExceptions="true"
 		convertNoticesToExceptions="true"
 		convertWarningsToExceptions="true"
+		convertDeprecationsToExceptions="true"
 >
 	<php>
 		<env name="WP_MULTISITE" value="1" />
diff --git a/phpunit/webfonts/wp-webfonts-testcase.php b/phpunit/webfonts/wp-webfonts-testcase.php
new file mode 100644
index 00000000000000..ec0e20c27bfc6d
--- /dev/null
+++ b/phpunit/webfonts/wp-webfonts-testcase.php
@@ -0,0 +1,268 @@
+<?php
+/**
+ * Test case for the WP Webfonts API tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-tests-dataset.php';
+
+/**
+ * Abstracts the common tasks for the API's tests.
+ */
+abstract class WP_Webfonts_TestCase extends WP_UnitTestCase {
+	use WP_Webfonts_Tests_Datasets;
+
+	/**
+	 * Original WP_Web_Fonts instance, before the tests.
+	 *
+	 * @var WP_Web_Fonts
+	 */
+	private $old_wp_webfonts;
+
+	/**
+	 * Current error reporting level (before a test changes it).
+	 *
+	 * @var null|int
+	 */
+	protected $error_reporting_level = null;
+
+	/**
+	 * Reflection data store for non-public property access.
+	 *
+	 * @var ReflectionProperty[]
+	 */
+	protected $property = array();
+
+	public function set_up() {
+		parent::set_up();
+
+		$this->old_wp_webfonts  = $GLOBALS['wp_webfonts'];
+		$GLOBALS['wp_webfonts'] = null;
+	}
+
+	public function tear_down() {
+		$this->property         = array();
+		$GLOBALS['wp_webfonts'] = $this->old_wp_webfonts;
+
+		// Reset the error reporting when modified within a test.
+		if ( is_int( $this->error_reporting_level ) ) {
+			error_reporting( $this->error_reporting_level );
+			$this->error_reporting_level = null;
+		}
+
+		parent::tear_down();
+	}
+
+	protected function set_up_mock( $method ) {
+		$mock = $this->setup_object_mock( $method, WP_Web_Fonts::class );
+
+		// Set the global.
+		$GLOBALS['wp_webfonts'] = $mock;
+
+		return $mock;
+	}
+
+	protected function setup_object_mock( $method, $class ) {
+		if ( is_string( $method ) ) {
+			$method = array( $method );
+		}
+
+		return $this->getMockBuilder( $class )->setMethods( $method )->getMock();
+	}
+
+	protected function get_registered_handles() {
+		return array_keys( $this->get_registered() );
+	}
+
+	protected function get_registered() {
+		return wp_webfonts()->registered;
+	}
+
+	protected function get_variations( $font_family, $wp_webfonts = null ) {
+		if ( ! ( $wp_webfonts instanceof WP_Web_Fonts ) ) {
+			$wp_webfonts = wp_webfonts();
+		}
+
+		return $wp_webfonts->registered[ $font_family ]->deps;
+	}
+
+	protected function get_enqueued_handles() {
+		return wp_webfonts()->queue;
+	}
+
+	protected function get_queued_before_register( $wp_webfonts = null ) {
+		return $this->get_property_value( 'queued_before_register', WP_Dependencies::class, $wp_webfonts );
+	}
+
+	protected function get_reflection_property( $property_name, $class = 'WP_Web_Fonts' ) {
+		$property = new ReflectionProperty( $class, $property_name );
+		$property->setAccessible( true );
+
+		return $property;
+	}
+
+	protected function get_property_value( $property_name, $class, $wp_webfonts = null ) {
+		$property = $this->get_reflection_property( $property_name, $class );
+
+		if ( ! $wp_webfonts ) {
+			$wp_webfonts = wp_webfonts();
+		}
+
+		return $property->getValue( $wp_webfonts );
+	}
+
+	protected function setup_property( $class, $property_name ) {
+		$key = $this->get_property_key( $class, $property_name );
+
+		if ( ! isset( $this->property[ $key ] ) ) {
+			$this->property[ $key ] = new ReflectionProperty( $class, 'providers' );
+			$this->property[ $key ]->setAccessible( true );
+		}
+
+		return $this->property[ $key ];
+	}
+
+	protected function get_property_key( $class, $property_name ) {
+		return $class . '::$' . $property_name;
+	}
+
+	/**
+	 * Opens the accessibility to access the given private or protected method.
+	 *
+	 * @param string $method_name Name of the method to open.
+	 * @return ReflectionMethod Instance of the method, ie to invoke it in the test.
+	 */
+	protected function get_reflection_method( $method_name ) {
+		$method = new ReflectionMethod( WP_Web_Fonts::class, $method_name );
+		$method->setAccessible( true );
+
+		return $method;
+	}
+
+	/**
+	 * Sets up multiple font family and variation mocks.
+	 *
+	 * @param array        $inputs      Array of array( font-family => variations ) to setup.
+	 * @param WP_Web_Fonts $wp_webfonts Instance of WP_Web_Fonts.
+	 * @return stdClass[] Array of registered mocks.
+	 */
+	protected function setup_registration_mocks( array $inputs, WP_Web_Fonts $wp_webfonts ) {
+		$mocks = array();
+
+		$build_mock = function ( $font_family, $is_font_family = false ) use ( &$mocks, $wp_webfonts ) {
+			$mock        = new stdClass();
+			$mock->deps  = array();
+			$mock->extra = array( 'is_font_family' => $is_font_family );
+			if ( $is_font_family ) {
+				$mock->extra['font-family'] = $font_family;
+			}
+
+			$handle = $is_font_family ? WP_Webfonts_Utils::convert_font_family_into_handle( $font_family ) : $font_family;
+
+			// Add to each queue.
+			$mocks[ $handle ]                   = $mock;
+			$wp_webfonts->registered[ $handle ] = $mock;
+
+			return $mock;
+		};
+
+		foreach ( $inputs as $font_family => $variations ) {
+			$font_mock = $build_mock( $font_family, true );
+
+			foreach ( $variations as $variation_handle => $variation ) {
+				if ( ! is_string( $variation_handle ) ) {
+					$variation_handle = $variation;
+				}
+				$variation_mock                           = $build_mock( $variation_handle );
+				$variation_mock->extra['font-properties'] = $variation;
+				$font_mock->deps[]                        = $variation_handle;
+			}
+		}
+
+		return $mocks;
+	}
+
+	/**
+	 * Register one or more font-family and its variations to set up a test.
+	 *
+	 * @param string            $font_family Font family to test.
+	 * @param array             $variations  Variations.
+	 * @param WP_Web_Fonts|null $wp_webfonts Optional. Instance of the WP_Web_Fonts.
+	 */
+	protected function setup_register( $font_family, $variations, $wp_webfonts = null ) {
+		if ( ! ( $wp_webfonts instanceof WP_Web_Fonts ) ) {
+			$wp_webfonts = wp_webfonts();
+		}
+
+		$font_family_handle = $wp_webfonts->add_font_family( $font_family );
+
+		foreach ( $variations as $variation_handle => $variation ) {
+			if ( ! is_string( $variation_handle ) ) {
+				$variation_handle = '';
+			}
+			$wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		}
+	}
+
+	/**
+	 * Sets up the WP_Web_Fonts::$provider property.
+	 *
+	 * @param WP_Web_Fonts $wp_webfonts  Instance of WP_Web_Fonts.
+	 * @param string|array $provider     Provider ID when string. Else provider definition with 'id' and 'class' keys.
+	 * @param array        $font_handles Optional. Font handles for this provider.
+	 */
+	protected function setup_provider_property_mock( WP_Web_Fonts $wp_webfonts, $provider, array $font_handles = array() ) {
+		if ( is_string( $provider ) ) {
+			$provider = $this->get_provider_definitions( $provider );
+		}
+
+		$property  = $this->setup_property( WP_Web_Fonts::class, 'providers' );
+		$providers = $property->getValue( $wp_webfonts );
+
+		if ( ! isset( $providers[ $provider['id'] ] ) ) {
+			$providers[ $provider['id'] ] = array(
+				'class' => $provider['class'],
+				'fonts' => $font_handles,
+			);
+		} else {
+			$providers[ $provider['id'] ] = array_merge( $font_handles, $providers[ $provider['id'] ]['fonts'] );
+		}
+
+		$property->setValue( $wp_webfonts, $providers );
+	}
+
+	/**
+	 * Gets the variation handles for the provider from the given fonts.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array  $fonts       Fonts definitions keyed by font family.
+	 * @param string $provider_id Provider ID.
+	 * @return array|string[] Array of handles on success. Else empty array.
+	 */
+	protected function get_handles_for_provider( array $fonts, $provider_id ) {
+		$handles = array();
+
+		foreach ( $fonts as $variations ) {
+			foreach ( $variations as $variation_handle => $variation ) {
+				if ( $provider_id !== $variation['provider'] ) {
+					continue;
+				}
+				$handles[] = $variation_handle;
+			}
+		}
+
+		return $handles;
+	}
+
+	/**
+	 * Suppresses deprecation notices allowing a test to skip deprecations
+	 * to test notices or other specifics.
+	 */
+	protected function suppress_deprecations() {
+		$this->error_reporting_level = error_reporting();
+		error_reporting( $this->error_reporting_level & ~E_USER_DEPRECATED );
+	}
+}
diff --git a/phpunit/webfonts/wp-webfonts-tests-dataset.php b/phpunit/webfonts/wp-webfonts-tests-dataset.php
new file mode 100644
index 00000000000000..100595c75a3fc2
--- /dev/null
+++ b/phpunit/webfonts/wp-webfonts-tests-dataset.php
@@ -0,0 +1,1155 @@
+<?php
+
+trait WP_Webfonts_Tests_Datasets {
+	/**
+	 * Data provider for testing variation registration that has valid structure.
+	 *
+	 * @return array
+	 */
+	public function data_valid_variation() {
+		return array(
+			'font-weight and font-style not defined; without variation handle' => array(
+				'expected'           => 'lato-400-normal',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'font-family' => 'Lato',
+					'src'         => 'https://example.com/assets/fonts/lato/lato.ttf.woff2',
+				),
+			),
+
+			'font-weight and font-style not defined; with variation handle' => array(
+				'expected'           => 'my-custom-handle',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'font-family' => 'Lato',
+					'src'         => 'https://example.com/assets/fonts/lato/lato.ttf.woff2',
+				),
+				'variation_handle'   => 'my-custom-handle',
+			),
+
+			'font-weight defined; without variation handle' => array(
+				'expected'           => 'source-serif-pro-200-900-normal',
+				'font_family_handle' => 'source-serif-pro',
+				'variation'          => array(
+					'font-family'  => 'Source Serif Pro',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+				),
+			),
+
+			'font-weight defined; with variation handle' => array(
+				'expected'           => 'my_custom_handle',
+				'font_family_handle' => 'source-serif-pro',
+				'variation'          => array(
+					'font-family'  => 'Source Serif Pro',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+				),
+				'variation_handle'   => 'my_custom_handle',
+			),
+
+			'font-weight defined; without variation handle' => array(
+				'expected'           => 'source-serif-pro-200-900-normal',
+				'font_family_handle' => 'source-serif-pro',
+				'variation'          => array(
+					'font-family'  => 'Source Serif Pro',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+				),
+			),
+
+			'font-weight defined; with variation handle' => array(
+				'expected'           => 'my_custom_handle',
+				'font_family_handle' => 'source-serif-pro',
+				'variation'          => array(
+					'font-family'  => 'Source Serif Pro',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+				),
+				'variation_handle'   => 'my_custom_handle',
+			),
+
+			'font-weight defined; without variation handle' => array(
+				'expected'           => 'source-serif-pro-200-900-normal',
+				'font_family_handle' => 'source-serif-pro',
+				'variation'          => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+			),
+
+			'more variation properties; with variation handle' => array(
+				'expected'           => 'my-custom-handle',
+				'font_family_handle' => 'source-serif-pro',
+				'variation'          => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'variation_handle'   => 'my-custom-handle',
+			),
+		);
+	}
+
+	/**
+	 * Data provider for testing registration of variations where the font family handle
+	 * is not defined.
+	 *
+	 * @return array
+	 */
+	public function data_font_family_handle_undefined() {
+		return array(
+			'empty string font family handle' => array(
+				'font_family_handle' => '',
+				'variation'          => array(
+					'src' => 'https://example.com/assets/fonts/lato/lato.ttf.woff2',
+				),
+				'expected_message'   => 'Font family handle must be a non-empty string',
+			),
+			'empty string font family handle with font-family defined in variant' => array(
+				'font_family_handle' => '',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Lato',
+					'font-weight' => '200',
+					'src'         => 'https://example.com/assets/fonts/lato/lato.ttf.woff2',
+				),
+				'expected_message'   => 'Font family handle must be a non-empty string',
+			),
+			'non string font family handle'   => array(
+				'font_family_handle' => 10,
+				'variation'          => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'expected_message'   => 'Font family handle must be a non-empty string',
+			),
+		);
+	}
+
+	/**
+	 * Data provider for testing registration of variations where the font family is not defined
+	 * in the variation.
+	 *
+	 * @return array
+	 */
+	public function data_font_family_undefined_in_variation() {
+		$message = 'Webfont font-family must be a non-empty string.';
+		return array(
+			'font-family: undefined'    => array(
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'src' => 'https://example.com/assets/fonts/lato/lato.ttf.woff2',
+				),
+				'expected_message'   => $message,
+			),
+			'font-family: null'         => array(
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => null,
+					'font-weight' => '200',
+					'src'         => 'https://example.com/assets/fonts/lato/lato.ttf.woff2',
+				),
+				'expected_message'   => $message,
+			),
+			'font-family: non string'   => array(
+				'font_family_handle' => 'source-serif-pro',
+				'variation'          => array(
+					'provider'     => 'local',
+					'font-family'  => 10,
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'expected_message'   => $message,
+			),
+			'font-family: empty string' => array(
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'font-family' => '',
+					'src'         => 'https://example.com/assets/fonts/lato/lato.ttf.woff2',
+				),
+				'expected_message'   => $message,
+			),
+		);
+	}
+
+	/**
+	 * Data provider for testing when the variation's handle can't be determine from the given input.
+	 *
+	 * @return array
+	 */
+	public function data_unable_determine_variation_handle() {
+		return array(
+			'integer values'                               => array(
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'font-family' => 'Lato',
+					'font-weight' => 400,
+					'font-style'  => 0,
+					'src'         => 'https://example.com/assets/fonts/lato.ttf.woff2',
+				),
+				'expected_message'   => 'Variant handle could not be determined as font-weight and/or font-style are require',
+			),
+			'with empty string font-weight and font-style' => array(
+				'font_family_handle' => 'merriweather',
+				'variation'          => array(
+					'font-family' => 'Merriweather',
+					'font-weight' => '',
+					'font-style'  => '',
+					'src'         => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+				),
+				'expected_message'   => 'Variant handle could not be determined as font-weight and/or font-style are require',
+			),
+			'integer font-weight, empty string font-style' => array(
+				'font_family'      => 'merriweather',
+				'variation'        => array(
+					'font-family' => 'Merriweather',
+					'font-weight' => 400,
+					'font-style'  => '',
+					'src'         => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+				),
+				'expected_message' => 'Variant handle could not be determined as font-weight and/or font-style are require',
+			),
+			'empty string font-weight, integer font-style' => array(
+				'font_family'      => 'lato',
+				'variation'        => array(
+					'font-family' => 'Merriweather',
+					'font-weight' => '',
+					'font-style'  => 400,
+					'src'         => 'https://example.com/assets/fonts/lato.ttf.woff2',
+				),
+				'expected_message' => 'Variant handle could not be determined as font-weight and/or font-style are require',
+			),
+		);
+	}
+
+	/**
+	 * Data provider for testing an invalid variation.
+	 *
+	 * @return array
+	 */
+	public function data_invalid_variation() {
+		return array(
+			'font-family: undefined'          => array(
+				'expected'           => 'Webfont font-family must be a non-empty string.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'src' => 'https://example.com/assets/fonts/lato.ttf.woff2',
+				),
+			),
+			'font-family: null'               => array(
+				'expected'           => 'Webfont font-family must be a non-empty string.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'font-family' => null,
+					'src'         => 'https://example.com/assets/fonts/lato.ttf.woff2',
+				),
+			),
+			'font-family: empty string'       => array(
+				'expected'           => 'Webfont font-family must be a non-empty string.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'font-family' => '',
+					'src'         => 'https://example.com/assets/fonts/lato.ttf.woff2',
+				),
+			),
+			'src: undefined'                  => array(
+				'expected'           => 'Webfont src must be a non-empty string or an array of strings.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Some font',
+					'font-weight' => '200',
+				),
+			),
+			'src: null'                       => array(
+				'expected'           => 'Webfont src must be a non-empty string or an array of strings.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Some font',
+					'font-weight' => '200',
+					'src'         => null,
+				),
+			),
+			'src: empty string'               => array(
+				'expected'           => 'Webfont src must be a non-empty string or an array of strings.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Some font',
+					'font-weight' => '200',
+					'src'         => '',
+				),
+			),
+			'src: empty array'                => array(
+				'expected'           => 'Webfont src must be a non-empty string or an array of strings.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Lato',
+					'font-weight' => '200',
+					'src'         => array(),
+				),
+			),
+			'src: array of an empty string'   => array(
+				'expected'           => 'Each webfont src must be a non-empty string.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Lato',
+					'font-weight' => '200',
+					'src'         => array( '' ),
+				),
+			),
+			'src: array of a non-string'      => array(
+				'expected'           => 'Each webfont src must be a non-empty string.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Lato',
+					'font-weight' => '200',
+					'src'         => array( null ),
+				),
+			),
+			'src: array with an empty string' => array(
+				'expected'           => 'Each webfont src must be a non-empty string.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Lato',
+					'font-weight' => '200',
+					'src'         => array(
+						'https://example.com/assets/fonts/merriweather.ttf.woff2',
+						'',
+						'https://example.com/assets/fonts/lato.ttf.woff2',
+					),
+				),
+			),
+			'src: array with a non-string'    => array(
+				'expected'           => 'Each webfont src must be a non-empty string.',
+				'font_family_handle' => 'lato',
+				'variation'          => array(
+					'provider'    => 'local',
+					'font-family' => 'Lato',
+					'font-weight' => '200',
+					'src'         => array(
+						'https://example.com/assets/fonts/merriweather.ttf.woff2',
+						null,
+						'https://example.com/assets/fonts/lato.ttf.woff2',
+					),
+				),
+			),
+			'provider does not exist'         => array(
+				'expected'           => 'The provider "doesnotexit" is not registered',
+				'font_family_handle' => 'merriweather',
+				'variation'          => array(
+					'provider'    => 'doesnotexit',
+					'font-family' => 'Merriweather',
+					'font-weight' => '200 900',
+				),
+			),
+			'font-weight: null'               => array(
+				'expected'           => 'Webfont font-weight must be a properly formatted string or integer.',
+				'font_family_handle' => 'merriweather',
+				'variation'          => array(
+					'font-family' => 'Merriweather',
+					'font-weight' => null,
+					'font-style'  => 'normal',
+					'src'         => 'https://example.com/assets/fonts/lato.ttf.woff2',
+				),
+			),
+		);
+	}
+
+	/**
+	 * Data provider for testing one or more font families with varying number of variations.
+	 *
+	 * @return array
+	 */
+	public function data_one_to_many_font_families_and_zero_to_many_variations() {
+		return array(
+			'one family family no variations'           => array(
+				'font_family' => 'lato',
+				'inputs'      => array(
+					'lato' => array(),
+				),
+				'handles'     => array( 'lato' ),
+				'expected'    => array(),
+			),
+			'one family family with 1 variation'        => array(
+				'font_family' => 'merriweather',
+				'inputs'      => array(
+					'merriweather' => array(
+						'merriweather-200-900-normal' => array(
+							'font-family'  => 'Merriweather',
+							'font-weight'  => '200 900',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+						),
+					),
+				),
+				'handles'     => array( 'merriweather', 'merriweather-200-900-normal' ),
+				'expected'    => array(),
+			),
+			'font family with multiple variations'      => array(
+				'font_family' => 'source-serif-pro',
+				'inputs'      => array(
+					'Source Serif Pro' => array(
+						'Source Serif Pro-300-normal' => array(
+							'provider'     => 'local',
+							'font-family'  => 'Source Serif Pro',
+							'font-style'   => 'normal',
+							'font-weight'  => '300',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+							'font-display' => 'fallback',
+						),
+						'Source Serif Pro-900-italic' => array(
+							'provider'     => 'local',
+							'font-family'  => 'Source Serif Pro',
+							'font-style'   => 'italic',
+							'font-weight'  => '900',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+							'font-display' => 'fallback',
+						),
+					),
+				),
+				'handles'     => array( 'source-serif-pro', 'Source Serif Pro-300-normal', 'Source Serif Pro-900-italic' ),
+				'expected'    => array(),
+			),
+			'multiple font families without variations' => array(
+				'font_family' => 'source-serif-pro',
+				'inputs'      => array(
+					'lato'             => array(),
+					'my-font'          => array(),
+					'Source Serif Pro' => array(),
+					'some other font'  => array(),
+				),
+				'handles'     => array( 'lato', 'my-font', 'source-serif-pro', 'some-other-font' ),
+				'expected'    => array( 'lato', 'my-font', 'some-other-font' ),
+			),
+			'multiple font families with variations'    => array(
+				'font_family' => 'my-font',
+				'inputs'      => array(
+					'merriweather'     => array(
+						'merriweather-200-900-normal' => array(
+							'font-family'  => 'Merriweather',
+							'font-weight'  => '200 900',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+						),
+					),
+					'Source Serif Pro' => array(
+						'Source Serif Pro-300-normal' => array(
+							'provider'     => 'local',
+							'font-family'  => 'Source Serif Pro',
+							'font-style'   => 'normal',
+							'font-weight'  => '300',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+							'font-display' => 'fallback',
+						),
+						'Source Serif Pro-900-italic' => array(
+							'provider'     => 'local',
+							'font-family'  => 'Source Serif Pro',
+							'font-style'   => 'italic',
+							'font-weight'  => '900',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+							'font-display' => 'fallback',
+						),
+					),
+					'my-font'          => array(
+						'my-font-300-italic' => array(
+							'font-family' => 'My Font',
+							'font-weight' => '300',
+							'src'         => 'https://example.com/assets/fonts/my-font.ttf.woff2',
+						),
+					),
+				),
+				'handles'     => array(
+					'merriweather',
+					'merriweather-200-900-normal',
+					'source-serif-pro',
+					'Source Serif Pro-300-normal',
+					'Source Serif Pro-900-italic',
+					'my-font',
+					'my-font-300-italic',
+				),
+				'expected'    => array(
+					'merriweather',
+					'merriweather-200-900-normal',
+					'source-serif-pro',
+					'Source Serif Pro-300-normal',
+					'Source Serif Pro-900-italic',
+				),
+			),
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_font_family_handles() {
+		return array(
+			'single word handle'   => array( 'lato' ),
+			'multiple word handle' => array( 'source-sans-pro' ),
+			'single word name'     => array( 'Merriweather' ),
+			'multiple word name'   => array( 'My Cool Font' ),
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_get_providers() {
+		$local = array(
+			'local' => array(
+				'class' => WP_Webfonts_Provider_Local::class,
+				'fonts' => array(),
+			),
+		);
+		$mock  = array(
+			'mock' => array(
+				'class' => Mock_Provider::class,
+				'fonts' => array(),
+			),
+		);
+
+		return array(
+			'local provider'           => array(
+				'providers' => array(
+					'local' => WP_Webfonts_Provider_Local::class,
+				),
+				'expected'  => $local,
+			),
+			'mock provider'            => array(
+				'providers' => array(
+					'mock' => Mock_Provider::class,
+				),
+				'expected'  => $mock,
+			),
+			'local and mock providers' => array(
+				'providers' => array(
+					'local' => WP_Webfonts_Provider_Local::class,
+					'mock'  => Mock_Provider::class,
+				),
+				'expected'  => array_merge( $local, $mock ),
+			),
+		);
+	}
+
+	/**
+	 * Data provider for testing removal of variations.
+	 *
+	 * @return array
+	 */
+	public function data_remove_variations() {
+		return array(
+			'Font with 1 variation'         => array(
+				'font_family'      => 'merriweather',
+				'variation_handle' => 'merriweather-200-900-normal',
+				'expected'         => array(
+					'registered'       => array(
+						'merriweather',
+						'source-serif-pro',
+						'Source Serif Pro-300-normal',
+						'Source Serif Pro-900-italic',
+					),
+					'font_family_deps' => array(),
+				),
+			),
+			'Font with multiple variations' => array(
+				'font_family'      => 'source-serif-pro',
+				'variation_handle' => 'Source Serif Pro-300-normal',
+				'expected'         => array(
+					'registered'       => array(
+						'merriweather',
+						'merriweather-200-900-normal',
+						'source-serif-pro',
+						'Source Serif Pro-900-italic',
+					),
+					'font_family_deps' => array( 'Source Serif Pro-900-italic' ),
+				),
+			),
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_enqueue() {
+		return array(
+			'1 font-family'   => array(
+				'handles'                         => 'lato',
+				'expected_queue'                  => array( 'lato' ),
+				'expected_queued_before_register' => array(
+					'lato' => null,
+				),
+			),
+			'2 font families' => array(
+				'handles'                         => array( 'merriweather', 'my-font' ),
+				'expected_queue'                  => array( 'merriweather', 'my-font' ),
+				'expected_queued_before_register' => array(
+					'merriweather' => null,
+					'my-font'      => null,
+				),
+			),
+			'3 font families' => array(
+				'handles'                         => array( 'merriweather', 'my-font', 'source-serif-pro' ),
+				'expected_queue'                  => array( 'merriweather', 'my-font', 'source-serif-pro' ),
+				'expected_queued_before_register' => array(
+					'merriweather'     => null,
+					'my-font'          => null,
+					'source-serif-pro' => null,
+				),
+			),
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_enqueue_variations() {
+		return array(
+			'1 variation'                               => array(
+				'handles'                         => array( 'my-font-300-normal' ),
+				'expected_queue'                  => array( 'my-font-300-normal' ),
+				'expected_queued_before_register' => array(
+					'my-font-300-normal' => null,
+				),
+			),
+			'1 variation from different font families'  => array(
+				'handles'                         => array( 'merriweather-200-900-normal', 'my-font-300-normal' ),
+				'expected_queue'                  => array( 'merriweather-200-900-normal', 'my-font-300-normal' ),
+				'expected_queued_before_register' => array(
+					'merriweather-200-900-normal' => null,
+					'my-font-300-normal'          => null,
+				),
+			),
+			'enqueue one variation and its font family' => array(
+				'handles'                         => array( 'merriweather', 'merriweather-200-900-normal' ),
+				'expected_queue'                  => array( 'merriweather', 'merriweather-200-900-normal' ),
+				'expected_queued_before_register' => array(
+					'merriweather'                => null,
+					'merriweather-200-900-normal' => null,
+				),
+			),
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_print_enqueued() {
+		$providers          = $this->get_provider_definitions();
+		$mock_fonts         = $this->get_registered_mock_fonts();
+		$mock_font_handles  = $this->get_handles_for_provider( $mock_fonts, 'mock' );
+		$local_fonts        = $this->get_registered_local_fonts();
+		$local_font_handles = $this->get_handles_for_provider( $local_fonts, 'local' );
+		$font_faces         = $this->get_registered_fonts_css();
+
+		$all_variation_handles = array_merge( $mock_font_handles, $local_font_handles );
+		$setup_all             = array(
+			'provider'         => array(
+				'local' => $providers['local'],
+				'mock'  => $providers['mock'],
+			),
+			'provider_handles' => array(
+				'local' => $local_font_handles,
+				'mock'  => $mock_font_handles,
+			),
+			'registered'       => array_merge( $mock_fonts, $local_fonts ),
+		);
+
+		return array(
+
+			// One provider registered with multiple fonts.
+
+			'print font2 for mock provider'             => array(
+				'setup'           => array(
+					'provider'         => array( 'mock' => $providers['mock'] ),
+					'provider_handles' => array( 'mock' => $mock_font_handles ),
+					'registered'       => $mock_fonts,
+					'enqueued'         => array( 'font2' ),
+				),
+				'expected_done'   => array( 'font2', 'font2-200-900-normal', 'font2-200-900-italic' ),
+				'expected_output' => sprintf(
+					'<mock id="wp-webfonts-mock" attr="some-attr">%s; %s</mock>\n',
+					$font_faces['font2-200-900-normal'],
+					$font_faces['font2-200-900-italic']
+				),
+			),
+			'print all fonts for mock provider'         => array(
+				'setup'           => array(
+					'provider'         => array( 'mock' => $providers['mock'] ),
+					'provider_handles' => array( 'mock' => $mock_font_handles ),
+					'registered'       => $mock_fonts,
+					'enqueued'         => array( 'font1', 'font2', 'font3' ),
+				),
+				'expected_done'   => array(
+					'font1',
+					'font1-300-normal',
+					'font1-300-italic',
+					'font1-900-normal',
+					'font2',
+					'font2-200-900-normal',
+					'font2-200-900-italic',
+					'font3',
+					'font3-bold-normal',
+				),
+				'expected_output' => sprintf(
+					'<mock id="wp-webfonts-mock" attr="some-attr">%s; %s; %s; %s; %s; %s</mock>\n',
+					$font_faces['font1-300-normal'],
+					$font_faces['font1-300-italic'],
+					$font_faces['font1-900-normal'],
+					$font_faces['font2-200-900-normal'],
+					$font_faces['font2-200-900-italic'],
+					$font_faces['font3-bold-normal']
+				),
+			),
+			'print merriweather for local provider'     => array(
+				'setup'           => array(
+					'provider'         => array( 'local' => $providers['local'] ),
+					'provider_handles' => array( 'local' => $local_font_handles ),
+					'registered'       => $local_fonts,
+					'enqueued'         => array( 'merriweather' ),
+				),
+				'expected_done'   => array( 'merriweather', 'merriweather-200-900-normal' ),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s\n</style>\n",
+					$font_faces['merriweather-200-900-normal']
+				),
+			),
+			'print Source Serif Pro for local provider' => array(
+				'setup'           => array(
+					'provider'         => array( 'local' => $providers['local'] ),
+					'provider_handles' => array( 'local' => $local_font_handles ),
+					'registered'       => $local_fonts,
+					'enqueued'         => array( 'source-serif-pro' ),
+				),
+				'expected_done'   => array( 'source-serif-pro', 'Source Serif Pro-300-normal', 'Source Serif Pro-900-italic' ),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s%s\n</style>\n",
+					$font_faces['Source Serif Pro-300-normal'],
+					$font_faces['Source Serif Pro-900-italic']
+				),
+			),
+			'print all fonts for local provider'        => array(
+				'setup'           => array(
+					'provider'         => array( 'local' => $providers['local'] ),
+					'provider_handles' => array( 'local' => $local_font_handles ),
+					'registered'       => $local_fonts,
+					'enqueued'         => array( 'merriweather', 'source-serif-pro' ),
+				),
+				'expected_done'   => array(
+					'merriweather',
+					'merriweather-200-900-normal',
+					'source-serif-pro',
+					'Source Serif Pro-300-normal',
+					'Source Serif Pro-900-italic',
+				),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s%s%s\n</style>\n",
+					$font_faces['merriweather-200-900-normal'],
+					$font_faces['Source Serif Pro-300-normal'],
+					$font_faces['Source Serif Pro-900-italic']
+				),
+			),
+
+			// All providers registered with multiple fonts.
+
+			'print font1 when all providers registered' => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => array( 'font1' ) ) ),
+				'expected_done'   => array( 'font1', 'font1-300-normal', 'font1-300-italic', 'font1-900-normal' ),
+				'expected_output' => sprintf(
+					'<mock id="wp-webfonts-mock" attr="some-attr">%s; %s; %s</mock>\n',
+					$font_faces['font1-300-normal'],
+					$font_faces['font1-300-italic'],
+					$font_faces['font1-900-normal']
+				),
+			),
+			'print all mock fonts when all providers registered' => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => array( 'font1', 'font2', 'font3' ) ) ),
+				'expected_done'   => array(
+					'font1',
+					'font1-300-normal',
+					'font1-300-italic',
+					'font1-900-normal',
+					'font2',
+					'font2-200-900-normal',
+					'font2-200-900-italic',
+					'font3',
+					'font3-bold-normal',
+				),
+				'expected_output' => sprintf(
+					'<mock id="wp-webfonts-mock" attr="some-attr">%s; %s; %s; %s; %s; %s</mock>\n',
+					$font_faces['font1-300-normal'],
+					$font_faces['font1-300-italic'],
+					$font_faces['font1-900-normal'],
+					$font_faces['font2-200-900-normal'],
+					$font_faces['font2-200-900-italic'],
+					$font_faces['font3-bold-normal']
+				),
+			),
+			'print merriweather when all providers registered' => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => array( 'merriweather' ) ) ),
+				'expected_done'   => array( 'merriweather', 'merriweather-200-900-normal' ),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s\n</style>\n",
+					$font_faces['merriweather-200-900-normal']
+				),
+			),
+			'print all local fonts when all providers registered' => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => array( 'merriweather', 'source-serif-pro' ) ) ),
+				'expected_done'   => array(
+					'merriweather',
+					'merriweather-200-900-normal',
+					'source-serif-pro',
+					'Source Serif Pro-300-normal',
+					'Source Serif Pro-900-italic',
+				),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s%s%s\n</style>\n",
+					$font_faces['merriweather-200-900-normal'],
+					$font_faces['Source Serif Pro-300-normal'],
+					$font_faces['Source Serif Pro-900-italic']
+				),
+			),
+
+			'print all fonts for all providers'         => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => $all_variation_handles ) ),
+				'expected_done'   => $all_variation_handles,
+				'expected_output' =>
+					sprintf(
+						"<style id='wp-webfonts-local' type='text/css'>\n%s%s%s\n</style>\n",
+						$font_faces['merriweather-200-900-normal'],
+						$font_faces['Source Serif Pro-300-normal'],
+						$font_faces['Source Serif Pro-900-italic']
+					) .
+					sprintf(
+						'<mock id="wp-webfonts-mock" attr="some-attr">%s; %s; %s; %s; %s; %s</mock>\n',
+						$font_faces['font1-300-normal'],
+						$font_faces['font1-300-italic'],
+						$font_faces['font1-900-normal'],
+						$font_faces['font2-200-900-normal'],
+						$font_faces['font2-200-900-italic'],
+						$font_faces['font3-bold-normal']
+					),
+			),
+
+			// Specific variations enqueued.
+			// Validates that only these specific variations print once.
+
+			'specific variation: 1 local'               => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => array( 'merriweather-200-900-normal' ) ) ),
+				'expected_done'   => array( 'merriweather-200-900-normal' ),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s\n</style>\n",
+					$font_faces['merriweather-200-900-normal']
+				),
+			),
+			'specific variation: 1 local from different font families' => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => array( 'merriweather-200-900-normal', 'Source Serif Pro-900-italic' ) ) ),
+				'expected_done'   => array( 'merriweather-200-900-normal', 'Source Serif Pro-900-italic' ),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s%s\n</style>\n",
+					$font_faces['merriweather-200-900-normal'],
+					$font_faces['Source Serif Pro-900-italic']
+				),
+			),
+			'specific variation: 1 local and 1 mock'    => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => array( 'merriweather-200-900-normal', 'font2-200-900-normal' ) ) ),
+				'expected_done'   => array( 'merriweather-200-900-normal', 'font2-200-900-normal' ),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s\n</style>\n" .
+					'<mock id="wp-webfonts-mock" attr="some-attr">%s</mock>\n',
+					$font_faces['merriweather-200-900-normal'],
+					$font_faces['font2-200-900-normal']
+				),
+			),
+			'specific variation: 1 mock and 1 local'    => array(
+				'setup'           => array_merge( $setup_all, array( 'enqueued' => array( 'font2-200-900-normal', 'Source Serif Pro-300-normal' ) ) ),
+				'expected_done'   => array( 'font2-200-900-normal', 'Source Serif Pro-300-normal' ),
+				'expected_output' => sprintf(
+					"<style id='wp-webfonts-local' type='text/css'>\n%s\n</style>\n" .
+					'<mock id="wp-webfonts-mock" attr="some-attr">%s</mock>\n',
+					$font_faces['Source Serif Pro-300-normal'],
+					$font_faces['font2-200-900-normal']
+				),
+			),
+		);
+	}
+
+	protected function get_data_registry() {
+		return array(
+			'lato'             => array(),
+			'merriweather'     => array(
+				'merriweather-200-900-normal' => array(
+					'font-family'  => 'Merriweather',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+				),
+			),
+			'Source Serif Pro' => array(
+				'Source Serif Pro-300-normal' => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'normal',
+					'font-weight'  => '300',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'Source Serif Pro-900-italic' => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'italic',
+					'font-weight'  => '900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+			),
+			'my-font'          => array(
+				'my-font-300-normal' => array(
+					'font-family' => 'My Font',
+					'font-weight' => '300',
+					'src'         => 'https://example.com/assets/fonts/my-font.ttf.woff2',
+				),
+				'my-font-300-italic' => array(
+					'font-family' => 'My Font',
+					'font-weight' => '300',
+					'font-style'  => 'italic',
+					'src'         => 'https://example.com/assets/fonts/my-font.ttf.woff2',
+				),
+				'my-font-900-normal' => array(
+					'font-family' => 'My Font',
+					'font-weight' => '900',
+					'src'         => 'https://example.com/assets/fonts/my-font.ttf.woff2',
+				),
+			),
+		);
+	}
+
+	/**
+	 * Gets the provider definitions.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param string $provider_id Optional. Provider ID to get. Default empty string.
+	 * @return array
+	 */
+	protected function get_provider_definitions( $provider_id = '' ) {
+		$providers = array(
+			'mock'  => array(
+				'id'    => 'mock',
+				'class' => Mock_Provider::class,
+			),
+			'local' => array(
+				'id'    => 'local',
+				'class' => WP_Webfonts_Provider_Local::class,
+			),
+		);
+
+		if ( '' === $provider_id ) {
+			return $providers;
+		}
+
+		if ( isset( $providers[ $provider_id ] ) ) {
+			return $providers[ $provider_id ];
+		}
+
+		return array(
+			'id'    => $provider_id,
+			'class' => '',
+		);
+	}
+
+	/**
+	 * Gets web font definitions for both local and mock providers.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return array|string[][][]
+	 */
+	protected function get_registered_fonts() {
+		return array_merge(
+			$this->get_registered_local_fonts(),
+			$this->get_registered_mock_fonts()
+		);
+	}
+
+	/**
+	 * Returns an array of font-face styles that matches the font definitions
+	 * in get_registered_local_fonts() and get_registered_mock_fonts().
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string[]
+	 */
+	protected function get_registered_fonts_css() {
+		return array(
+			'merriweather-200-900-normal' => <<<CSS
+@font-face{font-family:Merriweather;font-style:normal;font-weight:200 900;font-display:fallback;font-stretch:normal;src:local(Merriweather), url('https://example.com/assets/fonts/merriweather.ttf.woff2') format('woff2');}
+CSS
+		,
+			'Source Serif Pro-300-normal' => <<<CSS
+@font-face{font-family:"Source Serif Pro";font-style:normal;font-weight:300;font-display:fallback;font-stretch:normal;src:local("Source Serif Pro"), url('https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2') format('woff2');}
+CSS
+		,
+			'Source Serif Pro-900-italic' => <<<CSS
+@font-face{font-family:"Source Serif Pro";font-style:italic;font-weight:900;font-display:fallback;font-stretch:normal;src:local("Source Serif Pro"), url('https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2') format('woff2');}
+CSS
+		,
+			'font1-300-normal'            => 'font1-300-normal',
+			'font1-300-italic'            => 'font1-300-italic',
+			'font1-900-normal'            => 'font1-900-normal',
+			'font2-200-900-normal'        => 'font2-200-900-normal',
+			'font2-200-900-italic'        => 'font2-200-900-italic',
+			'font3-bold-normal'           => 'font3-bold-normal',
+		);
+	}
+
+	/**
+	 * Gets web font definitions for local provider.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string[][][]
+	 */
+	protected function get_registered_local_fonts() {
+		return array(
+			'lato'             => array(),
+			'merriweather'     => array(
+				'merriweather-200-900-normal' => array(
+					'provider'     => 'local',
+					'font-family'  => 'Merriweather',
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-display' => 'fallback',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+				),
+			),
+			'Source Serif Pro' => array(
+				'Source Serif Pro-300-normal' => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'normal',
+					'font-weight'  => '300',
+					'font-display' => 'fallback',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'Source Serif Pro-900-italic' => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'italic',
+					'font-weight'  => '900',
+					'font-display' => 'fallback',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+			),
+		);
+	}
+
+	/**
+	 * Gets web font definitions for mock provider.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string[][][]
+	 */
+	protected function get_registered_mock_fonts() {
+		return array(
+			'font1' => array(
+				'font1-300-normal' => array(
+					'provider'     => 'mock',
+					'font-family'  => 'Font 1',
+					'font-weight'  => '300',
+					'font-style'   => 'normal',
+					'font-display' => 'fallback',
+				),
+				'font1-300-italic' => array(
+					'provider'     => 'mock',
+					'font-family'  => 'Font 1',
+					'font-weight'  => '300',
+					'font-style'   => 'italic',
+					'font-display' => 'fallback',
+				),
+				'font1-900-normal' => array(
+					'provider'     => 'mock',
+					'font-family'  => 'Font 1',
+					'font-weight'  => '900',
+					'font-style'   => 'normal',
+					'font-display' => 'fallback',
+				),
+			),
+			'font2' => array(
+				'font2-200-900-normal' => array(
+					'provider'     => 'mock',
+					'font-family'  => 'Font 2',
+					'font-weight'  => '200 900',
+					'font-style'   => 'normal',
+					'font-display' => 'fallback',
+				),
+				'font2-200-900-italic' => array(
+					'provider'     => 'mock',
+					'font-family'  => 'Font 2',
+					'font-weight'  => '200 900',
+					'font-style'   => 'italic',
+					'font-display' => 'fallback',
+				),
+			),
+			'font3' => array(
+				'font3-bold-normal' => array(
+					'provider'     => 'mock',
+					'font-family'  => 'Font 3',
+					'font-weight'  => 'bold',
+					'font-style'   => 'normal',
+					'font-display' => 'fallback',
+					'font-stretch' => 'normal',
+				),
+			),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpDeregisterFontFamily-test.php b/phpunit/webfonts/wpDeregisterFontFamily-test.php
new file mode 100644
index 00000000000000..2487053b6149c5
--- /dev/null
+++ b/phpunit/webfonts/wpDeregisterFontFamily-test.php
@@ -0,0 +1,74 @@
+<?php
+/**
+ * Unit and integration tests for wp_deregister_font_family().
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-testcase.php';
+
+/**
+ * @group webfonts
+ * @group remove_webfonts
+ * @covers ::wp_deregister_font_family
+ * @covers WP_Web_Fonts::remove_font_family
+ */
+class Tests_Webfonts_WpDeregisterFontFamily extends WP_Webfonts_TestCase {
+
+	/**
+	 * Unit test for registering a font-family that mocks WP_Web_Fonts.
+	 *
+	 * @dataProvider data_font_family_handles
+	 *
+	 * @param string $font_family_handle Font family handle to test.
+	 */
+	public function test_unit_should_deregister( $font_family_handle ) {
+		$mock = $this->set_up_mock( 'remove_font_family' );
+		$mock->expects( $this->once() )
+			->method( 'remove_font_family' )
+			->with(
+				$this->identicalTo( $font_family_handle )
+			);
+
+		wp_deregister_font_family( $font_family_handle );
+	}
+
+	/**
+	 * Integration test for enqueuing before registering a font family and all of its variations.
+	 *
+	 * @dataProvider data_font_family_handles
+	 *
+	 * @param string $font_family Font family to test.
+	 */
+	public function test_should_deregister_before_registration( $font_family ) {
+		wp_deregister_font_family( $font_family );
+
+		$this->assertIsArray( $this->get_registered(), 'Registration queue should be an array' );
+		$this->assertEmpty( $this->get_registered(), 'Registration queue should be empty after deregistering' );
+	}
+
+	/**
+	 * Integration test for deregistering a font family and all of its variations.
+	 *
+	 * @dataProvider data_one_to_many_font_families_and_zero_to_many_variations
+	 *
+	 * @param string $font_family        Font family to test.
+	 * @param array  $inputs             Font family(ies) and variations to pre-register.
+	 * @param array  $registered_handles Expected handles after registering.
+	 * @param array  $expected           Array of expected handles.
+	 */
+	public function test_deregister_after_registration( $font_family, array $inputs, array $registered_handles, array $expected ) {
+		foreach ( $inputs as $handle => $variations ) {
+			$this->setup_register( $handle, $variations );
+		}
+		// Test the before state, just to make sure.
+		$this->assertSame( $registered_handles, $this->get_registered_handles(), 'Font family and variations should be registered before deregistering' );
+
+		wp_deregister_font_family( $font_family );
+
+		// Test after deregistering.
+		$this->assertIsArray( $this->get_registered_handles(), 'Registration queue should be an array' );
+		$this->assertSame( $expected, $this->get_registered_handles(), 'Registration queue should match after deregistering' );
+	}
+}
diff --git a/phpunit/webfonts/wpDeregisterWebfontVariation-test.php b/phpunit/webfonts/wpDeregisterWebfontVariation-test.php
new file mode 100644
index 00000000000000..a6a0ab67ad4480
--- /dev/null
+++ b/phpunit/webfonts/wpDeregisterWebfontVariation-test.php
@@ -0,0 +1,298 @@
+<?php
+/**
+ * Unit and integration tests for wp_deregister_webfont_variation().
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @group  remove_webfonts
+ * @covers ::wp_deregister_webfont_variation
+ * @covers WP_Webfonts::remove_variation
+ */
+class Tests_Webfonts_WpDeregisterWebfontVariation extends WP_Webfonts_TestCase {
+	private $wp_webfonts;
+	private $fonts_to_register = array();
+
+	public function set_up() {
+		parent::set_up();
+		$this->wp_webfonts       = wp_webfonts();
+		$this->fonts_to_register = $this->get_registered_local_fonts();
+	}
+
+	/**
+	 * Sets up the unit test by mocking the WP_Dependencies object using stdClass and
+	 * registering each font family directly to the WP_Webfonts::$registered property
+	 * and its variations to the mocked $deps property.
+	 */
+	private function setup_unit_test() {
+		$this->setup_registration_mocks( $this->fonts_to_register, $this->wp_webfonts );
+	}
+
+	/**
+	 * Sets up the integration test by properly registering each font family and its variations
+	 * by using the WP_Webfonts::add() and WP_Webfonts::add_variation() methods.
+	 */
+	private function setup_integration_test() {
+		foreach ( $this->fonts_to_register as $font_family_handle => $variations ) {
+			$this->setup_register( $font_family_handle, $variations, $this->wp_webfonts );
+		}
+	}
+
+	/**
+	 * Testing the test setup to ensure it works.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 */
+	public function test_mocked_setup( $font_family_handle, $variation_handle ) {
+		$this->setup_unit_test();
+
+		$this->assertArrayHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be in the registered queue before removal' );
+		$this->assertContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should be in its font family deps before removal' );
+	}
+
+	/**
+	 * Unit test for deregistering a font-family's variation using mock of WP_Webfonts.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family to test.
+	 * @param string $variation_handle   Variation's handle to test.
+	 */
+	public function test_should_deregister_when_mocked( $font_family_handle, $variation_handle ) {
+		$mock = $this->set_up_mock( 'remove_variation' );
+		$mock->expects( $this->once() )
+			->method( 'remove_variation' )
+			->with(
+				$this->identicalTo( $font_family_handle, $variation_handle )
+			);
+
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+	}
+
+	/**
+	 * Unit test.
+	 *
+	 * @dataProvider data_should_do_nothing
+	 *
+	 * @param string $font_family        Font family name.
+	 * @param string $font_family_handle Font family handle.
+	 * @param string $variation_handle   Variation handle to remove.
+	 */
+	public function test_unit_should_do_nothing_when_variation_and_font_family_not_registered( $font_family, $font_family_handle, $variation_handle ) {
+		// Set up the test.
+		unset( $this->fonts_to_register[ $font_family ] );
+		$this->setup_unit_test();
+		$registered_queue = $this->wp_webfonts->registered;
+
+		// Run the tests.
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $font_family_handle, $this->wp_webfonts->registered, 'Font family should not be registered' );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
+		$this->assertSame( $registered_queue, $this->wp_webfonts->registered, 'Registered queue should not have changed' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_should_do_nothing
+	 *
+	 * @param string $font_family        Font family name.
+	 * @param string $font_family_handle Font family handle.
+	 * @param string $variation_handle   Variation handle to remove.
+	 */
+	public function test_should_do_nothing_when_variation_and_font_family_not_registered( $font_family, $font_family_handle, $variation_handle ) {
+		// Set up the test.
+		unset( $this->fonts_to_register[ $font_family ] );
+		$this->setup_integration_test();
+		$registered_queue = $this->wp_webfonts->get_registered();
+
+		// Run the tests.
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $font_family_handle, $this->wp_webfonts->registered, 'Font family should not be registered' );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
+		$this->assertSameSets( $registered_queue, $this->wp_webfonts->get_registered(), 'Registered queue should not have changed' );
+	}
+
+	/**
+	 * Data provider for testing removal of variations.
+	 *
+	 * @return array
+	 */
+	public function data_should_do_nothing() {
+		return array(
+			'Font with 1 variation'         => array(
+				'font_family'        => 'merriweather',
+				'font_family_handle' => 'merriweather',
+				'variation_handle'   => 'merriweather-200-900-normal',
+			),
+			'Font with multiple variations' => array(
+				'font_family'        => 'Source Serif Pro',
+				'font_family_handle' => 'source-serif-pro',
+				'variation_handle'   => 'Source Serif Pro-300-normal',
+			),
+		);
+	}
+
+	/**
+	 * Unit test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_unit_should_only_remove_from_font_family_deps_when_variation_not_in_queue( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_unit_test();
+		$this->setup_remove_variation_from_registered( $variation_handle );
+
+		// Run the tests.
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_should_only_remove_from_font_family_deps_when_variation_not_in_queue( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_integration_test();
+		$this->setup_remove_variation_from_registered( $variation_handle );
+
+		// Run the tests.
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Unit test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_unit_should_remove_variation_from_registered_queue_though_font_family_not_registered( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_unit_test();
+		$this->setup_remove_from_font_family_deps( $font_family_handle, $variation_handle );
+
+		$this->assertArrayNotHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should not be in its font family deps before removal' );
+
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_should_remove_variation_from_registered_queue_though_font_family_not_registered( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_integration_test();
+		$this->setup_remove_from_font_family_deps( $font_family_handle, $variation_handle );
+
+		$this->assertArrayNotHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should not be in its font family deps before removal' );
+
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Unit test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_unit_should_remove_variation_from_queue_and_font_family_deps( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_unit_test();
+
+		$this->assertArrayHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should be in its font family deps before removal' );
+
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be not be in registered queue' );
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_should_remove_variation_from_queue_and_font_family_deps( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_integration_test();
+
+		$this->assertArrayHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should be in its font family deps before removal' );
+
+		wp_deregister_webfont_variation( $font_family_handle, $variation_handle );
+
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be not be in registered queue' );
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Remove the variation handle from the font family's deps.
+	 *
+	 * @param string $font_family_handle Font family.
+	 * @param string $variation_handle   The variation handle to remove.
+	 */
+	private function setup_remove_from_font_family_deps( $font_family_handle, $variation_handle ) {
+		foreach ( $this->wp_webfonts->registered[ $font_family_handle ]->deps as $index => $vhandle ) {
+			if ( $variation_handle !== $vhandle ) {
+				continue;
+			}
+			unset( $this->wp_webfonts->registered[ $font_family_handle ]->deps[ $index ] );
+			break;
+		}
+	}
+
+	/**
+	 * Removes the variation from the WP_Webfonts::$registered queue.
+	 *
+	 * @param string $variation_handle The variation handle to remove.
+	 */
+	private function setup_remove_variation_from_registered( $variation_handle ) {
+		unset( $this->wp_webfonts->registered[ $variation_handle ] );
+	}
+}
diff --git a/phpunit/webfonts/wpEnqueueWebfontVariations-test.php b/phpunit/webfonts/wpEnqueueWebfontVariations-test.php
new file mode 100644
index 00000000000000..f6ce62d3f47ee0
--- /dev/null
+++ b/phpunit/webfonts/wpEnqueueWebfontVariations-test.php
@@ -0,0 +1,82 @@
+<?php
+/**
+ * Unit and integration tests for wp_enqueue_webfont_variations().
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers ::wp_enqueue_webfont_variations
+ * @covers WP_Webfonts::enqueue
+ */
+class Tests_Webfonts_WpEnqueueWebfontVariations extends WP_Webfonts_TestCase {
+
+	/**
+	 * Unit test for registering one or more specific variations that mocks WP_Webfonts.
+	 *
+	 * @dataProvider data_variation_handles
+	 *
+	 * @param string|string[] $handles Variation handles to test.
+	 */
+	public function test_unit_should_enqueue( $handles ) {
+		$mock = $this->set_up_mock( 'enqueue' );
+		$mock->expects( $this->once() )
+			->method( 'enqueue' )
+			->with(
+				$this->identicalTo( $handles )
+			);
+
+		wp_enqueue_webfont_variations( $handles );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_variation_handles() {
+		return array(
+			'1 variation handle'                   => array( 'merriweather-200-900-normal' ),
+			'multiple same font family handles'    => array( array( 'Source Serif Pro-300-normal', 'Source Serif Pro-900-italic' ) ),
+			'handles from different font families' => array( array( 'merriweather-200-900-normal', 'Source Serif Pro-900-italic' ) ),
+		);
+	}
+
+	/**
+	 * Integration test for enqueuing one or more specific variations.
+	 *
+	 * @dataProvider data_enqueue_variations
+	 *
+	 * @param string|string[] $handles  Variation handles to test.
+	 * @param array           $expected Expected queue.
+	 */
+	public function test_should_enqueue_after_registration( $handles, array $expected ) {
+		foreach ( $this->get_data_registry() as $handle => $variations ) {
+			$this->setup_register( $handle, $variations );
+		}
+
+		wp_enqueue_webfont_variations( $handles );
+		$this->assertEmpty( $this->get_queued_before_register(), '"queued_before_register" queue should be empty' );
+		$this->assertSame( $expected, $this->get_enqueued_handles(), 'Queue should contain the given handles' );
+	}
+
+	/**
+	 * Integration test for enqueuing before registering one or more specific variations.
+	 *
+	 * @dataProvider data_enqueue_variations
+	 *
+	 * @param string|string[] $handles  Variation handles to test.
+	 * @param array           $not_used Not used.
+	 * @param array           $expected Expected "queued_before_register" queue.
+	 */
+	public function test_should_enqueue_before_registration( $handles, array $not_used, array $expected ) {
+		wp_enqueue_webfont_variations( $handles );
+
+		$this->assertSame( $expected, $this->get_queued_before_register(), '"queued_before_register" queue should contain the given handles' );
+		$this->assertEmpty( $this->get_enqueued_handles(), 'Queue should be empty' );
+	}
+}
diff --git a/phpunit/webfonts/wpEnqueueWebfonts-test.php b/phpunit/webfonts/wpEnqueueWebfonts-test.php
new file mode 100644
index 00000000000000..a0ee6af5c1ddad
--- /dev/null
+++ b/phpunit/webfonts/wpEnqueueWebfonts-test.php
@@ -0,0 +1,122 @@
+<?php
+/**
+ * Unit and integration tests for wp_enqueue_webfonts().
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers ::wp_enqueue_webfonts
+ * @covers WP_Web_Fonts::enqueue
+ */
+class Tests_Webfonts_WpEnqueueWebfonts extends WP_Webfonts_TestCase {
+
+	/**
+	 * Unit test for registering a font-family that mocks WP_Web_Fonts.
+	 *
+	 * @dataProvider data_should_enqueue
+	 *
+	 * @param string[] $font_families    Font families to test.
+	 * @param string[] $expected_handles Expected handles passed to WP_Web_Fonts::enqueue().
+	 */
+	public function test_unit_should_enqueue( $font_families, $expected_handles ) {
+		$mock = $this->set_up_mock( 'enqueue' );
+		$mock->expects( $this->once() )
+			->method( 'enqueue' )
+			->with(
+				$this->identicalTo( $expected_handles )
+			);
+
+		wp_enqueue_webfonts( $font_families );
+	}
+
+	/**
+	 * Integration test for enqueuing a font family and all of its variations.
+	 *
+	 * @dataProvider data_should_enqueue
+	 *
+	 * @param string[] $font_families    Font families to test.
+	 * @param string[] $expected_handles Expected handles passed to WP_Web_Fonts::enqueue().
+	 */
+	public function test_should_enqueue_after_registration( $font_families, $expected_handles ) {
+		// Register the font-families.
+		foreach ( $this->get_data_registry() as $handle => $variations ) {
+			$this->setup_register( $handle, $variations );
+		}
+
+		wp_enqueue_webfonts( $font_families );
+
+		$this->assertEmpty( $this->get_queued_before_register(), '"queued_before_register" queue should be empty' );
+		$this->assertSame( $expected_handles, $this->get_enqueued_handles(), 'Queue should contain the given font family(ies)' );
+	}
+
+	/**
+	 * Integration test for enqueuing before registering a font family and all of its variations.
+	 *
+	 * @dataProvider data_should_enqueue
+	 *
+	 * @param string[] $font_families    Font families to test.
+	 * @param string[] $expected_handles Expected handles passed to WP_Web_Fonts::enqueue().
+	 */
+	public function test_should_enqueue_before_registration( $font_families, $expected_handles ) {
+		wp_enqueue_webfonts( $font_families );
+
+		// Set up what "queued_before_register" queue should be.
+		$expected = array();
+		foreach ( $expected_handles as $handle ) {
+			$expected[ $handle ] = null;
+		}
+		$this->assertSame( $expected, $this->get_queued_before_register(), '"queued_before_register" queue should contain the given font family(ies)' );
+		$this->assertEmpty( $this->get_enqueued_handles(), 'Queue should be empty' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_should_enqueue() {
+		return array(
+			'1: single word handle'                 => array(
+				'font_families'    => array( 'lato' ),
+				'expected_handles' => array( 'lato' ),
+			),
+			'1: multiple word handle'               => array(
+				'font_families'    => array( 'source-serif-pro' ),
+				'expected_handles' => array( 'source-serif-pro' ),
+			),
+			'1: single word name'                   => array(
+				'font_families'    => array( 'Merriweather' ),
+				'expected_handles' => array( 'merriweather' ),
+			),
+			'1: multiple word name'                 => array(
+				'font_families'    => array( 'My Font' ),
+				'expected_handles' => array( 'my-font' ),
+			),
+			'>1: single word handle'                => array(
+				'font_families'    => array( 'lato', 'merriweather' ),
+				'expected_handles' => array( 'lato', 'merriweather' ),
+			),
+			'>1: multiple word handle'              => array(
+				'font_families'    => array( 'source-serif-pro', 'my-font' ),
+				'expected_handles' => array( 'source-serif-pro', 'my-font' ),
+			),
+			'>1: single word name'                  => array(
+				'font_families'    => array( 'Lato', 'Merriweather' ),
+				'expected_handles' => array( 'lato', 'merriweather' ),
+			),
+			'>1: multiple word name'                => array(
+				'font_families'    => array( 'My Font', 'Source Serif Pro' ),
+				'expected_handles' => array( 'my-font', 'source-serif-pro' ),
+			),
+			'>1: mixture of word handles and names' => array(
+				'font_families'    => array( 'Source Serif Pro', 'Merriweather', 'my-font', 'Lato' ),
+				'expected_handles' => array( 'source-serif-pro', 'merriweather', 'my-font', 'lato' ),
+			),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpPrintWebfonts-test.php b/phpunit/webfonts/wpPrintWebfonts-test.php
new file mode 100644
index 00000000000000..3f782fec580fd7
--- /dev/null
+++ b/phpunit/webfonts/wpPrintWebfonts-test.php
@@ -0,0 +1,127 @@
+<?php
+/**
+ * Unit and integration tests for wp_print_webfonts().
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-testcase.php';
+require_once __DIR__ . '/../fixtures/mock-provider.php';
+
+/**
+ * @group  webfonts
+ * @covers ::wp_print_webfonts
+ */
+class Tests_Webfonts_WpPrintWebfonts extends WP_Webfonts_TestCase {
+
+	public function test_should_return_empty_array_when_global_not_instance() {
+		global $wp_webfonts;
+		wp_webfonts();
+		$wp_webfonts = null;
+
+		$this->assertSame( array(), wp_print_webfonts() );
+		$this->assertNotInstanceOf( WP_Webfonts::class, $wp_webfonts );
+	}
+
+	/**
+	 * Unit test to mock WP_Webfonts::do_items().
+	 *
+	 * @dataProvider data_mocked_handles
+	 *
+	 * @param string|string[]|false $handles  Handles to test.
+	 * @param array|string[]        $expected Expected array of processed handles.
+	 */
+	public function test_should_return_mocked_handles( $handles, $expected ) {
+		$mock = $this->set_up_mock( 'do_items' );
+		$mock->expects( $this->once() )
+			->method( 'do_items' )
+			->with(
+				$this->identicalTo( $handles )
+			)
+			->will( $this->returnValue( $expected ) );
+
+		wp_print_webfonts( $handles );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_mocked_handles() {
+		return array(
+			'no handles'          => array(
+				'handles'  => false,
+				'expected' => array(),
+			),
+			'font family handles' => array(
+				'handles'  => array( 'my-custom-font' ),
+				'expected' => array( 'my-custom-font' ),
+			),
+		);
+	}
+
+	/**
+	 * Integration test that registers providers and fonts and then enqueues before
+	 * testing the printing functionality.
+	 *
+	 * @dataProvider data_print_enqueued
+	 *
+	 * @param array  $setup           Test set up information for provider, fonts, and enqueued.
+	 * @param array  $expected_done   Expected array of printed handles.
+	 * @param string $expected_output Expected printed output.
+	 */
+	public function test_should_print_enqueued( $setup, $expected_done, $expected_output ) {
+		$wp_webfonts = wp_webfonts();
+
+		$this->setup_integrated_deps( $setup, $wp_webfonts );
+
+		$this->expectOutputString( $expected_output );
+		$actual_done = wp_print_webfonts();
+		$this->assertSameSets( $expected_done, $actual_done, 'Printed handles should match' );
+	}
+
+	/**
+	 * Integration test to validate printing given handles. Rather than mocking internal functionality,
+	 * it registers providers and fonts but does not enqueue.
+	 *
+	 * @dataProvider data_print_enqueued
+	 *
+	 * @param array  $setup           Test set up information for provider, fonts, and enqueued.
+	 * @param array  $expected_done   Expected array of printed handles.
+	 * @param string $expected_output Expected printed output.
+	 */
+	public function test_should_print_handles_when_not_enqueued( $setup, $expected_done, $expected_output ) {
+		$wp_webfonts = wp_webfonts();
+
+		$this->setup_integrated_deps( $setup, $wp_webfonts, false );
+		// Do not enqueue. Instead, pass the handles to wp_print_webfonts().
+		$handles = $setup['enqueued'];
+		$this->assertEmpty( $wp_webfonts->queue, 'No fonts should be enqueued' );
+
+		$this->expectOutputString( $expected_output );
+		$actual_done = wp_print_webfonts( $handles );
+		$this->assertSameSets( $expected_done, $actual_done, 'Printed handles should match' );
+	}
+
+	/**
+	 * Sets up the dependencies for integration test.
+	 *
+	 * @param array        $setup       Dependencies to set up.
+	 * @param WP_Web_Fonts $wp_webfonts Instance of WP_Web_Fonts.
+	 * @param bool         $enqueue     Whether to enqueue. Default true.
+	 */
+	private function setup_integrated_deps( array $setup, $wp_webfonts, $enqueue = true ) {
+		foreach ( $setup['provider'] as $provider ) {
+			$wp_webfonts->register_provider( $provider['id'], $provider['class'] );
+		}
+		foreach ( $setup['registered'] as $handle => $variations ) {
+			$this->setup_register( $handle, $variations, $wp_webfonts );
+		}
+
+		if ( $enqueue ) {
+			$wp_webfonts->enqueue( $setup['enqueued'] );
+		}
+	}
+}
diff --git a/phpunit/webfonts/wpRegisterWebfontProvider-test.php b/phpunit/webfonts/wpRegisterWebfontProvider-test.php
new file mode 100644
index 00000000000000..8f1367d6dbb23d
--- /dev/null
+++ b/phpunit/webfonts/wpRegisterWebfontProvider-test.php
@@ -0,0 +1,96 @@
+<?php
+/**
+ * Unit tests for wp_register_webfont_provider().
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-testcase.php';
+require_once __DIR__ . '/../fixtures/mock-provider.php';
+
+/**
+ * @group  webfonts
+ * @covers ::wp_register_webfont_provider
+ */
+class Tests_Webfonts_WpRegisterWebfontProvider extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_register_providers
+	 *
+	 * @param string $provider_id Provider ID.
+	 * @param string $class       Provider class name.
+	 */
+	public function test_should_register_provider( $provider_id, $class ) {
+		$mock = $this->set_up_mock( 'register_provider' );
+		$mock->expects( $this->once() )
+			->method( 'register_provider' )
+			->with(
+				$this->identicalTo( $provider_id ),
+				$this->identicalTo( $class )
+			)
+			->will( $this->returnValue( true ) );
+
+		$this->assertTrue( wp_register_webfont_provider( $provider_id, $class ), 'wp_register_webfont_provider() should return true' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_register_providers() {
+		return array(
+			'mock'  => array(
+				'provider_id' => 'mock',
+				'class'       => Mock_Provider::class,
+			),
+			'local' => array(
+				'provider_id' => 'local',
+				'class'       => WP_Webfonts_Provider_Local::class,
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_invalid_providers
+	 *
+	 * @param string $provider_id Provider ID.
+	 * @param string $class       Provider class name.
+	 */
+	public function test_should_not_register( $provider_id, $class ) {
+		$mock = $this->set_up_mock( 'register_provider' );
+		$mock->expects( $this->once() )
+			->method( 'register_provider' )
+			->with(
+				$this->identicalTo( $provider_id ),
+				$this->identicalTo( $class )
+			)
+			->will( $this->returnValue( false ) );
+
+		$this->assertFalse( wp_register_webfont_provider( $provider_id, $class ), 'wp_register_webfont_provider() should return false' );
+
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_invalid_providers() {
+		return array(
+			'provider_id is empty' => array(
+				'provider_id' => '',
+				'class'       => Mock_Provider::class,
+			),
+			'class is empty'       => array(
+				'provider_id' => 'local',
+				'class'       => '',
+			),
+			'class does not exist' => array(
+				'provider_id' => 'doesnotexist',
+				'class'       => 'Provider_Does_Not_Exist',
+			),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpRegisterWebfonts-test.php b/phpunit/webfonts/wpRegisterWebfonts-test.php
new file mode 100644
index 00000000000000..11dbf9d73c2ea3
--- /dev/null
+++ b/phpunit/webfonts/wpRegisterWebfonts-test.php
@@ -0,0 +1,325 @@
+<?php
+/**
+ * Integration tests for wp_register_webfonts().
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers ::wp_register_webfonts
+ * @covers WP_Web_Fonts::add
+ * @covers WP_Web_Fonts::add_variation
+ */
+class Tests_Webfonts_WpRegisterWebfonts extends WP_Webfonts_TestCase {
+	use WP_Webfonts_Tests_Datasets;
+
+	/**
+	 * @dataProvider data_webfonts
+	 *
+	 * @param array $webfonts Array of webfonts to test.
+	 * @param array $expected Expected results.
+	 */
+	public function test_should_register( array $webfonts, array $expected ) {
+		$actual = wp_register_webfonts( $webfonts );
+		$this->assertSame( $expected['wp_register_webfonts'], $actual, 'Font family handle(s) should be returned' );
+		$this->assertSame( $expected['get_registered'], $this->get_registered_handles(), 'Web fonts should match registered queue' );
+	}
+
+	/**
+	 * @dataProvider data_webfonts
+	 *
+	 * @param array $webfonts Array of webfonts to test.
+	 */
+	public function test_should_not_enqueue_on_registration( array $webfonts ) {
+		wp_register_webfonts( $webfonts );
+		$this->assertEmpty( $this->get_enqueued_handles() );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_webfonts() {
+		return array(
+			'font family keyed with slug' => array(
+				'webfonts' => array(
+					'source-serif-pro' => array(
+						array(
+							'provider'     => 'local',
+							'font-family'  => 'Source Serif Pro',
+							'font-style'   => 'normal',
+							'font-weight'  => '200 900',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+							'font-display' => 'fallback',
+						),
+					),
+				),
+				'expected' => array(
+					'wp_register_webfonts' => array( 'source-serif-pro' ),
+					'get_registered'       => array(
+						'source-serif-pro',
+						'source-serif-pro-200-900-normal',
+					),
+				),
+			),
+			'font family keyed with name' => array(
+				'webfonts' => array(
+					'Source Serif Pro' => array(
+						array(
+							'provider'     => 'local',
+							'font-family'  => 'Source Serif Pro',
+							'font-style'   => 'normal',
+							'font-weight'  => '200 900',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+							'font-display' => 'fallback',
+						),
+						array(
+							'provider'     => 'local',
+							'font-family'  => 'Source Serif Pro',
+							'font-style'   => 'italic',
+							'font-weight'  => '200 900',
+							'font-stretch' => 'normal',
+							'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+							'font-display' => 'fallback',
+						),
+					),
+				),
+				'expected' => array(
+					'wp_register_webfonts' => array( 'source-serif-pro' ),
+					'get_registered'       => array(
+						'source-serif-pro',
+						'source-serif-pro-200-900-normal',
+						'source-serif-pro-200-900-italic',
+					),
+				),
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_deprecated_structure
+	 *
+	 * @param array $webfonts Webfonts to test.
+	 */
+	public function test_should_throw_deprecation_with_deprecated_structure( array $webfonts ) {
+		$this->expectDeprecation();
+		$this->expectDeprecationMessage(
+			'A deprecated web fonts array structure passed to wp_register_webfonts(). ' .
+			'Variations must be grouped and keyed by their font family.'
+		);
+
+		wp_register_webfonts( $webfonts );
+	}
+
+	/**
+	 * @dataProvider data_deprecated_structure
+	 *
+	 * @param array $webfonts Webfonts to test.
+	 * @param array $expected Expected results.
+	 */
+	public function test_should_register_with_deprecated_structure( array $webfonts, array $expected ) {
+		$this->suppress_deprecations();
+
+		$actual = wp_register_webfonts( $webfonts );
+		$this->assertSame( $expected['wp_register_webfonts'], $actual, 'Font family handle(s) should be returned' );
+		$this->assertSame( $expected['get_registered'], $this->get_registered_handles(), 'Web fonts should match registered queue' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_deprecated_structure() {
+		return array(
+			'1 web font'                           => array(
+				'webfonts' => array(
+					array(
+						'provider'     => 'local',
+						'font-family'  => 'Merriweather',
+						'font-style'   => 'normal',
+						'font-weight'  => '200 900',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+					),
+				),
+				'expected' => array(
+					'wp_register_webfonts' => array( 'merriweather' ),
+					'get_registered'       => array( 'merriweather', 'merriweather-200-900-normal' ),
+				),
+			),
+			'2 web font in same font family'       => array(
+				'webfonts' => array(
+					array(
+						'provider'     => 'local',
+						'font-family'  => 'Source Serif Pro',
+						'font-style'   => 'normal',
+						'font-weight'  => '300',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+						'font-display' => 'fallback',
+					),
+					array(
+						'provider'     => 'local',
+						'font-family'  => 'Source Serif Pro',
+						'font-style'   => 'italic',
+						'font-weight'  => '900',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+						'font-display' => 'fallback',
+					),
+				),
+				'expected' => array(
+					'wp_register_webfonts' => array( 'source-serif-pro' ),
+					'get_registered'       => array(
+						'source-serif-pro',
+						'source-serif-pro-300-normal',
+						'source-serif-pro-900-italic',
+					),
+				),
+			),
+			'Web fonts in different font families' => array(
+				'webfonts' => array(
+					array(
+						'provider'     => 'local',
+						'font-family'  => 'Source Serif Pro',
+						'font-style'   => 'normal',
+						'font-weight'  => '300',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+						'font-display' => 'fallback',
+					),
+					array(
+						'provider'     => 'local',
+						'font-family'  => 'Merriweather',
+						'font-style'   => 'normal',
+						'font-weight'  => '200 900',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+					),
+					array(
+						'provider'     => 'local',
+						'font-family'  => 'Source Serif Pro',
+						'font-style'   => 'italic',
+						'font-weight'  => '900',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+						'font-display' => 'fallback',
+					),
+				),
+				'expected' => array(
+					'wp_register_webfonts' => array( 'source-serif-pro', 'merriweather' ),
+					'get_registered'       => array(
+						'source-serif-pro',
+						'source-serif-pro-300-normal',
+						'source-serif-pro-900-italic',
+						'merriweather',
+						'merriweather-200-900-normal',
+					),
+				),
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_invalid_font_family
+	 *
+	 * @param array  $webfonts         Web fonts to test.
+	 * @param string $expected_message Expected notice message.
+	 */
+	public function test_should_not_register_with_undefined_font_family( array $webfonts, $expected_message ) {
+		$this->suppress_deprecations();
+
+		$this->expectNotice();
+		$this->expectNoticeMessage( $expected_message );
+
+		$actual = wp_register_webfonts( $webfonts );
+		$this->assertSame( array(), $actual, 'Return value should be an empty array' );
+		$this->assertEmpty( $this->get_registered_handles(), 'No Web fonts should have registered' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_invalid_font_family() {
+		return array(
+			'non-string'                                  => array(
+				'webfonts'         => array(
+					array(
+						'provider'     => 'local',
+						'font-family'  => null,
+						'font-style'   => 'normal',
+						'font-weight'  => '200 900',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+					),
+				),
+				'expected_message' => 'Font family not defined in the variation.',
+			),
+			'empty string in deprecated structure'        => array(
+				'webfonts'         => array(
+					'0' => array(
+						'provider'     => 'local',
+						'font-style'   => 'normal',
+						'font-weight'  => '300',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+						'font-display' => 'fallback',
+					),
+				),
+				'expected_message' => 'Font family not found.',
+			),
+			'incorrect parameter in deprecated structure' => array(
+				'webfonts'         => array(
+					array(
+						'provider'     => 'local',
+						'FontFamily'   => 'Source Serif Pro',
+						'font-style'   => 'normal',
+						'font-weight'  => '300',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+						'font-display' => 'fallback',
+					),
+					array(
+						'provider'     => 'local',
+						'font_family'  => 'Merriweather',
+						'font-style'   => 'normal',
+						'font-weight'  => '200 900',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+					),
+					array(
+						'provider'     => 'local',
+						'font family'  => 'Source Serif Pro',
+						'font-style'   => 'italic',
+						'font-weight'  => '900',
+						'font-display' => 'fallback',
+						'font-stretch' => 'normal',
+						'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+						'font-display' => 'fallback',
+					),
+				),
+				'expected_message' => 'Font family not found.',
+			),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts-test.php b/phpunit/webfonts/wpWebfonts-test.php
new file mode 100644
index 00000000000000..17ab8c60583fae
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts-test.php
@@ -0,0 +1,38 @@
+<?php
+/**
+ * Unit and integration tests for wp_webfonts().
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers ::wp_webfonts
+ */
+class Tests_Webfonts_WpWebfonts extends WP_Webfonts_TestCase {
+
+	public function test_returns_instance() {
+		$this->assertInstanceOf( WP_Web_Fonts::class, wp_webfonts() );
+	}
+
+	public function test_global_set() {
+		global $wp_webfonts;
+		$this->assertNull( $wp_webfonts );
+		$instance = wp_webfonts();
+		$this->assertInstanceOf( WP_Web_Fonts::class, $wp_webfonts );
+		$this->assertSame( $instance, $wp_webfonts );
+	}
+
+	public function test_local_provider_is_automatically_registered() {
+		$expected = array(
+			'local' => array(
+				'class' => 'WP_Webfonts_Provider_Local',
+				'fonts' => array(),
+			),
+		);
+		$this->assertSame( $expected, wp_webfonts()->get_providers() );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/add-test.php b/phpunit/webfonts/wpWebfonts/add-test.php
new file mode 100644
index 00000000000000..a432c7e8572129
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/add-test.php
@@ -0,0 +1,45 @@
+<?php
+/**
+ * WP_Web_Fonts::add() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::add
+ */
+class Tests_Webfonts_WpWebfonts_Add extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_handles
+	 *
+	 * @param string $handle Handle to register.
+	 */
+	public function test_add( $handle ) {
+		$wp_webfonts = new WP_Web_Fonts();
+
+		$this->assertTrue( $wp_webfonts->add( $handle, false ), 'Registering a handle should return true' );
+		$this->assertCount( 1, $wp_webfonts->registered );
+		$this->assertArrayHasKey( $handle, $wp_webfonts->registered, 'Font family handle should be in the registry after registration' );
+
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_handles() {
+		return array(
+			'name: multiple'    => array( 'Source Serif Pro' ),
+			'handle: multiple'  => array( 'source-serif-pro' ),
+			'name: single'      => array( 'Merriweather' ),
+			'handle: single'    => array( 'merriweather' ),
+			'handle: variation' => array( 'my-custom-font-200-900-normal' ),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/addFontFamily-test.php b/phpunit/webfonts/wpWebfonts/addFontFamily-test.php
new file mode 100644
index 00000000000000..4aa5e55b1ef3cb
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/addFontFamily-test.php
@@ -0,0 +1,66 @@
+<?php
+/**
+ * WP_Web_Fonts::add_font_family() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::add_font_family
+ */
+class Tests_Webfonts_WpWebfonts_AddFontFamily extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_handles
+	 *
+	 * @param string $font_family Font family to register.
+	 * @param string $expected    Expected handle.
+	 */
+	public function test_should_register( $font_family, $expected ) {
+		$wp_webfonts        = new WP_Web_Fonts();
+		$font_family_handle = $wp_webfonts->add_font_family( $font_family );
+
+		$this->assertSame( $expected, $font_family_handle, 'Registering a font-family should return its handle' );
+		$this->assertCount( 1, $wp_webfonts->registered );
+		$this->assertArrayHasKey( $font_family_handle, $wp_webfonts->registered, 'Font family handle should be in the registry after registration' );
+
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_handles() {
+		return array(
+			'name: multiple'               => array(
+				'font_family' => 'Source Serif Pro',
+				'expected'    => 'source-serif-pro',
+			),
+			'handle: multiple'             => array(
+				'font_family' => 'source-serif-pro',
+				'expected'    => 'source-serif-pro',
+			),
+			'name: single'                 => array(
+				'font_family' => 'Merriweather',
+				'expected'    => 'merriweather',
+			),
+			'handle: single'               => array(
+				'font_family' => 'merriweather',
+				'expected'    => 'merriweather',
+			),
+			'handle: variation'            => array(
+				'font_family' => 'my-custom-font-200-900-normal',
+				'expected'    => 'my-custom-font-200-900-normal',
+			),
+			'name: multiple font-families' => array(
+				'font_family' => 'Source Serif Pro, Merriweather',
+				'expected'    => 'source-serif-pro',
+			),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/addVariation-test.php b/phpunit/webfonts/wpWebfonts/addVariation-test.php
new file mode 100644
index 00000000000000..5f948b81fd146b
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/addVariation-test.php
@@ -0,0 +1,149 @@
+<?php
+/**
+ * WP_Web_Fonts::add_variation() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::add_variation
+ */
+class Tests_Webfonts_WpWebfonts_AddVariation extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_valid_variation
+	 *
+	 * @param string|bool $expected           Expected results.
+	 * @param string      $font_family_handle The font family's handle for this variation.
+	 * @param array       $variation          An array of variation properties to add.
+	 * @param string      $variation_handle   Optional. The variation's handle.
+	 */
+	public function test_should_register_variation_when_font_family_is_registered( $expected, $font_family_handle, array $variation, $variation_handle = '' ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		$wp_webfonts->add( $font_family_handle, false );
+
+		$variation_handle = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		$this->assertSame( $expected, $variation_handle, 'Registering a variation should return its handle' );
+		$this->assertArrayHasKey( $variation_handle, $wp_webfonts->registered, 'Variation handle should be in the registry after registration' );
+		$this->assertSame( array( $expected ), $this->get_variations( $font_family_handle, $wp_webfonts ), 'Variation should be registered to font family' );
+	}
+
+	/**
+	 * @dataProvider data_valid_variation
+	 *
+	 * @param string|bool $expected           Expected results.
+	 * @param string      $font_family_handle The font family's handle for this variation.
+	 * @param array       $variation          An array of variation properties to add.
+	 * @param string      $variation_handle   Optional. The variation's handle.
+	 */
+	public function test_should_not_reregister_font_family( $expected, $font_family_handle, array $variation, $variation_handle = '' ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		$wp_webfonts->add( $font_family_handle, false );
+
+		$variation_handle = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+
+		// Font family should appear only once in the registered queue.
+		$expected = array( $font_family_handle, $variation_handle );
+		$this->assertSame( $expected, array_keys( $wp_webfonts->registered ), 'Font family should not be re-registered after registering a variation' );
+	}
+
+	/**
+	 * @dataProvider data_valid_variation
+	 *
+	 * @param string|bool $expected           Expected results.
+	 * @param string      $font_family_handle The font family's handle for this variation.
+	 * @param array       $variation          An array of variation properties to add.
+	 * @param string      $variation_handle   Optional. The variation's handle.
+	 */
+	public function test_should_not_reregister_variation( $expected, $font_family_handle, array $variation, $variation_handle = '' ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		$wp_webfonts->add( $font_family_handle, false );
+
+		// Set up the test.
+		$variation_handle = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+
+		// Run the test.
+		$variant_handle_on_reregister = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		$this->assertSame( $expected, $variant_handle_on_reregister, 'Variation should be registered to font family' );
+		$this->assertSame( $variation_handle, $variant_handle_on_reregister, 'Variation should return the previously registered variant handle' );
+		$this->assertSame( array( $variation_handle ), $this->get_variations( $font_family_handle, $wp_webfonts ), 'Variation should only be registered once' );
+
+		$this->assertCount( 2, $wp_webfonts->registered );
+		$this->assertArrayHasKey( $variation_handle, $wp_webfonts->registered, 'Variation handle should be in the registry after registration' );
+	}
+
+	/**
+	 * @dataProvider data_valid_variation
+	 *
+	 * @param string|bool $expected           Expected results.
+	 * @param string      $font_family_handle The font family's handle for this variation.
+	 * @param array       $variation          An array of variation properties to add.
+	 * @param string      $variation_handle   Optional. The variation's handle.
+	 */
+	public function test_should_register_font_family_and_variation( $expected, $font_family_handle, array $variation, $variation_handle = '' ) {
+		$wp_webfonts = new WP_Web_Fonts();
+
+		$variation_handle = $wp_webfonts->add_variation( $font_family_handle, $variation, $variation_handle );
+		$this->assertSame( $expected, $variation_handle, 'Variation should return its registered handle' );
+
+		// Extra checks to ensure both are registered.
+		$this->assertCount( 2, $wp_webfonts->registered );
+		$this->assertArrayHasKey( $font_family_handle, $wp_webfonts->registered, 'Font family handle should be in the registry after registration' );
+		$this->assertArrayHasKey( $variation_handle, $wp_webfonts->registered, 'Variation handle should be in the registry after registration' );
+		$this->assertSame( array( $variation_handle ), $this->get_variations( $font_family_handle, $wp_webfonts ), 'Variation should be registered to the font family' );
+	}
+
+	/**
+	 * @dataProvider data_font_family_handle_undefined
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param array  $variation          An array of variation properties to add.
+	 */
+	public function test_should_not_register_font_family_or_variant( $font_family_handle, array $variation ) {
+		$this->expectNotice();
+		$this->expectNoticeMessage( 'Font family handle must be a non-empty string.' );
+
+		$wp_webfonts = new WP_Web_Fonts();
+		$wp_webfonts->add_variation( $font_family_handle, $variation );
+
+		$this->assertEmpty( $wp_webfonts->registered, 'Registered queue should be empty' );
+		$this->assertEmpty( $this->get_variations( $font_family_handle, $wp_webfonts ), 'Variation should not be registered to the font family' );
+	}
+
+	/**
+	 * @dataProvider data_font_family_undefined_in_variation
+	 * @dataProviders data_unable_determine_variation_handle
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param array  $variation          An array of variation properties to add.
+	 * @param string $expected_message   Expected notice message.
+	 */
+	public function test_should_not_register_variation_when_font_family_not_defined( $font_family_handle, array $variation, $expected_message ) {
+		$this->expectNotice();
+		$this->expectNoticeMessage( $expected_message );
+
+		$wp_webfonts = new WP_Web_Fonts();
+		$this->assertNull( $wp_webfonts->add_variation( $font_family_handle, $variation ) );
+	}
+
+	/**
+	 * @dataProvider data_unable_determine_variation_handle
+	 *
+	 * @param string $font_family_handle The font family's handle for this variation.
+	 * @param array  $variation          An array of variation properties to add.
+	 */
+	public function test_should_register_font_family_when_variant_fails_to_register( $font_family_handle, array $variation ) {
+		$this->expectNotice();
+		$this->expectNoticeMessage( 'Variant handle could not be determined as font-weight and/or font-style are require' );
+
+		$wp_webfonts = new WP_Web_Fonts();
+		$wp_webfonts->add_variation( $font_family_handle, $variation );
+
+		$this->assertCount( 1, $wp_webfonts->registered );
+		$this->assertArrayHasKey( $font_family_handle, $wp_webfonts->registered );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/dequeue-test.php b/phpunit/webfonts/wpWebfonts/dequeue-test.php
new file mode 100644
index 00000000000000..c4959958a2ccf4
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/dequeue-test.php
@@ -0,0 +1,72 @@
+<?php
+/**
+ * WP_Web_Fonts::dequeue() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::dequeue
+ */
+class Tests_Webfonts_WpWebfonts_Dequeue extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_enqueue
+	 * @dataProvider data_enqueue_variations
+	 *
+	 * @param string|string[] $handles Handles to test.
+	 */
+	public function test_should_do_nothing_when_handles_not_queued( $handles ) {
+		$wp_webfonts = new WP_Web_Fonts();
+
+		$wp_webfonts->dequeue( $handles );
+		$this->assertEmpty( $this->get_queued_before_register( $wp_webfonts ), 'Prequeue should be empty' );
+		$this->assertEmpty( $wp_webfonts->queue, 'Queue should be empty' );
+	}
+
+	/**
+	 * Integration test for dequeuing from queue. It first registers and then enqueues before dequeuing.
+	 *
+	 * @dataProvider data_enqueue
+	 * @dataProvider data_enqueue_variations
+	 *
+	 * @param string|string[] $handles Handles to test.
+	 */
+	public function test_should_dequeue_from_queue( $handles ) {
+		$wp_webfonts = new WP_Web_Fonts();
+
+		// Register and enqueue.
+		foreach ( $this->get_data_registry() as $handle => $variations ) {
+			$this->setup_register( $handle, $variations, $wp_webfonts );
+		}
+		$wp_webfonts->enqueue( $handles );
+
+		// To make sure the handles are in the queue before dequeuing.
+		$this->assertNotEmpty( $wp_webfonts->queue, 'Queue not be empty before dequeueing' );
+
+		// Run the test.
+		$wp_webfonts->dequeue( $handles );
+		$this->assertEmpty( $wp_webfonts->queue, 'Queue should be empty after dequeueing' );
+	}
+
+	/**
+	 * Integration test for dequeuing from prequeue. It enqueues first.
+	 *
+	 * @dataProvider data_enqueue
+	 * @dataProvider data_enqueue_variations
+	 *
+	 * @param string|string[] $handles Handles to test.
+	 */
+	public function test_should_dequeue_from_prequeue( $handles ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		$wp_webfonts->enqueue( $handles );
+		$this->assertNotEmpty( $this->get_queued_before_register( $wp_webfonts ), 'Prequeue not be empty before dequeueing' );
+
+		$wp_webfonts->dequeue( $handles );
+		$this->assertEmpty( $this->get_queued_before_register( $wp_webfonts ), 'Prequeue should be empty after dequeueing' );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/doItem-test.php b/phpunit/webfonts/wpWebfonts/doItem-test.php
new file mode 100644
index 00000000000000..e54b909f83429e
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/doItem-test.php
@@ -0,0 +1,336 @@
+<?php
+/**
+ * WP_Web_Fonts::do_item() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @group  printwebfonts
+ * @covers WP_Web_Fonts::do_item
+ */
+class Tests_Webfonts_WpWebfonts_DoItem extends WP_Webfonts_TestCase {
+	private $wp_webfonts;
+
+	public function set_up() {
+		parent::set_up();
+		$this->wp_webfonts = new WP_Web_Fonts;
+	}
+
+	public function test_should_return_false_when_provider_not_registered() {
+		$this->assertFalse( $this->wp_webfonts->do_item( 'provider_not_registered' ) );
+	}
+
+	/**
+	 * @dataProvider data_provider_definitions
+	 *
+	 * @param array $provider Provider to mock.
+	 */
+	public function test_should_return_false_when_no_fonts_enqueued_for_provider( array $provider ) {
+		$this->setup_provider_property_mock( $this->wp_webfonts, $provider );
+		$this->assertFalse( $this->wp_webfonts->do_item( $provider['id'] ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_provider_definitions() {
+		$providers = $this->get_provider_definitions();
+
+		return array(
+			'mock'  => array( $providers['mock'] ),
+			'local' => array( $providers['local'] ),
+		);
+	}
+
+	/**
+	 * Test the test set up to ensure the `Tests_Webfonts_WpWebfonts_DoItem_::setup_provider_property_mock()`
+	 * method works as expected.
+	 */
+	public function test_mocking_providers_property() {
+		$font_handles = array( 'font1', 'font2', 'font3' );
+		$expected     = array(
+			'mock' => array(
+				'class' => Mock_Provider::class,
+				'fonts' => $font_handles,
+			),
+		);
+
+		$this->setup_provider_property_mock( $this->wp_webfonts, $this->get_provider_definitions( 'mock' ), $font_handles );
+		$actual = $this->property['WP_Web_Fonts::$providers']->getValue( $this->wp_webfonts );
+		$this->assertSame( $expected, $actual );
+	}
+
+	/**
+	 * Test the private method WP_Web_Fonts::get_enqueued_fonts_for_provider().
+	 *
+	 * Why? This test validates the right fonts are returned for use within
+	 * WP_Web_Fonts::do_item().
+	 *
+	 * @dataProvider data_get_enqueued_fonts_for_provider
+	 *
+	 * @param array $font_handles Array of handles for the provider.
+	 * @param array $to_do        Handles to set for the WP_Web_Fonts::$to_do property.
+	 * @param array $expected     Expected result.
+	 */
+	public function test_get_enqueued_fonts_for_provider( $font_handles, $to_do, $expected ) {
+		// Set up the `to_do` property.
+		$this->wp_webfonts->to_do = $to_do;
+
+		// Open the method's visibility for testing.
+		$get_enqueued_fonts_for_provider = $this->get_reflection_method( 'get_enqueued_fonts_for_provider' );
+
+		// Mock the WP_Web_Fonts::$property to set up the test.
+		$this->setup_provider_property_mock( $this->wp_webfonts, $this->get_provider_definitions( 'mock' ), $font_handles );
+
+		$actual = $get_enqueued_fonts_for_provider->invoke( $this->wp_webfonts, 'mock' );
+		$this->assertSameSets( $expected, $actual );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_get_enqueued_fonts_for_provider() {
+		return array(
+			'to_do queue is empty'                   => array(
+				'font_handles ' => array( 'font1', 'font2', 'font3' ),
+				'to_do'         => array(),
+				'expected'      => array(),
+			),
+			'fonts not in to_do queue'               => array(
+				'font_handles ' => array( 'font1', 'font2', 'font3' ),
+				'to_do'         => array( 'font12', 'font13' ),
+				'expected'      => array(),
+			),
+			'2 of the provider fonts in to_do queue' => array(
+				'font_handles ' => array( 'font11', 'font12', 'font13' ),
+				'to_do'         => array( 'font11', 'font13' ),
+				'expected'      => array( 'font11', 'font13' ),
+			),
+			'do all of the provider fonts'           => array(
+				'font_handles ' => array( 'font21', 'font22', 'font23' ),
+				'to_do'         => array( 'font21', 'font22', 'font23' ),
+				'expected'      => array( 'font21', 'font22', 'font23' ),
+			),
+		);
+	}
+
+	/**
+	 * Test the private method WP_Web_Fonts::get_font_properties_for_provider().
+	 *
+	 * Why? This test validates the right font properties are returned for use within
+	 * WP_Web_Fonts::do_item().
+	 *
+	 * @dataProvider data_get_font_properties_for_provider
+	 *
+	 * @param array $font_handles Web fonts for testing.
+	 * @param array $expected     Expected result.
+	 */
+	public function test_get_font_properties_for_provider( $font_handles, $expected ) {
+		// Set up the fonts for WP_Dependencies:get_data().
+		$fonts = $this->get_registered_fonts();
+		// Set all variations to 'mock' provider.
+
+		// Mock the WP_Web_Fonts::$property to set up the test.
+		$this->setup_provider_property_mock( $this->wp_webfonts, $this->get_provider_definitions( 'mock' ), $font_handles );
+		$this->setup_registration_mocks( $fonts, $this->wp_webfonts );
+
+		// Open the method's visibility for testing.
+		$method = $this->get_reflection_method( 'get_font_properties_for_provider' );
+
+		$actual = $method->invoke( $this->wp_webfonts, $font_handles );
+		$this->assertSame( $expected, $actual );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_get_font_properties_for_provider() {
+		$fonts = $this->get_registered_fonts();
+
+		return array(
+			'handles not registered'                => array(
+				'font_handles' => array( 'font-not-registered1', 'font-not-registered2', 'font-not-registered3' ),
+				'expected'     => array(),
+			),
+			'registered and non-registered handles' => array(
+				'font_handles' => array( 'Source Serif Pro-300-normal', 'not-registered-handle', 'Source Serif Pro-900-italic' ),
+				'expected'     => array(
+					'Source Serif Pro-300-normal' => $fonts['Source Serif Pro']['Source Serif Pro-300-normal'],
+					'Source Serif Pro-900-italic' => $fonts['Source Serif Pro']['Source Serif Pro-900-italic'],
+				),
+			),
+			'font-family handles, ie no "font-properties" extra data' => array(
+				'font_handles' => array( 'font1', 'font2', 'merriweather' ),
+				'expected'     => array(),
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_print_enqueued_fonts
+	 *
+	 * @param array $provider Define provider.
+	 * @param array $fonts    Fonts to register and enqueue.
+	 * @param array $expected Expected results.
+	 */
+	public function test_should_trigger_provider_when_mocked( array $provider, array $fonts, array $expected ) {
+		$this->setup_print_deps( $provider, $fonts );
+
+		$provider_mock = $this->setup_object_mock( array( 'set_webfonts', 'print_styles' ), $provider['class'] );
+
+		// Test the provider's methods are invoked.
+		$provider_mock->expects( $this->once() )->method( 'set_webfonts' )->with( $this->identicalTo( $expected['set_webfonts'] ) );
+		$provider_mock->expects( $this->once() )->method( 'print_styles' );
+
+		// Set up the WP_Web_Fonts::$provider_instances property.
+		$provider_instances = $this->get_reflection_property( 'provider_instances' );
+		$provider_instances->setValue( $this->wp_webfonts, array( $provider['id'] => $provider_mock ) );
+
+		// Test the method successfully processes the provider.
+		$this->expectOutputString( '' );
+		$this->assertTrue( $this->wp_webfonts->do_item( $provider['id'] ), 'WP_Web_Fonts::do_item() should return true' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_print_enqueued_fonts
+	 *
+	 * @param array $provider Define provider.
+	 * @param array $fonts    Fonts to register and enqueue.
+	 * @param array $expected Expected results.
+	 */
+	public function test_should_print( array $provider, array $fonts, array $expected ) {
+		$this->setup_print_deps( $provider, $fonts );
+
+		// Test the method successfully processes the provider.
+		$this->expectOutputString( $expected['printed_output'] );
+		$this->assertTrue( $this->wp_webfonts->do_item( $provider['id'] ), 'WP_Web_Fonts::do_item() should return true' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_print_enqueued_fonts() {
+		$mock       = $this->get_registered_mock_fonts();
+		$local      = $this->get_registered_local_fonts();
+		$font_faces = $this->get_registered_fonts_css();
+
+		return array(
+			'mock'  => array(
+				'provider' => $this->get_provider_definitions( 'mock' ),
+				'fonts'    => $mock,
+				'expected' => array(
+					'set_webfonts'   => array_merge( $mock['font1'], $mock['font2'], $mock['font3'] ),
+					'printed_output' => sprintf(
+						'<mock id="wp-webfonts-mock" attr="some-attr">%s; %s; %s; %s; %s; %s</mock>\n',
+						$font_faces['font1-300-normal'],
+						$font_faces['font1-300-italic'],
+						$font_faces['font1-900-normal'],
+						$font_faces['font2-200-900-normal'],
+						$font_faces['font2-200-900-italic'],
+						$font_faces['font3-bold-normal']
+					),
+				),
+			),
+			'local' => array(
+				'provider' => $this->get_provider_definitions( 'local' ),
+				'fonts'    => $local,
+				'expected' => array(
+					'set_webfonts'   => array_merge( $local['merriweather'], $local['Source Serif Pro'] ),
+					'printed_output' => sprintf(
+						"<style id='wp-webfonts-local' type='text/css'>\n%s%s%s\n</style>\n",
+						$font_faces['merriweather-200-900-normal'],
+						$font_faces['Source Serif Pro-300-normal'],
+						$font_faces['Source Serif Pro-900-italic']
+					),
+				),
+			),
+		);
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_not_print_enqueued_fonts
+	 *
+	 * @param array $provider    Define provider.
+	 * @param array $fonts       Fonts to register and enqueue.
+	 * @param array $expected    Not used.
+	 * @param array $to_do_queue Value to set in the WP_Web_Fonts::$to_do queue.
+	 */
+	public function test_should_not_print_when_to_do_queue_empty( array $provider, array $fonts, $expected, $to_do_queue ) {
+		$this->setup_print_deps( $provider, $fonts, $to_do_queue );
+
+		// Test the method successfully processes the provider.
+		$this->expectOutputString( '' );
+		$this->assertFalse( $this->wp_webfonts->do_item( $provider['id'] ), 'WP_Web_Fonts::do_item() should return false' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_not_print_enqueued_fonts() {
+		$mock  = $this->get_registered_mock_fonts();
+		$local = $this->get_registered_local_fonts();
+
+		return array(
+			'mock provider when to_do queue is empty'  => array(
+				'provider'    => $this->get_provider_definitions( 'mock' ),
+				'fonts'       => $mock,
+				'expected'    => array(),
+				'to_do_queue' => array(),
+			),
+			'local provider when to_do queue is empty' => array(
+				'provider'    => $this->get_provider_definitions( 'local' ),
+				'fonts'       => $local,
+				'expected'    => array(),
+				'to_do_queue' => array(),
+			),
+			'fonts not in to_do queue'                 => array(
+				'provider'    => $this->get_provider_definitions( 'mock' ),
+				'fonts'       => $mock,
+				'expected'    => array(),
+				'to_do_queue' => array(),
+			),
+		);
+	}
+
+	/**
+	 * Sets up the print dependencies.
+	 *
+	 * @param array      $provider    Provider id and class.
+	 * @param array      $fonts       Fonts to register and enqueue.
+	 * @param array|null $to_do_queue Set the WP_Web_Fonts:$to_do queue.
+	 */
+	private function setup_print_deps( $provider, $fonts, $to_do_queue = null ) {
+		// Set up the fonts for WP_Dependencies:get_data().
+		$mocks   = $this->setup_registration_mocks( $fonts, $this->wp_webfonts );
+		$handles = array_keys( $mocks );
+		$this->setup_provider_property_mock( $this->wp_webfonts, $provider, $handles );
+
+		// Set up the `WP_Web_Fonts::$to_do` and `WP_Web_Fonts::$to_do_keyed_handles` properties.
+		if ( null === $to_do_queue ) {
+			$to_do_queue = $handles;
+		}
+
+		$this->wp_webfonts->to_do = $to_do_queue;
+		$to_do_keyed_handles      = $this->get_reflection_property( 'to_do_keyed_handles' );
+		$to_do_keyed_handles->setValue( $this->wp_webfonts, array_flip( $to_do_queue ) );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/doItems-test.php b/phpunit/webfonts/wpWebfonts/doItems-test.php
new file mode 100644
index 00000000000000..7efb8dff67b7ec
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/doItems-test.php
@@ -0,0 +1,196 @@
+<?php
+/**
+ * WP_Web_Fonts::do_items() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+require_once __DIR__ . '/../../fixtures/mock-provider.php';
+
+/**
+ * @group  webfonts
+ * @group  printwebfonts
+ * @covers WP_Web_Fonts::do_items
+ */
+class Tests_Webfonts_WpWebfonts_DoItems extends WP_Webfonts_TestCase {
+	private $wp_webfonts;
+
+	public function set_up() {
+		parent::set_up();
+		$this->wp_webfonts = new WP_Web_Fonts;
+	}
+
+	public function test_should_not_process_when_no_providers_registered() {
+		$this->setup_deps( array( 'enqueued' => 'font1' ) );
+
+		$done = $this->wp_webfonts->do_items();
+
+		$this->assertSame( array(), $done, 'WP_Web_Fonts::do_items() should return an empty array' );
+		$this->assertSame( array(), $this->wp_webfonts->to_do, 'WP_Web_Fonts::$to_do should be an empty array' );
+	}
+
+	/**
+	 * @dataProvider data_invalid_handles
+	 *
+	 * @param mixed $handles Handles to test.
+	 */
+	public function test_should_throw_notice_when_invalid_handles( $handles ) {
+		$this->expectNotice();
+		$this->expectNoticeMessage( 'Handles must be a non-empty string or array of non-empty strings' );
+
+		$this->wp_webfonts->do_items( $handles );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_invalid_handles() {
+		return array(
+			'null'                         => array( null ),
+			'empty array'                  => array( array() ),
+			'empty string'                 => array( '' ),
+			'array of empty strings'       => array( array( '', '' ) ),
+			'array of mixed falsey values' => array( array( '', false, null, array() ) ),
+		);
+	}
+
+	public function test_should_throw_notice_when_provider_class_not_found() {
+		$this->expectNotice();
+		$this->expectNoticeMessage( 'Class "Provider_Does_Not_Exist" not found for "doesnotexist" web font provider' );
+
+		$setup = array(
+			'provider'         => array(
+				'doesnotexist' => array(
+					'id'    => 'doesnotexist',
+					'class' => 'Provider_Does_Not_Exist',
+				),
+			),
+			'provider_handles' => array( 'doesnotexist' => array( 'font1' ) ),
+			'registered'       => array(
+				'doesnotexist' => array(
+					'font1' => array(
+						'font1-300-normal' => array(
+							'provider'     => 'doesnotexist',
+							'font-weight'  => '300',
+							'font-style'   => 'normal',
+							'font-display' => 'fallback',
+						),
+					),
+				),
+			),
+			'enqueued'         => array( 'font1', 'font1-300-normal' ),
+		);
+		$this->setup_deps( $setup );
+
+		$this->wp_webfonts->do_items();
+	}
+
+	/**
+	 * @dataProvider data_print_enqueued
+	 *
+	 * @param array  $setup           Test set up information for provider, fonts, and enqueued.
+	 * @param array  $expected_done   Expected array of printed handles.
+	 * @param string $expected_output Expected printed output.
+	 */
+	public function test_should_print_mocked_enqueued( $setup, $expected_done, $expected_output ) {
+		$this->setup_deps( $setup );
+
+		$this->expectOutputString( $expected_output );
+		$actual_done = $this->wp_webfonts->do_items();
+		$this->assertSameSets( $expected_done, $actual_done, 'Printed handles should match' );
+	}
+
+	/**
+	 * Integration test that registers providers and fonts and then enqueues before
+	 * testing the printing functionality.
+	 *
+	 * @dataProvider data_print_enqueued
+	 *
+	 * @param array  $setup           Test set up information for provider, fonts, and enqueued.
+	 * @param array  $expected_done   Expected array of printed handles.
+	 * @param string $expected_output Expected printed output.
+	 */
+	public function test_should_print_enqueued( $setup, $expected_done, $expected_output ) {
+		$this->setup_integrated_deps( $setup );
+
+		$this->expectOutputString( $expected_output, 'Printed @font-face styles should match' );
+		$actual_done = $this->wp_webfonts->do_items();
+		$this->assertSameSets( $expected_done, $actual_done, 'Printed handles should match' );
+	}
+
+	/**
+	 * Integration test to validate printing given handles. Rather than mocking internal functionality,
+	 * it registers providers and fonts but does not enqueue.
+	 *
+	 * @dataProvider data_print_enqueued
+	 *
+	 * @param array  $setup           Test set up information for provider, fonts, and enqueued.
+	 * @param array  $expected_done   Expected array of printed handles.
+	 * @param string $expected_output Expected printed output.
+	 */
+	public function test_should_print_handles_when_not_enqueued( $setup, $expected_done, $expected_output ) {
+		$this->setup_integrated_deps( $setup, false );
+		// Do not enqueue. Instead, pass the handles to WP_Web_Fonts::do_items().
+		$handles = $setup['enqueued'];
+		$this->assertEmpty( $this->wp_webfonts->queue, 'No fonts should be enqueued' );
+
+		$this->expectOutputString( $expected_output );
+		$actual_done = $this->wp_webfonts->do_items( $handles );
+		$this->assertSameSets( $expected_done, $actual_done, 'Printed handles should match' );
+	}
+
+	/**
+	 * Sets up the dependencies for the mocked test.
+	 *
+	 * @param array $setup Dependencies to set up.
+	 */
+	private function setup_deps( array $setup ) {
+		$setup = array_merge(
+			array(
+				'provider'         => array(),
+				'provider_handles' => array(),
+				'registered'       => array(),
+				'enqueued'         => array(),
+			),
+			$setup
+		);
+
+		if ( ! empty( $setup['provider'] ) ) {
+			foreach ( $setup['provider'] as $provider_id => $provider ) {
+				$this->setup_provider_property_mock( $this->wp_webfonts, $provider, $setup['provider_handles'][ $provider_id ] );
+			}
+		}
+
+		if ( ! empty( $setup['registered'] ) ) {
+			$this->setup_registration_mocks( $setup['registered'], $this->wp_webfonts );
+		}
+
+		if ( ! empty( $setup['enqueued'] ) ) {
+			$queue = $this->get_reflection_property( 'queue' );
+			$queue->setValue( $this->wp_webfonts, $setup['enqueued'] );
+		}
+	}
+
+	/**
+	 * Sets up the dependencies for integration test.
+	 *
+	 * @param array $setup   Dependencies to set up.
+	 * @param bool  $enqueue Whether to enqueue. Default true.
+	 */
+	private function setup_integrated_deps( array $setup, $enqueue = true ) {
+		foreach ( $setup['provider'] as $provider ) {
+			$this->wp_webfonts->register_provider( $provider['id'], $provider['class'] );
+		}
+		foreach ( $setup['registered'] as $handle => $variations ) {
+			$this->setup_register( $handle, $variations, $this->wp_webfonts );
+		}
+
+		if ( $enqueue ) {
+			$this->wp_webfonts->enqueue( $setup['enqueued'] );
+		}
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/enqueue-test.php b/phpunit/webfonts/wpWebfonts/enqueue-test.php
new file mode 100644
index 00000000000000..dde2d92c6df377
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/enqueue-test.php
@@ -0,0 +1,53 @@
+<?php
+/**
+ * WP_Web_Fonts::enqueue() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::enqueue
+ */
+class Tests_Webfonts_WpWebfonts_Enqueue extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_enqueue
+	 * @dataProvider data_enqueue_variations
+	 *
+	 * @param string|string[] $handles  Handles to test.
+	 * @param array           $not_used Not used.
+	 * @param array           $expected Expected "queued_before_register" queue.
+	 */
+	public function test_should_prequeue_when_not_registered( $handles, $not_used, $expected ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		$wp_webfonts->enqueue( $handles );
+
+		$this->assertSame( $expected, $this->get_queued_before_register( $wp_webfonts ), 'Handles should be added to before registered queue' );
+		$this->assertEmpty( $wp_webfonts->queue, 'Handles should not be added to the enqueue queue when not registered' );
+	}
+
+	/**
+	 * Integration test for enqueuing (a) a font family and all of its variations or (b) specific variations.
+	 *
+	 * @dataProvider data_enqueue
+	 * @dataProviders data_enqueue_variations
+	 *
+	 * @param string|string[] $handles  Handles to test.
+	 * @param array           $expected Expected queue.
+	 */
+	public function test_should_enqueue_when_registered( $handles, array $expected ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		foreach ( $this->get_data_registry() as $font_family => $variations ) {
+			$this->setup_register( $font_family, $variations, $wp_webfonts );
+		}
+
+		$wp_webfonts->enqueue( $handles );
+
+		$this->assertEmpty( $this->get_queued_before_register( $wp_webfonts ), '"queued_before_register" queue should be empty' );
+		$this->assertSame( $expected, $wp_webfonts->queue, 'Queue should contain the given handles' );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/getEnqueued-test.php b/phpunit/webfonts/wpWebfonts/getEnqueued-test.php
new file mode 100644
index 00000000000000..63ea923c085f54
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/getEnqueued-test.php
@@ -0,0 +1,57 @@
+<?php
+/**
+ * WP_Web_Fonts::get_enqueued() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::get_enqueued
+ */
+class Tests_Webfonts_WpWebfonts_GetEnqueued extends WP_Webfonts_TestCase {
+
+	public function test_should_return_empty_when_non_enqueued() {
+		$wp_webfonts = new WP_Web_Fonts();
+		$this->assertEmpty( $wp_webfonts->get_enqueued() );
+	}
+
+	/**
+	 * Unit test for when font families are enqueued.
+	 *
+	 * @dataProvider data_enqueue
+	 *
+	 * @param string|string[] $not_used Not used.
+	 * @param array           $expected    Expected queue.
+	 */
+	public function test_should_return_queue_when_property_has_font_families( $not_used, array $expected ) {
+		$wp_webfonts        = new WP_Web_Fonts();
+		$wp_webfonts->queue = $expected;
+
+		$this->assertSame( $expected, $wp_webfonts->get_enqueued() );
+	}
+
+	/**
+	 * Full integration test that registers and enqueues the queue
+	 * is properly wired for "get_enqueued()".
+	 *
+	 * @dataProvider data_enqueue
+	 *
+	 * @param string|string[] $font_family Font family to test.
+	 * @param array           $expected    Expected queue.
+	 */
+	public function test_should_return_queue_when_font_families_registered_and_enqueued( $font_family, array $expected ) {
+		$wp_webfonts = new WP_Web_Fonts();
+
+		// Register and enqueue.
+		foreach ( $this->get_data_registry() as $handle => $variations ) {
+			$this->setup_register( $handle, $variations, $wp_webfonts );
+		}
+		$wp_webfonts->enqueue( $font_family );
+
+		$this->assertSame( $expected, $wp_webfonts->get_enqueued() );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/getProviders-test.php b/phpunit/webfonts/wpWebfonts/getProviders-test.php
new file mode 100644
index 00000000000000..7aa758582cb7c7
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/getProviders-test.php
@@ -0,0 +1,62 @@
+<?php
+/**
+ * WP_Web_Fonts::get_providers() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+require_once __DIR__ . '/../../fixtures/mock-provider.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::get_providers
+ */
+class Tests_Webfonts_WpWebfonts_GetProviders extends WP_Webfonts_TestCase {
+	private $wp_webfonts;
+	private $providers_property;
+
+	public function set_up() {
+		parent::set_up();
+		$this->wp_webfonts = new WP_Web_Fonts();
+
+		$this->providers_property = new ReflectionProperty( WP_Web_Fonts::class, 'providers' );
+		$this->providers_property->setAccessible( true );
+	}
+
+	public function test_should_be_empty() {
+		$actual = $this->wp_webfonts->get_providers();
+		$this->assertIsArray( $actual, 'Should return an empty array' );
+		$this->assertEmpty( $actual, 'Should return an empty array when no providers are registered' );
+	}
+
+	/**
+	 * @dataProvider data_get_providers
+	 *
+	 * @param array $providers Array of providers to test.
+	 * @param array $expected  Expected results.
+	 */
+	public function test_get_providers( array $providers, array $expected ) {
+		$this->setup_providers( $providers );
+		$this->assertSame( $expected, $this->wp_webfonts->get_providers() );
+	}
+
+	/**
+	 * Sets up the given providers and stores them in the `WP_Web_Fonts::providers` property.
+	 *
+	 * @param array $providers Array of providers to set up.
+	 */
+	private function setup_providers( array $providers ) {
+		$data = array();
+
+		foreach ( $providers as $provider_id => $class ) {
+			$data[ $provider_id ] = array(
+				'class' => $class,
+				'fonts' => array(),
+			);
+		}
+
+		$this->providers_property->setValue( $this->wp_webfonts, $data );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/getRegistered-test.php b/phpunit/webfonts/wpWebfonts/getRegistered-test.php
new file mode 100644
index 00000000000000..76b0ab3a5d097c
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/getRegistered-test.php
@@ -0,0 +1,90 @@
+<?php
+/**
+ * WP_Web_Fonts::get_registered() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::get_registered
+ */
+class Tests_Webfonts_WpWebfonts_GetRegistered extends WP_Webfonts_TestCase {
+
+	public function test_should_return_empty_when_none_registered() {
+		$wp_webfonts = new WP_Web_Fonts();
+		$this->assertEmpty( $wp_webfonts->get_registered() );
+	}
+
+	/**
+	 * Unit test for when font families are enqueued.
+	 *
+	 * @dataProvider data_get_registered
+	 *
+	 * @param array $inputs Font family(ies) and variations to register.
+	 */
+	public function test_should_return_queue_when_mocking_registered_property( array $inputs ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		$mocks       = $this->setup_registration_mocks( $inputs, $wp_webfonts );
+		$expected    = array_keys( $mocks );
+
+		$this->assertSame( $expected, $wp_webfonts->get_registered() );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_get_registered() {
+		return array(
+			'no variations'                          => array(
+				'inputs' => array(
+					'lato' => array(),
+				),
+			),
+			'with 1 variation'                       => array(
+				'inputs' => array(
+					'Source Serif Pro' => array( 'variation-1' ),
+				),
+			),
+			'with 2 variations'                      => array(
+				'inputs' => array(
+					'my-cool-font' => array( 'cool-1', 'cool-2' ),
+				),
+			),
+			'when multiple font families registered' => array(
+				'inputs' => array(
+					'font-family-1' => array( 'variation-11', 'variation-12' ),
+					'font-family-2' => array( 'variation-21', 'variation-22' ),
+					'font-family-3' => array( 'variation-31', 'variation-32' ),
+				),
+			),
+		);
+	}
+
+	/**
+	 * Full integration test that registers varying number of font families and variations
+	 * to validate if "get_registered()" internals is property wired to the registered queue.
+	 *
+	 * @dataProvider data_one_to_many_font_families_and_zero_to_many_variations
+	 *
+	 * @param string $font_family Not used.
+	 * @param array  $inputs      Font family(ies) and variations to register.
+	 * @param array  $expected    Expected results.
+	 */
+	public function test_should_return_queue_when_items_are_registered( $font_family, array $inputs, array $expected ) {
+		$wp_webfonts = new WP_Web_Fonts();
+
+		// Register before testing.
+		foreach ( $inputs as $handle => $variations ) {
+			$this->setup_register( $handle, $variations, $wp_webfonts );
+		}
+
+		$this->assertSame( $expected, $wp_webfonts->get_registered() );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/query-test.php b/phpunit/webfonts/wpWebfonts/query-test.php
new file mode 100644
index 00000000000000..75b44b2717f2b9
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/query-test.php
@@ -0,0 +1,151 @@
+<?php
+/**
+ * WP_Web_Fonts::query() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::query
+ */
+class Tests_Webfonts_WpWebfonts_Query extends WP_Webfonts_TestCase {
+	private $wp_webfonts;
+
+	public function set_up() {
+		parent::set_up();
+
+		$this->wp_webfonts = new WP_Web_Fonts();
+	}
+
+	/**
+	 * @dataProvider data_invalid_query
+	 * @dataProvider data_valid_query
+	 *
+	 * @param string $query_handle Handle to test.
+	 */
+	public function test_should_fail_when_handles_not_registered( $query_handle ) {
+		$this->assertFalse( $this->wp_webfonts->query( $query_handle, 'registered' ) );
+	}
+
+	/**
+	 * @dataProvider data_invalid_query
+	 * @dataProvider data_valid_query
+	 *
+	 * @param string $query_handle Handle to test.
+	 */
+	public function test_should_fail_when_handles_not_registered_or_enqueued( $query_handle ) {
+		$this->assertFalse( $this->wp_webfonts->query( $query_handle, 'queue' ) );
+	}
+
+	/**
+	 * @dataProvider data_valid_query
+	 *
+	 * @param string $query_handle Handle to test.
+	 */
+	public function test_registered_query_should_succeed_when_registered( $query_handle ) {
+		$this->setup_registry();
+
+		$actual = $this->wp_webfonts->query( $query_handle, 'registered' );
+		$this->assertInstanceOf( '_WP_Dependency', $actual, 'Query should return an instance of _WP_Dependency' );
+		$this->assertSame( $query_handle, $actual->handle, 'Query object handle should match the given handle to query' );
+	}
+
+	/**
+	 * @dataProvider data_valid_query
+	 *
+	 * @param string $query_handle Handle to test.
+	 */
+	public function test_enqueued_query_should_succeed_when_registered_and_enqueued( $query_handle ) {
+		$this->setup_registry();
+		$this->wp_webfonts->enqueue( $query_handle );
+
+		$this->assertTrue( $this->wp_webfonts->query( $query_handle, 'enqueued' ) );
+	}
+
+	/**
+	 * @dataProvider data_valid_query
+	 *
+	 * @param string $query_handle Handle to test.
+	 */
+	public function test_enqueued_query_should_fail_when_not_registered_but_enqueued( $query_handle ) {
+		$this->wp_webfonts->enqueue( $query_handle );
+
+		$this->assertFalse( $this->wp_webfonts->query( $query_handle, 'enqueued' ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_invalid_query() {
+		return array(
+			'DM Sans' => array( 'DM Sans' ),
+			'roboto'  => array( 'roboto' ),
+			'my-font' => array( 'my-font' ),
+		);
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_valid_query() {
+		return array(
+			'lato'             => array( 'lato' ),
+			'merriweather'     => array( 'merriweather' ),
+			'Source Serif Pro' => array( 'source-serif-pro' ),
+		);
+	}
+
+	public function test_done_query_should_fail_when_no_variations() {
+		$this->wp_webfonts->register_provider( 'local', WP_Webfonts_Provider_Local::class );
+		$this->setup_registry();
+		$this->wp_webfonts->enqueue( 'lato' );
+
+		$this->wp_webfonts->do_items( 'lato' );
+
+		$this->assertFalse( $this->wp_webfonts->query( 'lato', 'done' ) );
+	}
+
+	/**
+	 * @dataProvider data_done_query
+	 *
+	 * @param string $query_handle Handle to test.
+	 */
+	public function test_done_query_should_succeed_when_registered_and_enqueued( $query_handle ) {
+		$this->wp_webfonts->register_provider( 'local', WP_Webfonts_Provider_Local::class );
+		$this->setup_registry();
+		$this->wp_webfonts->enqueue( $query_handle );
+
+		// Process the web fonts while ignoring all the printed output.
+		$this->expectOutputRegex( '`.`' );
+		$this->wp_webfonts->do_items( $query_handle );
+		$this->getActualOutput();
+
+		$this->assertTrue( $this->wp_webfonts->query( $query_handle, 'done' ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_done_query() {
+		return array(
+			'merriweather'     => array( 'merriweather' ),
+			'Source Serif Pro' => array( 'source-serif-pro' ),
+		);
+	}
+
+	private function setup_registry() {
+		foreach ( $this->get_registered_local_fonts() as $handle => $variations ) {
+			$this->setup_register( $handle, $variations, $this->wp_webfonts );
+		}
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/registerProvider-test.php b/phpunit/webfonts/wpWebfonts/registerProvider-test.php
new file mode 100644
index 00000000000000..b73623259fcf48
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/registerProvider-test.php
@@ -0,0 +1,116 @@
+<?php
+/**
+ * WP_Web_Fonts::register_provider() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+require_once __DIR__ . '/../../fixtures/mock-provider.php';
+
+/**
+ * @group  webfonts
+ * @covers WP_Web_Fonts::register_provider
+ */
+class Tests_Webfonts_WpWebfonts_RegisterProvider extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_register_providers
+	 *
+	 * @param string $provider_id Provider ID.
+	 * @param string $class       Provider class name.
+	 * @param array  $expected    Expected providers queue.
+	 */
+	public function test_should_register_provider( $provider_id, $class, $expected ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		$this->assertTrue( $wp_webfonts->register_provider( $provider_id, $class ), 'WP_Web_Fonts::register_provider() should return true' );
+		$this->assertSame( $expected, $wp_webfonts->get_providers(), 'Provider "' . $provider_id . '" should be registered in providers queue' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_register_providers() {
+		return array(
+			'mock'  => array(
+				'provider_id' => 'mock',
+				'class'       => Mock_Provider::class,
+				'expected'    => array(
+					'mock' => array(
+						'class' => Mock_Provider::class,
+						'fonts' => array(),
+					),
+				),
+			),
+			'local' => array(
+				'provider_id' => 'local',
+				'class'       => WP_Webfonts_Provider_Local::class,
+				'expected'    => array(
+					'local' => array(
+						'class' => WP_Webfonts_Provider_Local::class,
+						'fonts' => array(),
+					),
+				),
+			),
+		);
+	}
+
+	public function test_should_register_mutliple_providers() {
+		$wp_webfonts = new WP_Web_Fonts();
+		$providers   = $this->get_provider_definitions();
+		foreach ( $providers as $provider ) {
+			$this->assertTrue( $wp_webfonts->register_provider( $provider['id'], $provider['class'] ), 'WP_Web_Fonts::register_provider() should return true for provider ' . $provider['id'] );
+		}
+
+		$expected = array(
+			'mock'  => array(
+				'class' => $providers['mock']['class'],
+				'fonts' => array(),
+			),
+			'local' => array(
+				'class' => $providers['local']['class'],
+				'fonts' => array(),
+			),
+		);
+
+		$this->assertSame( $expected, $wp_webfonts->get_providers(), 'Both local and mock providers should be registered' );
+	}
+
+	/**
+	 * @dataProvider data_invalid_providers
+	 *
+	 * @param string $provider_id Provider ID.
+	 * @param string $class       Provider class name.
+	 */
+	public function test_should_not_register( $provider_id, $class ) {
+		$wp_webfonts = new WP_Web_Fonts();
+
+		$this->assertFalse( $wp_webfonts->register_provider( $provider_id, $class ), 'WP_Web_Fonts::register_provider() should return false' );
+		$this->assertArrayNotHasKey( $provider_id, $wp_webfonts->get_providers(), 'Both local and mock providers should be registered' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_invalid_providers() {
+		return array(
+			'provider_id is empty' => array(
+				'provider_id' => '',
+				'class'       => Mock_Provider::class,
+			),
+			'class is empty'       => array(
+				'provider_id' => 'local',
+				'class'       => '',
+			),
+			'class does not exist' => array(
+				'provider_id' => 'doesnotexist',
+				'class'       => 'Provider_Does_Not_Exist',
+			),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/remove-test.php b/phpunit/webfonts/wpWebfonts/remove-test.php
new file mode 100644
index 00000000000000..86cf9fa6ad1bac
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/remove-test.php
@@ -0,0 +1,118 @@
+<?php
+/**
+ * WP_Web_Fonts::remove() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @group  remove_webfonts
+ * @covers WP_Web_Fonts::remove
+ */
+class Tests_Webfonts_WpWebfonts_Remove extends WP_Webfonts_TestCase {
+
+	public function test_should_not_remove_when_none_registered() {
+		$wp_webfonts = new WP_Web_Fonts();
+
+		$wp_webfonts->remove( array( 'handle-1', 'handle2' ) );
+
+		$this->assertEmpty( $wp_webfonts->registered );
+	}
+
+	/**
+	 * @dataProvider data_remove_when_registered
+	 *
+	 * @param array $handles  Handles to remove.
+	 * @param array $expected Expected handles are running test.
+	 */
+	public function test_should_remove_when_registered( array $handles, array $expected ) {
+		$wp_webfonts             = new WP_Web_Fonts();
+		$wp_webfonts->registered = $this->generate_registered_queue();
+
+		$wp_webfonts->remove( $handles );
+
+		$this->assertSameSets( $expected, array_keys( $wp_webfonts->registered ), 'Registered queue should match after removing handles' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_remove_when_registered() {
+		$all = array(
+			'handle-1',
+			'handle-2',
+			'handle-3',
+			'handle-4',
+			'handle-5',
+			'handle-6',
+			'handle-7',
+			'handle-8',
+			'handle-9',
+			'handle-10',
+		);
+
+		return array(
+			'remove none'                 => array(
+				'handles'  => array(),
+				'expected' => $all,
+			),
+			'remove handle-5'             => array(
+				'handles'  => array( 'handle-5' ),
+				'expected' => array(
+					'handle-1',
+					'handle-2',
+					'handle-3',
+					'handle-4',
+					'handle-6',
+					'handle-7',
+					'handle-8',
+					'handle-9',
+					'handle-10',
+				),
+			),
+			'remove 2 from start and end' => array(
+				'handles'  => array( 'handle-1', 'handle-2', 'handle-9', 'handle-10' ),
+				'expected' => array(
+					'handle-3',
+					'handle-4',
+					'handle-5',
+					'handle-6',
+					'handle-7',
+					'handle-8',
+				),
+			),
+			'remove all'                  => array(
+				'handles'  => $all,
+				'expected' => array(),
+			),
+			'remove only registered'      => array(
+				'handles'  => array( 'handle-1', 'handle-10', 'handle-abc', 'handle-5' ),
+				'expected' => array(
+					'handle-2',
+					'handle-3',
+					'handle-4',
+					'handle-6',
+					'handle-7',
+					'handle-8',
+					'handle-9',
+				),
+			),
+		);
+	}
+
+	private function generate_registered_queue() {
+		$queue = array();
+		for ( $num = 1; $num <= 10; $num++ ) {
+			$handle           = "handle-{$num}";
+			$queue[ $handle ] = $num;
+		}
+
+		return $queue;
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/removeFontFamily-test.php b/phpunit/webfonts/wpWebfonts/removeFontFamily-test.php
new file mode 100644
index 00000000000000..959744e555202f
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/removeFontFamily-test.php
@@ -0,0 +1,89 @@
+<?php
+/**
+ * WP_Web_Fonts::remove_font_family() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group webfonts
+ * @group remove_webfonts
+ * @covers WP_Web_Fonts::remove_font_family
+ */
+class Tests_Webfonts_WpWebfonts_RemoveFontFamily extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_one_to_many_font_families_and_zero_to_many_variations
+	 *
+	 * @param string $font_family        Font family to test.
+	 * @param array  $inputs             Font family(ies) and variations to pre-register.
+	 * @param array  $registered_handles Expected handles after registering.
+	 * @param array  $expected           Array of expected handles.
+	 */
+	public function test_should_dequeue_when_mocks_registered( $font_family, array $inputs, array $registered_handles, array $expected ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		$this->setup_registration_mocks( $inputs, $wp_webfonts );
+		// Test the before state, just to make sure.
+		$this->assertArrayHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should contain the font family before remove' );
+		$this->assertSame( $registered_handles, array_keys( $wp_webfonts->registered ), 'Font family and variations should be registered before remove' );
+
+		$wp_webfonts->remove_font_family( $font_family );
+
+		$this->assertArrayNotHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should not contain the font family' );
+		$this->assertSame( $expected, array_keys( $wp_webfonts->registered ), 'Registered queue should match after removing font family' );
+	}
+
+	/**
+	 * @dataProvider data_one_to_many_font_families_and_zero_to_many_variations
+	 *
+	 * @param string $font_family        Font family to test.
+	 * @param array  $inputs             Font family(ies) and variations to pre-register.
+	 * @param array  $registered_handles Not used.
+	 * @param array  $expected           Array of expected handles.
+	 */
+	public function test_should_bail_out_when_not_registered( $font_family, array $inputs, array $registered_handles, array $expected ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		unset( $inputs[ $font_family ] );
+		$this->setup_registration_mocks( $inputs, $wp_webfonts );
+
+		$wp_webfonts->remove_font_family( $font_family );
+
+		$this->assertArrayNotHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should not contain the font family' );
+		$this->assertSame( $expected, array_keys( $wp_webfonts->registered ), 'Registered queue should match after removing font family' );
+	}
+
+	/**
+	 * Integration test for removing a font family and all of its variation when font family is registered.
+	 *
+	 * @dataProvider data_one_to_many_font_families_and_zero_to_many_variations
+	 *
+	 * @param string $font_family        Font family to test.
+	 * @param array  $inputs             Font family(ies) and variations to pre-register.
+	 * @param array  $registered_handles Expected handles after registering.
+	 * @param array  $expected           Array of expected handles.
+	 */
+	public function test_should_deregister_when_registered( $font_family, array $inputs, array $registered_handles, array $expected ) {
+		$wp_webfonts = new WP_Web_Fonts();
+		// Register all font families and their variations.
+		foreach ( $inputs as $input_font_family => $variations ) {
+			$handle = $wp_webfonts->add_font_family( $input_font_family );
+			foreach ( $variations as $variation_handle => $variation ) {
+				if ( ! is_string( $variation_handle ) ) {
+					$variation_handle = '';
+				}
+				$wp_webfonts->add_variation( $handle, $variation, $variation_handle );
+			}
+		}
+		// Test the before state, just to make sure.
+		$this->assertArrayHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should contain the font family before remove' );
+		$this->assertSame( $registered_handles, array_keys( $wp_webfonts->registered ), 'Font family and variations should be registered before remove' );
+
+		$wp_webfonts->remove_font_family( $font_family );
+
+		$this->assertArrayNotHasKey( $font_family, $wp_webfonts->registered, 'Registered queue should not contain the font family' );
+		$this->assertSame( $expected, array_keys( $wp_webfonts->registered ), 'Registered queue should match after removing font family' );
+	}
+}
diff --git a/phpunit/webfonts/wpWebfonts/removeVariation-test.php b/phpunit/webfonts/wpWebfonts/removeVariation-test.php
new file mode 100644
index 00000000000000..dd3b21a9573eaa
--- /dev/null
+++ b/phpunit/webfonts/wpWebfonts/removeVariation-test.php
@@ -0,0 +1,278 @@
+<?php
+/**
+ * WP_Web_Fonts::remove_variation() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group  webfonts
+ * @group  remove_webfonts
+ * @covers WP_Web_Fonts::remove_variation
+ */
+class Tests_Webfonts_WpWebfonts_RemoveVariation extends WP_Webfonts_TestCase {
+	private $wp_webfonts;
+	private $fonts_to_register = array();
+
+	public function set_up() {
+		parent::set_up();
+		$this->wp_webfonts       = new WP_Web_Fonts();
+		$this->fonts_to_register = $this->get_registered_local_fonts();
+	}
+
+	/**
+	 * Sets up the unit test by mocking the WP_Dependencies object using stdClass and
+	 * registering each font family directly to the WP_Web_Fonts::$registered property
+	 * and its variations to the mocked $deps property.
+	 */
+	private function setup_unit_test() {
+		$this->setup_registration_mocks( $this->fonts_to_register, $this->wp_webfonts );
+	}
+
+	/**
+	 * Sets up the integration test by properly registering each font family and its variations
+	 * by using the WP_Web_Fonts::add() and WP_Web_Fonts::add_variation() methods.
+	 */
+	private function setup_integration_test() {
+		foreach ( $this->fonts_to_register as $font_family_handle => $variations ) {
+			$this->setup_register( $font_family_handle, $variations, $this->wp_webfonts );
+		}
+	}
+
+	/**
+	 * Testing the test setup to ensure it works.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 */
+	public function test_mocked_setup( $font_family_handle, $variation_handle ) {
+		$this->setup_unit_test();
+
+		$this->assertArrayHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be in the registered queue before remval' );
+		$this->assertContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should be in its font family deps before removal' );
+	}
+
+	/**
+	 * Unit test.
+	 *
+	 * @dataProvider data_should_do_nothing_when_variation_and_font_family_not_registered
+	 *
+	 * @param string $font_family        Font family name.
+	 * @param string $font_family_handle Font family handle.
+	 * @param string $variation_handle   Variation handle to remove.
+	 */
+	public function test_unit_should_do_nothing_when_variation_and_font_family_not_registered( $font_family, $font_family_handle, $variation_handle ) {
+		// Set up the test.
+		unset( $this->fonts_to_register[ $font_family ] );
+		$this->setup_unit_test();
+		$registered_queue = $this->wp_webfonts->registered;
+
+		// Run the tests.
+		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $font_family_handle, $this->wp_webfonts->registered, 'Font family should not be registered' );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
+		$this->assertSame( $registered_queue, $this->wp_webfonts->registered, 'Registered queue should not have changed' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_should_do_nothing_when_variation_and_font_family_not_registered
+	 *
+	 * @param string $font_family        Font family name.
+	 * @param string $font_family_handle Font family handle.
+	 * @param string $variation_handle   Variation handle to remove.
+	 */
+	public function test_should_do_nothing_when_variation_and_font_family_not_registered( $font_family, $font_family_handle, $variation_handle ) {
+		// Set up the test.
+		unset( $this->fonts_to_register[ $font_family ] );
+		$this->setup_integration_test();
+		$registered_queue = $this->wp_webfonts->get_registered();
+
+		// Run the tests.
+		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $font_family_handle, $this->wp_webfonts->registered, 'Font family should not be registered' );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
+		$this->assertSameSets( $registered_queue, $this->wp_webfonts->get_registered(), 'Registered queue should not have changed' );
+	}
+
+	/**
+	 * Data provider for testing removal of variations.
+	 *
+	 * @return array
+	 */
+	public function data_should_do_nothing_when_variation_and_font_family_not_registered() {
+		return array(
+			'Font with 1 variation'         => array(
+				'font_family'        => 'merriweather',
+				'font_family_handle' => 'merriweather',
+				'variation_handle'   => 'merriweather-200-900-normal',
+			),
+			'Font with multiple variations' => array(
+				'font_family'        => 'Source Serif Pro',
+				'font_family_handle' => 'source-serif-pro',
+				'variation_handle'   => 'Source Serif Pro-300-normal',
+			),
+		);
+	}
+
+	/**
+	 * Unit test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_unit_should_only_remove_from_font_family_deps_when_variation_not_in_queue( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_unit_test();
+		$this->setup_remove_variation_from_registered( $variation_handle );
+
+		// Run the tests.
+		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_should_only_remove_from_font_family_deps_when_variation_not_in_queue( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_integration_test();
+		$this->setup_remove_variation_from_registered( $variation_handle );
+
+		// Run the tests.
+		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variant should not be registered' );
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Unit test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_unit_should_remove_variation_from_registered_queue_though_font_family_not_registered( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_unit_test();
+		$this->setup_remove_from_font_family_deps( $font_family_handle, $variation_handle );
+
+		$this->assertArrayNotHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should not be in its font family deps before removal' );
+
+		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_should_remove_variation_from_registered_queue_though_font_family_not_registered( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_integration_test();
+		$this->setup_remove_from_font_family_deps( $font_family_handle, $variation_handle );
+
+		$this->assertArrayNotHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should not be in its font family deps before removal' );
+
+		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Unit test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_unit_should_remove_variation_from_queue_and_font_family_deps( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_unit_test();
+
+		$this->assertArrayHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should be in its font family deps before removal' );
+
+		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be not be in registered queue' );
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Integration test.
+	 *
+	 * @dataProvider data_remove_variations
+	 *
+	 * @param string $font_family_handle Font family for the variation.
+	 * @param string $variation_handle   Variation handle to remove.
+	 * @param array  $expected           Expected results.
+	 */
+	public function test_should_remove_variation_from_queue_and_font_family_deps( $font_family_handle, $variation_handle, $expected ) {
+		// Set up the test.
+		$this->setup_integration_test();
+
+		$this->assertArrayHasKey( $variation_handle, array_flip( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Variation should be in its font family deps before removal' );
+
+		$this->wp_webfonts->remove_variation( $font_family_handle, $variation_handle );
+
+		$this->assertArrayNotHasKey( $variation_handle, $this->wp_webfonts->registered, 'Variation should be not be in registered queue' );
+		$this->assertNotContains( $variation_handle, $this->wp_webfonts->registered[ $font_family_handle ]->deps, 'Variation should not be its font family deps' );
+		$this->assertSameSets( $expected['font_family_deps'], array_values( $this->wp_webfonts->registered[ $font_family_handle ]->deps ), 'Only the tested variation handle should be removed from font family deps' );
+	}
+
+	/**
+	 * Remove the variation handle from the font family's deps.
+	 *
+	 * @param string $font_family_handle Font family.
+	 * @param string $variation_handle   The variation handle to remove.
+	 */
+	private function setup_remove_from_font_family_deps( $font_family_handle, $variation_handle ) {
+		foreach ( $this->wp_webfonts->registered[ $font_family_handle ]->deps as $index => $vhandle ) {
+			if ( $variation_handle !== $vhandle ) {
+				continue;
+			}
+			unset( $this->wp_webfonts->registered[ $font_family_handle ]->deps[ $index ] );
+			break;
+		}
+	}
+
+	/**
+	 * Removes the variation from the WP_Web_Fonts::$registered queue.
+	 *
+	 * @param string $variation_handle The variation handle to remove.
+	 */
+	private function setup_remove_variation_from_registered( $variation_handle ) {
+		unset( $this->wp_webfonts->registered[ $variation_handle ] );
+	}
+}
diff --git a/phpunit/class-wp-webfonts-local-provider-test.php b/phpunit/webfonts/wpWebfontsProviderLocal-test.php
similarity index 78%
rename from phpunit/class-wp-webfonts-local-provider-test.php
rename to phpunit/webfonts/wpWebfontsProviderLocal-test.php
index 43ef4a84951c84..08f9f18c3cd6a2 100644
--- a/phpunit/class-wp-webfonts-local-provider-test.php
+++ b/phpunit/webfonts/wpWebfontsProviderLocal-test.php
@@ -1,10 +1,15 @@
 <?php
+/**
+ * WP_WebfontsLocal_Provider tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
 
 /**
- * @group  webfonts
- * @covers WP_WebfontsLocal_Provider
+ * @group webfonts
  */
-class WP_Webfonts_Provider_Local_Test extends WP_UnitTestCase {
+class Tests_Webfonts_WpWebfontsProviderLocal extends WP_UnitTestCase {
 	private $provider;
 	private $theme_root;
 	private $orig_theme_dir;
@@ -17,27 +22,6 @@ public function set_up() {
 		$this->set_up_theme();
 	}
 
-	/**
-	 * Local `src` paths to need to be relative to the theme. This method sets up the
-	 * `wp-content/themes/` directory to ensure consistency when running tests.
-	 */
-	private function set_up_theme() {
-		$this->theme_root                = realpath( DIR_TESTDATA . '/themedir1' );
-		$this->orig_theme_dir            = $GLOBALS['wp_theme_directories'];
-		$GLOBALS['wp_theme_directories'] = array( $this->theme_root );
-
-		$theme_root_callback = function () {
-			return $this->theme_root;
-		};
-		add_filter( 'theme_root', $theme_root_callback );
-		add_filter( 'stylesheet_root', $theme_root_callback );
-		add_filter( 'template_root', $theme_root_callback );
-
-		// Clear caches.
-		wp_clean_themes_cache();
-		unset( $GLOBALS['wp_themes'] );
-	}
-
 	public function tear_down() {
 		// Restore the original theme directory setup.
 		$GLOBALS['wp_theme_directories'] = $this->orig_theme_dir;
@@ -79,7 +63,7 @@ public function test_set_webfonts() {
 	/**
 	 * @covers WP_Webfonts_Provider_Local::get_css
 	 *
-	 * @dataProvider data_get_css
+	 * @dataProvider data_get_css_print_styles
 	 *
 	 * @param array  $webfonts Prepared webfonts (to store in WP_Webfonts_Provider_Local::$webfonts property).
 	 * @param string $expected Expected CSS.
@@ -88,7 +72,24 @@ public function test_get_css( array $webfonts, $expected ) {
 		$property = $this->get_webfonts_property();
 		$property->setValue( $this->provider, $webfonts );
 
-		$this->assertSame( $expected, $this->provider->get_css() );
+		$this->assertSame( $expected['font-face-css'], $this->provider->get_css() );
+	}
+
+	/**
+	 * @covers WP_Webfonts_Provider_Local::print_styles
+	 *
+	 * @dataProvider data_get_css_print_styles
+	 *
+	 * @param array  $webfonts Prepared webfonts (to store in WP_Webfonts_Provider_Local::$webfonts property).
+	 * @param string $expected Expected CSS.
+	 */
+	public function test_print_styles( array $webfonts, $expected ) {
+		$property = $this->get_webfonts_property();
+		$property->setValue( $this->provider, $webfonts );
+
+		$expected_output = sprintf( $expected['style-element'], $expected['font-face-css'] );
+		$this->expectOutputString( $expected_output );
+		$this->provider->print_styles();
 	}
 
 	/**
@@ -96,7 +97,7 @@ public function test_get_css( array $webfonts, $expected ) {
 	 *
 	 * @return array
 	 */
-	public function data_get_css() {
+	public function data_get_css_print_styles() {
 		return array(
 			'truetype format' => array(
 				'webfonts' => array(
@@ -108,10 +109,13 @@ public function data_get_css() {
 						'src'         => 'http://example.org/assets/fonts/OpenSans-Italic-VariableFont_wdth,wght.ttf',
 					),
 				),
-				'expected' => <<<CSS
+				'expected' => array(
+					'style-element' => "<style id='wp-webfonts-local' type='text/css'>\n%s\n</style>\n",
+					'font-face-css' => <<<CSS
 @font-face{font-family:"Open Sans";font-style:italic;font-weight:bold;src:local("Open Sans"), url('http://example.org/assets/fonts/OpenSans-Italic-VariableFont_wdth,wght.ttf') format('truetype');}
 CSS
-			,
+					,
+				),
 			),
 			'woff2 format'    => array(
 				'webfonts' => array(
@@ -132,14 +136,39 @@ public function data_get_css() {
 						'src'          => 'http://example.org/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
 					),
 				),
-				'expected' => <<<CSS
+				'expected' => array(
+					'style-element' => "<style id='wp-webfonts-local' type='text/css'>\n%s\n</style>\n",
+					'font-face-css' => <<<CSS
 @font-face{font-family:"Source Serif Pro";font-style:normal;font-weight:200 900;font-stretch:normal;src:local("Source Serif Pro"), url('http://example.org/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2') format('woff2');}@font-face{font-family:"Source Serif Pro";font-style:italic;font-weight:200 900;font-stretch:normal;src:local("Source Serif Pro"), url('http://example.org/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2') format('woff2');}
 CSS
-			,
+
+					,
+				),
 			),
 		);
 	}
 
+	/**
+	 * Local `src` paths to need to be relative to the theme. This method sets up the
+	 * `wp-content/themes/` directory to ensure consistency when running tests.
+	 */
+	private function set_up_theme() {
+		$this->theme_root                = realpath( DIR_TESTDATA . '/themedir1' );
+		$this->orig_theme_dir            = $GLOBALS['wp_theme_directories'];
+		$GLOBALS['wp_theme_directories'] = array( $this->theme_root );
+
+		$theme_root_callback = function () {
+			return $this->theme_root;
+		};
+		add_filter( 'theme_root', $theme_root_callback );
+		add_filter( 'stylesheet_root', $theme_root_callback );
+		add_filter( 'template_root', $theme_root_callback );
+
+		// Clear caches.
+		wp_clean_themes_cache();
+		unset( $GLOBALS['wp_themes'] );
+	}
+
 	private function get_webfonts_property() {
 		$property = new ReflectionProperty( $this->provider, 'webfonts' );
 		$property->setAccessible( true );
diff --git a/phpunit/webfonts/wpWebfontsUtils/convertFontFamilyIntoHandle-test.php b/phpunit/webfonts/wpWebfontsUtils/convertFontFamilyIntoHandle-test.php
new file mode 100644
index 00000000000000..d258f1e5c435df
--- /dev/null
+++ b/phpunit/webfonts/wpWebfontsUtils/convertFontFamilyIntoHandle-test.php
@@ -0,0 +1,84 @@
+<?php
+/**
+ * WP_Webfonts_Utils::convert_font_family_into_handle() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group webfonts
+ * @covers WP_Webfonts_Utils::convert_font_family_into_handle
+ */
+class Tests_Webfonts_WpWebfontsUtils_ConvertFontFamilyIntoHandle extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_with_valid_input
+	 *
+	 * @param mixed  $font_family Font family to test.
+	 * @param string $expected    Expected results.
+	 */
+	public function test_should_convert_with_valid_input( $font_family, $expected ) {
+		$this->assertSame( $expected, WP_Webfonts_Utils::convert_font_family_into_handle( $font_family ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_with_valid_input() {
+		return array(
+			'font family single word name'               => array(
+				'font_family' => 'Merriweather',
+				'expected'    => 'merriweather',
+			),
+			'font family multiword name'                 => array(
+				'font_family' => 'Source Sans Pro',
+				'expected'    => 'source-sans-pro',
+			),
+			'font family handle delimited by hyphens'    => array(
+				'font_family' => 'source-serif-pro',
+				'expected'    => 'source-serif-pro',
+			),
+			'font family handle delimited by underscore' => array(
+				'font_family' => 'source_serif_pro',
+				'expected'    => 'source_serif_pro',
+			),
+			'font family handle delimited by hyphens and underscore' => array(
+				'font_family' => 'my-custom_font_family',
+				'expected'    => 'my-custom_font_family',
+			),
+			'font family handle delimited mixture'       => array(
+				'font_family' => 'My custom_font-family',
+				'expected'    => 'my-custom_font-family',
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_with_invalid_input
+	 *
+	 * @covers WP_Webfonts_Utils::convert_font_family_into_handle
+	 *
+	 * @param mixed $invalid_input Invalid input.
+	 */
+	public function test_should_not_convert_with_invalid_input( $invalid_input ) {
+		$this->assertNull( WP_Webfonts_Utils::convert_font_family_into_handle( $invalid_input ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_with_invalid_input() {
+		return array(
+			'empty string'                    => array( '' ),
+			'integer'                         => array( 10 ),
+			'font family wrapped in an array' => array( array( 'source-serif-pro' ) ),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpWebfontsUtils/convertVariationIntoHandle-test.php b/phpunit/webfonts/wpWebfontsUtils/convertVariationIntoHandle-test.php
new file mode 100644
index 00000000000000..9e2a3462ed7a82
--- /dev/null
+++ b/phpunit/webfonts/wpWebfontsUtils/convertVariationIntoHandle-test.php
@@ -0,0 +1,122 @@
+<?php
+/**
+ * WP_Webfonts_Utils::convert_variation_into_handle() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group webfonts
+ * @covers WP_Webfonts_Utils::convert_variation_into_handle
+ */
+class Tests_Webfonts_WpWebfontsUtils_ConvertVariationIntoHandle extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_with_valid_input
+	 *
+	 * @param string $font_family Font family to test.
+	 * @param array  $variation   Variation to test.
+	 * @param string $expected    Expected results.
+	 */
+	public function test_should_convert_with_valid_inputs( $font_family, array $variation, $expected ) {
+		$this->assertSame( $expected, WP_Webfonts_Utils::convert_variation_into_handle( $font_family, $variation ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_with_valid_input() {
+		return array(
+			'with only font-weight'                  => array(
+				'font_family' => 'merriweather',
+				'variation'   => array(
+					'font-weight' => '400',
+				),
+				'expected'    => 'merriweather-400',
+			),
+			'with no font-style'                     => array(
+				'font_family' => 'source-sans-pro',
+				'variation'   => array(
+					'font-weight' => '200 900',
+					'src'         => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'provider'    => 'local',
+				),
+				'expected'    => 'source-sans-pro-200-900',
+			),
+			'with font family name and full variant' => array(
+				'font_family' => 'source-sans-pro',
+				'variation'   => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'expected'    => 'source-sans-pro-200-900-normal',
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_with_invalid_input
+	 *
+	 * @param string $font_family   Font family to test.
+	 * @param array  $invalid_input Variation to test.
+	 */
+	public function tests_should_convert_with_invalid_input( $font_family, $invalid_input ) {
+		$this->expectNotice();
+		$this->expectNoticeMessage( 'Variant handle could not be determined as font-weight and/or font-style are require' );
+
+		$this->assertNull( WP_Webfonts_Utils::convert_variation_into_handle( $font_family, $invalid_input ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_with_invalid_input() {
+		return array(
+			'with no font-weight or font-style' => array(
+				'font_family' => 'merriweather',
+				'variation'   => array(
+					'provider'     => 'local',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+			),
+			'with non-string font-weight'       => array(
+				'font_family' => 'merriweather',
+				'variation'   => array(
+					'font-weight' => 400,
+				),
+			),
+			'with non-string font-style'        => array(
+				'font_family' => 'merriweather',
+				'variation'   => array(
+					'font-style' => 0,
+				),
+			),
+			'with empty string font-weight'     => array(
+				'font_family' => 'merriweather',
+				'variation'   => array(
+					'font-weight' => '',
+				),
+			),
+			'with empty string font-style'      => array(
+				'font_family' => 'merriweather',
+				'variation'   => array(
+					'font-style' => '',
+				),
+			),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpWebfontsUtils/getFontFamilyFromVariation-test.php b/phpunit/webfonts/wpWebfontsUtils/getFontFamilyFromVariation-test.php
new file mode 100644
index 00000000000000..f370e1d043222c
--- /dev/null
+++ b/phpunit/webfonts/wpWebfontsUtils/getFontFamilyFromVariation-test.php
@@ -0,0 +1,134 @@
+<?php
+/**
+ * WP_Webfonts_Utils::get_font_family_from_variation() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group webfonts
+ * @covers WP_Webfonts_Utils::get_font_family_from_variation
+ */
+class Tests_Webfonts_WpWebfontsUtils_GetFontFamilyFromVariation extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_with_valid_variation
+	 *
+	 * @param array  $variation Variation to test.
+	 * @param string $expected  Expected results.
+	 */
+	public function test_with_valid_variation( array $variation, $expected ) {
+		$this->assertSame( $expected, WP_Webfonts_Utils::get_font_family_from_variation( $variation ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_with_valid_variation() {
+		return array(
+			'keyed by font-family'                   => array(
+				'variation' => array(
+					'provider'     => 'local',
+					'font-family'  => 'Source Serif Pro',
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'expected'  => 'Source Serif Pro',
+			),
+			'keyed by fontFamily and as a handle'    => array(
+				'variation' => array(
+					'fontFamily'  => 'source-sans-pro',
+					'font-weight' => '200 900',
+					'src'         => 'https://example.com/assets/fonts/source-sans-pro/source-sans-pro.ttf.woff2',
+					'provider'    => 'local',
+				),
+				'expected'  => 'source-sans-pro',
+			),
+			'with font family name and full variant' => array(
+				'variation' => array(
+					'provider'     => 'local',
+					'font-family'  => 'Merriweather',
+					'font-style'   => 'normal',
+					'font-weight'  => '400 600',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/merriweather.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'expected'  => 'Merriweather',
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_with_invalid_input
+	 *
+	 * @param array  $invalid_variation Variation to test.
+	 * @param string $expected_message  Expected notice message.
+	 */
+	public function test_with_invalid_input( array $invalid_variation, $expected_message ) {
+		$this->expectNotice();
+		$this->expectNoticeMessage( $expected_message );
+
+		$this->assertNull( WP_Webfonts_Utils::get_font_family_from_variation( $invalid_variation ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_with_invalid_input() {
+		return array(
+			'keyed with underscore'       => array(
+				'variation'        => array(
+					'provider'     => 'local',
+					'font_family'  => 'Source Serif Pro',
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'expected_message' => 'Font family not found.',
+			),
+			'keyed with space'            => array(
+				'variation'        => array(
+					'font family' => 'Source Sans Pro',
+					'font-weight' => '200 900',
+					'src'         => 'https://example.com/assets/fonts/source-sans-pro/source-sans-pro.ttf.woff2',
+					'provider'    => 'local',
+				),
+				'expected_message' => 'Font family not found.',
+			),
+			'fontFamily => empty string'  => array(
+				'variation'        => array(
+					'fontFamily'  => '',
+					'font-weight' => '200 900',
+					'src'         => 'https://example.com/assets/fonts/source-sans-pro/source-sans-pro.ttf.woff2',
+					'provider'    => 'local',
+				),
+				'expected_message' => 'Font family not defined in the variation.',
+			),
+			'font-family => empty string' => array(
+				'variation'        => array(
+					'provider'     => 'local',
+					'font-family'  => '',
+					'font-style'   => 'normal',
+					'font-weight'  => '200 900',
+					'font-stretch' => 'normal',
+					'src'          => 'https://example.com/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+					'font-display' => 'fallback',
+				),
+				'expected_message' => 'Font family not defined in the variation.',
+			),
+		);
+	}
+}
diff --git a/phpunit/webfonts/wpWebfontsUtils/isDefined-test.php b/phpunit/webfonts/wpWebfontsUtils/isDefined-test.php
new file mode 100644
index 00000000000000..c5b2a1608269c8
--- /dev/null
+++ b/phpunit/webfonts/wpWebfontsUtils/isDefined-test.php
@@ -0,0 +1,61 @@
+<?php
+/**
+ * WP_Webfonts_Utils::is_defined() tests.
+ *
+ * @package    WordPress
+ * @subpackage Webfonts
+ */
+
+require_once __DIR__ . '/../wp-webfonts-testcase.php';
+
+/**
+ * @group webfonts
+ * @covers WP_Webfonts_Utils::is_defined
+ */
+class Tests_Webfonts_WpWebfontsUtils_IsDefined extends WP_Webfonts_TestCase {
+
+	/**
+	 * @dataProvider data_when_defined
+	 *
+	 * @param mixed $input Input to test.
+	 */
+	public function test_should_return_true_when_defined( $input ) {
+		$this->assertTrue( WP_Webfonts_Utils::is_defined( $input ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_when_defined() {
+		return array(
+			'name: non empty string'   => array( 'Some Font Family' ),
+			'handle: non empty string' => array( 'some-font-family' ),
+		);
+	}
+
+	/**
+	 * @dataProvider data_when_not_defined
+	 *
+	 * @param mixed $invalid_input Input to test.
+	 */
+	public function test_should_return_false_when_not_defined( $invalid_input ) {
+		$this->assertFalse( WP_Webfonts_Utils::is_defined( $invalid_input ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_when_not_defined() {
+		return array(
+			'empty string'               => array( '' ),
+			'string 0'                   => array( '0' ),
+			'integer'                    => array( 10 ),
+			'name wrapped in an array'   => array( array( 'Some Font Family' ) ),
+			'handle wrapped in an array' => array( array( 'some-font-family' ) ),
+		);
+	}
+}