@wordpress/data 6.4.0 → 6.6.0

package/src/plugins/persistence/test/index.js

@@ -9,9 +9,11 @@ import deepFreeze from 'deep-freeze';
 import plugin, {
 	createPersistenceInterface,
 	withLazySameState,
-	migrateFeaturePreferencesToInterfaceStore,
 	migrateFeaturePreferencesToPreferencesStore,
+	migrateThirdPartyFeaturePreferencesToPreferencesStore,
 	migrateIndividualPreferenceToPreferencesStore,
+	convertEditPostPanels,
+	migrateInterfaceEnableItemsToPreferencesStore,
 } from '../';
 import objectStorage from '../storage/object';
 import { createRegistry } from '../../../';
@@ -384,13 +386,13 @@ describe( 'persistence', () => {
 	} );
 } );
 
-describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
-	it( 'migrates preferences from the source to the interface store', () => {
+describe( 'migrateFeaturePreferencesToPreferencesStore', () => {
+	it( 'migrates multiple preferences from persisted source stores to preferences', () => {
 		const persistenceInterface = createPersistenceInterface( {
 			storageKey: 'test-username',
 		} );
 
-		const initialState = {
+		const sourceStateA = {
 			preferences: {
 				features: {
 					featureA: true,
@@ -400,26 +402,50 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 			},
 		};
 
-		persistenceInterface.set( 'core/test', initialState );
+		const sourceStateB = {
+			preferences: {
+				features: {
+					featureD: true,
+					featureE: false,
+					featureF: true,
+				},
+			},
+		};
+
+		persistenceInterface.set( 'core/test-a', sourceStateA );
+		persistenceInterface.set( 'core/test-b', sourceStateB );
+
+		migrateFeaturePreferencesToPreferencesStore(
+			persistenceInterface,
+			'core/test-a'
+		);
 
-		migrateFeaturePreferencesToInterfaceStore(
+		migrateFeaturePreferencesToPreferencesStore(
 			persistenceInterface,
-			'core/test'
+			'core/test-b'
 		);
 
 		expect( persistenceInterface.get() ).toEqual( {
-			'core/interface': {
+			'core/preferences': {
 				preferences: {
-					features: {
-						'core/test': {
-							featureA: true,
-							featureB: false,
-							featureC: true,
-						},
+					'core/test-a': {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+					'core/test-b': {
+						featureD: true,
+						featureE: false,
+						featureF: true,
 					},
 				},
 			},
-			'core/test': {
+			'core/test-a': {
+				preferences: {
+					features: undefined,
+				},
+			},
+			'core/test-b': {
 				preferences: {
 					features: undefined,
 				},
@@ -427,12 +453,12 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 		} );
 	} );
 
-	it( 'handles multiple preferences from different stores to be migrated', () => {
+	it( 'migrates multiple preferences from the persisted interface store to preferences, with interface state taking precedence over source stores', () => {
 		const persistenceInterface = createPersistenceInterface( {
 			storageKey: 'test-username',
 		} );
 
-		const initialStateA = {
+		const sourceStateA = {
 			preferences: {
 				features: {
 					featureA: true,
@@ -442,7 +468,7 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 			},
 		};
 
-		const initialStateB = {
+		const sourceStateB = {
 			preferences: {
 				features: {
 					featureD: true,
@@ -452,33 +478,63 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 			},
 		};
 
-		persistenceInterface.set( 'core/test-a', initialStateA );
-		persistenceInterface.set( 'core/test-b', initialStateB );
+		const interfaceState = {
+			otherData: {
+				test: 1,
+			},
+			preferences: {
+				features: {
+					'core/test-a': {
+						featureG: true,
+						featureH: false,
+						featureI: true,
+					},
+					'core/test-b': {
+						featureJ: true,
+						featureK: false,
+						featureL: true,
+					},
+				},
+			},
+		};
+
+		persistenceInterface.set( 'core/test-a', sourceStateA );
+		persistenceInterface.set( 'core/test-b', sourceStateB );
+		persistenceInterface.set( 'core/interface', interfaceState );
 
-		migrateFeaturePreferencesToInterfaceStore(
+		migrateFeaturePreferencesToPreferencesStore(
 			persistenceInterface,
 			'core/test-a'
 		);
 
-		migrateFeaturePreferencesToInterfaceStore(
+		migrateFeaturePreferencesToPreferencesStore(
 			persistenceInterface,
 			'core/test-b'
 		);
 
 		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/test-a': {
+						featureG: true,
+						featureH: false,
+						featureI: true,
+					},
+					'core/test-b': {
+						featureJ: true,
+						featureK: false,
+						featureL: true,
+					},
+				},
+			},
 			'core/interface': {
+				otherData: {
+					test: 1,
+				},
 				preferences: {
 					features: {
-						'core/test-a': {
-							featureA: true,
-							featureB: false,
-							featureC: true,
-						},
-						'core/test-b': {
-							featureD: true,
-							featureE: false,
-							featureF: true,
-						},
+						'core/test-a': undefined,
+						'core/test-b': undefined,
 					},
 				},
 			},
@@ -495,23 +551,67 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 		} );
 	} );
 
-	describe( 'migrateFeaturePreferencesToPreferencesStore', () => {
-		it( 'migrates multiple preferences from persisted source stores to preferences', () => {
-			const persistenceInterface = createPersistenceInterface( {
-				storageKey: 'test-username',
-			} );
+	it( 'only migrates persisted preference data for the source name from source stores', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		const sourceStateA = {
+			otherData: {
+				test: 1,
+			},
+			preferences: {
+				features: {
+					featureA: true,
+					featureB: false,
+					featureC: true,
+				},
+			},
+		};
+
+		const sourceStateB = {
+			otherData: {
+				test: 2,
+			},
+			preferences: {
+				features: {
+					featureD: true,
+					featureE: false,
+					featureF: true,
+				},
+			},
+		};
+
+		persistenceInterface.set( 'core/test-a', sourceStateA );
+		persistenceInterface.set( 'core/test-b', sourceStateB );
 
-			const sourceStateA = {
+		migrateFeaturePreferencesToPreferencesStore(
+			persistenceInterface,
+			'core/test-a'
+		);
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
 				preferences: {
-					features: {
+					'core/test-a': {
 						featureA: true,
 						featureB: false,
 						featureC: true,
 					},
 				},
-			};
-
-			const sourceStateB = {
+			},
+			'core/test-a': {
+				otherData: {
+					test: 1,
+				},
+				preferences: {
+					features: undefined,
+				},
+			},
+			'core/test-b': {
+				otherData: {
+					test: 2,
+				},
 				preferences: {
 					features: {
 						featureD: true,
@@ -519,82 +619,53 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 						featureF: true,
 					},
 				},
-			};
-
-			persistenceInterface.set( 'core/test-a', sourceStateA );
-			persistenceInterface.set( 'core/test-b', sourceStateB );
-
-			migrateFeaturePreferencesToPreferencesStore(
-				persistenceInterface,
-				'core/test-a'
-			);
+			},
+		} );
+	} );
 
-			migrateFeaturePreferencesToPreferencesStore(
-				persistenceInterface,
-				'core/test-b'
-			);
+	it( 'only migrates persisted data for the source name from interface', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
 
-			expect( persistenceInterface.get() ).toEqual( {
-				'core/preferences': {
-					preferences: {
-						'core/test-a': {
-							featureA: true,
-							featureB: false,
-							featureC: true,
-						},
-						'core/test-b': {
-							featureD: true,
-							featureE: false,
-							featureF: true,
-						},
-					},
-				},
-				'core/test-a': {
-					preferences: {
-						features: undefined,
+		const interfaceState = {
+			preferences: {
+				features: {
+					'core/test-a': {
+						featureG: true,
+						featureH: false,
+						featureI: true,
 					},
-				},
-				'core/test-b': {
-					preferences: {
-						features: undefined,
+					'core/test-b': {
+						featureJ: true,
+						featureK: false,
+						featureL: true,
 					},
 				},
-			} );
-		} );
+			},
+		};
 
-		it( 'migrates multiple preferences from the persisted interface store to preferences, with interface state taking precedence over source stores', () => {
-			const persistenceInterface = createPersistenceInterface( {
-				storageKey: 'test-username',
-			} );
+		persistenceInterface.set( 'core/interface', interfaceState );
 
-			const sourceStateA = {
-				preferences: {
-					features: {
-						featureA: true,
-						featureB: false,
-						featureC: true,
-					},
-				},
-			};
+		migrateFeaturePreferencesToPreferencesStore(
+			persistenceInterface,
+			'core/test-a'
+		);
 
-			const sourceStateB = {
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
 				preferences: {
-					features: {
-						featureD: true,
-						featureE: false,
-						featureF: true,
+					'core/test-a': {
+						featureG: true,
+						featureH: false,
+						featureI: true,
 					},
 				},
-			};
-
-			const interfaceState = {
+			},
+			'core/interface': {
 				preferences: {
 					features: {
-						'core/test-a': {
-							featureG: true,
-							featureH: false,
-							featureI: true,
-						},
+						'core/test-a': undefined,
 						'core/test-b': {
 							featureJ: true,
 							featureK: false,
@@ -602,299 +673,483 @@ describe( 'migrateFeaturePreferencesToInterfaceStore', () => {
 						},
 					},
 				},
-			};
+			},
+		} );
+	} );
+} );
 
-			persistenceInterface.set( 'core/test-a', sourceStateA );
-			persistenceInterface.set( 'core/test-b', sourceStateB );
-			persistenceInterface.set( 'core/interface', interfaceState );
+describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
+	it( 'migrates an individual preference from the source to the preferences store', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
 
-			migrateFeaturePreferencesToPreferencesStore(
-				persistenceInterface,
-				'core/test-a'
-			);
+		const initialState = {
+			preferences: {
+				myPreference: '123',
+			},
+		};
 
-			migrateFeaturePreferencesToPreferencesStore(
-				persistenceInterface,
-				'core/test-b'
-			);
+		persistenceInterface.set( 'core/test', initialState );
 
-			expect( persistenceInterface.get() ).toEqual( {
-				'core/preferences': {
-					preferences: {
-						'core/test-a': {
-							featureG: true,
-							featureH: false,
-							featureI: true,
-						},
-						'core/test-b': {
-							featureJ: true,
-							featureK: false,
-							featureL: true,
-						},
+		migrateIndividualPreferenceToPreferencesStore(
+			persistenceInterface,
+			{ from: 'core/test', scope: 'core/test' },
+			'myPreference'
+		);
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/test': {
+						myPreference: '123',
 					},
 				},
-				'core/interface': {
-					preferences: {
-						features: {
-							'core/test-a': undefined,
-							'core/test-b': undefined,
-						},
+			},
+			'core/test': {
+				preferences: {
+					myPreference: undefined,
+				},
+			},
+		} );
+	} );
+
+	it( 'does not overwrite other preferences in the preferences store', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		const initialState = {
+			otherData: {
+				test: 1,
+			},
+			preferences: {
+				myPreference: '123',
+			},
+		};
+
+		persistenceInterface.set( 'core/test', initialState );
+		persistenceInterface.set( 'core/preferences', {
+			preferences: {
+				'core/other-store': {
+					preferenceA: 1,
+					preferenceB: 2,
+				},
+				'core/test': {
+					unrelatedPreference: 'unrelated-value',
+				},
+			},
+		} );
+
+		migrateIndividualPreferenceToPreferencesStore(
+			persistenceInterface,
+			{ from: 'core/test', scope: 'core/test' },
+			'myPreference'
+		);
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/other-store': {
+						preferenceA: 1,
+						preferenceB: 2,
+					},
+					'core/test': {
+						unrelatedPreference: 'unrelated-value',
+						myPreference: '123',
 					},
 				},
-				'core/test-a': {
-					preferences: {
-						features: undefined,
+			},
+			'core/test': {
+				otherData: {
+					test: 1,
+				},
+				preferences: {
+					myPreference: undefined,
+				},
+			},
+		} );
+	} );
+
+	it( 'supports moving data to a scope that is differently named to the source store', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		const initialState = {
+			preferences: {
+				myPreference: '123',
+			},
+		};
+
+		persistenceInterface.set( 'core/source', initialState );
+
+		migrateIndividualPreferenceToPreferencesStore(
+			persistenceInterface,
+			{ from: 'core/source', scope: 'core/destination' },
+			'myPreference'
+		);
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/destination': {
+						myPreference: '123',
 					},
 				},
-				'core/test-b': {
-					preferences: {
-						features: undefined,
+			},
+			'core/source': {
+				preferences: {
+					myPreference: undefined,
+				},
+			},
+		} );
+	} );
+
+	it( 'does not migrate data if there is already a matching preference key at the target', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		persistenceInterface.set( 'core/test', {
+			preferences: {
+				myPreference: '123',
+			},
+		} );
+
+		persistenceInterface.set( 'core/preferences', {
+			preferences: {
+				'core/test': {
+					myPreference: 'already-set',
+				},
+			},
+		} );
+
+		migrateIndividualPreferenceToPreferencesStore(
+			persistenceInterface,
+			{ from: 'core/test', scope: 'core/test' },
+			'myPreference'
+		);
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/test': {
+						myPreference: 'already-set',
 					},
 				},
-			} );
+			},
+			'core/test': {
+				preferences: {
+					myPreference: '123',
+				},
+			},
+		} );
+	} );
+
+	it( 'migrates preferences that have a `false` value', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
 		} );
 
