@automattic/data-stores 2.0.0 → 3.0.1

package/src/site/test/actions.ts

@@ -1,17 +1,28 @@
 /**
  * @jest-environment jsdom
  */
-/**
- * Internal dependencies
- */
+
 import { createActions } from '../actions';
-import { SiteLaunchError } from '../types';
+import {
+	SiteLaunchError,
+	AtomicTransferError,
+	LatestAtomicTransfer,
+	LatestAtomicTransferError,
+	AtomicSoftwareStatus,
+} from '../types';
 
 const client_id = 'magic_client_id';
 const client_secret = 'magic_client_secret';
 const mockedClientCredentials = { client_id, client_secret };
 const siteId = 12345;
 const error = SiteLaunchError.INTERNAL;
+const atomicTransferError = AtomicTransferError.INTERNAL;
+const latestAtomicTransferError: LatestAtomicTransferError = {
+	name: 'NotFoundError',
+	status: 404,
+	message: 'Transfer not found',
+	code: 'no_transfer_error',
+};
 
 describe( 'Site Actions', () => {
 	describe( 'LAUNCH_SITE Actions', () => {
@@ -114,4 +125,255 @@ describe( 'Site Actions', () => {
 			expect( finalResult.done ).toBe( true );
 		} );
 	} );
+
+	describe( 'Atomic Actions', () => {
+		it( 'should return a ATOMIC_TRANSFER_START Action', () => {
+			const { atomicTransferStart } = createActions( mockedClientCredentials );
+			const softwareSet = 'woo-on-plans';
+
+			const expected = {
+				type: 'ATOMIC_TRANSFER_START',
+				siteId,
+				softwareSet,
+			};
+
+			expect( atomicTransferStart( siteId, softwareSet ) ).toEqual( expected );
+		} );
+
+		it( 'should return a ATOMIC_TRANSFER_SUCCESS Action', () => {
+			const { atomicTransferSuccess } = createActions( mockedClientCredentials );
+			const softwareSet = 'woo-on-plans';
+
+			const expected = {
+				type: 'ATOMIC_TRANSFER_SUCCESS',
+				siteId,
+				softwareSet,
+			};
+
+			expect( atomicTransferSuccess( siteId, softwareSet ) ).toEqual( expected );
+		} );
+
+		it( 'should return a ATOMIC_TRANSFER_FAILURE Action', () => {
+			const { atomicTransferFailure } = createActions( mockedClientCredentials );
+			const softwareSet = 'woo-on-plans';
+
+			const expected = {
+				type: 'ATOMIC_TRANSFER_FAILURE',
+				siteId,
+				softwareSet,
+				error: atomicTransferError,
+			};
+
+			expect( atomicTransferFailure( siteId, softwareSet, atomicTransferError ) ).toEqual(
+				expected
+			);
+		} );
+
+		it( 'should start an Atomic transfer', () => {
+			const { initiateAtomicTransfer } = createActions( mockedClientCredentials );
+			const softwareSet = 'woo-on-plans';
+			const generator = initiateAtomicTransfer( siteId, softwareSet );
+
+			const mockedApiResponse = {
+				request: {
+					apiNamespace: 'wpcom/v2',
+					method: 'POST',
+					path: `/sites/${ siteId }/atomic/transfers`,
+					body: { software_set: softwareSet },
+				},
+				type: 'WPCOM_REQUEST',
+			};
+
+			// First iteration: ATOMIC_TRANSFER_START is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'ATOMIC_TRANSFER_START',
+				siteId,
+				softwareSet,
+			} );
+
+			// Second iteration: WP_COM_REQUEST is fired
+			expect( generator.next().value ).toEqual( mockedApiResponse );
+
+			// Third iteration: ATOMIC_TRANSFER_SUCCESS is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'ATOMIC_TRANSFER_SUCCESS',
+				siteId,
+				softwareSet,
+			} );
+		} );
+		it( 'should fail to transfer a site to Atomic', () => {
+			const { initiateAtomicTransfer } = createActions( mockedClientCredentials );
+			const softwareSet = 'woo-on-plans';
+			const generator = initiateAtomicTransfer( siteId, softwareSet );
+
+			const mockedApiResponse = {
+				request: {
+					apiNamespace: 'wpcom/v2',
+					method: 'POST',
+					path: `/sites/${ siteId }/atomic/transfers`,
+					body: { software_set: softwareSet },
+				},
+				type: 'WPCOM_REQUEST',
+			};
+
+			// First iteration: ATOMIC_TRANSFER_START is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'ATOMIC_TRANSFER_START',
+				siteId,
+				softwareSet,
+			} );
+
+			// Second iteration: WP_COM_REQUEST is fired
+			expect( generator.next().value ).toEqual( mockedApiResponse );
+
+			// Third iteration: ATOMIC_TRANSFER_FAILURE is fired
+			expect( generator.throw( atomicTransferError ).value ).toEqual( {
+				type: 'ATOMIC_TRANSFER_FAILURE',
+				siteId,
+				softwareSet,
+				error: atomicTransferError,
+			} );
+		} );
+
+		it( 'should request succesfully the Atomic transfer status', () => {
+			const { requestLatestAtomicTransfer } = createActions( mockedClientCredentials );
+			const generator = requestLatestAtomicTransfer( siteId );
+			const transfer: LatestAtomicTransfer = {
+				atomic_transfer_id: 123,
+				blog_id: 12345,
+				status: 'SUCCESS',
+				created_at: 'now',
+				is_stuck: false,
+				is_stuck_reset: false,
+				in_lossless_revert: false,
+			};
+
+			const mockedApiResponse = {
+				request: {
+					apiNamespace: 'wpcom/v2',
+					method: 'GET',
+					path: `/sites/${ siteId }/atomic/transfers/latest`,
+				},
+				type: 'WPCOM_REQUEST',
+			};
+
+			// First iteration: LATEST_ATOMIC_TRANSFER_START is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'LATEST_ATOMIC_TRANSFER_START',
+				siteId,
+			} );
+
+			// Second iteration: WP_COM_REQUEST is fired
+			expect( generator.next().value ).toEqual( mockedApiResponse );
+
+			// Third iteration: ATOMIC_TRANSFER_SUCCESS is fired
+			expect( generator.next( transfer ).value ).toEqual( {
+				type: 'LATEST_ATOMIC_TRANSFER_SUCCESS',
+				siteId,
+				transfer,
+			} );
+		} );
+
+		it( 'should request the Atomic transfer status and fail', () => {
+			const { requestLatestAtomicTransfer } = createActions( mockedClientCredentials );
+			const generator = requestLatestAtomicTransfer( siteId );
+
+			const mockedApiResponse = {
+				request: {
+					apiNamespace: 'wpcom/v2',
+					method: 'GET',
+					path: `/sites/${ siteId }/atomic/transfers/latest`,
+				},
+				type: 'WPCOM_REQUEST',
+			};
+
+			// First iteration: LATEST_ATOMIC_TRANSFER_START is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'LATEST_ATOMIC_TRANSFER_START',
+				siteId,
+			} );
+
+			// Second iteration: WP_COM_REQUEST is fired
+			expect( generator.next().value ).toEqual( mockedApiResponse );
+
+			// Third iteration: LATEST_ATOMIC_TRANSFER_FAILURE is fired
+			expect( generator.throw( latestAtomicTransferError ).value ).toEqual( {
+				type: 'LATEST_ATOMIC_TRANSFER_FAILURE',
+				siteId,
+				error: latestAtomicTransferError,
+			} );
+		} );
+
+		it( 'should request the Atomic software install status succesfully', () => {
+			const { requestAtomicSoftwareStatus } = createActions( mockedClientCredentials );
+			const softwareSet = 'woo-on-plans';
+			const generator = requestAtomicSoftwareStatus( siteId, softwareSet );
+			const status: AtomicSoftwareStatus = {
+				blog_id: 123,
+				software_set: {
+					test: { path: '/valid_path.php', state: 'activate' },
+				},
+				applied: false,
+			};
+
+			const mockedApiResponse = {
+				request: {
+					apiNamespace: 'wpcom/v2',
+					method: 'GET',
+					path: `/sites/${ siteId }/atomic/software/${ softwareSet }`,
+				},
+				type: 'WPCOM_REQUEST',
+			};
+
+			// First iteration
+			expect( generator.next().value ).toEqual( {
+				type: 'ATOMIC_SOFTWARE_STATUS_START',
+				siteId,
+				softwareSet,
+			} );
+
+			// Second iteration: WP_COM_REQUEST is fired
+			expect( generator.next().value ).toEqual( mockedApiResponse );
+
+			// Third iteration: LATEST_ATOMIC_TRANSFER_SUCCESS is fired
+			expect( generator.next( status ).value ).toEqual( {
+				type: 'ATOMIC_SOFTWARE_STATUS_SUCCESS',
+				siteId,
+				softwareSet,
+				status,
+			} );
+		} );
+		it( 'should start an Atomic software install', () => {
+			const { initiateSoftwareInstall } = createActions( mockedClientCredentials );
+			const softwareSet = 'woo-on-plans';
+			const generator = initiateSoftwareInstall( siteId, softwareSet );
+
+			const mockedApiResponse = {
+				request: {
+					apiNamespace: 'wpcom/v2',
+					method: 'POST',
+					path: `/sites/${ siteId }/atomic/software/${ softwareSet }`,
+					body: {},
+				},
+				type: 'WPCOM_REQUEST',
+			};
+
+			// First iteration: ATOMIC_SOFTWARE_INSTALL_START is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'ATOMIC_SOFTWARE_INSTALL_START',
+				siteId,
+				softwareSet,
+			} );
+
+			// Second iteration: WP_COM_REQUEST is fired
+			expect( generator.next().value ).toEqual( mockedApiResponse );
+
+			// Third iteration: ATOMIC_SOFTWARE_INSTALL_SUCCESS is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'ATOMIC_SOFTWARE_INSTALL_SUCCESS',
+				siteId,
+				softwareSet,
+			} );
+		} );
+	} );
 } );

