@wordpress/env 5.16.0 → 7.0.0

package/lib/config/test/post-process-config.js

@@ -0,0 +1,295 @@
+'use strict';
+/**
+ * Internal dependencies
+ */
+const { ValidationError } = require( '..' );
+const postProcessConfig = require( '../post-process-config' );
+
+describe( 'postProcessConfig', () => {
+	afterEach( () => {
+		jest.clearAllMocks();
+	} );
+
+	it( 'should merge relevant root options into environment options', () => {
+		const processed = postProcessConfig( {
+			port: 123,
+			testsPort: 456,
+			coreSource: {
+				type: 'test',
+			},
+			config: {
+				TESTS_ROOT: 'root',
+			},
+			pluginSources: [
+				{
+					type: 'root-plugin',
+				},
+			],
+			themeSources: [
+				{
+					type: 'root-theme',
+				},
+			],
+			mappings: {
+				'root-mapping': {
+					type: 'root-mapping',
+				},
+			},
+			env: {
+				development: {
+					coreSource: {
+						type: 'test',
+					},
+					config: {
+						TEST_ENV: 'development',
+					},
+					pluginSources: [
+						{
+							type: 'development-plugin',
+						},
+					],
+					themeSources: [
+						{
+							type: 'development-theme',
+						},
+					],
+					mappings: {
+						'development-mapping': {
+							type: 'development-mapping',
+						},
+					},
+				},
+				tests: {
+					coreSource: {
+						type: 'test',
+					},
+					config: {
+						TEST_ENV: 'tests',
+					},
+				},
+			},
+		} );
+
+		expect( processed ).toEqual( {
+			port: 123,
+			testsPort: 456,
+			coreSource: {
+				type: 'test',
+			},
+			config: {
+				TESTS_ROOT: 'root',
+			},
+			pluginSources: [
+				{
+					type: 'root-plugin',
+				},
+			],
+			themeSources: [
+				{
+					type: 'root-theme',
+				},
+			],
+			mappings: {
+				'root-mapping': {
+					type: 'root-mapping',
+				},
+			},
+			env: {
+				development: {
+					port: 123,
+					coreSource: {
+						type: 'test',
+					},
+					config: {
+						TESTS_ROOT: 'root',
+						TEST_ENV: 'development',
+					},
+					pluginSources: [
+						{
+							type: 'development-plugin',
+						},
+					],
+					themeSources: [
+						{
+							type: 'development-theme',
+						},
+					],
+					mappings: {
+						'root-mapping': {
+							type: 'root-mapping',
+						},
+						'development-mapping': {
+							type: 'development-mapping',
+						},
+					},
+				},
+				tests: {
+					port: 456,
+					coreSource: {
+						type: 'test',
+					},
+					config: {
+						TESTS_ROOT: 'root',
+						TEST_ENV: 'tests',
+					},
+					pluginSources: [
+						{
+							type: 'root-plugin',
+						},
+					],
+					themeSources: [
+						{
+							type: 'root-theme',
+						},
+					],
+					mappings: {
+						'root-mapping': {
+							type: 'root-mapping',
+						},
+					},
+				},
+			},
+		} );
+	} );
+
+	it( 'should not merge some root options into environment options', () => {
+		const processed = postProcessConfig( {
+			port: 8888,
+			testsPort: 8889,
+			afterSetup: 'test',
+			env: {
+				development: {},
+				tests: {},
+			},
+		} );
+
+		expect( processed ).toEqual( {
+			port: 8888,
+			testsPort: 8889,
+			afterSetup: 'test',
+			env: {
+				development: {
+					port: 8888,
+				},
+				tests: {
+					port: 8889,
+				},
+			},
+		} );
+	} );
+
+	describe( 'appendPortToWPConfigs', () => {
+		it( 'should add port to certain environment config options', () => {
+			const processed = postProcessConfig( {
+				port: 123,
+				config: {
+					WP_TESTS_DOMAIN: 'localhost',
+					WP_SITEURL: 'localhost',
+					WP_HOME: 'localhost',
+				},
+				env: {
+					development: {
+						port: 123,
+					},
+					tests: {
+						port: 456,
+					},
+				},
+			} );
+
+			expect( processed ).toEqual( {
+				// Since the root-level config shouldn't apply to an environment,
+				// we shouldn't add the port to the config options for it.
+				port: 123,
+				config: {
+					WP_TESTS_DOMAIN: 'localhost',
+					WP_SITEURL: 'localhost',
+					WP_HOME: 'localhost',
+				},
+				env: {
+					development: {
+						port: 123,
+						config: {
+							WP_TESTS_DOMAIN: 'localhost:123',
+							WP_SITEURL: 'localhost:123',
+							WP_HOME: 'localhost:123',
+						},
+					},
+					tests: {
+						port: 456,
+						config: {
+							WP_TESTS_DOMAIN: 'localhost:456',
+							WP_SITEURL: 'localhost:456',
+							WP_HOME: 'localhost:456',
+						},
+					},
+				},
+			} );
+		} );
+
+		it( 'should not overwrite port in WP_HOME', () => {
+			const processed = postProcessConfig( {
+				env: {
+					development: {
+						port: 123,
+						config: {
+							WP_TESTS_DOMAIN: 'localhost:777',
+							WP_SITEURL: 'localhost:777',
+							WP_HOME: 'localhost:777',
+						},
+					},
+					tests: {
+						port: 456,
+						config: {
+							WP_TESTS_DOMAIN: 'localhost:777',
+							WP_SITEURL: 'localhost:777',
+							WP_HOME: 'localhost:777',
+						},
+					},
+				},
+			} );
+
+			expect( processed ).toEqual( {
+				env: {
+					development: {
+						port: 123,
+						config: {
+							WP_TESTS_DOMAIN: 'localhost:123',
+							WP_SITEURL: 'localhost:123',
+							WP_HOME: 'localhost:777',
+						},
+					},
+					tests: {
+						port: 456,
+						config: {
+							WP_TESTS_DOMAIN: 'localhost:456',
+							WP_SITEURL: 'localhost:456',
+							WP_HOME: 'localhost:777',
+						},
+					},
+				},
+			} );
+		} );
+	} );
+
+	describe( 'validatePortUniqueness', () => {
+		it( 'should fail when two environments have the same port', () => {
+			expect( () => {
+				postProcessConfig( {
+					env: {
+						development: {
+							port: 123,
+						},
+						tests: {
+							port: 123,
+						},
+					},
+				} );
+			} ).toThrow(
+				new ValidationError(
+					'The "development" and "tests" environments may not have the same port.'
+				)
+			);
+		} );
+	} );
+} );