-		it( 'only migrates persisted data for the source name from source stores', () => {
-			const persistenceInterface = createPersistenceInterface( {
-				storageKey: 'test-username',
-			} );
+		persistenceInterface.set( 'core/test', {
+			preferences: {
+				myFalsePreference: false,
+			},
+		} );
+
+		migrateIndividualPreferenceToPreferencesStore(
+			persistenceInterface,
+			{ from: 'core/test', scope: 'core/test' },
+			'myFalsePreference'
+		);
 
-			const sourceStateA = {
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
 				preferences: {
-					features: {
+					'core/test': {
+						myFalsePreference: false,
+					},
+				},
+			},
+			'core/test': {
+				preferences: {},
+			},
+		} );
+	} );
+} );
+
+describe( 'migrateThirdPartyFeaturePreferencesToPreferencesStore', () => {
+	it( 'migrates multiple scopes from the interface package to the preferences package', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
+
+		const interfaceState = {
+			otherData: {
+				test: 1,
+			},
+			preferences: {
+				features: {
+					'plugin-a': {
 						featureA: true,
 						featureB: false,
 						featureC: true,
 					},
+					'plugin-b': {
+						featureD: true,
+						featureE: false,
+						featureF: true,
+					},
 				},
-			};
+			},
+		};
+		persistenceInterface.set( 'core/interface', interfaceState );
+
+		migrateThirdPartyFeaturePreferencesToPreferencesStore(
+			persistenceInterface
+		);
 
-			const sourceStateB = {
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
 				preferences: {
-					features: {
+					'plugin-a': {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+					'plugin-b': {
 						featureD: true,
 						featureE: false,
 						featureF: true,
 					},
 				},
-			};
-
-			persistenceInterface.set( 'core/test-a', sourceStateA );
-			persistenceInterface.set( 'core/test-b', sourceStateB );
+			},
+			'core/interface': {
+				otherData: {
+					test: 1,
+				},
+				preferences: {
+					features: {
+						'plugin-a': undefined,
+						'plugin-b': undefined,
+					},
+				},
+			},
+		} );
+	} );
 