package/src/site/test/reducer.ts

@@ -6,10 +6,8 @@
  * @jest-environment jsdom
  */
 
-/**
- * Internal dependencies
- */
-import { sites, launchStatus } from '../reducer';
+import { createActions } from '../actions';
+import { sites, launchStatus, siteSetupErrors } from '../reducer';
 import {
 	SiteLaunchError,
 	SiteLaunchState,
@@ -17,7 +15,6 @@ import {
 	SiteDetails,
 	SiteError,
 } from '../types';
-import { createActions } from '../actions';
 
 describe( 'Site', () => {
 	const siteDetailsResponse: SiteDetails = {
@@ -128,4 +125,51 @@ describe( 'Site', () => {
 			expect( launchStatus( originalState, action ) ).toEqual( expected );
 		} );
 	} );
+
+	describe( 'Site Setup Errors', () => {
+		type ClientCredentials = { client_id: string; client_secret: string };
+
+		let siteId: number;
+		let client_id: string;
+		let client_secret: string;
+		let mockedClientCredentials: ClientCredentials;
+		let originalState: { [ key: number ]: SiteLaunchState };
+
+		beforeEach( () => {
+			siteId = 12345;
+			client_id = 'magic_client_id';
+			client_secret = 'magic_client_secret';
+			mockedClientCredentials = { client_id, client_secret };
+			originalState = {};
+		} );
+
+		it( 'should default to the initial state when an unknown action is dispatched', () => {
+			const state = siteSetupErrors( undefined, { type: 'TEST_ACTION' } );
+			expect( state ).toStrictEqual( {} );
+		} );
+
+		it( 'should set a site setup error when a SET_SITE_SETUP_ERROR action is dispatched', () => {
+			const { setSiteSetupError } = createActions( mockedClientCredentials );
+
+			const error = 'test_error';
+			const message = 'This is a test error';
+
+			const action = setSiteSetupError( error, message );
+			const expected = {
+				error,
+				message,
+			};
+
+			expect( siteSetupErrors( originalState, action ) ).toEqual( expected );
+		} );
+
+		it( 'should clear a site setup error when a CLEAR_SITE_SETUP_ERROR action is dispatched', () => {
+			const { clearSiteSetupError } = createActions( mockedClientCredentials );
+
+			const action = clearSiteSetupError( siteId );
+			const expected = {};
+
+			expect( siteSetupErrors( originalState, action ) ).toEqual( expected );
+		} );
+	} );
 } );

