@wordpress/env 6.0.0 → 7.0.0

package/lib/test/cli.js

@@ -0,0 +1,149 @@
+'use strict';
+/**
+ * Internal dependencies
+ */
+const cli = require( '../cli' );
+const env = require( '../env' );
+
+/**
+ * Mocked dependencies
+ */
+jest.spyOn( process, 'exit' ).mockImplementation( () => {} );
+jest.mock( 'ora', () => () => ( {
+	start() {
+		return { text: '', succeed: jest.fn(), fail: jest.fn() };
+	},
+} ) );
+jest.mock( '../env', () => {
+	const actual = jest.requireActual( '../env' );
+	return {
+		start: jest.fn( Promise.resolve.bind( Promise ) ),
+		stop: jest.fn( Promise.resolve.bind( Promise ) ),
+		clean: jest.fn( Promise.resolve.bind( Promise ) ),
+		run: jest.fn( Promise.resolve.bind( Promise ) ),
+		ValidationError: actual.ValidationError,
+		AfterSetupError: actual.AfterSetupError,
+	};
+} );
+
+describe( 'env cli', () => {
+	beforeEach( jest.clearAllMocks );
+
+	it( 'parses start commands.', () => {
+		cli().parse( [ 'start' ] );
+		const { spinner } = env.start.mock.calls[ 0 ][ 0 ];
+		expect( spinner.text ).toBe( '' );
+	} );
+
+	it( 'parses stop commands.', () => {
+		cli().parse( [ 'stop' ] );
+		const { spinner } = env.stop.mock.calls[ 0 ][ 0 ];
+		expect( spinner.text ).toBe( '' );
+	} );
+
+	it( 'parses clean commands for the default environment.', () => {
+		cli().parse( [ 'clean' ] );
+		const { environment, spinner } = env.clean.mock.calls[ 0 ][ 0 ];
+		expect( environment ).toBe( 'tests' );
+		expect( spinner.text ).toBe( '' );
+	} );
+	it( 'parses clean commands for all environments.', () => {
+		cli().parse( [ 'clean', 'all' ] );
+		const { environment, spinner } = env.clean.mock.calls[ 0 ][ 0 ];
+		expect( environment ).toBe( 'all' );
+		expect( spinner.text ).toBe( '' );
+	} );
+	it( 'parses clean commands for the development environment.', () => {
+		cli().parse( [ 'clean', 'development' ] );
+		const { environment, spinner } = env.clean.mock.calls[ 0 ][ 0 ];
+		expect( environment ).toBe( 'development' );
+		expect( spinner.text ).toBe( '' );
+	} );
+	it( 'parses clean commands for the tests environment.', () => {
+		cli().parse( [ 'clean', 'tests' ] );
+		const { environment, spinner } = env.clean.mock.calls[ 0 ][ 0 ];
+		expect( environment ).toBe( 'tests' );
+		expect( spinner.text ).toBe( '' );
+	} );
+
+	it( 'parses run commands without arguments.', () => {
+		cli().parse( [ 'run', 'tests-wordpress', 'test' ] );
+		const { container, command, spinner } = env.run.mock.calls[ 0 ][ 0 ];
+		expect( container ).toBe( 'tests-wordpress' );
+		expect( command ).toStrictEqual( [ 'test' ] );
+		expect( spinner.text ).toBe( '' );
+	} );
+	it( 'parses run commands with variadic arguments.', () => {
+		cli().parse( [ 'run', 'tests-wordpress', 'test', 'test1', '--test2' ] );
+		const { container, command, spinner } = env.run.mock.calls[ 0 ][ 0 ];
+		expect( container ).toBe( 'tests-wordpress' );
+		expect( command ).toStrictEqual( [ 'test', 'test1', '--test2' ] );
+		expect( spinner.text ).toBe( '' );
+	} );
+
+	it( 'handles successful commands with messages.', async () => {
+		env.start.mockResolvedValueOnce( 'success message' );
+		cli().parse( [ 'start' ] );
+		const { spinner } = env.start.mock.calls[ 0 ][ 0 ];
+		await env.start.mock.results[ 0 ].value;
+		expect( spinner.succeed ).toHaveBeenCalledWith(
+			expect.stringMatching( /^success message \(in \d+s \d+ms\)$/ )
+		);
+	} );
+	it( 'handles successful commands with spinner text.', async () => {
+		env.start.mockResolvedValueOnce();
+		cli().parse( [ 'start' ] );
+		const { spinner } = env.start.mock.calls[ 0 ][ 0 ];
+		spinner.text = 'success spinner text';
+		await env.start.mock.results[ 0 ].value;
+		expect( spinner.succeed ).toHaveBeenCalledWith(
+			expect.stringMatching( /^success spinner text \(in \d+s \d+ms\)$/ )
+		);
+	} );
+
+	it( 'handles failed commands with messages.', async () => {
+		env.start.mockRejectedValueOnce( {
+			message: 'failure message',
+		} );
+		const consoleError = console.error;
+		console.error = jest.fn();
+		const processExit = process.exit;
+		process.exit = jest.fn();
+
+		cli().parse( [ 'start' ] );
+		const { spinner } = env.start.mock.calls[ 0 ][ 0 ];
+		await env.start.mock.results[ 0 ].value.catch( () => {} );
+
+		expect( spinner.fail ).toHaveBeenCalledWith( 'failure message' );
+		expect( console.error ).toHaveBeenCalled();
+		expect( process.exit ).toHaveBeenCalledWith( 1 );
+		console.error = consoleError;
+		process.exit = processExit;
+	} );
+	it( 'handles failed docker commands with errors.', async () => {
+		env.start.mockRejectedValueOnce( {
+			err: 'failure error',
+			out: 'message',
+			exitCode: 1,
+		} );
+		const consoleError = console.error;
+		console.error = jest.fn();
+		const processExit = process.exit;
+		process.exit = jest.fn();
+		const stderr = process.stderr.write;
+		process.stderr.write = jest.fn();
+
+		cli().parse( [ 'start' ] );
+		const { spinner } = env.start.mock.calls[ 0 ][ 0 ];
+		await env.start.mock.results[ 0 ].value.catch( () => {} );
+
+		expect( spinner.fail ).toHaveBeenCalledWith(
+			'Error while running docker-compose command.'
+		);
+		expect( process.stderr.write ).toHaveBeenCalledWith( 'failure error' );
+		expect( process.exit ).toHaveBeenCalledWith( 1 );
+		console.error = consoleError;
+		process.exit = processExit;
+		process.stderr.write = stderr;
+	} );
+} );

