@wordpress/edit-site 6.33.3 → 6.34.0

package/src/components/global-styles/font-library-modal/utils/test/fonts-outline.spec.js

@@ -1,109 +0,0 @@
-/**
- * Internal dependencies
- */
-import { getFontsOutline, isFontFontFaceInOutline } from '../fonts-outline';
-
-describe( 'getFontsOutline', () => {
-	test( 'should return an empty object for an empty fonts array', () => {
-		const fonts = [];
-		const result = getFontsOutline( fonts );
-		expect( result ).toEqual( {} );
-	} );
-
-	test( 'should handle fonts with no fontFace property', () => {
-		const fonts = [
-			{ slug: 'font1' },
-			{
-				slug: 'font2',
-				fontFace: [ { fontStyle: 'normal', fontWeight: '400' } ],
-			},
-		];
-		const result = getFontsOutline( fonts );
-		expect( result ).toEqual( {
-			font1: {},
-			font2: { 'normal-400': true },
-		} );
-	} );
-
-	test( 'should handle fonts with an empty fontFace array', () => {
-		const fonts = [ { slug: 'font1', fontFace: [] } ];
-		const result = getFontsOutline( fonts );
-		expect( result ).toEqual( {
-			font1: {},
-		} );
-	} );
-
-	test( 'should handle fonts with multiple font faces', () => {
-		const fonts = [
-			{
-				slug: 'font1',
-				fontFace: [
-					{ fontStyle: 'normal', fontWeight: '400' },
-					{ fontStyle: 'italic', fontWeight: '700' },
-				],
-			},
-		];
-		const result = getFontsOutline( fonts );
-		expect( result ).toEqual( {
-			font1: {
-				'normal-400': true,
-				'italic-700': true,
-			},
-		} );
-	} );
-} );
-
-describe( 'isFontFontFaceInOutline', () => {
-	test( 'should return false for an empty outline', () => {
-		const slug = 'font1';
-		const face = { fontStyle: 'normal', fontWeight: '400' };
-		const outline = {};
-
-		const result = isFontFontFaceInOutline( slug, face, outline );
-
-		expect( result ).toBe( false );
-	} );
-
-	test( 'should return false when outline has the slug but no matching fontStyle-fontWeight', () => {
-		const slug = 'font1';
-		const face = { fontStyle: 'normal', fontWeight: '400' };
-		const outline = {
-			font1: {
-				'italic-700': true,
-			},
-		};
-
-		const result = isFontFontFaceInOutline( slug, face, outline );
-
-		expect( result ).toBe( false );
-	} );
-
-	test( 'should return false when outline does not have the slug', () => {
-		const slug = 'font1';
-		const face = { fontStyle: 'normal', fontWeight: '400' };
-		const outline = {
-			font2: {
-				'normal-400': true,
-			},
-		};
-
-		const result = isFontFontFaceInOutline( slug, face, outline );
-
-		expect( result ).toBe( false );
-	} );
-
-	test( 'should return true when outline has the slug and the matching fontStyle-fontWeight', () => {
-		const slug = 'font1';
-		const face = { fontStyle: 'normal', fontWeight: '400' };
-		const outline = {
-			font1: {
-				'normal-400': true,
-				'italic-700': true,
-			},
-		};
-
-		const result = isFontFontFaceInOutline( slug, face, outline );
-
-		expect( result ).toBe( true );
-	} );
-} );

package/src/components/global-styles/font-library-modal/utils/test/getDisplaySrcFromFontFace.spec.js

@@ -1,42 +0,0 @@
-/**
- * Internal dependencies
- */
-import { getDisplaySrcFromFontFace } from '../index';
-
-describe( 'getDisplaySrcFromFontFace', () => {
-	it( 'returns the first item when input is an array', () => {
-		const input = [
-			'http://example.com/font-asset-1.ttf',
-			'http://example.com/font-asset-2.ttf',
-		];
-		expect( getDisplaySrcFromFontFace( input ) ).toBe(
-			'http://example.com/font-asset-1.ttf'
-		);
-	} );
-
-	it( 'returns the input when it is a string', () => {
-		const input = 'http://example.com/font-asset-1.ttf';
-		expect( getDisplaySrcFromFontFace( input ) ).toBe(
-			'http://example.com/font-asset-1.ttf'
-		);
-	} );
-
-	it( 'return undefined when the url starts with file:', () => {
-		const input = 'file:./theme/assets/font1.ttf';
-		expect( getDisplaySrcFromFontFace( input ) ).toBe( undefined );
-	} );
-
-	it( 'encodes the URL if it is not encoded', () => {
-		const input = 'https://example.org/font one with spaces.ttf';
-		expect( getDisplaySrcFromFontFace( input ) ).toBe(
-			'https://example.org/font%20one%20with%20spaces.ttf'
-		);
-	} );
-
-	it( 'does not encode the URL if it is already encoded', () => {
-		const input = 'https://example.org/fonts/font%20one.ttf';
-		expect( getDisplaySrcFromFontFace( input ) ).toBe(
-			'https://example.org/fonts/font%20one.ttf'
-		);
-	} );
-} );

