@wordpress/env 6.0.0 → 8.0.0

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

@@ -0,0 +1,393 @@
+'use strict';
+/* eslint-disable jest/no-conditional-expect */
+/**
+ * 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: {
+		FS_METHOD: 'direct',
+		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: {},
+	lifecycleScripts: {
+		afterStart: null,
+		afterClean: null,
+		afterDestroy: 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_LIFECYCLE_SCRIPT_AFTER_START;
+	} );
+
+	it( 'should return default config', async () => {
+		const parsed = await parseConfig( '/test/gutenberg', '/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( '/test/gutenberg', '/cache' );
+
+		expect( parsed.pluginSources ).toHaveLength( 0 );
+		expect( parsed.themeSources ).toHaveLength( 0 );
+		expect( parsed.coreSource ).toMatchObject( { type: 'local' } );
+	} );
+
+	it( 'should infer a plugin mounting default when ran from a plugin directory', async () => {
+		detectDirectoryType.mockResolvedValue( 'plugin' );
+
+		const parsed = await parseConfig( '/test/gutenberg', '/cache' );
+
+		expect( parsed.coreSource ).toMatchObject( { type: 'git' } );
+		expect( parsed.themeSources ).toHaveLength( 0 );
+		expect( parsed.pluginSources ).toHaveLength( 1 );
+		expect( parsed.pluginSources[ 0 ] ).toMatchObject( { type: 'local' } );
+	} );
+
+	it( 'should infer a theme mounting default when ran from a theme directory', async () => {
+		detectDirectoryType.mockResolvedValue( 'theme' );
+
+		const parsed = await parseConfig( '/test/gutenberg', '/cache' );
+
+		expect( parsed.coreSource ).toMatchObject( { type: 'git' } );
+		expect( parsed.pluginSources ).toHaveLength( 0 );
+		expect( parsed.themeSources ).toHaveLength( 1 );
+		expect( parsed.themeSources[ 0 ] ).toMatchObject( { type: 'local' } );
+	} );
+
+	it( 'should merge configs with precedence', async () => {
+		readRawConfigFile.mockImplementation( async ( configFile ) => {
+			if ( configFile === '/test/gutenberg/.wp-env.json' ) {
+				return {
+					core: 'WordPress/WordPress#Test',
+					phpVersion: '1.0',
+					lifecycleScripts: {
+						afterStart: 'test',
+					},
+					env: {
+						development: {
+							port: 1234,
+						},
+						tests: {
+							port: 5678,
+						},
+					},
+				};
+			}
+
+			if ( configFile === '/test/gutenberg/.wp-env.override.json' ) {
+				return {
+					phpVersion: '2.0',
+					lifecycleScripts: {
+						afterDestroy: 'test',
+					},
+					env: {
+						tests: {
+							port: 1011,
+						},
+					},
+				};
+			}
+
+			throw new Error( 'Invalid File: ' + configFile );
+		} );
+
+		const parsed = await parseConfig( '/test/gutenberg', '/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',
+			lifecycleScripts: {
+				...DEFAULT_CONFIG.lifecycleScripts,
+				afterStart: 'test',
+				afterDestroy: '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 === '/test/gutenberg/.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 === '/test/gutenberg/.wp-env.override.json' ) {
+				return {};
+			}
+
+			throw new Error( 'Invalid File: ' + configFile );
+		} );
+
+		const parsed = await parseConfig( '/test/gutenberg', '/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_LIFECYCLE_SCRIPT_AFTER_START = 'test after';
+
+		const parsed = await parseConfig( '/test/gutenberg', '/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',
+			lifecycleScripts: {
+				...DEFAULT_CONFIG.lifecycleScripts,
+				afterStart: '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( '/test/gutenberg', '/cache' );
+		} catch ( error ) {
+			expect( error ).toEqual(
+				new ValidationError(
+					'Could not find the latest WordPress version. There may be a network issue.'
+				)
+			);
+		}
+	} );
+
+	it( 'throws for unknown config options', async () => {
+		readRawConfigFile.mockImplementation( async ( configFile ) => {
+			if ( configFile === '/test/gutenberg/.wp-env.json' ) {
+				return {
+					test: 'test',
+				};
+			}
+
+			if ( configFile === '/test/gutenberg/.wp-env.override.json' ) {
+				return {};
+			}
+
+			throw new Error( 'Invalid File: ' + configFile );
+		} );
+
+		expect.assertions( 1 );
+		try {
+			await parseConfig( '/test/gutenberg', '/cache' );
+		} catch ( error ) {
+			expect( error ).toEqual(
+				new ValidationError(
+					`Invalid /test/gutenberg/.wp-env.json: "test" is not a configuration option.`
+				)
+			);
+		}
+	} );
+
+	it( 'throws for root-only config options', async () => {
+		readRawConfigFile.mockImplementation( async ( configFile ) => {
+			if ( configFile === '/test/gutenberg/.wp-env.json' ) {
+				return {
+					env: {
+						development: {
+							// Only the root can have environment-specific configurations.
+							env: {},
+						},
+					},
+				};
+			}
+
+			if ( configFile === '/test/gutenberg/.wp-env.override.json' ) {
+				return {};
+			}
+
+			throw new Error( 'Invalid File: ' + configFile );
+		} );
+
+		expect.assertions( 1 );
+		try {
+			await parseConfig( '/test/gutenberg', '/cache' );
+		} catch ( error ) {
+			expect( error ).toEqual(
+				new ValidationError(
+					`Invalid /test/gutenberg/.wp-env.json: "development.env" is not a configuration option.`
+				)
+			);
+		}
+	} );
+} );
+/* eslint-enable jest/no-conditional-expect */

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