-			migrateFeaturePreferencesToPreferencesStore(
-				persistenceInterface,
-				'core/test-a'
-			);
+	it( 'ignores any core scopes', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
 
-			expect( persistenceInterface.get() ).toEqual( {
-				'core/preferences': {
-					preferences: {
-						'core/test-a': {
-							featureA: true,
-							featureB: false,
-							featureC: true,
-						},
+		const interfaceState = {
+			preferences: {
+				features: {
+					'plugin-a': {
+						featureA: true,
+						featureB: false,
+						featureC: true,
+					},
+					'core/edit-post': {
+						featureD: true,
+						featureE: false,
+						featureF: true,
 					},
 				},
-				'core/test-a': {
-					preferences: {
-						features: undefined,
+			},
+		};
+		persistenceInterface.set( 'core/interface', interfaceState );
+
+		migrateThirdPartyFeaturePreferencesToPreferencesStore(
+			persistenceInterface
+		);
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'plugin-a': {
+						featureA: true,
+						featureB: false,
+						featureC: true,
 					},
 				},
-				'core/test-b': {
-					preferences: {
-						features: {
+			},
+			'core/interface': {
+				preferences: {
+					features: {
+						'plugin-a': undefined,
+						'core/edit-post': {
 							featureD: true,
 							featureE: false,
 							featureF: true,
 						},
 					},
 				},
-			} );
+			},
 		} );
+	} );
+} );
 
