@automattic/data-stores 1.0.0-alpha.0 → 3.0.0

package/src/site/test/actions.ts

@@ -0,0 +1,379 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { createActions } from '../actions';
+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', () => {
+		it( 'should return a LAUNCH_SITE_START Action', () => {
+			const { launchSiteStart } = createActions( mockedClientCredentials );
+
+			const expected = {
+				type: 'LAUNCH_SITE_START',
+				siteId,
+			};
+
+			expect( launchSiteStart( siteId ) ).toEqual( expected );
+		} );
+
+		it( 'should return a LAUNCH_SITE_SUCCESS Action', () => {
+			const { launchSiteSuccess } = createActions( mockedClientCredentials );
+
+			const expected = {
+				type: 'LAUNCH_SITE_SUCCESS',
+				siteId,
+			};
+
+			expect( launchSiteSuccess( siteId ) ).toEqual( expected );
+		} );
+
+		it( 'should return a LAUNCH_SITE_FAILURE Action', () => {
+			const { launchSiteFailure } = createActions( mockedClientCredentials );
+
+			const expected = {
+				type: 'LAUNCH_SITE_FAILURE',
+				siteId,
+				error,
+			};
+
+			expect( launchSiteFailure( siteId, error ) ).toEqual( expected );
+		} );
+
+		it( 'should launch a site successfully', () => {
+			const { launchSite } = createActions( mockedClientCredentials );
+			const generator = launchSite( siteId );
+
+			const mockedApiResponse = {
+				request: {
+					apiVersion: '1.1',
+					method: 'post',
+					path: `/sites/${ siteId }/launch`,
+				},
+				type: 'WPCOM_REQUEST',
+			};
+
+			// First iteration: LAUNCH_SITE_IDLE is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'LAUNCH_SITE_START',
+				siteId,
+			} );
+
+			// Second iteration: WP_COM_REQUEST is fired
+			expect( generator.next().value ).toEqual( mockedApiResponse );
+
+			// Third iteration: LAUNCH_SITE_SUCCESS is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'LAUNCH_SITE_SUCCESS',
+				siteId,
+			} );
+		} );
+
+		it( 'should fail to launch a site', () => {
+			const { launchSite } = createActions( mockedClientCredentials );
+			const generator = launchSite( siteId );
+
+			const mockedApiResponse = {
+				request: {
+					apiVersion: '1.1',
+					method: 'post',
+					path: `/sites/${ siteId }/launch`,
+				},
+				type: 'WPCOM_REQUEST',
+			};
+
+			// First iteration: LAUNCH_SITE_IDLE is fired
+			expect( generator.next().value ).toEqual( {
+				type: 'LAUNCH_SITE_START',
+				siteId,
+			} );
+
+			// Second iteration: WP_COM_REQUEST is fired
+			expect( generator.next().value ).toEqual( mockedApiResponse );
+
+			// Third iteration: Throw an error
+			expect( generator.throw( error ).value ).toEqual( {
+				type: 'LAUNCH_SITE_FAILURE',
+				siteId,
+				error,
+			} );
+
+			// Fourth iteration: Complete the cycle
+			const finalResult = generator.next();
+
+			expect( finalResult.value ).toBeFalsy();
+			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

@@ -0,0 +1,175 @@
+/*
+ * These tests shouldn't require the jsdom environment,
+ * but we're waiting for this PR to merge:
+ * https://github.com/WordPress/gutenberg/pull/20486
+ *
+ * @jest-environment jsdom
+ */
+
+import { createActions } from '../actions';
+import { sites, launchStatus, siteSetupErrors } from '../reducer';
+import {
+	SiteLaunchError,
+	SiteLaunchState,
+	SiteLaunchStatus,
+	SiteDetails,
+	SiteError,
+} from '../types';
+
+describe( 'Site', () => {
+	const siteDetailsResponse: SiteDetails = {
+		ID: 12345,
+		name: 'My test site',
+		description: '',
+		URL: 'http://mytestsite12345.wordpress.com',
+	};
+
+	const siteErrorResponse: SiteError = {
+		error: 'unknown_blog',
+		message: 'Unknown blog',
+	};
+
+	it( 'returns the correct default state', () => {
+		const state = sites( undefined, { type: 'TEST_ACTION' } );
+		expect( state ).toEqual( {} );
+	} );
+
+	it( 'returns site data keyed by id', () => {
+		const state = sites( undefined, {
+			type: 'RECEIVE_SITE',
+			siteId: 12345,
+			response: siteDetailsResponse,
+		} );
+		expect( state ).toEqual( {
+			12345: siteDetailsResponse,
+		} );
+	} );
+
+	it( 'clears data keyed by id, and no other data is affected', () => {
+		const originalState = {
+			12345: siteDetailsResponse,
+			23456: siteDetailsResponse,
+		};
+		const updatedState = sites( originalState, {
+			type: 'RECEIVE_SITE_FAILED',
+			siteId: 23456,
+			response: siteErrorResponse,
+		} );
+
+		expect( updatedState ).toEqual( {
+			12345: siteDetailsResponse,
+		} );
+	} );
+
+	describe( 'Launch Status', () => {
+		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 = {
+				[ siteId ]: { status: SiteLaunchStatus.UNINITIALIZED, errorCode: undefined },
+			};
+		} );
+
+		it( 'should default to the initial state when an unknown action is dispatched', () => {
+			const state = launchStatus( undefined, { type: 'TEST_ACTION' } );
+			expect( state ).toStrictEqual( {} );
+		} );
+
+		it( 'should set the status to SiteLaunchStatus.IN_PROGRESS when a LAUNCH_SITE_START action is dispatched', () => {
+			const { launchSiteStart } = createActions( mockedClientCredentials );
+
+			const action = launchSiteStart( siteId );
+			const expected = {
+				...originalState,
+				[ siteId ]: { ...originalState[ siteId ], status: SiteLaunchStatus.IN_PROGRESS },
+			};
+
+			expect( launchStatus( originalState, action ) ).toEqual( expected );
+		} );
+
+		it( 'should set the status to SiteLaunchStatus.SUCCESS when a LAUNCH_SITE_SUCCESS action is dispatched', () => {
+			const { launchSiteSuccess } = createActions( mockedClientCredentials );
+
+			const action = launchSiteSuccess( siteId );
+			const expected = {
+				...originalState,
+				[ siteId ]: { ...originalState[ siteId ], status: SiteLaunchStatus.SUCCESS },
+			};
+
+			expect( launchStatus( originalState, action ) ).toEqual( expected );
+		} );
+
+		it( 'should set the status to SiteLaunchStatus.FAILURE and set an errorCode when a LAUNCH_SITE_FAILURE action is dispatched', () => {
+			const { launchSiteFailure } = createActions( mockedClientCredentials );
+			const error = SiteLaunchError.INTERNAL;
+			const action = launchSiteFailure( siteId, error );
+			const expected = {
+				...originalState,
+				[ siteId ]: {
+					...originalState[ siteId ],
+					status: SiteLaunchStatus.FAILURE,
+					errorCode: SiteLaunchError.INTERNAL,
+				},
+			};
+
+			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 );
+		} );
+	} );
+} );