@@ -0,0 +1,154 @@
+'use strict';
+/* eslint-disable jest/no-conditional-expect */
+/**
+ * External dependencies
+ */
+const path = require( 'path' );
+const { homedir } = require( 'os' );
+
+/**
+ * Internal dependencies
+ */
+const { ValidationError } = require( '../validate-config' );
+const { parseSourceString } = require( '../parse-source-string' );
+
+jest.mock( 'os', () => ( {
+	homedir: jest.fn(),
+} ) );
+
+describe( 'parseSourceString', () => {
+	const options = {
+		cacheDirectoryPath: '/test/cache',
+	};
+
+	beforeEach( () => {
+		homedir.mockReturnValue( '/home/test' );
+	} );
+
+	it( 'should do nothing when given an empty source', () => {
+		expect( parseSourceString( null, options ) ).toEqual( null );
+	} );
+
+	it( 'should throw when source not parseable', () => {
+		expect.assertions( 1 );
+		try {
+			parseSourceString( 'test://test', options );
+		} catch ( error ) {
+			expect( error ).toEqual(
+				new ValidationError(
+					'Invalid or unrecognized source: "test://test".'
+				)
+			);
+		}
+	} );
+
+	describe( 'local sources', () => {
+		it( 'should parse relative directories', () => {
+			expect( parseSourceString( '.', options ) ).toEqual( {
+				basename: path.basename( path.resolve( '.' ) ),
+				path: path.resolve( '.' ),
+				type: 'local',
+			} );
+		} );
+
+		it( 'should parse home directories', () => {
+			expect( parseSourceString( '~/test', options ) ).toEqual( {
+				basename: 'test',
+				path: '/home/test/test',
+				type: 'local',
+			} );
+		} );
+
+		it( 'should parse absolute directories', () => {
+			expect( parseSourceString( '/absolute/test', options ) ).toEqual( {
+				basename: 'test',
+				path: '/absolute/test',
+				type: 'local',
+			} );
+		} );
+	} );
+
+	describe( 'zip sources', () => {
+		it( 'should parse WordPress.org sources', () => {
+			expect(
+				parseSourceString(
+					'http://downloads.wordpress.org/plugin/gutenberg.zip',
+					options
+				)
+			).toEqual( {
+				basename: 'gutenberg',
+				path: '/test/cache/gutenberg',
+				type: 'zip',
+				url: 'http://downloads.wordpress.org/plugin/gutenberg.zip',
+			} );
+		} );
+
+		it( 'should parse other sources', () => {
+			expect(
+				parseSourceString( 'http://test.com/testing.zip', options )
+			).toEqual( {
+				basename: 'testing',
+				path: '/test/cache/testing',
+				type: 'zip',
+				url: 'http://test.com/testing.zip',
+			} );
+		} );
+	} );
+
+	describe( 'Git SSH sources', () => {
+		it( 'should parse ssh protocol', () => {
+			expect(
+				parseSourceString( 'ssh://test/test.git#trunk', options )
+			).toEqual( {
+				basename: 'test',
+				path: '/test/cache/test',
+				clonePath: '/test/cache/test',
+				ref: 'trunk',
+				type: 'git',
+				url: 'ssh://test/test.git',
+			} );
+		} );
+
+		it( 'should parse git+ssh protocol', () => {
+			expect(
+				parseSourceString( 'git+ssh://test/test.git#trunk', options )
+			).toEqual( {
+				basename: 'test',
+				path: '/test/cache/test',
+				clonePath: '/test/cache/test',
+				ref: 'trunk',
+				type: 'git',
+				url: 'git+ssh://test/test.git',
+			} );
+		} );
+
+		it( 'should work without ref', () => {
+			expect(
+				parseSourceString( 'ssh://test/test.git', options )
+			).toEqual( {
+				basename: 'test',
+				path: '/test/cache/test',
+				clonePath: '/test/cache/test',
+				ref: undefined,
+				type: 'git',
+				url: 'ssh://test/test.git',
+			} );
+		} );
+	} );
+
+	describe( 'GitHub sources', () => {
+		it( 'should parse', () => {
+			expect(
+				parseSourceString( 'WordPress/gutenberg#trunk', options )
+			).toEqual( {
+				basename: 'gutenberg',
+				path: '/test/cache/gutenberg',
+				clonePath: '/test/cache/gutenberg',
+				ref: 'trunk',
+				type: 'git',
+				url: 'https://github.com/WordPress/gutenberg.git',
+			} );
+		} );
+	} );
+} );
+/* eslint-enable jest/no-conditional-expect */