package/src/components/global-styles/font-library-modal/utils/test/getFontFaceVariantName.spec.js

@@ -1,30 +0,0 @@
-/**
- * Internal dependencies
- */
-import { getFontFaceVariantName } from '../index';
-
-describe( 'getFontFaceVariantName', () => {
-	it( 'should return "Normal" for fontWeight 400 and fontStyle "normal"', () => {
-		const face = { fontWeight: 400, fontStyle: 'normal' };
-		const result = getFontFaceVariantName( face );
-		expect( result ).toBe( 'Normal ' );
-	} );
-
-	it( 'should return "Bold Italic" for fontWeight 700 and fontStyle "italic"', () => {
-		const face = { fontWeight: 700, fontStyle: 'italic' };
-		const result = getFontFaceVariantName( face );
-		expect( result ).toBe( 'Bold Italic' );
-	} );
-
-	it( 'should return the numerical weight when fontWeight is not recognized', () => {
-		const face = { fontWeight: 150, fontStyle: 'normal' };
-		const result = getFontFaceVariantName( face );
-		expect( result ).toBe( '150 ' );
-	} );
-
-	it( 'should return the raw style when fontStyle is not recognized', () => {
-		const face = { fontWeight: 400, fontStyle: 'oblique' };
-		const result = getFontFaceVariantName( face );
-		expect( result ).toBe( 'Normal oblique' );
-	} );
-} );

package/src/components/global-styles/font-library-modal/utils/test/isUrlEncoded.spec.js

@@ -1,31 +0,0 @@
-/**
- * Internal dependencies
- */
-import { isUrlEncoded } from '../index';
-
-describe( 'isUrlEncoded', () => {
-	// Test when input is not a string
-	it( 'should return false if the input is not a string', () => {
-		expect( isUrlEncoded( 123 ) ).toBe( false );
-		expect( isUrlEncoded( null ) ).toBe( false );
-		expect( isUrlEncoded( undefined ) ).toBe( false );
-		expect( isUrlEncoded( {} ) ).toBe( false );
-		expect( isUrlEncoded( [] ) ).toBe( false );
-	} );
-
-	// Test when URL is not encoded
-	it( 'should return false for non-encoded URLs', () => {
-		expect( isUrlEncoded( 'http://example.com' ) ).toBe( false );
-		expect( isUrlEncoded( 'https://www.google.com' ) ).toBe( false );
-		expect( isUrlEncoded( '/path/to/resource' ) ).toBe( false );
-		expect( isUrlEncoded( '' ) ).toBe( false );
-	} );
-
-	// Test when URL is encoded
-	it( 'should return true for encoded URLs', () => {
-		expect( isUrlEncoded( 'http%3A%2F%2Fexample.com' ) ).toBe( true );
-		expect( isUrlEncoded( 'https%3A%2F%2Fwww.google.com' ) ).toBe( true );
-		expect( isUrlEncoded( '%2Fpath%2Fto%2Fresource' ) ).toBe( true );
-		expect( isUrlEncoded( '%20' ) ).toBe( true );
-	} );
-} );

package/src/components/global-styles/font-library-modal/utils/test/makeFamiliesFromFaces.spec.js