package/lib/test/execute-after-setup.js

@@ -0,0 +1,66 @@
+'use strict';
+/**
+ * External dependencies
+ */
+const { execSync } = require( 'child_process' );
+
+/**
+ * Internal dependencies
+ */
+const {
+	AfterSetupError,
+	executeAfterSetup,
+} = require( '../execute-after-setup' );
+
+jest.mock( 'child_process', () => ( {
+	execSync: jest.fn(),
+} ) );
+
+describe( 'executeAfterSetup', () => {
+	const spinner = {
+		info: jest.fn(),
+	};
+
+	afterEach( () => {
+		jest.clearAllMocks();
+	} );
+
+	it( 'should do nothing without afterSetup option', () => {
+		executeAfterSetup( { afterSetup: null }, spinner );
+
+		expect( spinner.info ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should run afterSetup option and print output without extra whitespace', () => {
+		execSync.mockReturnValue( 'Test   \n' );
+
+		executeAfterSetup( { afterSetup: 'Test Setup' }, spinner );
+
+		expect( execSync ).toHaveBeenCalled();
+		expect( execSync.mock.calls[ 0 ][ 0 ] ).toEqual( 'Test Setup' );
+		expect( spinner.info ).toHaveBeenCalledWith( 'After Setup:\nTest' );
+	} );
+
+	it( 'should print nothing if afterSetup returns no output', () => {
+		execSync.mockReturnValue( '' );
+
+		executeAfterSetup( { afterSetup: 'Test Setup' }, spinner );
+
+		expect( execSync ).toHaveBeenCalled();
+		expect( execSync.mock.calls[ 0 ][ 0 ] ).toEqual( 'Test Setup' );
+		expect( spinner.info ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should throw AfterSetupError when process errors', () => {
+		execSync.mockImplementation( ( command ) => {
+			expect( command ).toEqual( 'Test Setup' );
+			throw { stderr: 'Something bad happened.' };
+		} );
+
+		expect( () =>
+			executeAfterSetup( { afterSetup: 'Test Setup' }, spinner )
+		).toThrow(
+			new AfterSetupError( 'After Setup:\nSomething bad happened.' )
+		);
+	} );
+} );

package/lib/test/md5.js

@@ -0,0 +1,35 @@
+'use strict';
+/**
+ * Internal dependencies
+ */
+const md5 = require( '../md5' );
+
+describe( 'md5', () => {
+	it( 'creates a hash of a string', () => {
+		const result = md5( 'hello' );
+		expect( result ).toMatchSnapshot();
+	} );
+	it( 'creates a hash of a object', () => {
+		const result = md5( { foo: 'xyz', test: { anotherFoo: 123 } } );
+		expect( result ).toMatchSnapshot();
+	} );
+	it( 'creates a hash of a number', () => {
+		const result = md5( 123789 );
+		expect( result ).toMatchSnapshot();
+	} );
+	it( 'creates a hash of null', () => {
+		const result = md5( null );
+		expect( result ).toMatchSnapshot();
+	} );
+	it( 'uses the same hash for the same values', () => {
+		const testObj = {
+			test: 1,
+			otherTest: {
+				foo: 'hello',
+			},
+		};
+		const result1 = md5( testObj );
+		const result2 = md5( { ...testObj } );
+		expect( result1 ).toBe( result2 );
+	} );
+} );

package/lib/test/parse-xdebug-mode.js

@@ -0,0 +1,41 @@
+'use strict';
+/**
+ * Internal dependencies
+ */
+const parseXdebugMode = require( '../parse-xdebug-mode' );
+
+describe( 'parseXdebugMode', () => {
+	it( 'throws an error if the passed value is neither a string nor undefined', () => {
+		const errorMessage = 'is not a mode recognized by Xdebug';
+		expect( () => parseXdebugMode( true ) ).toThrow( errorMessage );
+		expect( () => parseXdebugMode( false ) ).toThrow( errorMessage );
+		expect( () => parseXdebugMode( 1 ) ).toThrow( errorMessage );
+	} );
+
+	it( 'sets the Xdebug mode to "off" if no --xdebug flag is passed', () => {
+		const result = parseXdebugMode( undefined );
+		expect( result ).toEqual( 'off' );
+	} );
+
+	it( 'sets the Xdebug mode to "debug" if no mode is specified', () => {
+		const result = parseXdebugMode( '' );
+		expect( result ).toEqual( 'debug' );
+	} );
+
+	it( 'throws an error if a given mode is not recognized, including the invalid mode in the output', () => {
+		const fakeMode = 'fake-mode-123';
+		expect.assertions( 2 );
+		// Single mode:
+		expect( () => parseXdebugMode( fakeMode ) ).toThrow( fakeMode );
+
+		// Many modes:
+		expect( () =>
+			parseXdebugMode( `debug,profile,${ fakeMode }` )
+		).toThrow( fakeMode );
+	} );
+
+	it( 'returns all modes passed', () => {
+		const result = parseXdebugMode( 'debug,profile,trace' );
+		expect( result ).toEqual( 'debug,profile,trace' );
+	} );
+} );

package/lib/wordpress.js

@@ -1,3 +1,4 @@
+'use strict';
 /**
  * External dependencies
  */
@@ -14,7 +15,7 @@ const copyDir = util.promisify( require( 'copy-dir' ) );
 
 /**
  * @typedef {import('./config').WPConfig} WPConfig
- * @typedef {import('./config').WPServiceConfig} WPServiceConfig
+ * @typedef {import('./config').WPEnvironmentConfig} WPEnvironmentConfig
  * @typedef {import('./config').WPSource} WPSource
  * @typedef {'development'|'tests'} WPEnvironment
  * @typedef {'development'|'tests'|'all'} WPEnvironmentSelection
@@ -86,6 +87,7 @@ async function configureWordPress( environment, config, spinner ) {
 		[ 'bash', '-c', setupCommands.join( ' && ' ) ],
 		{
 			config: config.dockerComposeConfigPath,
+			commandOptions: [ '--rm' ],
 			log: config.debug,
 		}
 	);
@@ -147,30 +149,13 @@ async function setupWordPressDirectories( config ) {
 			config.env.development.coreSource.path,
 			config.env.development.coreSource.testsPath
 		);
-		await createUploadsDir( config.env.development.coreSource.testsPath );
 	}
-
-	const checkedPaths = {};
-	for ( const { coreSource } of Object.values( config.env ) ) {
-		if ( coreSource && ! checkedPaths[ coreSource.path ] ) {
-			await createUploadsDir( coreSource.path );
-			checkedPaths[ coreSource.path ] = true;
-		}
-	}
-}
-
-async function createUploadsDir( corePath ) {
-	// Ensure the tests uploads folder is writeable for travis,
-	// creating the folder if necessary.
-	const uploadPath = path.join( corePath, 'wp-content/uploads' );
-	await fs.mkdir( uploadPath, { recursive: true } );
-	await fs.chmod( uploadPath, 0o0767 );
 }
 
 /**
  * Returns true if all given environment configs have the same core source.
  *
- * @param {WPServiceConfig[]} envs An array of environments to check.
+ * @param {WPEnvironmentConfig[]} envs An array of environments to check.
  *
  * @return {boolean} True if all the environments have the same core source.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/env",
-	"version": "6.0.0",
+	"version": "7.0.0",
 	"description": "A zero-config, self contained local WordPress environment for development and testing.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -51,5 +51,5 @@
 	"scripts": {
 		"test": "echo \"Error: run tests from root\" && exit 1"
 	},
-	"gitHead": "6df0c62d43b8901414ccd22ffbe56eaa99d012a6"
+	"gitHead": "e936127e1e13881f1a940b7bd1593a9e500147f3"
 }