wp-advads 1.0.31 → 1.0.34

package/test/github-final.test.js

@@ -0,0 +1,93 @@
+/**
+ * TASK-004: githubFinalTasks must add an explicit file list, run hooks, and not push on failure.
+ */
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { mock, test, beforeEach } from 'node:test'
+
+const execCalls = []
+let execImpl = ( cmd, cb ) => cb( '', null, '' )
+
+mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
+	exports: {
+		execCommand( cmd, cb, options = {} ) {
+			execCalls.push( typeof cmd === 'string' ? cmd : cmd.join( ' ' ) )
+			execImpl( cmd, cb, options )
+		},
+		runCommand() {},
+	},
+} )
+
+const { pluginData } = await import( '../src/commands/release.js' )
+const { githubFinalTasks } = await import( '../src/commands/release/github.js' )
+
+function runFinal() {
+	return new Promise( ( resolve ) => {
+		githubFinalTasks( ( err ) => resolve( err ) )
+	} )
+}
+
+beforeEach( () => {
+	execCalls.length = 0
+	execImpl = ( cmd, cb ) => cb( '', null, '' )
+	pluginData.semver = { getNextVersionString: () => '1.2.3' }
+	pluginData.commitMessages = [ 'update readme.txt' ]
+} )
+
+async function withReleaseFiles( run ) {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-' ) )
+	const cwd = process.cwd()
+	await writeFile( join( dir, 'wp.advads' ), '{}' )
+	await writeFile( join( dir, 'changelog.txt' ), '== Changelog ==\n' )
+	await writeFile( join( dir, 'readme.txt' ), 'Stable tag: 1.0.0\n' )
+	await writeFile( join( dir, 'advanced-ads.php' ), '<?php\n' )
+	await mkdir( join( dir, 'languages' ) )
+	process.chdir( dir )
+	try {
+		return await run()
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+}
+
+test( 'does not git add the whole working tree', async () => {
+	await withReleaseFiles( async () => {
+		await runFinal()
+		assert.equal(
+			execCalls.some( ( cmd ) => /(^| )git add \.( |$)/.test( cmd ) ),
+			false
+		)
+	} )
+} )
+
+test( 'commit runs hooks instead of --no-verify', async () => {
+	await withReleaseFiles( async () => {
+		await runFinal()
+		const commit = execCalls.find( ( cmd ) => cmd.includes( 'git commit' ) )
+		assert.ok( commit, 'expected a git commit' )
+		assert.equal( commit.includes( '--no-verify' ), false )
+	} )
+} )
+
+test( 'does not push when commit fails', async () => {
+	await withReleaseFiles( async () => {
+		execImpl = ( cmd, cb ) => {
+			const line = typeof cmd === 'string' ? cmd : cmd.join( ' ' )
+			if ( line.includes( 'git commit' ) ) {
+				cb( '', new Error( 'hook failed' ), 'phpcs' )
+				return
+			}
+			cb( '', null, '' )
+		}
+
+		const err = await runFinal()
+		assert.ok( err )
+		assert.equal(
+			execCalls.some( ( cmd ) => cmd.includes( 'git push' ) ),
+			false
+		)
+	} )
+} )

package/test/glotpress-download.test.js

@@ -0,0 +1,176 @@
+/**
+ * TASK-011: GlotPress downloader returns { files, locales } in-process.
+ * Run with --test-isolation=none
+ */
+import assert from 'node:assert/strict'
+import { existsSync, readFileSync } from 'node:fs'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { saveConfig } from '../src/utilities/settings.js'
+import { downloadTranslations } from '../src/commands/wp-glotpress.js'
+
+test( 'glotpress downloader is a function, not a class', () => {
+	const src = readFileSync( new URL( '../src/commands/wp-glotpress.js', import.meta.url ), 'utf8' )
+	assert.doesNotMatch( src, /class GlotPressDownloader/ )
+} )
+
+test( 'downloadTranslations returns files and locale names without scraping CLI stdout', async () => {
+	const dest = await mkdtemp( join( tmpdir(), 'wp-advads-glotpress-' ) )
+	const cwd = process.cwd()
+	process.chdir( dest )
+	saveConfig( {
+		glotpress: { project: 'my-plugin', destination: dest },
+		wpPot: { domain: 'myplugin' },
+	} )
+
+	const originalFetch = globalThis.fetch
+	globalThis.fetch = async ( url ) => {
+		const href = String( url )
+		if ( href.endsWith( '/api/projects/my-plugin' ) ) {
+			return {
+				ok: true,
+				json: async () => ( {
+					translation_sets: [
+						{
+							wp_locale: 'de_DE',
+							slug: 'default',
+							name: 'German',
+							locale: 'de',
+							current_count: 4,
+						},
+					],
+				} ),
+			}
+		}
+		return { ok: true, text: async () => 'translation-bytes' }
+	}
+
+	try {
+		const result = await downloadTranslations()
+
+		assert.ok( result )
+		assert.ok( Array.isArray( result.files ) )
+		assert.ok( result.files.some( ( file ) => file.endsWith( 'myplugin-de_DE.po' ) ) )
+		assert.ok( result.files.some( ( file ) => file.endsWith( 'myplugin-de_DE.mo' ) ) )
+		assert.equal(
+			Object.values( result.locales ).includes( 'German' ),
+			true
+		)
+	} finally {
+		globalThis.fetch = originalFetch
+		process.chdir( cwd )
+		await rm( dest, { recursive: true, force: true } )
+	}
+} )
+
+async function downloadWithSets( dest, sets, fileResponse ) {
+	const cwd = process.cwd()
+	process.chdir( dest )
+	saveConfig( {
+		glotpress: { project: 'my-plugin', destination: dest },
+		wpPot: { domain: 'myplugin' },
+	} )
+
+	const originalFetch = globalThis.fetch
+	globalThis.fetch = async ( url ) => {
+		const href = String( url )
+		if ( href.endsWith( '/api/projects/my-plugin' ) ) {
+			return {
+				ok: true,
+				json: async () => ( { translation_sets: sets } ),
+			}
+		}
+		return fileResponse
+	}
+
+	try {
+		return await downloadTranslations()
+	} finally {
+		globalThis.fetch = originalFetch
+		process.chdir( cwd )
+	}
+}
+
+test( 'downloadTranslations skips locale ids that are not alphanumeric', async () => {
+	const dest = await mkdtemp( join( tmpdir(), 'wp-advads-glotpress-' ) )
+	try {
+		await downloadWithSets( dest, [
+			{
+				wp_locale: '../evil',
+				slug: 'default',
+				name: 'Evil',
+				locale: 'de',
+				current_count: 4,
+			},
+		], { ok: true, text: async () => 'translation-bytes' } )
+
+		assert.equal( existsSync( join( dest, '..', 'evil.po' ) ), false )
+		assert.equal( existsSync( join( dest, '..', 'evil.mo' ) ), false )
+	} finally {
+		await rm( dest, { recursive: true, force: true } )
+	}
+} )
+
+test( 'downloadTranslations does not write HTML error bodies as po/mo files', async () => {
+	const dest = await mkdtemp( join( tmpdir(), 'wp-advads-glotpress-' ) )
+	try {
+		const result = await downloadWithSets( dest, [
+			{
+				wp_locale: 'de_DE',
+				slug: 'default',
+				name: 'German',
+				locale: 'de',
+				current_count: 4,
+			},
+		], { ok: false, text: async () => '<html>nope</html>' } )
+
+		assert.equal( existsSync( join( dest, 'myplugin-de_DE.po' ) ), false )
+		assert.equal( existsSync( join( dest, 'myplugin-de_DE.mo' ) ), false )
+		assert.deepEqual( result.files, [] )
+	} finally {
+		await rm( dest, { recursive: true, force: true } )
+	}
+} )
+
+test( 'downloadTranslations creates nested destination directories', async () => {
+	const dest = await mkdtemp( join( tmpdir(), 'wp-advads-glotpress-' ) )
+	const nested = join( dest, 'languages', 'i18n' )
+	const cwd = process.cwd()
+	process.chdir( dest )
+	saveConfig( {
+		glotpress: { project: 'my-plugin', destination: nested },
+		wpPot: { domain: 'myplugin' },
+	} )
+
+	const originalFetch = globalThis.fetch
+	globalThis.fetch = async ( url ) => {
+		if ( String( url ).endsWith( '/api/projects/my-plugin' ) ) {
+			return {
+				ok: true,
+				json: async () => ( {
+					translation_sets: [
+						{
+							wp_locale: 'de_DE',
+							slug: 'default',
+							name: 'German',
+							locale: 'de',
+							current_count: 4,
+						},
+					],
+				} ),
+			}
+		}
+		return { ok: true, text: async () => 'translation-bytes' }
+	}
+
+	try {
+		await downloadTranslations()
+		assert.equal( existsSync( join( nested, 'myplugin-de_DE.po' ) ), true )
+	} finally {
+		globalThis.fetch = originalFetch
+		process.chdir( cwd )
+		await rm( dest, { recursive: true, force: true } )
+	}
+} )

package/test/nested-path.test.js

@@ -0,0 +1,39 @@
+/**
+ * TASK-032: js, css, and view nested names accept / and \\.
+ */
+import assert from 'node:assert/strict'
+import { existsSync } from 'node:fs'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import css from '../src/commands/css.js'
+import javascript from '../src/commands/javascript.js'
+import views from '../src/commands/views.js'
+
+test( 'js css and view nested paths accept slash and backslash', async () => {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-nested-' ) )
+	const cwd = process.cwd()
+	process.chdir( dir )
+
+	try {
+		await writeFile( join( dir, 'wp.advads' ), JSON.stringify( {
+			paths: { views: 'views', javascript: 'assets/src', css: 'assets/css' },
+			wp: { version: '1.0.0' },
+			misc: { package: 'AdvancedAds' },
+			author: { name: 'Test', email: 'test@example.com' },
+		} ) )
+
+		javascript( 'Admin/App', {} )
+		assert.equal( existsSync( join( dir, 'assets', 'src', 'admin', 'app.js' ) ), true )
+
+		css( 'Admin/App', {} )
+		assert.equal( existsSync( join( dir, 'assets', 'css', 'admin', 'app.css' ) ), true )
+
+		views( 'Admin\\Box' )
+		assert.equal( existsSync( join( dir, 'views', 'admin', 'box.php' ) ), true )
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+} )

package/test/no-fs-extra.test.js

@@ -0,0 +1,11 @@
+/**
+ * TASK-040: drop fs-extra; stdlib mkdir/write is enough.
+ */
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { test } from 'node:test'
+
+test( 'package.json does not depend on fs-extra', () => {
+	const pkg = JSON.parse( readFileSync( new URL( '../package.json', import.meta.url ), 'utf8' ) )
+	assert.equal( pkg.dependencies['fs-extra'], undefined )
+} )

package/test/package-identity.test.js

@@ -0,0 +1,19 @@
+/**
+ * TASK-057: package description grammar/capitalization; no StandardJS claim without tooling.
+ */
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { test } from 'node:test'
+
+test( 'package.json description uses WordPress and correct article', () => {
+	const { description } = JSON.parse( readFileSync( new URL( '../package.json', import.meta.url ), 'utf8' ) )
+	assert.doesNotMatch( description, /wordPress/ )
+	assert.doesNotMatch( description, /Create a Advanced/ )
+	assert.doesNotMatch( description, /eco system/ )
+	assert.match( description, /WordPress/ )
+} )
+
+test( 'README does not claim StandardJS', () => {
+	const readme = readFileSync( new URL( '../README.md', import.meta.url ), 'utf8' )
+	assert.doesNotMatch( readme, /StandardJS/i )
+} )

package/test/path-confine.test.js

@@ -0,0 +1,42 @@
+/**
+ * TASK-013: scaffold writes must stay inside the project root.
+ * Run with --test-isolation=none
+ */
+import assert from 'node:assert/strict'
+import { existsSync } from 'node:fs'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import views from '../src/commands/views.js'
+import { writeFile as writeScaffold } from '../src/utilities/filesystem.js'
+
+test( 'scaffold writes stay inside the project root', async () => {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-path-' ) )
+	const project = join( dir, 'project' )
+	const outside = join( dir, 'outside' )
+	await mkdir( project )
+	await mkdir( outside )
+	await writeFile( join( project, 'wp.advads' ), JSON.stringify( {
+		paths: { views: 'views' },
+		wp: { version: '1.0.0' },
+		misc: { package: 'AdvancedAds' },
+		author: { name: 'Test', email: 'test@example.com' },
+	} ) )
+
+	const cwd = process.cwd()
+	process.chdir( project )
+
+	try {
+		assert.throws( () => views( '../../outside/pwned' ) )
+		assert.equal( existsSync( join( outside, 'pwned.php' ) ), false )
+
+		assert.throws( () => writeScaffold( join( project, 'views' ), 'foo\0.php', 'nope' ) )
+
+		assert.throws( () => writeScaffold( join( project, 'views' ), join( outside, 'pwned.php' ), 'nope' ) )
+		assert.equal( existsSync( join( outside, 'pwned.php' ) ), false )
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+} )

package/test/pot-docs.test.js

@@ -0,0 +1,27 @@
+/**
+ * TASK-030: pot creates a .pot; docs and CLI copy must not claim po/mo.
+ */
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { test } from 'node:test'
+
+test( 'pot command and docs describe a .pot, not po/mo files', () => {
+	const pot = readFileSync( new URL( '../src/commands/wp-pot.js', import.meta.url ), 'utf8' )
+	assert.match( pot, /make-pot/ )
+	assert.doesNotMatch( pot, /make-mo|make-json/ )
+	assert.doesNotMatch( pot, /PO and MO/ )
+
+	const app = readFileSync( new URL( '../src/app.js', import.meta.url ), 'utf8' )
+	const potCmd = app.split( ".command('pot')" )[1].split( '.command(' )[0]
+	assert.match( potCmd, /\.pot/ )
+	assert.doesNotMatch( potCmd, /\bpo\b|\bmo\b/i )
+
+	const readme = readFileSync( new URL( '../README.md', import.meta.url ), 'utf8' )
+	const potSection = readme.split( '#### `pot`' )[1].split( '####' )[0]
+	assert.match( potSection, /\.pot/ )
+	assert.doesNotMatch( potSection, /\.po\b|\.mo\b/ )
+
+	const changelog = readFileSync( new URL( '../CHANGELOG.md', import.meta.url ), 'utf8' )
+	assert.match( changelog, /`pot` command to generate `\.pot`/ )
+	assert.doesNotMatch( changelog, /`pot` command to generate `\.po` and `\.mo`/ )
+} )

package/test/pot-headers.test.js

@@ -0,0 +1,49 @@
+/**
+ * TASK-038: pot headers come from wp.advads author, not a hardcoded name.
+ * Run with --experimental-test-module-mocks
+ */
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { mock, test } from 'node:test'
+
+const potArgs = []
+
+mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
+	exports: {
+		execCommand() {},
+		runCommand( cmd, args, cb ) {
+			potArgs.push( { cmd, args } )
+			cb()
+		},
+	},
+} )
+
+const { default: wpPot } = await import( '../src/commands/wp-pot.js' )
+const { saveConfig } = await import( '../src/utilities/settings.js' )
+
+test( 'pot Last-Translator and Language-Team use author from config', async () => {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-pot-' ) )
+	const cwd = process.cwd()
+	process.chdir( dir )
+	potArgs.length = 0
+
+	try {
+		saveConfig( {
+			author: { name: 'Jane Doe', email: 'jane@example.com' },
+			wpPot: { output: '/languages/', file: 'plugin.pot', domain: 'plugin' },
+		} )
+
+		await new Promise( ( resolve ) => wpPot( resolve ) )
+
+		const headersArg = potArgs[0].args.find( ( arg ) => arg.startsWith( '--headers=' ) )
+		const headers = JSON.parse( headersArg.slice( '--headers='.length ) )
+		assert.equal( headers['Last-Translator'], 'Jane Doe <jane@example.com>' )
+		assert.equal( headers['Language-Team'], 'Jane Doe <jane@example.com>' )
+		assert.doesNotMatch( headersArg, /Shakeeb Ahmed/ )
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+} )

package/test/project-root.test.js

@@ -0,0 +1,26 @@
+/**
+ * TASK-015: a failed getProjectRoot walk must not cache the filesystem root.
+ */
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { getProjectRoot } from '../src/utilities/filesystem.js'
+
+test( 'failed getProjectRoot does not make a later lookup return the filesystem root', async () => {
+	const empty = await mkdtemp( join( tmpdir(), 'wp-advads-empty-' ) )
+	const project = await mkdtemp( join( tmpdir(), 'wp-advads-root-' ) )
+	await writeFile( join( project, 'wp.advads' ), '{}' )
+
+	try {
+		assert.throws(
+			() => getProjectRoot( empty ),
+			/Project root not found/
+		)
+		assert.equal( getProjectRoot( project ), project )
+	} finally {
+		await rm( empty, { recursive: true, force: true } )
+		await rm( project, { recursive: true, force: true } )
+	}
+} )

package/test/release-waterfall.test.js

@@ -0,0 +1,62 @@
+/**
+ * TASK-003: release changelog and version waterfalls must pass errors to next.
+ */
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { mock, test } from 'node:test'
+
+mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
+	exports: {
+		execCommand( cmd, cb ) {
+			cb( '', null, '' )
+		},
+		runCommand() {},
+	},
+} )
+
+const { pluginData } = await import( '../src/commands/release.js' )
+const { default: updateChangelog } = await import( '../src/commands/release/changelog.js' )
+const { default: updateVersionNumber } = await import( '../src/commands/release/change-version.js' )
+
+async function inTempDir( run ) {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-' ) )
+	const cwd = process.cwd()
+	process.chdir( dir )
+	try {
+		return await run()
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+}
+
+test( 'updateChangelog passes a missing .changelog directory to next', async () => {
+	await inTempDir( async () => {
+		pluginData.semver = { preRelease: true }
+		pluginData.glotpress = { destination: './languages/' }
+		pluginData.locales = {}
+
+		const err = await new Promise( ( resolve ) => {
+			updateChangelog( ( error ) => resolve( error ) )
+		} )
+
+		assert.ok( err, 'expected changelog failure to reach next' )
+	} )
+} )
+
+test( 'updateVersionNumber passes missing PHP files to next', async () => {
+	await inTempDir( async () => {
+		pluginData.semver = {
+			preRelease: true,
+			getNextVersionString: () => '1.2.3',
+		}
+
+		const err = await new Promise( ( resolve ) => {
+			updateVersionNumber( ( error ) => resolve( error ) )
+		} )
+
+		assert.ok( err, 'expected version-update failure to reach next' )
+	} )
+} )

package/test/semver.test.js

@@ -0,0 +1,25 @@
+/**
+ * TASK-009: SemVer parse, pre-count, and JS isset replacement.
+ */
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { SemVer } from '../src/commands/release/semver.js'
+
+test( 'same-line alpha pre-release increments the count past 2', () => {
+	const semver = new SemVer( '1.2.0-alpha.2', 'patch', 'alpha' )
+	assert.equal( semver.getNextVersionString(), '1.2.0-alpha.3' )
+} )
+
+test( 'same-line alpha.1 becomes alpha.2', () => {
+	const semver = new SemVer( '1.2.0-alpha.1', 'patch', 'alpha' )
+	assert.equal( semver.getNextVersionString(), '1.2.0-alpha.2' )
+} )
+
+test( 'invalid version throws instead of crashing on .groups', () => {
+	assert.throws( () => new SemVer( 'not-a-version', 'patch', false ), /failed/ )
+} )
+
+test( 'switching alpha to beta on the same numbers does not throw', () => {
+	const semver = new SemVer( '1.2.1-alpha.1', 'patch', 'beta' )
+	assert.equal( semver.getNextVersionString(), '1.2.1-beta.1' )
+} )

package/test/settings-clone.test.js

@@ -0,0 +1,34 @@
+/**
+ * TASK-018: scaffold commands must not mutate the cached getSetting() object.
+ * Run with --test-isolation=none
+ */
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { getSetting } from '../src/utilities/index.js'
+import views from '../src/commands/views.js'
+
+test( 'view command does not persist heading onto the cached settings', async () => {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-clone-' ) )
+	const cwd = process.cwd()
+	process.chdir( dir )
+
+	try {
+		await writeFile( join( dir, 'wp.advads' ), JSON.stringify( {
+			paths: { views: 'views' },
+			wp: { version: '1.0.0' },
+			misc: { package: 'AdvancedAds' },
+			author: { name: 'Test', email: 'test@example.com' },
+		} ) )
+
+		views( 'sidebar', 'Sidebar Heading' )
+
+		assert.equal( getSetting().heading, undefined )
+		assert.equal( getSetting().description, undefined )
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+} )

package/test/settings-path.test.js

@@ -0,0 +1,31 @@
+/**
+ * TASK-016: saveConfig and readConfigFile must use the same wp.advads path.
+ */
+import assert from 'node:assert/strict'
+import { existsSync } from 'node:fs'
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { saveConfig, readConfigFile } from '../src/utilities/settings.js'
+
+test( 'saveConfig from a subdirectory writes the discovered wp.advads', async () => {
+	const project = await mkdtemp( join( tmpdir(), 'wp-advads-cfg-' ) )
+	const sub = join( project, 'includes' )
+	await mkdir( sub )
+	await writeFile( join( project, 'wp.advads' ), JSON.stringify( { keep: true } ) )
+
+	const cwd = process.cwd()
+	process.chdir( sub )
+
+	try {
+		saveConfig( { keep: false } )
+		assert.equal( existsSync( join( sub, 'wp.advads' ) ), false )
+		const saved = JSON.parse( await readFile( join( project, 'wp.advads' ), 'utf8' ) )
+		assert.equal( saved.keep, false )
+		assert.equal( readConfigFile().keep, false )
+	} finally {
+		process.chdir( cwd )
+		await rm( project, { recursive: true, force: true } )
+	}
+} )