@@ -1,57 +0,0 @@
-/**
- * Internal dependencies
- */
-import makeFamiliesFromFaces from '../make-families-from-faces';
-
-describe( 'makeFamiliesFromFaces', () => {
-	it( 'handles empty fontFaces list', () => {
-		const result = makeFamiliesFromFaces( [] );
-		expect( result ).toEqual( [] );
-	} );
-
-	it( 'groups fontFaces by fontFamily', () => {
-		const fontFaces = [
-			{ fontFamily: 'Lobster' },
-			{
-				fontFamily: 'Piazzolla',
-				file: { name: 'piazzolla.ttf' },
-			},
-			{ fontFamily: 'Lobster', file: { name: 'piazzolla.ttf' } },
-		];
-
-		const result = makeFamiliesFromFaces( fontFaces );
-
-		expect( result ).toHaveLength( 2 );
-		expect(
-			result.find( ( family ) => family.name === 'Lobster' ).fontFace
-		).toHaveLength( 2 );
-		expect(
-			result.find( ( family ) => family.name === 'Piazzolla' ).fontFace
-		).toHaveLength( 1 );
-	} );
-
-	it( 'generates correct name for fontFamily names', () => {
-		const fontFaces = [
-			{
-				fontFamily: 'Piazzolla',
-				file: { name: 'piazzolla.ttf' },
-			},
-		];
-
-		const result = makeFamiliesFromFaces( fontFaces );
-		expect( result[ 0 ].name ).toBe( 'Piazzolla' );
-	} );
-
-	it( 'generates correct slug for fontFamily names', () => {
-		const fontFaces = [
-			{
-				fontFamily: 'Times New Roman',
-				file: { name: 'times.ttf' },
-			},
-		];
-
-		const result = makeFamiliesFromFaces( fontFaces );
-
-		expect( result[ 0 ].slug ).toBe( 'times-new-roman' );
-	} );
-} );

package/src/components/global-styles/font-library-modal/utils/test/mergeFontFaces.spec.js

@@ -1,56 +0,0 @@
-/**
- * Internal dependencies
- */
-import { mergeFontFaces } from '../index';
-
-describe( 'mergeFontFaces', () => {
-	it( 'should return an empty array when both existing and incoming arrays are empty', () => {
-		expect( mergeFontFaces() ).toEqual( [] );
-	} );
-
-	it( 'should return the existing array when the incoming array is empty', () => {
-		const existing = [ { fontWeight: 'normal', fontStyle: 'italic' } ];
-		expect( mergeFontFaces( existing, [] ) ).toEqual( existing );
-	} );
-
-	it( 'should return the incoming array when the existing array is empty', () => {
-		const incoming = [ { fontWeight: 'bold', fontStyle: 'normal' } ];
-		expect( mergeFontFaces( [], incoming ) ).toEqual( incoming );
-	} );
-
-	it( 'should merge non-overlapping existing and incoming arrays', () => {
-		const existing = [ { fontWeight: 'normal', fontStyle: 'italic' } ];
-		const incoming = [ { fontWeight: 'bold', fontStyle: 'normal' } ];
-		expect( mergeFontFaces( existing, incoming ) ).toEqual( [
-			...existing,
-			...incoming,
-		] );
-	} );
-
-	it( 'should overwrite duplicates with the incoming array', () => {
-		const existing = [
-			{ fontWeight: 'normal', fontStyle: 'italic', src: 'old-src' },
-		];
-		const incoming = [
-			{ fontWeight: 'normal', fontStyle: 'italic', src: 'new-src' },
-		];
-		expect( mergeFontFaces( existing, incoming ) ).toEqual( incoming );
-	} );
-
-	it( 'should handle multiple elements in both existing and incoming arrays', () => {
-		const existing = [
-			{ fontWeight: 'normal', fontStyle: 'italic', src: 'old-1' },
-			{ fontWeight: 'bold', fontStyle: 'normal', src: 'old-2' },
-		];
-		const incoming = [
-			{ fontWeight: 'normal', fontStyle: 'italic', src: 'new-1' },
-			{ fontWeight: 'bold', fontStyle: 'oblique', src: 'new-2' },
-		];
-		const expected = [
-			{ fontWeight: 'normal', fontStyle: 'italic', src: 'new-1' },
-			{ fontWeight: 'bold', fontStyle: 'normal', src: 'old-2' },
-			{ fontWeight: 'bold', fontStyle: 'oblique', src: 'new-2' },
-		];
-		expect( mergeFontFaces( existing, incoming ) ).toEqual( expected );
-	} );
-} );

package/src/components/global-styles/font-library-modal/utils/test/mergeFontFamilies.spec.js

