@wordpress/env 5.16.0 → 7.0.0

package/lib/test/build-docker-compose-config.js

@@ -0,0 +1,134 @@
+'use strict';
+/**
+ * Internal dependencies
+ */
+const buildDockerComposeConfig = require( '../build-docker-compose-config' );
+const getHostUser = require( '../get-host-user' );
+
+// The basic config keys which build docker compose config requires.
+const CONFIG = {
+	mappings: {},
+	pluginSources: [],
+	themeSources: [],
+	port: 8888,
+	configDirectoryPath: '/path/to/config',
+};
+
+jest.mock( '../get-host-user', () => jest.fn() );
+getHostUser.mockImplementation( () => {
+	return {
+		name: 'test',
+		uid: 1,
+		gid: 2,
+		fullUser: '1:2',
+	};
+} );
+
+describe( 'buildDockerComposeConfig', () => {
+	it( 'should map directories before individual sources', () => {
+		const envConfig = {
+			...CONFIG,
+			mappings: {
+				'wp-content/plugins': {
+					path: '/path/to/wp-plugins',
+				},
+			},
+			pluginSources: [
+				{ path: '/path/to/local/plugin', basename: 'test-name' },
+			],
+		};
+		const dockerConfig = buildDockerComposeConfig( {
+			workDirectoryPath: '/path',
+			env: { development: envConfig, tests: envConfig },
+		} );
+		const { volumes } = dockerConfig.services.wordpress;
+		expect( volumes ).toEqual( [
+			'wordpress:/var/www/html', // WordPress root.
+			'/path/WordPress-PHPUnit/tests/phpunit:/wordpress-phpunit', // WordPress test library,
+			'user-home:/home/test',
+			'/path/to/wp-plugins:/var/www/html/wp-content/plugins', // Mapped plugins root.
+			'/path/to/local/plugin:/var/www/html/wp-content/plugins/test-name', // Mapped plugin.
+		] );
+	} );
+
+	it( 'should add all specified sources to tests, dev, and cli services', () => {
+		const envConfig = {
+			...CONFIG,
+			mappings: {
+				'wp-content/plugins': {
+					path: '/path/to/wp-plugins',
+				},
+			},
+			pluginSources: [
+				{ path: '/path/to/local/plugin', basename: 'test-name' },
+			],
+			themeSources: [
+				{ path: '/path/to/local/theme', basename: 'test-theme' },
+			],
+		};
+		const dockerConfig = buildDockerComposeConfig( {
+			workDirectoryPath: '/path',
+			env: { development: envConfig, tests: envConfig },
+		} );
+		const devVolumes = dockerConfig.services.wordpress.volumes;
+		const cliVolumes = dockerConfig.services.cli.volumes;
+		expect( devVolumes ).toEqual( cliVolumes );
+
+		const testsVolumes = dockerConfig.services[ 'tests-wordpress' ].volumes;
+		const testsCliVolumes = dockerConfig.services[ 'tests-cli' ].volumes;
+		expect( testsVolumes ).toEqual( testsCliVolumes );
+
+		let localSources = [
+			'/path/to/wp-plugins:/var/www/html/wp-content/plugins',
+			'/path/WordPress-PHPUnit/tests/phpunit:/wordpress-phpunit',
+			'user-home:/home/test',
+			'/path/to/local/plugin:/var/www/html/wp-content/plugins/test-name',
+			'/path/to/local/theme:/var/www/html/wp-content/themes/test-theme',
+		];
+		expect( devVolumes ).toEqual( expect.arrayContaining( localSources ) );
+
+		localSources = [
+			'/path/to/wp-plugins:/var/www/html/wp-content/plugins',
+			'/path/tests-WordPress-PHPUnit/tests/phpunit:/wordpress-phpunit',
+			'tests-user-home:/home/test',
+			'/path/to/local/plugin:/var/www/html/wp-content/plugins/test-name',
+			'/path/to/local/theme:/var/www/html/wp-content/themes/test-theme',
+		];
+		expect( testsVolumes ).toEqual(
+			expect.arrayContaining( localSources )
+		);
+	} );
+
+	it( 'should create "wordpress" and "tests-wordpress" volumes if they are needed by containers', () => {
+		// CONFIG has no coreSource entry, so there are no core sources on the
+		// local filesystem, so a volume should be created to contain core
+		// sources.
+		const dockerConfig = buildDockerComposeConfig( {
+			workDirectoryPath: '/path',
+			env: { development: CONFIG, tests: CONFIG },
+		} );
+
+		expect( dockerConfig.volumes.wordpress ).not.toBe( undefined );
+		expect( dockerConfig.volumes[ 'tests-wordpress' ] ).not.toBe(
+			undefined
+		);
+	} );
+
+	it( 'should NOT create "wordpress" and "tests-wordpress" volumes if they are not needed by containers', () => {
+		const envConfig = {
+			...CONFIG,
+			coreSource: {
+				path: '/some/random/path',
+				local: true,
+			},
+		};
+
+		const dockerConfig = buildDockerComposeConfig( {
+			workDirectoryPath: '/path',
+			env: { development: envConfig, tests: envConfig },
+		} );
+
+		expect( dockerConfig.volumes.wordpress ).toBe( undefined );
+		expect( dockerConfig.volumes[ 'tests-wordpress' ] ).toBe( undefined );
+	} );
+} );