-		it( 'only migrates persisted data for the source name from interface', () => {
-			const persistenceInterface = createPersistenceInterface( {
-				storageKey: 'test-username',
-			} );
-
-			const interfaceState = {
-				preferences: {
-					features: {
-						'core/test-a': {
-							featureG: true,
-							featureH: false,
-							featureI: true,
-						},
-						'core/test-b': {
-							featureJ: true,
-							featureK: false,
-							featureL: true,
-						},
+describe( 'convertEditPostPanels', () => {
+	it( 'converts from one format to another', () => {
+		expect(
+			convertEditPostPanels( {
+				panels: {
+					tags: {
+						enabled: true,
+						opened: true,
+					},
+					permalinks: {
+						enabled: false,
+						opened: false,
+					},
+					categories: {
+						enabled: true,
+						opened: false,
+					},
+					excerpt: {
+						enabled: false,
+						opened: true,
+					},
+					discussion: {
+						enabled: false,
+					},
+					template: {
+						opened: true,
 					},
 				},
-			};
+			} )
+		).toEqual( {
+			inactivePanels: [ 'permalinks', 'excerpt', 'discussion' ],
+			openPanels: [ 'tags', 'excerpt', 'template' ],
+		} );
+	} );
 
-			persistenceInterface.set( 'core/interface', interfaceState );
+	it( 'returns empty arrays when there is no data to convert', () => {
+		expect( convertEditPostPanels( {} ) ).toEqual( {
+			inactivePanels: [],
+			openPanels: [],
+		} );
+	} );
+} );
 
-			migrateFeaturePreferencesToPreferencesStore(
-				persistenceInterface,
-				'core/test-a'
-			);
+describe( 'migrateInterfaceEnableItemsToPreferencesStore', () => {
+	it( 'migrates enableItems to the preferences store', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
 
-			expect( persistenceInterface.get() ).toEqual( {
-				'core/preferences': {
-					preferences: {
-						'core/test-a': {
-							featureG: true,
-							featureH: false,
-							featureI: true,
-						},
+		persistenceInterface.set( 'core/interface', {
+			enableItems: {
+				singleEnableItems: {
+					complementaryArea: {
+						'core/edit-post': 'edit-post/document',
+						'core/edit-site': 'edit-site/global-styles',
 					},
 				},
-				'core/interface': {
-					preferences: {
-						features: {
-							'core/test-a': undefined,
-							'core/test-b': {
-								featureJ: true,
-								featureK: false,
-								featureL: true,
-							},
+				multipleEnableItems: {
+					pinnedItems: {
+						'core/edit-post': {
+							'plugin-1': true,
+						},
+						'core/edit-site': {
+							'plugin-2': true,
 						},
 					},
 				},
-			} );
+			},
 		} );
-	} );
 
-	describe( 'migrateIndividualPreferenceToPreferencesStore', () => {
-		it( 'migrates an individual preference from the source to the preferences store', () => {
-			const persistenceInterface = createPersistenceInterface( {
-				storageKey: 'test-username',
-			} );
+		migrateInterfaceEnableItemsToPreferencesStore( persistenceInterface );
 
-			const initialState = {
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
 				preferences: {
-					myPreference: '123',
-				},
-			};
-
-			persistenceInterface.set( 'core/test', initialState );
-
-			migrateIndividualPreferenceToPreferencesStore(
-				persistenceInterface,
-				'core/test',
-				'myPreference'
-			);
-
-			expect( persistenceInterface.get() ).toEqual( {
-				'core/preferences': {
-					preferences: {
-						'core/test': {
-							myPreference: '123',
+					'core/edit-post': {
+						complementaryArea: 'edit-post/document',
+						pinnedItems: {
+							'plugin-1': true,
 						},
 					},
-				},
-				'core/test': {
-					preferences: {
-						myPreference: undefined,
+					'core/edit-site': {
+						complementaryArea: 'edit-site/global-styles',
+						pinnedItems: {
+							'plugin-2': true,
+						},
 					},
 				},
-			} );
+			},
+			'core/interface': {
+				enableItems: undefined,
+			},
 		} );
+	} );
 
-		it( 'does not overwrite other preferences in the preferences store', () => {
-			const persistenceInterface = createPersistenceInterface( {
-				storageKey: 'test-username',
-			} );
-
-			const initialState = {
-				preferences: {
-					myPreference: '123',
-				},
-			};
+	it( 'merges pinnedItems and complementaryAreas with existing preferences store data', () => {
+		const persistenceInterface = createPersistenceInterface( {
+			storageKey: 'test-username',
+		} );
 
-			persistenceInterface.set( 'core/test', initialState );
-			persistenceInterface.set( 'core/preferences', {
-				preferences: {
-					'core/other-store': {
-						preferenceA: 1,
-						preferenceB: 2,
-					},
-					'core/test': {
-						unrelatedPreference: 'unrelated-value',
+		persistenceInterface.set( 'core/interface', {
+			enableItems: {
+				singleEnableItems: {
+					complementaryArea: {
+						'core/edit-post': 'edit-post/document',
+						'core/edit-site': 'edit-site/global-styles',
 					},
 				},
-			} );
-
-			migrateIndividualPreferenceToPreferencesStore(
-				persistenceInterface,
-				'core/test',
-				'myPreference'
-			);
-
-			expect( persistenceInterface.get() ).toEqual( {
-				'core/preferences': {
-					preferences: {
-						'core/other-store': {
-							preferenceA: 1,
-							preferenceB: 2,
+				multipleEnableItems: {
+					pinnedItems: {
+						'core/edit-post': {
+							'plugin-1': true,
 						},
-						'core/test': {
-							unrelatedPreference: 'unrelated-value',
-							myPreference: '123',
+						'core/edit-site': {
+							'plugin-2': true,
 						},
 					},
 				},
-				'core/test': {
-					preferences: {
-						myPreference: undefined,
-					},
-				},
-			} );
+			},
 		} );
 
-		it( 'does not migrate data if there is already a matching preference key at the target', () => {
-			const persistenceInterface = createPersistenceInterface( {
-				storageKey: 'test-username',
-			} );
-
-			persistenceInterface.set( 'core/test', {
-				preferences: {
-					myPreference: '123',
+		persistenceInterface.set( 'core/preferences', {
+			preferences: {
+				'core/edit-post': {
+					preferenceA: 1,
+					preferenceB: 2,
 				},
-			} );
-
-			persistenceInterface.set( 'core/preferences', {
-				preferences: {
-					'core/test': {
-						myPreference: 'already-set',
-					},
+				'core/edit-site': {
+					preferenceC: true,
 				},
-			} );
+			},
+		} );
 
-			migrateIndividualPreferenceToPreferencesStore(
-				persistenceInterface,
-				'core/test',
-				'myPreference'
-			);
-
-			expect( persistenceInterface.get() ).toEqual( {
-				'core/preferences': {
-					preferences: {
-						'core/test': {
-							myPreference: 'already-set',
+		migrateInterfaceEnableItemsToPreferencesStore( persistenceInterface );
+
+		expect( persistenceInterface.get() ).toEqual( {
+			'core/preferences': {
+				preferences: {
+					'core/edit-post': {
+						preferenceA: 1,
+						preferenceB: 2,
+						complementaryArea: 'edit-post/document',
+						pinnedItems: {
+							'plugin-1': true,
 						},
 					},
-				},
-				'core/test': {
-					preferences: {
-						myPreference: '123',
+					'core/edit-site': {
+						preferenceC: true,
+						complementaryArea: 'edit-site/global-styles',
+						pinnedItems: {
+							'plugin-2': true,
+						},
 					},
 				},
-			} );
+			},
+			'core/interface': {
+				enableItems: undefined,
+			},
 		} );
 	} );
 } );