@@ -1,108 +0,0 @@
-/**
- * Internal dependencies
- */
-import { mergeFontFamilies } from '../index';
-
-describe( 'mergeFontFamilies', () => {
-	it( 'should return an empty array when both inputs are empty', () => {
-		const result = mergeFontFamilies( [], [] );
-		expect( result ).toEqual( [] );
-	} );
-
-	it( 'should return the existing array when incoming array is empty', () => {
-		const existing = [
-			{ slug: 'lobster', name: 'Lobster', fontFamily: 'Lobster' },
-		];
-		const result = mergeFontFamilies( existing, [] );
-		expect( result ).toEqual( existing );
-	} );
-
-	it( 'should concar non-conflicting arrays', () => {
-		const existing = [
-			{ slug: 'lobster', name: 'Lobster', fontFamily: 'Lobster' },
-		];
-		const incoming = [
-			{ slug: 'piazzola', name: 'Piazzolla', fontFamily: 'Piazzolla' },
-		];
-		const result = mergeFontFamilies( existing, incoming );
-		expect( result ).toEqual( [ ...existing, ...incoming ] );
-	} );
-
-	it( 'should merge non-conflicting arrays', () => {
-		const existing = [
-			{ slug: 'lobster', name: 'Lobster', fontFamily: 'Lobster' },
-			{ slug: 'piazzola', name: 'Piazzolla', fontFamily: 'Piazzolla' },
-		];
-		const incoming = [
-			{ slug: 'piazzola', name: 'Piazzolla', fontFamily: 'Piazzolla' },
-		];
-		const result = mergeFontFamilies( existing, incoming );
-		expect( result ).toHaveLength( 2 );
-	} );
-
-	it( 'should overwrite existing font family data with incoming data', () => {
-		const existing = [
-			{ slug: 'lobster', name: 'Lobster', fontFamily: 'Lobster' },
-			{ slug: 'piazzola', name: 'Piazzolla', fontFamily: 'Piazzolla' },
-		];
-		const incoming = [
-			{
-				slug: 'piazzola',
-				name: 'Piazzolla',
-				fontFamily: 'Piazzolla, serif',
-			},
-		];
-		const result = mergeFontFamilies( existing, incoming );
-		expect( result[ 1 ].fontFamily ).toBe( 'Piazzolla, serif' );
-	} );
-
-	it( 'should merge fontFaces from incoming array', () => {
-		const existing = [
-			{
-				slug: 'lobster',
-				name: 'Lobster',
-				fontFamily: 'Lobster',
-			},
-			{
-				slug: 'piazzola',
-				name: 'Piazzolla',
-				fontFamily: 'Piazzolla',
-				fontFace: [
-					{ fontWeight: 400, fontStyle: 'normal', src: 'url' },
-					{ fontWeight: 500, fontStyle: 'normal', src: 'url' },
-				],
-			},
-		];
-		const incoming = [
-			{
-				slug: 'piazzola',
-				name: 'Piazzolla',
-				fontFamily: 'Piazzolla, serif',
-				fontFace: [
-					{ fontWeight: 800, fontStyle: 'normal', src: 'url' },
-					{ fontWeight: 400, fontStyle: 'normal', src: 'url' },
-				],
-			},
-		];
-		const expected = [
-			{
-				slug: 'lobster',
-				name: 'Lobster',
-				fontFamily: 'Lobster',
-			},
-			{
-				slug: 'piazzola',
-				name: 'Piazzolla',
-				fontFamily: 'Piazzolla, serif',
-				fontFace: [
-					{ fontWeight: 400, fontStyle: 'normal', src: 'url' },
-					{ fontWeight: 500, fontStyle: 'normal', src: 'url' },
-					{ fontWeight: 800, fontStyle: 'normal', src: 'url' },
-				],
-			},
-		];
-
-		const result = mergeFontFamilies( existing, incoming );
-		expect( result ).toEqual( expected );
-	} );
-} );

package/src/components/global-styles/font-library-modal/utils/test/preview-styles.spec.js