package/lib/config/test/read-raw-config-file.js

@@ -1,3 +1,5 @@
+'use strict';
+/* eslint-disable jest/no-conditional-expect */
 /**
  * External dependencies
  */
@@ -6,7 +8,8 @@ const { readFile } = require( 'fs' ).promises;
 /**
  * Internal dependencies
  */
-const readConfigFile = require( '../read-raw-config-file' );
+const readRawConfigFile = require( '../read-raw-config-file' );
+const { ValidationError } = require( '../validate-config' );
 
 jest.mock( 'fs', () => ( {
 	promises: {
@@ -15,76 +18,29 @@ jest.mock( 'fs', () => ( {
 } ) );
 
 describe( 'readRawConfigFile', () => {
-	beforeEach( () => {
+	afterEach( () => {
 		jest.clearAllMocks();
 	} );
 
 	it( 'returns null if it cannot find a file', async () => {
-		readFile.mockImplementation( () =>
-			Promise.reject( { code: 'ENOENT' } )
-		);
-		const result = await readConfigFile( 'wp-env', '/.wp-env.json' );
+		readFile.mockRejectedValue( { code: 'ENOENT' } );
+
+		const result = await readRawConfigFile( '/.wp-env.json' );
 		expect( result ).toBe( null );
 	} );
 
-	it( 'converts testPort into tests.port', async () => {
-		readFile.mockImplementation( () =>
-			Promise.resolve( JSON.stringify( { testsPort: 100 } ) )
-		);
-		const result = await readConfigFile( 'wp-env', '/.wp-env.json' );
-		expect( result ).toEqual( {
-			env: {
-				tests: {
-					port: 100,
-				},
-			},
-		} );
-	} );
+	it( 'rejects when read file fails', async () => {
+		readFile.mockRejectedValue( { message: 'Test' } );
 
-	it( 'does not overwrite other test config values', async () => {
-		readFile.mockImplementation( () =>
-			Promise.resolve(
-				JSON.stringify( {
-					testsPort: 100,
-					env: {
-						tests: {
-							something: 'test',
-						},
-					},
-				} )
-			)
-		);
-		const result = await readConfigFile( 'wp-env', '/.wp-env.json' );
-		expect( result ).toEqual( {
-			env: {
-				tests: {
-					port: 100,
-					something: 'test',
-				},
-			},
-		} );
-	} );
+		expect.assertions( 1 );
 
-	it( 'uses tests.port if both tests.port and testsPort exist', async () => {
-		readFile.mockImplementation( () =>
-			Promise.resolve(
-				JSON.stringify( {
-					testsPort: 100,
-					env: {
-						tests: {
-							port: 200,
-						},
-					},
-				} )
-			)
-		);
-		const result = await readConfigFile( 'wp-env', '/.wp-env.json' );
-		expect( result ).toEqual( {
-			env: {
-				tests: {
-					port: 200,
-				},
-			},
-		} );
+		try {
+			await readRawConfigFile( '/.wp-env.json' );
+		} catch ( error ) {
+			expect( error ).toEqual(
+				new ValidationError( 'Could not read .wp-env.json: Test' )
+			);
+		}
 	} );
 } );
+/* eslint-enable jest/no-conditional-expect */

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

@@ -0,0 +1,305 @@
+'use strict';
+/**
+ * Internal dependencies
+ */
+const {
+	ValidationError,
+	checkString,
+	checkPort,
+	checkStringArray,
+	checkObjectWithValues,
+	checkVersion,
+	checkValidURL,
+} = require( '../validate-config' );
+
+describe( 'validate-config', () => {
+	describe( 'checkString', () => {
+		it( 'throws when not a string', () => {
+			expect( () => checkString( 'test.json', 'test', 1234 ) ).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be a string.'
+				)
+			);
+		} );
+
+		it( 'passes for string', () => {
+			expect( () =>
+				checkString( 'test.json', 'test', 'test' )
+			).not.toThrow();
+		} );
+	} );
+
+	describe( 'checkPort', () => {
+		it( 'throws when not a number', () => {
+			expect( () => checkPort( 'test.json', 'test', 'test' ) ).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be an integer.'
+				)
+			);
+
+			expect( () =>
+				checkPort( 'test.json', 'test', { test: 'test' } )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be an integer.'
+				)
+			);
+		} );
+
+		it( 'throws when port out of range', () => {
+			expect( () => checkPort( 'test.json', 'test', -1 ) ).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be a valid port.'
+				)
+			);
+
+			expect( () => checkPort( 'test.json', 'test', 99999999 ) ).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be a valid port.'
+				)
+			);
+		} );
+
+		it( 'passes for valid port', () => {
+			expect( () =>
+				checkPort( 'test.json', 'test', 8888 )
+			).not.toThrow();
+		} );
+	} );
+
+	describe( 'checkStringArray', () => {
+		it( 'throws when not an array', () => {
+			expect( () =>
+				checkStringArray( 'test.json', 'test', 'test' )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be an array.'
+				)
+			);
+
+			expect( () =>
+				checkStringArray( 'test.json', 'test', { test: 'test' } )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be an array.'
+				)
+			);
+		} );
+
+		it( 'throws when array contains non-strings', () => {
+			expect( () =>
+				checkStringArray( 'test.json', 'test', [ 12 ] )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be an array of strings.'
+				)
+			);
+
+			expect( () =>
+				checkStringArray( 'test.json', 'test', [ 'test', 12 ] )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be an array of strings.'
+				)
+			);
+		} );
+
+		it( 'passes for string arrays', () => {
+			expect( () =>
+				checkStringArray( 'test.json', 'test', [] )
+			).not.toThrow();
+			expect( () =>
+				checkStringArray( 'test.json', 'test', [ 'test' ] )
+			).not.toThrow();
+		} );
+	} );
+
+	describe( 'checkObjectWithValues', () => {
+		it( 'throws when not an object', () => {
+			expect( () =>
+				checkObjectWithValues( 'test.json', 'test', 'test', [] )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be an object.'
+				)
+			);
+
+			expect( () =>
+				checkObjectWithValues( 'test.json', 'test', [ 'test' ], [] )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be an object.'
+				)
+			);
+		} );
+
+		it( 'throws when no allowed types are given', () => {
+			expect( () =>
+				checkObjectWithValues(
+					'test.json',
+					'test',
+					{ test: 'test' },
+					[]
+				)
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test.test" must be a .'
+				)
+			);
+		} );
+
+		it( 'throws when type is not allowed', () => {
+			expect( () =>
+				checkObjectWithValues( 'test.json', 'test', { test: 'test' }, [
+					'number',
+				] )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test.test" must be a number.'
+				)
+			);
+
+			expect( () =>
+				checkObjectWithValues( 'test.json', 'test', { test: 1 }, [
+					'string',
+				] )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test.test" must be a string.'
+				)
+			);
+
+			expect( () =>
+				checkObjectWithValues(
+					'test.json',
+					'test',
+					{ test: [ 'test' ] },
+					[ 'object', 'string' ]
+				)
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test.test" must be a object or string.'
+				)
+			);
+		} );
+
+		it( 'passes when type is allowed', () => {
+			expect( () =>
+				checkObjectWithValues( 'test.json', 'test', { test: 'test' }, [
+					'string',
+				] )
+			).not.toThrow();
+			expect( () =>
+				checkObjectWithValues( 'test.json', 'test', { test: 1 }, [
+					'number',
+				] )
+			).not.toThrow();
+			expect( () =>
+				checkObjectWithValues(
+					'test.json',
+					'test',
+					{ test: { nested: 'test' } },
+					[ 'object' ]
+				)
+			).not.toThrow();
+			expect( () =>
+				checkObjectWithValues(
+					'test.json',
+					'test',
+					{ test: [ 'test' ] },
+					[ 'array' ]
+				)
+			).not.toThrow();
+		} );
+	} );
+
+	describe( 'checkVersion', () => {
+		it( 'throws for invalid input', () => {
+			expect( () => checkVersion( 'test.json', 'test', 'test' ) ).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be a string of the format "X", "X.X", or "X.X.X".'
+				)
+			);
+
+			expect( () => checkVersion( 'test.json', 'test', 123 ) ).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be a string.'
+				)
+			);
+		} );
+
+		it( 'passes for different version formats', () => {
+			expect( () =>
+				checkVersion( 'test.json', 'test', '1' )
+			).not.toThrow();
+			expect( () =>
+				checkVersion( 'test.json', 'test', '1.1' )
+			).not.toThrow();
+			expect( () =>
+				checkVersion( 'test.json', 'test', '1.1.1' )
+			).not.toThrow();
+			expect( () =>
+				checkVersion( 'test.json', 'test', '15.7.2' )
+			).not.toThrow();
+			expect( () =>
+				checkVersion( 'test.json', 'test', '26634543' )
+			).not.toThrow();
+		} );
+	} );
+
+	describe( 'checkValidURL', () => {
+		it( 'throws for invaid URLs', () => {
+			expect( () =>
+				checkValidURL( 'test.json', 'test', 'localhost' )
+			).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be a valid URL.'
+				)
+			);
+
+			expect( () => checkValidURL( 'test.json', 'test', '' ) ).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be a valid URL.'
+				)
+			);
+
+			expect( () => checkValidURL( 'test.json', 'test', 123 ) ).toThrow(
+				new ValidationError(
+					'Invalid test.json: "test" must be a valid URL.'
+				)
+			);
+		} );
+
+		it( 'passes for valid URLs', () => {
+			expect( () =>
+				checkValidURL( 'test.json', 'test', 'http://test.com' )
+			).not.toThrow();
+			expect( () =>
+				checkValidURL( 'test.json', 'test', 'https://test.com' )
+			).not.toThrow();
+			expect( () =>
+				checkValidURL( 'test.json', 'test', 'http://test' )
+			).not.toThrow();
+			expect( () =>
+				checkValidURL(
+					'test.json',
+					'test',
+					'http://test/test?test=test'
+				)
+			).not.toThrow();
+			expect( () =>
+				checkValidURL( 'test.json', 'test', 'http://test.co.uk' )
+			).not.toThrow();
+			expect( () =>
+				checkValidURL( 'test.json', 'test', 'https://test.co.uk:8888' )
+			).not.toThrow();
+			expect( () =>
+				checkValidURL(
+					'test.json',
+					'test',
+					'http://test.co.uk:8888/test?test=test#test'
+				)
+			).not.toThrow();
+		} );
+	} );
+} );