@wordpress/env 6.0.0 → 7.0.0

package/lib/config/test/add-or-replace-port.js

@@ -1,10 +1,11 @@
+'use strict';
 /**
  * Internal dependencies
  */
 const addOrReplacePort = require( '../add-or-replace-port.js' );
 
 describe( 'addOrReplacePort', () => {
-	beforeEach( () => {
+	afterEach( () => {
 		jest.clearAllMocks();
 	} );
 
@@ -39,6 +40,33 @@ describe( 'addOrReplacePort', () => {
 		}
 	} );
 
+	it( 'should support number ports', () => {
+		const testMap = [ { in: 'test', expect: 'test:104' } ];
+
+		for ( const test of testMap ) {
+			const result = addOrReplacePort( test.in, 104, false );
+			expect( result ).toEqual( test.expect );
+		}
+	} );
+
+	it( 'should not add default HTTP port', () => {
+		const testMap = [ { in: 'test', expect: 'test' } ];
+
+		for ( const test of testMap ) {
+			const result = addOrReplacePort( test.in, 80, false );
+			expect( result ).toEqual( test.expect );
+		}
+	} );
+
+	it( 'should not add default HTTPS port', () => {
+		const testMap = [ { in: 'test', expect: 'test' } ];
+
+		for ( const test of testMap ) {
+			const result = addOrReplacePort( test.in, 443, false );
+			expect( result ).toEqual( test.expect );
+		}
+	} );
+
 	it( 'should do nothing if port is present but replacement is not requested', () => {
 		const testMap = [
 			{ in: 'test', expect: 'test:103' },

package/lib/config/test/config-integration.js

@@ -0,0 +1,143 @@
+'use strict';
+/* eslint-disable jest/no-conditional-expect */
+/**
+ * External dependencies
+ */
+const path = require( 'path' );
+const { readFile } = require( 'fs' ).promises;
+
+/**
+ * Internal dependencies
+ */
+const loadConfig = require( '../load-config' );
+const detectDirectoryType = require( '../detect-directory-type' );
+
+jest.mock( 'fs', () => ( {
+	promises: {
+		readFile: jest.fn(),
+		stat: jest.fn().mockResolvedValue( true ),
+	},
+} ) );
+
+// This mocks a small response with a format matching the stable-check API.
+// It makes getLatestWordPressVersion resolve to "100.0.0".
+jest.mock( 'got', () =>
+	jest.fn( ( url ) => ( {
+		json: () => {
+			if ( url === 'https://api.wordpress.org/core/stable-check/1.0/' ) {
+				return Promise.resolve( {
+					'1.0': 'insecure',
+					'99.1.1': 'outdated',
+					'100.0.0': 'latest',
+					'100.0.1': 'fancy',
+				} );
+			}
+		},
+	} ) )
+);
+
+jest.mock( '../detect-directory-type', () => jest.fn() );
+
+describe( 'Config Integration', () => {
+	beforeEach( () => {
+		process.env.WP_ENV_HOME = '/cache';
+		detectDirectoryType.mockResolvedValue( null );
+	} );
+
+	afterEach( () => {
+		delete process.env.WP_ENV_HOME;
+		delete process.env.WP_ENV_PORT;
+		delete process.env.WP_ENV_TESTS_PORT;
+		delete process.env.WP_ENV_AFTER_SETUP;
+	} );
+
+	it( 'should use default configuration', async () => {
+		readFile.mockImplementation( async () => {
+			throw { code: 'ENOENT' };
+		} );
+
+		const config = await loadConfig( '/test/gutenberg' );
+
+		expect( config.env.development.port ).toEqual( 8888 );
+		expect( config.env.tests.port ).toEqual( 8889 );
+		expect( config ).toMatchSnapshot();
+	} );
+
+	it( 'should load local configuration file', async () => {
+		readFile.mockImplementation( async ( fileName ) => {
+			if ( fileName === '/test/gutenberg/.wp-env.json' ) {
+				return JSON.stringify( {
+					core: 'WordPress/WordPress#trunk',
+					port: 123,
+					afterSetup: 'test',
+				} );
+			}
+
+			throw { code: 'ENOENT' };
+		} );
+
+		const config = await loadConfig( path.resolve( '/test/gutenberg' ) );
+
+		expect( config.env.development.port ).toEqual( 123 );
+		expect( config.env.tests.port ).toEqual( 8889 );
+		expect( config ).toMatchSnapshot();
+	} );
+
+	it( 'should load local and override configuration files', async () => {
+		readFile.mockImplementation( async ( fileName ) => {
+			if ( fileName === '/test/gutenberg/.wp-env.json' ) {
+				return JSON.stringify( {
+					core: 'WordPress/WordPress#trunk',
+					port: 123,
+					testsPort: 456,
+				} );
+			}
+
+			if ( fileName === '/test/gutenberg/.wp-env.override.json' ) {
+				return JSON.stringify( {
+					port: 999,
+				} );
+			}
+
+			throw { code: 'ENOENT' };
+		} );
+
+		const config = await loadConfig( path.resolve( '/test/gutenberg' ) );
+
+		expect( config.env.development.port ).toEqual( 999 );
+		expect( config.env.tests.port ).toEqual( 456 );
+		expect( config ).toMatchSnapshot();
+	} );
+
+	it( 'should use environment variables over local and override configuration files', async () => {
+		process.env.WP_ENV_PORT = 12345;
+		process.env.WP_ENV_TESTS_PORT = 61234;
+		process.env.WP_ENV_AFTER_SETUP = 'test';
+
+		readFile.mockImplementation( async ( fileName ) => {
+			if ( fileName === '/test/gutenberg/.wp-env.json' ) {
+				return JSON.stringify( {
+					core: 'WordPress/WordPress#trunk',
+					port: 123,
+					testsPort: 456,
+					afterSetup: 'local',
+				} );
+			}
+
+			if ( fileName === '/test/gutenberg/.wp-env.override.json' ) {
+				return JSON.stringify( {
+					port: 999,
+				} );
+			}
+
+			throw { code: 'ENOENT' };
+		} );
+
+		const config = await loadConfig( path.resolve( '/test/gutenberg' ) );
+
+		expect( config.env.development.port ).toEqual( 12345 );
+		expect( config.env.tests.port ).toEqual( 61234 );
+		expect( config ).toMatchSnapshot();
+	} );
+} );
+/* eslint-enable jest/no-conditional-expect */

package/lib/config/test/get-cache-directory.js

@@ -0,0 +1,57 @@
+'use strict';
+/* eslint-disable jest/no-conditional-expect */
+/**
+ * External dependencies
+ */
+const { stat } = require( 'fs' ).promises;
+const { homedir } = require( 'os' );
+
+/**
+ * Internal dependencies
+ */
+const getCacheDirectory = require( '../get-cache-directory' );
+
+jest.mock( 'fs', () => ( {
+	promises: {
+		stat: jest.fn(),
+	},
+} ) );
+jest.mock( 'os', () => ( {
+	homedir: jest.fn(),
+} ) );
+
+describe( 'getCacheDirectory', () => {
+	afterEach( () => {
+		delete process.env.WP_ENV_HOME;
+	} );
+
+	it( 'uses WP_ENV_HOME for cache directory when set', async () => {
+		process.env.WP_ENV_HOME = '/test';
+
+		const parsed = await getCacheDirectory();
+
+		expect( homedir ).not.toHaveBeenCalled();
+		expect( parsed ).toEqual( '/test' );
+	} );
+
+	it( 'uses hidden home directory for cache', async () => {
+		stat.mockRejectedValue( false );
+		homedir.mockReturnValue( '/home/test' );
+
+		const parsed = await getCacheDirectory();
+
+		expect( homedir ).toHaveBeenCalled();
+		expect( parsed ).toEqual( '/home/test/.wp-env' );
+	} );
+
+	it( 'uses non-hidden cache directory when using Snap-installed Docker', async () => {
+		stat.mockResolvedValue( true );
+		homedir.mockReturnValue( '/home/test' );
+
+		const parsed = await getCacheDirectory();
+
+		expect( homedir ).toHaveBeenCalled();
+		expect( parsed ).toEqual( '/home/test/wp-env' );
+	} );
+} );
+/* eslint-enable jest/no-conditional-expect */

package/lib/config/test/merge-configs.js

@@ -0,0 +1,111 @@
+'use strict';
+/**
+ * Internal dependencies
+ */
+const mergeConfigs = require( '../merge-configs' );
+
+describe( 'mergeConfigs', () => {
+	it( 'should merge configs without environments', () => {
+		const merged = mergeConfigs(
+			{
+				port: 8888,
+				coreSource: {
+					type: 'local',
+					path: '/home/test',
+				},
+				config: {
+					WP_TEST: 'test',
+				},
+			},
+			{
+				port: 8889,
+				config: {
+					WP_TEST_2: 'test-2',
+				},
+			}
+		);
+
+		expect( merged ).toEqual( {
+			port: 8889,
+			coreSource: {
+				type: 'local',
+				path: '/home/test',
+			},
+			config: {
+				WP_TEST: 'test',
+				WP_TEST_2: 'test-2',
+			},
+		} );
+	} );
+
+	it( 'should merge configs with environments', () => {
+		const merged = mergeConfigs(
+			{
+				port: 8888,
+				coreSource: {
+					type: 'local',
+					path: '/home/test',
+				},
+				config: {
+					WP_TEST: 'test',
+				},
+				env: {
+					development: {
+						config: {
+							WP_TEST_3: 'test-3',
+						},
+					},
+					tests: {
+						config: {
+							WP_TEST_4: 'test-4',
+						},
+					},
+				},
+			},
+			{
+				port: 8889,
+				config: {
+					WP_TEST_2: 'test-2',
+				},
+				env: {
+					development: {
+						config: {
+							WP_TEST_5: 'test-5',
+						},
+					},
+					tests: {
+						config: {
+							WP_TEST_6: 'test-6',
+						},
+					},
+				},
+			}
+		);
+
+		expect( merged ).toEqual( {
+			port: 8889,
+			coreSource: {
+				type: 'local',
+				path: '/home/test',
+			},
+			config: {
+				WP_TEST: 'test',
+				WP_TEST_2: 'test-2',
+			},
+			env: {
+				development: {
+					config: {
+						WP_TEST_3: 'test-3',
+						WP_TEST_5: 'test-5',
+					},
+				},
+				tests: {
+					config: {
+						WP_TEST_4: 'test-4',
+						WP_TEST_6: 'test-6',
+					},
+				},
+			},
+		} );
+	} );
+} );

package/lib/config/test/parse-config.js

@@ -0,0 +1,342 @@
+'use strict';
+/* eslint-disable jest/no-conditional-expect */
+/**
+ * External dependencies
+ */
+const path = require( 'path' );
+
+/**
+ * Internal dependencies
+ */
+const { parseConfig } = require( '../parse-config' );
+const readRawConfigFile = require( '../read-raw-config-file' );
+const { getLatestWordPressVersion } = require( '../../wordpress' );
+const { ValidationError } = require( '../validate-config' );
+const detectDirectoryType = require( '../detect-directory-type' );
+
+jest.mock( 'got', () => jest.fn() );
+jest.mock( '../read-raw-config-file', () => jest.fn() );
+jest.mock( '../detect-directory-type', () => jest.fn() );
+jest.mock( '../../wordpress', () => ( {
+	getLatestWordPressVersion: jest.fn(),
+} ) );
+
+/**
+ * Since our configurations are merged, we will want to refer to the parsed default config frequently.
+ */
+const DEFAULT_CONFIG = {
+	port: 8888,
+	testsPort: 8889,
+	phpVersion: null,
+	coreSource: {
+		type: 'git',
+		url: 'https://github.com/WordPress/WordPress.git',
+		ref: '100.0.0',
+		path: '/cache/WordPress',
+		clonePath: '/cache/WordPress',
+		basename: 'WordPress',
+		testsPath: '/cache/tests-WordPress',
+	},
+	pluginSources: [],
+	themeSources: [],
+	config: {
+		WP_DEBUG: true,
+		SCRIPT_DEBUG: true,
+		WP_ENVIRONMENT_TYPE: 'local',
+		WP_PHP_BINARY: 'php',
+		WP_TESTS_EMAIL: 'admin@example.org',
+		WP_TESTS_TITLE: 'Test Blog',
+		WP_TESTS_DOMAIN: 'localhost',
+		WP_SITEURL: 'http://localhost',
+		WP_HOME: 'http://localhost',
+	},
+	mappings: {},
+	afterSetup: null,
+	env: {
+		development: {},
+		tests: {
+			config: {
+				WP_DEBUG: false,
+				SCRIPT_DEBUG: false,
+			},
+		},
+	},
+};
+
+describe( 'parseConfig', () => {
+	beforeEach( () => {
+		readRawConfigFile.mockResolvedValue( null );
+		detectDirectoryType.mockResolvedValue( null );
+		getLatestWordPressVersion.mockResolvedValue( '100.0.0' );
+	} );
+
+	afterEach( () => {
+		jest.clearAllMocks();
+		delete process.env.WP_ENV_PORT;
+		delete process.env.WP_ENV_TESTS_PORT;
+		delete process.env.WP_ENV_CORE;
+		delete process.env.WP_ENV_PHP_VERSION;
+		delete process.env.WP_ENV_AFTER_SETUP;
+	} );
+
+	it( 'should return default config', async () => {
+		const parsed = await parseConfig( './', '/cache' );
+
+		expect( parsed ).toEqual( DEFAULT_CONFIG );
+	} );
+
+	it( 'should infer a core mounting default when ran from a WordPress directory', async () => {
+		detectDirectoryType.mockResolvedValue( 'core' );
+
+		const parsed = await parseConfig( './', '/cache' );
+
+		expect( parsed ).toEqual( {
+			...DEFAULT_CONFIG,
+			coreSource: {
+				basename: 'gutenberg',
+				path: path.resolve( '.' ),
+				testsPath: '/cache/tests-gutenberg',
+				type: 'local',
+			},
+		} );
+	} );
+
+	it( 'should infer a plugin mounting default when ran from a plugin directory', async () => {
+		detectDirectoryType.mockResolvedValue( 'plugin' );
+
+		const parsed = await parseConfig( './', '/cache' );
+
+		expect( parsed ).toEqual( {
+			...DEFAULT_CONFIG,
+			pluginSources: [
+				{
+					basename: 'gutenberg',
+					path: path.resolve( '.' ),
+					type: 'local',
+				},
+			],
+		} );
+	} );
+
+	it( 'should infer a theme mounting default when ran from a theme directory', async () => {
+		detectDirectoryType.mockResolvedValue( 'theme' );
+
+		const parsed = await parseConfig( './', '/cache' );
+
+		expect( parsed ).toEqual( {
+			...DEFAULT_CONFIG,
+			themeSources: [
+				{
+					basename: 'gutenberg',
+					path: path.resolve( '.' ),
+					type: 'local',
+				},
+			],
+		} );
+	} );
+
+	it( 'should merge configs with precedence', async () => {
+		readRawConfigFile.mockImplementation( async ( configFile ) => {
+			if ( configFile === path.resolve( './.wp-env.json' ) ) {
+				return {
+					core: 'WordPress/WordPress#Test',
+					phpVersion: '1.0',
+					afterSetup: 'test',
+					env: {
+						development: {
+							port: 1234,
+						},
+						tests: {
+							port: 5678,
+						},
+					},
+				};
+			}
+
+			if ( configFile === path.resolve( './.wp-env.override.json' ) ) {
+				return {
+					phpVersion: '2.0',
+					env: {
+						tests: {
+							port: 1011,
+						},
+					},
+				};
+			}
+
+			throw new Error( 'Invalid File: ' + configFile );
+		} );
+
+		const parsed = await parseConfig( './', '/cache' );
+
+		const expected = {
+			...DEFAULT_CONFIG,
+			coreSource: {
+				basename: 'WordPress',
+				path: '/cache/WordPress',
+				clonePath: '/cache/WordPress',
+				ref: 'Test',
+				testsPath: '/cache/tests-WordPress',
+				url: 'https://github.com/WordPress/WordPress.git',
+				type: 'git',
+			},
+			phpVersion: '2.0',
+			afterSetup: 'test',
+			env: {
+				development: {
+					...DEFAULT_CONFIG.env.development,
+					port: 1234,
+				},
+				tests: {
+					...DEFAULT_CONFIG.env.tests,
+					port: 1011,
+				},
+			},
+		};
+		expect( parsed ).toEqual( expected );
+	} );
+
+	it( 'should parse core, plugin, theme, and mapping sources', async () => {
+		readRawConfigFile.mockImplementation( async ( configFile ) => {
+			if ( configFile === path.resolve( '.', './.wp-env.json' ) ) {
+				return {
+					core: 'WordPress/WordPress#Test',
+					plugins: [ 'WordPress/TestPlugin#Test' ],
+					themes: [ 'WordPress/TestTheme#Test' ],
+					mappings: {
+						'/var/www/html/wp-content/plugins/test-mapping':
+							'WordPress/TestMapping#Test',
+					},
+				};
+			}
+
+			if (
+				configFile === path.resolve( '.', './.wp-env.override.json' )
+			) {
+				return {};
+			}
+
+			throw new Error( 'Invalid File: ' + configFile );
+		} );
+
+		const parsed = await parseConfig( './', '/cache' );
+
+		expect( parsed ).toEqual( {
+			...DEFAULT_CONFIG,
+			coreSource: {
+				basename: 'WordPress',
+				path: '/cache/WordPress',
+				clonePath: '/cache/WordPress',
+				ref: 'Test',
+				testsPath: '/cache/tests-WordPress',
+				url: 'https://github.com/WordPress/WordPress.git',
+				type: 'git',
+			},
+			pluginSources: [
+				{
+					basename: 'TestPlugin',
+					path: '/cache/TestPlugin',
+					clonePath: '/cache/TestPlugin',
+					ref: 'Test',
+					url: 'https://github.com/WordPress/TestPlugin.git',
+					type: 'git',
+				},
+			],
+			themeSources: [
+				{
+					basename: 'TestTheme',
+					path: '/cache/TestTheme',
+					clonePath: '/cache/TestTheme',
+					ref: 'Test',
+					url: 'https://github.com/WordPress/TestTheme.git',
+					type: 'git',
+				},
+			],
+			mappings: {
+				'/var/www/html/wp-content/plugins/test-mapping': {
+					basename: 'TestMapping',
+					path: '/cache/TestMapping',
+					clonePath: '/cache/TestMapping',
+					ref: 'Test',
+					url: 'https://github.com/WordPress/TestMapping.git',
+					type: 'git',
+				},
+			},
+		} );
+	} );
+
+	it( 'should override with environment variables', async () => {
+		process.env.WP_ENV_PORT = 123;
+		process.env.WP_ENV_TESTS_PORT = 456;
+		process.env.WP_ENV_CORE = 'WordPress/WordPress#test';
+		process.env.WP_ENV_PHP_VERSION = '3.0';
+		process.env.WP_ENV_AFTER_SETUP = 'test after';
+
+		const parsed = await parseConfig( './', '/cache' );
+
+		expect( parsed ).toEqual( {
+			...DEFAULT_CONFIG,
+			port: 123,
+			testsPort: 456,
+			coreSource: {
+				basename: 'WordPress',
+				path: '/cache/WordPress',
+				clonePath: '/cache/WordPress',
+				ref: 'test',
+				testsPath: '/cache/tests-WordPress',
+				url: 'https://github.com/WordPress/WordPress.git',
+				type: 'git',
+			},
+			phpVersion: '3.0',
+			afterSetup: 'test after',
+			env: {
+				development: {
+					port: 123,
+					phpVersion: '3.0',
+					coreSource: {
+						basename: 'WordPress',
+						path: '/cache/WordPress',
+						clonePath: '/cache/WordPress',
+						ref: 'test',
+						testsPath: '/cache/tests-WordPress',
+						url: 'https://github.com/WordPress/WordPress.git',
+						type: 'git',
+					},
+				},
+				tests: {
+					port: 456,
+					phpVersion: '3.0',
+					coreSource: {
+						basename: 'WordPress',
+						path: '/cache/WordPress',
+						clonePath: '/cache/WordPress',
+						ref: 'test',
+						testsPath: '/cache/tests-WordPress',
+						url: 'https://github.com/WordPress/WordPress.git',
+						type: 'git',
+					},
+					config: {
+						WP_DEBUG: false,
+						SCRIPT_DEBUG: false,
+					},
+				},
+			},
+		} );
+	} );
+
+	it( 'throws when latest WordPress version needed but not found', async () => {
+		getLatestWordPressVersion.mockResolvedValue( null );
+
+		expect.assertions( 1 );
+		try {
+			await parseConfig( './', '/cache' );
+		} catch ( error ) {
+			expect( error ).toEqual(
+				new ValidationError(
+					'Could not find the latest WordPress version. There may be a network issue.'
+				)
+			);
+		}
+	} );
+} );
+/* eslint-enable jest/no-conditional-expect */