@@ -1,216 +0,0 @@
-/**
- * Internal dependencies
- */
-import {
-	getFamilyPreviewStyle,
-	formatFontFamily,
-	formatFontFaceName,
-} from '../preview-styles';
-
-describe( 'getFamilyPreviewStyle', () => {
-	it( 'should return default fontStyle and fontWeight if fontFace is not provided', () => {
-		const family = { fontFamily: 'Rosario' };
-		const result = getFamilyPreviewStyle( family );
-		const expected = {
-			fontFamily: 'Rosario',
-			fontWeight: '400',
-			fontStyle: 'normal',
-		};
-		expect( result ).toEqual( expected );
-	} );
-
-	it( 'should return fontStyle as "normal" if fontFace contains "normal" style', () => {
-		const family = {
-			fontFamily: 'Rosario',
-			fontFace: [
-				{ fontStyle: 'italic', fontWeight: '500' },
-				{ fontStyle: 'normal', fontWeight: '600' },
-			],
-		};
-		const result = getFamilyPreviewStyle( family );
-		const expected = {
-			fontFamily: 'Rosario',
-			fontStyle: 'normal',
-			fontWeight: '600',
-		};
-		expect( result ).toEqual( expected );
-	} );
-
-	it( 'should return fontStyle as "itaic" if fontFace does not contain "normal" style', () => {
-		const family = {
-			fontFamily: 'Rosario',
-			fontFace: [
-				{ fontStyle: 'italic', fontWeight: '500' },
-				{ fontStyle: 'italic', fontWeight: '600' },
-			],
-		};
-		const result = getFamilyPreviewStyle( family );
-		const expected = {
-			fontFamily: 'Rosario',
-			fontStyle: 'italic',
-			fontWeight: '500',
-		};
-		expect( result ).toEqual( expected );
-	} );
-
-	it( 'should return fontWeight as string', () => {
-		const family = {
-			fontFamily: 'Rosario',
-			fontFace: [
-				{ fontStyle: 'italic', fontWeight: '500' },
-				{ fontStyle: 'normal', fontWeight: '700' },
-			],
-		};
-		const result = getFamilyPreviewStyle( family );
-		const expected = {
-			fontFamily: 'Rosario',
-			fontStyle: 'normal',
-			fontWeight: '700',
-		};
-		expect( result ).toEqual( expected );
-	} );
-
-	it( 'should return fontWeight as "400" if fontFace contains "normal" style with "400" weight', () => {
-		const family = {
-			fontFamily: 'Rosario',
-			fontFace: [
-				{ fontStyle: 'italic', fontWeight: '500' },
-				{ fontStyle: 'normal', fontWeight: '400' },
-			],
-		};
-		const result = getFamilyPreviewStyle( family );
-		const expected = {
-			fontFamily: 'Rosario',
-			fontStyle: 'normal',
-			fontWeight: '400',
-		};
-		expect( result ).toEqual( expected );
-	} );
-
-	it( 'should return the fontWeight of the nearest "normal" style if no "400" weight is found', () => {
-		const family = {
-			fontFamily: 'Rosario',
-			fontFace: [
-				{ fontStyle: 'normal', fontWeight: '800' },
-				{ fontStyle: 'italic', fontWeight: '500' },
-				{ fontStyle: 'normal', fontWeight: '600' },
-			],
-		};
-		const result = getFamilyPreviewStyle( family );
-		const expected = {
-			fontFamily: 'Rosario',
-			fontStyle: 'normal',
-			fontWeight: '600',
-		};
-		expect( result ).toEqual( expected );
-	} );
-
-	it( 'should return 400 or the the nearest "normal" style if it using a variable weight font', () => {
-		const family = {
-			fontFamily: 'Rosario',
-			fontFace: [
-				{ fontStyle: 'normal', fontWeight: '100' },
-				{ fontStyle: 'normal', fontWeight: '200 900' },
-				{ fontStyle: 'italic', fontWeight: '200 900' },
-			],
-		};
-		const result = getFamilyPreviewStyle( family );
-		const expected = {
-			fontFamily: 'Rosario',
-			fontStyle: 'normal',
-			fontWeight: '400',
-		};
-		expect( result ).toEqual( expected );
-	} );
-} );
-
-describe( 'formatFontFamily', () => {
-	it( 'should transform "Baloo 2, system-ui" correctly', () => {
-		expect( formatFontFamily( 'Baloo 2, system-ui' ) ).toBe(
-			'"Baloo 2", system-ui'
-		);
-	} );
-
-	it( 'should ignore extra spaces', () => {
-		expect( formatFontFamily( '  Baloo 2   , system-ui' ) ).toBe(
-			'"Baloo 2", system-ui'
-		);
-	} );
-
-	it( 'should keep quoted strings unchanged', () => {
-		expect(
-			formatFontFamily(
-				"Seravek, 'Gill Sans Nova', Ubuntu, Calibri, 'DejaVu Sans', source-sans-pro, sans-serif"
-			)
-		).toBe(
-			'Seravek, "Gill Sans Nova", Ubuntu, Calibri, "DejaVu Sans", source-sans-pro, sans-serif'
-		);
-	} );
-
-	it( 'should wrap single font name with spaces in quotes', () => {
-		expect( formatFontFamily( 'Baloo 2' ) ).toBe( '"Baloo 2"' );
-	} );
-
-	it( 'should wrap multiple font names with spaces in quotes', () => {
-		expect( formatFontFamily( 'Baloo Bhai 2, Baloo 2' ) ).toBe(
-			'"Baloo Bhai 2", "Baloo 2"'
-		);
-	} );
-
-	it( 'should wrap names with special characters in quotes', () => {
-		expect(
-			formatFontFamily(
-				'Font+Name, Font*Name, _Font_Name_, generic(kai), sans-serif'
-			)
-		).toBe(
-			'"Font+Name", "Font*Name", "_Font_Name_", generic(kai), sans-serif'
-		);
-	} );
-
-	it( 'should fix empty wrong formatted font family', () => {
-		expect( formatFontFamily( ', Abril Fatface,Times,serif' ) ).toBe(
-			'"Abril Fatface", Times, serif'
-		);
-	} );
-
-	it( 'should not add quotes to generic names', () => {
-		expect(
-			formatFontFamily(
-				'Paren(thesis)Font, generic(kai), generic(fasongsong), generic( abc ), Helvetica Neue'
-			)
-		).toBe(
-			'"Paren(thesis)Font", generic(kai), generic(fasongsong), generic( abc ), "Helvetica Neue"'
-		);
-	} );
-} );
-
-describe( 'formatFontFaceName', () => {
-	it( 'should remove leading and trailing quotes', () => {
-		expect( formatFontFaceName( '"Open Sans"' ) ).toBe( 'Open Sans' );
-	} );
-
-	it( 'should remove leading and trailing quotes from multiple font face names', () => {
-		expect(
-			formatFontFaceName( "'Open Sans', 'Helvetica Neue', sans-serif" )
-		).toBe( 'Open Sans' );
-	} );
-
-	it( 'should remove leading and trailing quotes even from names with spaces and special characters', () => {
-		expect( formatFontFaceName( "'Font+Name 24', sans-serif" ) ).toBe(
-			'Font+Name 24'
-		);
-	} );
-
-	it( 'should output the font face name with quotes on Firefox', () => {
-		const mockUserAgent =
-			'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:122.0) Gecko/20100101 Firefox/122.0';
-
-		// Mock the userAgent for this test
-		Object.defineProperty( window.navigator, 'userAgent', {
-			value: mockUserAgent,
-			configurable: true,
-		} );
-
-		expect( formatFontFaceName( 'Open Sans' ) ).toBe( '"Open Sans"' );
-	} );
-} );