package/src/site/test/selectors.ts

@@ -6,16 +6,17 @@
  * @jest-environment jsdom
  */
 
-/**
- * External dependencies
- */
 import { dispatch, select, subscribe } from '@wordpress/data';
 import wpcomRequest from 'wpcom-proxy-request';
-
-/**
- * Internal dependencies
- */
-import { register } from '..';
+import { AtomicSoftwareStatus, AtomicSoftwareStatusError, register } from '..';
+import {
+	getAtomicSoftwareStatus,
+	getAtomicSoftwareError,
+	getSiteOptions,
+	getSiteOption,
+} from '../selectors';
+import { SiteDetails } from '../types';
+import type { State } from '../reducer';
 
 jest.mock( 'wpcom-proxy-request', () => ( {
 	__esModule: true,
@@ -112,3 +113,245 @@ describe( 'getSite', () => {
 		);
 	} );
 } );
+
+describe( 'requiresUpgrade', () => {
+	it( 'Retrieves an available site feature from the store', async () => {
+		const siteId = 12345;
+		const apiResponse = {
+			URL: 'http://mytestsite12345.wordpress.com',
+			ID: siteId,
+			plan: {
+				features: {
+					active: [],
+					available: {
+						woop: 'This is a test feature',
+					},
+				},
+			},
+		};
+		( wpcomRequest as jest.Mock ).mockResolvedValue( apiResponse );
+
+		// First call returns undefined
+		expect( select( store ).getSite( 'plan' ) ).toEqual( undefined );
+
+		const listenForStateUpdate = () => {
+			return new Promise( ( resolve ) => {
+				const unsubscribe = subscribe( () => {
+					unsubscribe();
+					resolve();
+				} );
+			} );
+		};
+
+		// In the first state update, the resolver starts resolving
+		await listenForStateUpdate();
+
+		// In the second update, the resolver is finished resolving and we can read the result in state
+		await listenForStateUpdate();
+
+		// Site requires upgrade
+		expect( select( store ).requiresUpgrade( siteId ) ).toEqual( true );
+	} );
+
+	it( 'Does not requires upgrade', async () => {
+		const siteId = 12345;
+		const apiResponse = {
+			URL: 'http://mytestsite12345.wordpress.com',
+			ID: siteId,
+			plan: {
+				features: {
+					active: [ 'woop' ],
+					available: {
+						woop: 'This is a test feature',
+					},
+				},
+			},
+		};
+		( wpcomRequest as jest.Mock ).mockResolvedValue( apiResponse );
+
+		// First call returns undefined
+		expect( select( store ).getSite( 'plan' ) ).toEqual( undefined );
+
+		const listenForStateUpdate = () => {
+			return new Promise( ( resolve ) => {
+				const unsubscribe = subscribe( () => {
+					unsubscribe();
+					resolve();
+				} );
+			} );
+		};
+
+		// In the first state update, the resolver starts resolving
+		await listenForStateUpdate();
+
+		// In the second update, the resolver is finished resolving and we can read the result in state
+		await listenForStateUpdate();
+
+		// Site requires upgrade
+		expect( select( store ).requiresUpgrade( siteId ) ).toEqual( false );
+	} );
+} );
+
+describe( 'getAtomicSoftwareStatus', () => {
+	it( 'Tries to retrive the Atomic Software Status', async () => {
+		const siteId = 1234;
+		const softwareSet = 'woo-on-plans';
+		const status: AtomicSoftwareStatus = {
+			blog_id: 123,
+			software_set: {
+				test: { path: '/valid_path.php', state: 'activate' },
+			},
+			applied: false,
+		};
+		const state: State = {
+			atomicSoftwareStatus: {
+				[ siteId ]: {
+					[ softwareSet ]: {
+						status: status,
+						error: undefined,
+					},
+				},
+			},
+		};
+
+		// Successfuly returns the status
+		expect( getAtomicSoftwareStatus( state, siteId, softwareSet ) ).toEqual( status );
+
+		// Should return undefined when the software set is not found.
+		expect( getAtomicSoftwareStatus( state, siteId, 'unknown_software_set' ) ).toEqual( undefined );
+
+		// Should return undefined when the site ID is not found
+		expect( getAtomicSoftwareStatus( state, 123456, softwareSet ) ).toEqual( undefined );
+	} );
+
+	it( 'Fails to retrive the Atomic Software Status', async () => {
+		const siteId = 1234;
+		const softwareSet = 'non-existing-software-set';
+		const error: AtomicSoftwareStatusError = {
+			name: 'NotFoundError',
+			status: 404,
+			message: 'Transfer not found',
+			code: 'no_transfer_record',
+		};
+
+		const state: State = {
+			atomicSoftwareStatus: {
+				[ siteId ]: {
+					[ softwareSet ]: {
+						status: undefined,
+						error: error,
+					},
+				},
+			},
+		};
+
+		// Successfuly returns the status
+		expect( getAtomicSoftwareError( state, siteId, softwareSet ) ).toEqual( error );
+	} );
+} );
+
+describe( 'getSiteOptions', () => {
+	const siteId = 1234;
+	const adminUrl = 'https://test.wordpress.com/wp-admin';
+	const options = {
+		admin_url: adminUrl,
+	};
+	const site: SiteDetails = {
+		ID: siteId,
+		name: 'test',
+		description: 'test site',
+		URL: 'https://test.wordpress.com',
+		launch_status: '',
+		jetpack: false,
+		is_fse_eligible: false,
+		is_fse_active: false,
+		options,
+		capabilities: {
+			edit_pages: true,
+			edit_posts: true,
+			edit_others_posts: true,
+			edit_others_pages: true,
+			delete_posts: true,
+			delete_others_posts: true,
+			edit_theme_options: true,
+			edit_users: true,
+			list_users: true,
+			manage_categories: true,
+			manage_options: true,
+			moderate_comments: true,
+			activate_wordads: true,
+			promote_users: true,
+			publish_posts: true,
+			upload_files: true,
+			delete_users: true,
+			remove_users: true,
+			own_site: true,
+			view_hosting: true,
+			view_stats: true,
+			activate_plugins: true,
+		},
+	};
+
+	it( 'Tries to retrive the site options', async () => {
+		const state: State = {
+			sites: {
+				[ siteId ]: site,
+			},
+		};
+
+		expect( getSiteOptions( state, siteId ) ).toEqual( options );
+	} );
+
+	it( 'Tries to retrive a specific site option', async () => {
+		const state: State = {
+			sites: {
+				[ siteId ]: site,
+			},
+		};
+
+		expect( getSiteOption( state, siteId, 'admin_url' ) ).toEqual( adminUrl );
+	} );
+} );
+
+describe( 'siteHasFeature', () => {
+	it( 'Test if site has features', async () => {
+		const siteId = 924785;
+		const siteSlug = `http://mytestsite${ siteId }.wordpress.com`;
+		const apiResponse = {
+			URL: siteSlug,
+			ID: siteId,
+			plan: {
+				features: {
+					active: [ 'woop' ],
+					available: {
+						woop: 'This is a test feature',
+					},
+				},
+			},
+		};
+
+		( wpcomRequest as jest.Mock ).mockResolvedValue( apiResponse );
+
+		const listenForStateUpdate = () => {
+			return new Promise( ( resolve ) => {
+				const unsubscribe = subscribe( () => {
+					unsubscribe();
+					resolve();
+				} );
+			} );
+		};
+
+		// First call returns undefined
+		expect( select( store ).getSite( siteId ) ).toEqual( undefined );
+
+		// In the first state update, the resolver starts resolving
+		await listenForStateUpdate();
+
+		// In the second update, the resolver is finished resolving and we can read the result in state
+		await listenForStateUpdate();
+
+		expect( select( store ).siteHasFeature( siteId, 'woop' ) ).toEqual( true );
+
+		expect( select( store ).siteHasFeature( siteId, 'loop' ) ).toEqual( false );
+	} );
+} );