@wordpress/env 6.0.0 → 7.0.0

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: 'gutenberg',
+				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 */

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 */