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

package/src/auth/test/actions.ts

@@ -0,0 +1,231 @@
+/*
+ * 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 { STORE_KEY } from '../constants';
+
+const client_id = 'magic_client_id';
+const client_secret = 'magic_client_secret';
+
+describe( 'submitUsernameOrEmail', () => {
+	const { submitUsernameOrEmail } = createActions( {
+		client_id,
+		client_secret,
+	} );
+
+	it( 'requests auth options for a username', () => {
+		const username = 'user1';
+		const generator = submitUsernameOrEmail( username );
+
+		expect( generator.next().value ).toEqual( { type: 'CLEAR_ERRORS' } );
+
+		const apiResponse = {
+			success: true,
+			data: { token_links: [] as string[] },
+		};
+
+		expect( generator.next().value ).toEqual( {
+			type: 'WPCOM_REQUEST',
+			request: expect.objectContaining( {
+				path: `/users/${ username }/auth-options`,
+			} ),
+		} );
+
+		expect( generator.next( apiResponse ).value ).toEqual( {
+			type: 'RECEIVE_AUTH_OPTIONS',
+			response: apiResponse,
+			usernameOrEmail: username,
+		} );
+	} );
+
+	it( 'escapes email addresses', () => {
+		const generator = submitUsernameOrEmail( 'test@email.com' );
+
+		expect( generator.next().value ).toEqual( { type: 'CLEAR_ERRORS' } );
+
+		expect( generator.next().value ).toEqual( {
+			type: 'WPCOM_REQUEST',
+			request: expect.objectContaining( {
+				path: '/users/test%40email.com/auth-options',
+			} ),
+		} );
+	} );
+} );
+
+describe( 'submitPassword', () => {
+	const { submitPassword } = createActions( {
+		client_id,
+		client_secret,
+		loadCookiesAfterLogin: false,
+	} );
+
+	it( 'logs in to remote services on successful login', async () => {
+		const password = 'passw0rd';
+		const generator = submitPassword( password );
+
+		expect( generator.next().value ).toEqual( {
+			type: 'CLEAR_ERRORS',
+		} );
+
+		// Implementation detail; needs to select username from store
+		expect( generator.next().value ).toMatchObject( {
+			type: '@@data/RESOLVE_SELECT',
+			storeKey: STORE_KEY,
+		} );
+
+		const username = 'user1';
+		const fetchAction = generator.next( username ).value;
+		expect( fetchAction ).toEqual( {
+			type: 'FETCH_AND_PARSE',
+			resource: 'https://wordpress.com/wp-login.php?action=login-endpoint',
+			options: expect.objectContaining( {
+				method: 'POST',
+				body: expect.stringMatching(
+					RegExp(
+						`^(?=.*username=${ username })(?=.*password=${ password })(?=.*client_id=${ client_id })(?=.*client_secret=${ client_secret }).*$`
+					)
+				),
+			} ),
+		} );
+
+		const token_links = [ 'https://gravator.com?login-url', 'https://jetpack.com?login-url' ];
+
+		expect(
+			generator.next( { ok: true, body: { success: true, data: { token_links } } } ).value
+		).toEqual( {
+			type: 'REMOTE_LOGIN_USER',
+			loginLinks: token_links,
+		} );
+	} );
+
+	it( 'dispatches failed action if exception is thrown by fetch', async () => {
+		const password = 'passw0rd';
+		const generator = submitPassword( password );
+
+		expect( generator.next().value ).toEqual( {
+			type: 'CLEAR_ERRORS',
+		} );
+
+		// Implementation detail; needs to select username from store
+		expect( generator.next().value ).toMatchObject( {
+			type: '@@data/RESOLVE_SELECT',
+			storeKey: STORE_KEY,
+		} );
+
+		const username = 'user1';
+		const fetchAction = generator.next( username ).value;
+		expect( fetchAction ).toEqual( {
+			type: 'FETCH_AND_PARSE',
+			resource: 'https://wordpress.com/wp-login.php?action=login-endpoint',
+			options: expect.objectContaining( {
+				method: 'POST',
+				body: expect.stringMatching(
+					RegExp(
+						`^(?=.*username=${ username })(?=.*password=${ password })(?=.*client_id=${ client_id })(?=.*client_secret=${ client_secret }).*$`
+					)
+				),
+			} ),
+		} );
+
+		const errorMessage = 'Error!!1';
+		expect( generator.throw( new Error( errorMessage ) ).value ).toEqual( {
+			type: 'RECEIVE_WP_LOGIN_FAILED',
+			response: {
+				success: false,
+				data: {
+					errors: [ { code: 'Error', message: 'Error!!1' } ],
+				},
+			},
+		} );
+	} );
+
+	it( 'stops polling 2fa when an error occurs', async () => {
+		const password = 'passw0rd';
+		const generator = submitPassword( password );
+
+		expect( generator.next().value ).toEqual( {
+			type: 'CLEAR_ERRORS',
+		} );
+
+		// Implementation detail; needs to select username from store
+		expect( generator.next().value ).toMatchObject( {
+			type: '@@data/RESOLVE_SELECT',
+			storeKey: STORE_KEY,
+		} );
+
+		const username = 'user1';
+		const fetchAction = generator.next( username ).value;
+		expect( fetchAction ).toEqual( {
+			type: 'FETCH_AND_PARSE',
+			resource: 'https://wordpress.com/wp-login.php?action=login-endpoint',
+			options: expect.objectContaining( {
+				method: 'POST',
+				body: expect.stringMatching(
+					RegExp(
+						`^(?=.*username=${ username })(?=.*password=${ password })(?=.*client_id=${ client_id })(?=.*client_secret=${ client_secret }).*$`
+					)
+				),
+			} ),
+		} );
+
+		const authType = 'push';
+		const userId = 113;
+		const nonce = 'secret-nonce';
+		const token = 'secret-token';
+		const pushSentResponse = {
+			success: true,
+			data: {
+				two_step_notification_sent: authType,
+				user_id: userId,
+				push_web_token: token,
+				two_step_nonce_push: nonce,
+			},
+		};
+		expect( generator.next( { ok: true, body: pushSentResponse } ).value ).toEqual( {
+			type: 'RECEIVE_WP_LOGIN',
+			response: pushSentResponse,
+		} );
+
+		expect( generator.next().value ).toEqual( {
+			type: 'START_POLLING_TASK',
+			pollingTaskId: 0,
+		} );
+
+		// Checking that the polling hasn't been canceled
+		expect( generator.next().value ).toMatchObject( {
+			type: '@@data/RESOLVE_SELECT',
+			storeKey: STORE_KEY,
+		} );
+
+		expect( generator.next( 0 ).value ).toEqual( {
+			type: 'FETCH_AND_PARSE',
+			resource: 'https://wordpress.com/wp-login.php?action=two-step-authentication-endpoint',
+			options: expect.objectContaining( {
+				method: 'POST',
+				body: expect.stringMatching(
+					RegExp(
+						`^(?=.*auth_type=${ authType })(?=.*user_id=${ userId })(?=.*two_step_nonce=${ nonce })(?=.*two_step_push_token=${ token }).*$`
+					)
+				),
+			} ),
+		} );
+
+		const pollResponse = {
+			success: false,
+			data: {
+				errors: [ { code: 'error-code', message: 'error-message' } ],
+			},
+		};
+		expect( generator.next( { ok: false, body: pollResponse } ).value ).toEqual( {
+			type: 'RECEIVE_WP_LOGIN_FAILED',
+			response: pollResponse,
+		} );
+
+		expect( generator.next().done ).toBe( true );
+	} );
+} );

package/src/auth/test/flows.ts

@@ -0,0 +1,301 @@
+/*
+ * 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 { dispatch, select } from '@wordpress/data';
+import nock from 'nock';
+import { parse } from 'qs';
+import waitForExpect from 'wait-for-expect';
+import wpcomRequest from 'wpcom-proxy-request';
+import 'jest-fetch-mock';
+import { register } from '..';
+
+jest.mock( '../constants', () => ( {
+	STORE_KEY: 'automattic/auth',
+	POLL_APP_PUSH_INTERVAL_SECONDS: 0, // Shorten 2fa polling time for quick tests
+} ) );
+
+jest.mock( 'wpcom-proxy-request', () => ( {
+	__esModule: true,
+	default: jest.fn(),
+	requestAllBlogsAccess: jest.fn( () => Promise.resolve() ),
+} ) );
+
+let store: ReturnType< typeof register >;
+beforeAll( () => {
+	store = register( { client_id: '', client_secret: '', loadCookiesAfterLogin: false } );
+} );
+
+beforeEach( () => {
+	dispatch( store ).reset();
+	( wpcomRequest as jest.Mock ).mockReset();
+} );
+
+describe( 'password login flow', () => {
+	it( 'logs in with correct credentials', async () => {
+		const { getErrors, getLoginFlowState } = select( store );
+		const { submitUsernameOrEmail, submitPassword } = dispatch( store );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+
+		( wpcomRequest as jest.Mock ).mockResolvedValue( {
+			email_verified: true,
+			passwordless: false,
+		} );
+
+		await submitUsernameOrEmail( 'user1' );
+
+		expect( wpcomRequest ).toHaveBeenLastCalledWith(
+			expect.objectContaining( {
+				path: '/users/user1/auth-options',
+			} )
+		);
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_PASSWORD' );
+
+		nock( 'https://wordpress.com' )
+			.post( '/wp-login.php?action=login-endpoint', ( body ) => {
+				expect( parse( body ) ).toEqual(
+					expect.objectContaining( {
+						username: 'user1',
+						password: 'passw0rd',
+						remember_me: 'true',
+					} )
+				);
+				return true;
+			} )
+			.reply( 200, {
+				success: true,
+				data: { token_links: [] },
+			} );
+
+		await submitPassword( 'passw0rd' );
+
+		expect( getLoginFlowState() ).toBe( 'LOGGED_IN' );
+		expect( getErrors() ).toEqual( [] );
+	} );
+
+	it( 'errors for unknown users', async () => {
+		const { getErrors, getLoginFlowState } = select( store );
+		const { submitUsernameOrEmail } = dispatch( store );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+
+		( wpcomRequest as jest.Mock ).mockRejectedValue( {
+			error: 'unknown_user',
+			message: 'User does not exist',
+		} );
+
+		await submitUsernameOrEmail( 'unknown' );
+
+		expect( wpcomRequest ).toHaveBeenLastCalledWith(
+			expect.objectContaining( {
+				path: '/users/unknown/auth-options',
+			} )
+		);
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+		expect( getErrors() ).toEqual( [
+			{
+				code: 'unknown_user',
+				message: 'User does not exist',
+			},
+		] );
+	} );
+
+	it( "doesn't log in with incorrect passord", async () => {
+		const { getErrors, getLoginFlowState } = select( store );
+		const { submitUsernameOrEmail, submitPassword } = dispatch( store );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+
+		( wpcomRequest as jest.Mock ).mockResolvedValue( {
+			email_verified: true,
+			passwordless: false,
+		} );
+
+		await submitUsernameOrEmail( 'user1' );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_PASSWORD' );
+
+		nock( 'https://wordpress.com' )
+			.post( '/wp-login.php?action=login-endpoint', ( body ) => {
+				expect( parse( body ) ).toEqual(
+					expect.objectContaining( {
+						username: 'user1',
+						password: 'wrongpassword',
+						remember_me: 'true',
+					} )
+				);
+				return true;
+			} )
+			.reply( 400, {
+				success: false,
+				data: { errors: [ { code: 'incorrect_password', message: 'message for user' } ] },
+			} );
+
+		await submitPassword( 'wrongpassword' );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_PASSWORD' );
+		expect( getErrors() ).toEqual( [
+			{
+				code: 'incorrect_password',
+				message: 'message for user',
+			},
+		] );
+	} );
+
+	it( 'logs in using mobile app for 2fa', async () => {
+		const { getLoginFlowState } = select( store );
+		const { submitUsernameOrEmail, submitPassword } = dispatch( store );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+
+		( wpcomRequest as jest.Mock ).mockResolvedValue( {
+			email_verified: true,
+			passwordless: false,
+		} );
+
+		await submitUsernameOrEmail( 'user1' );
+
+		expect( wpcomRequest ).toHaveBeenLastCalledWith(
+			expect.objectContaining( {
+				path: '/users/user1/auth-options',
+			} )
+		);
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_PASSWORD' );
+
+		const user_id = 12341234;
+		const two_step_nonce = 'secretnonce';
+		const two_step_push_token = 'push:token';
+
+		let userHandledPushNotification = false;
+
+		nock( 'https://wordpress.com' )
+			.persist()
+			.post( '/wp-login.php?action=login-endpoint', ( body ) => {
+				expect( parse( body ) ).toEqual(
+					expect.objectContaining( {
+						username: 'user1',
+						password: 'passw0rd',
+						remember_me: 'true',
+					} )
+				);
+				return true;
+			} )
+			.reply( 200, {
+				success: true,
+				data: {
+					user_id,
+					two_step_supported_auth_types: [ 'push' ],
+					two_step_notification_sent: 'push',
+					two_step_nonce_push: two_step_nonce,
+					push_web_token: two_step_push_token,
+				},
+			} )
+			.post( '/wp-login.php?action=two-step-authentication-endpoint', ( body ) => {
+				expect( parse( body ) ).toEqual(
+					expect.objectContaining( {
+						user_id: user_id.toString( 10 ),
+						auth_type: 'push',
+						two_step_nonce,
+						two_step_push_token,
+					} )
+				);
+				return true;
+			} )
+			.reply( () => [
+				userHandledPushNotification ? 200 : 403,
+				{
+					success: userHandledPushNotification,
+					data: userHandledPushNotification
+						? { token_links: [] }
+						: {
+								two_step_nonce,
+								errors: [
+									{
+										code: 'invalid_two_step_code',
+										message: 'Double check the app and try again',
+									},
+								],
+						  },
+				},
+			] );
+
+		// Don't await the promise, it doesn't resolve until login flow is complete
+		submitPassword( 'passw0rd' );
+
+		await waitForExpect( () => expect( getLoginFlowState() ).toBe( 'WAITING_FOR_2FA_APP' ) );
+
+		userHandledPushNotification = true;
+
+		await waitForExpect( () => expect( getLoginFlowState() ).toBe( 'LOGGED_IN' ) );
+	} );
+} );
+
+describe( 'passwordless login flow', () => {
+	it( 'requests a login link to be sent', async () => {
+		const { getLoginFlowState } = select( store );
+		const { submitUsernameOrEmail } = dispatch( store );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+
+		( wpcomRequest as jest.Mock )
+			.mockResolvedValueOnce( { email_verified: true, passwordless: true } )
+			.mockResolvedValueOnce( { success: true } );
+
+		await submitUsernameOrEmail( 'test@example.com' );
+
+		expect( wpcomRequest ).toHaveBeenCalledTimes( 2 );
+
+		expect( wpcomRequest ).toHaveBeenNthCalledWith(
+			1,
+			expect.objectContaining( {
+				path: '/users/test%40example.com/auth-options',
+			} )
+		);
+		expect( wpcomRequest ).toHaveBeenNthCalledWith(
+			2,
+			expect.objectContaining( {
+				method: 'post',
+				path: '/auth/send-login-email',
+				body: expect.objectContaining( {
+					lang_id: 1,
+					locale: 'en',
+					email: 'test@example.com',
+				} ),
+			} )
+		);
+
+		expect( getLoginFlowState() ).toBe( 'LOGIN_LINK_SENT' );
+	} );
+
+	it( 'reports error if login email fails to send', async () => {
+		const { getFirstError, getLoginFlowState } = select( store );
+		const { submitUsernameOrEmail } = dispatch( store );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+
+		( wpcomRequest as jest.Mock )
+			.mockResolvedValueOnce( { email_verified: true, passwordless: true } )
+			.mockRejectedValueOnce( {
+				error: 'unauthorized',
+				message: "You're not allowed to request a login link for this account.",
+			} );
+
+		await submitUsernameOrEmail( 'test@example.com' );
+
+		expect( wpcomRequest ).toHaveBeenCalledTimes( 2 );
+
+		expect( getLoginFlowState() ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+		expect( getFirstError() ).toEqual( {
+			code: 'unauthorized',
+			message: "You're not allowed to request a login link for this account.",
+		} );
+	} );
+} );

package/src/auth/test/reducer.ts

@@ -0,0 +1,70 @@
+/*
+ * 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 { errors, loginFlowState, usernameOrEmail } from '../reducer';
+
+const { reset, receiveAuthOptions, clearErrors } = createActions( {
+	client_id: '',
+	client_secret: '',
+} );
+
+describe( 'login flow state', () => {
+	it( 'returns the correct default state', () => {
+		const state = loginFlowState( undefined, { type: 'TEST_ACTION' } );
+		expect( state ).toBe( 'ENTER_USERNAME_OR_EMAIL' );
+	} );
+
+	it( 'is returned to the default state by the reset action', () => {
+		const defaultState = loginFlowState( undefined, { type: 'TEST_ACTION' } );
+
+		const state = loginFlowState( 'ENTER_PASSWORD', reset() );
+		expect( state ).toBe( defaultState );
+	} );
+} );
+
+describe( 'usernameOrEmail', () => {
+	it( 'defaults to empty', () => {
+		const state = usernameOrEmail( undefined, { type: 'TEST_ACTION' } );
+		expect( state ).toEqual( '' );
+	} );
+
+	it( 'is returned to the default state by the reset action', () => {
+		const defaultState = usernameOrEmail( undefined, { type: 'TEST_ACTION' } );
+
+		const state = usernameOrEmail( 'test', reset() );
+		expect( state ).toEqual( defaultState );
+	} );
+
+	it( 'updates after successfully checking auth_options', () => {
+		const state = usernameOrEmail(
+			'old username',
+			receiveAuthOptions( { passwordless: true, email_verified: true }, 'new username' )
+		);
+		expect( state ).toBe( 'new username' );
+	} );
+} );
+
+describe( 'errors', () => {
+	it( 'defaults to empty', () => {
+		const state = errors( undefined, { type: 'TEST_ACTION' } );
+		expect( state ).toEqual( [] );
+	} );
+
+	it( 'is returned to the default state by the reset action', () => {
+		const defaultState = errors( undefined, { type: 'TEST_ACTION' } );
+
+		const state = errors( [ { code: 'code', message: '' } ], reset() );
+		expect( state ).toEqual( defaultState );
+	} );
+
+	it( 'is emptied by the clearErrors action', () => {
+		const state = errors( [ { code: 'code', message: '' } ], clearErrors() );
+		expect( state ).toEqual( [] );
+	} );
+} );

package/src/auth/types.ts

@@ -0,0 +1,64 @@
+export type LoginFlowState =
+	| 'ENTER_USERNAME_OR_EMAIL'
+	| 'ENTER_PASSWORD'
+	| 'ENTER_2FA_CODE'
+	| 'LOGIN_LINK_SENT'
+	| 'WAITING_FOR_2FA_APP'
+	| 'LOGGED_IN';
+
+export interface AuthOptionsSuccessResponse {
+	passwordless: boolean;
+	email_verified: boolean;
+}
+
+export interface AuthOptionsErrorResponse {
+	error: string;
+	message: string;
+}
+
+export type AuthOptionsResponse = AuthOptionsSuccessResponse | AuthOptionsErrorResponse;
+
+export interface LoginCompleteData {
+	token_links: string[];
+	two_step_notification_sent: undefined;
+}
+
+export interface PushNotificationSentData {
+	user_id?: number;
+	two_step_supported_auth_types?: string[];
+	two_step_nonce?: string;
+	two_step_nonce_backup?: string;
+	two_step_nonce_authenticator?: string;
+	two_step_nonce_push?: string;
+	push_web_token?: string;
+	two_step_notification_sent: 'push';
+}
+
+export interface WpLoginSuccessResponse {
+	success: true;
+	data: LoginCompleteData | PushNotificationSentData;
+}
+
+export interface WpLoginErrorResponse {
+	success: false;
+	data: {
+		errors: Array< {
+			code: string;
+			message: string;
+		} >;
+		two_step_nonce?: string;
+	};
+}
+
+export type WpLoginResponse = WpLoginSuccessResponse | WpLoginErrorResponse;
+
+export interface SendLoginEmailSuccessResponse {
+	success: true;
+}
+
+export interface SendLoginEmailErrorResponse {
+	error: string;
+	message: string;
+}
+
+export type SendLoginEmailResponse = SendLoginEmailSuccessResponse | SendLoginEmailErrorResponse;

package/src/auth/utils.ts

@@ -0,0 +1,4 @@
+let nextTaskId = 0;
+export function getNextTaskId() {
+	return nextTaskId++;
+}

package/src/automated-transfer-eligibility/actions.ts

@@ -0,0 +1,15 @@
+import { TransferEligibility } from './types';
+
+export const receiveTransferEligibility = (
+	transferEligibility: TransferEligibility,
+	siteId: number
+) => ( {
+	type: 'TRANSFER_ELIGIBILITY_RECEIVE' as const,
+	transferEligibility,
+	siteId,
+} );
+
+export type Action =
+	| ReturnType< typeof receiveTransferEligibility >
+	// Type added so we can dispatch actions in tests, but has no runtime cost
+	| { type: 'TEST_ACTION' };