package/src/components/global-styles/font-library-modal/utils/test/setUIValuesNeeded.spec.js

@@ -1,41 +0,0 @@
-/**
- * Internal dependencies
- */
-import { setUIValuesNeeded } from '../index';
-
-describe( 'setUIValuesNeeded function', () => {
-	test( 'Should set name from fontFamily if name is missing', () => {
-		const font = { fontFamily: 'Arial' };
-		const result = setUIValuesNeeded( font );
-		expect( result.name ).toBe( 'Arial' );
-	} );
-
-	test( 'Should set name from slug if name and fontFamily are missing', () => {
-		const font = { slug: 'arial-slug' };
-		const result = setUIValuesNeeded( font );
-		expect( result.name ).toBe( 'arial-slug' );
-	} );
-
-	test( 'Should not overwrite name if it exists', () => {
-		const font = { name: 'ExistingName', fontFamily: 'Arial' };
-		const result = setUIValuesNeeded( font );
-		expect( result.name ).toBe( 'ExistingName' );
-	} );
-
-	test( 'Should merge extra values', () => {
-		const font = { name: 'Arial', slug: 'arial' };
-		const extraValues = { source: 'custom' };
-		const result = setUIValuesNeeded( font, extraValues );
-		expect( result ).toEqual( {
-			name: 'Arial',
-			slug: 'arial',
-			source: 'custom',
-		} );
-	} );
-
-	test( 'Should return the same object if no conditions met', () => {
-		const font = { randomProperty: 'randomValue' };
-		const result = setUIValuesNeeded( font );
-		expect( result ).toEqual( font );
-	} );
-} );