package/lib/test/cache.js

@@ -0,0 +1,154 @@
+'use strict';
+/**
+ * External dependencies
+ */
+const { readFile, writeFile } = require( 'fs' ).promises;
+
+/**
+ * Internal dependencies
+ */
+const {
+	didCacheChange,
+	setCache,
+	getCache,
+	getCacheFile,
+} = require( '../cache' );
+
+jest.mock( 'fs', () => ( {
+	promises: {
+		readFile: jest.fn(),
+		writeFile: jest.fn(),
+	},
+} ) );
+
+const cacheOptions = {
+	workDirectoryPath: '/a/b/c',
+};
+
+function deleteCacheFile() {
+	readFile.mockImplementation( () => Promise.reject( 'No file!' ) );
+}
+
+function setCacheFile( data ) {
+	readFile.mockImplementation( () =>
+		Promise.resolve( JSON.stringify( data ) )
+	);
+}
+
+function setupWriteFile() {
+	writeFile.mockImplementation( ( fileName, data ) => {
+		readFile.mockClear();
+		readFile.mockImplementation( () => Promise.resolve( data ) );
+	} );
+}
+
+describe( 'cache file', () => {
+	beforeEach( () => {
+		jest.clearAllMocks();
+	} );
+
+	describe( 'didCacheChange', () => {
+		it( 'returns true if the existing cache value is different', async () => {
+			setCacheFile( { test: 'test1' } );
+			const result = await didCacheChange( 'test', 'nope', cacheOptions );
+			expect( result ).toBe( true );
+		} );
+		it( 'returns false if the existing cache value is the same', async () => {
+			setCacheFile( { test: 'test1' } );
+			const result = await didCacheChange(
+				'test',
+				'test1',
+				cacheOptions
+			);
+			expect( result ).toBe( false );
+		} );
+		it( 'returns true if the existing cache value does not exist', async () => {
+			expect.assertions( 2 );
+
+			setCacheFile( { howdy: 'test1' } );
+			const result = await didCacheChange( 'test', 'nope', cacheOptions );
+			expect( result ).toBe( true );
+
+			deleteCacheFile();
+			const result2 = await didCacheChange(
+				'test',
+				'nope',
+				cacheOptions
+			);
+			expect( result2 ).toBe( true );
+		} );
+	} );
+
+	describe( 'setCache', () => {
+		it( 'saves a new cache value to the file', async () => {
+			setupWriteFile();
+			await setCache( 'test', 'abc', cacheOptions );
+			const result = await getCacheFile( cacheOptions );
+			expect( result ).toEqual( { test: 'abc' } );
+		} );
+		it( 'overwrites an existing key', async () => {
+			expect.assertions( 2 );
+			setCacheFile( { test: 'abc' } );
+			const result = await getCacheFile( cacheOptions );
+			expect( result ).toEqual( { test: 'abc' } );
+
+			await setCache( 'test', '123', cacheOptions );
+			const result2 = await getCacheFile( cacheOptions );
+			expect( result2 ).toEqual( { test: '123' } );
+		} );
+		it( 'does not overwrite other keys', async () => {
+			setCacheFile( { test: 'abc' } );
+
+			await setCache( 'test2', 1234, cacheOptions );
+			const result = await getCacheFile( cacheOptions );
+			expect( result ).toEqual( { test: 'abc', test2: 1234 } );
+		} );
+	} );
+
+	describe( 'getCache', () => {
+		it( 'returns the cache value associated with the key', async () => {
+			const value = 'test1';
+			setCacheFile( { test: value } );
+			const result = await getCache( 'test', cacheOptions );
+			expect( result ).toBe( value );
+		} );
+		it( 'returns undefined if there is no existing value', async () => {
+			setCacheFile( { anotherValue: 'hello' } );
+			const result = await getCache( 'test', cacheOptions );
+			expect( result ).toBe( undefined );
+		} );
+		it( 'returns undefined if the file does not exist', async () => {
+			deleteCacheFile();
+			const result = await getCache( 'test', cacheOptions );
+			expect( result ).toBe( undefined );
+		} );
+	} );
+
+	describe( 'getCacheFile', () => {
+		it( 'returns the stored JSON data as an Object', async () => {
+			const testData = {
+				a: 'test',
+				b: 1,
+				c: true,
+				d: null,
+				e: {
+					foo: 'test2',
+				},
+			};
+			setCacheFile( testData );
+
+			const result = await getCacheFile( cacheOptions );
+			expect( result ).toEqual( testData );
+		} );
+		it( 'returns an empty object if the file does not exist', async () => {
+			deleteCacheFile();
+			const result = await getCacheFile( cacheOptions );
+			expect( result ).toEqual( {} );
+		} );
+		it( 'returns an empty object if the file is invalid', async () => {
+			readFile.mockImplementation( () => Promise.resolve( '{' ) );
+			const result = await getCacheFile( cacheOptions );
+			expect( result ).toEqual( {} );
+		} );
+	} );
+} );

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
@@ -44,20 +45,7 @@ async function checkDatabaseConnection( { dockerComposeConfigPath, debug } ) {
  * @param {Object}        spinner     A CLI spinner which indicates progress.
  */
 async function configureWordPress( environment, config, spinner ) {
-	const url = ( () => {
-		const port = config.env[ environment ].port;
-		const domain =
-			environment === 'tests'
-				? config.env.tests.config.WP_TESTS_DOMAIN
-				: config.env.development.config.WP_SITEURL;
-		if ( port === 80 ) {
-			return domain;
-		}
-
-		return `${ domain }:${ port }`;
-	} )();
-
-	const installCommand = `wp core install --url="${ url }" --title="${ config.name }" --admin_user=admin --admin_password=password --admin_email=wordpress@example.com --skip-email`;
+	const installCommand = `wp core install --url="${ config.env[ environment ].config.WP_SITEURL }" --title="${ config.name }" --admin_user=admin --admin_password=password --admin_email=wordpress@example.com --skip-email`;
 
 	// -eo pipefail exits the command as soon as anything fails in bash.
 	const setupCommands = [ 'set -eo pipefail', installCommand ];
@@ -99,6 +87,7 @@ async function configureWordPress( environment, config, spinner ) {
 		[ 'bash', '-c', setupCommands.join( ' && ' ) ],
 		{
 			config: config.dockerComposeConfigPath,
+			commandOptions: [ '--rm' ],
 			log: config.debug,
 		}
 	);
@@ -160,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": "5.16.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": "d61700b9f1c72ba0b030fc815ef1685b4f4031ec"
+	"gitHead": "e936127e1e13881f1a940b7bd1593a9e500147f3"
 }