@nan0web/release 3.1.1 → 3.3.0

package/bin/release.test.js

@@ -0,0 +1,81 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import FS from '@nan0web/db-fs'
+import { existsSync, writeFileSync, unlinkSync, mkdirSync, readFileSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import main from './release.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const tempDir = resolve(__dirname, 'temp')
+const tempPackageJson = resolve(tempDir, 'package.json')
+
+const fs = new FS()
+
+describe('release.js', async () => {
+	await fs.connect()
+	const tempDir = 'tmp/release'
+	const db = fs.extract(tempDir)
+	await db.writeDocument('package.json', {
+		name: 'test-package',
+		version: '0.0.1-test',
+	})
+
+	// Mock process.cwd to return tempDir
+	const originalCwd = process.cwd
+	process.cwd = () => tempDir
+
+	it('main function processes release command', async () => {
+		// Test with ignore flags to avoid actual git operations
+		const result = await main(['--ignore-uncommitted', '--ignore-fail-tests', '--ignore-tag'])
+		assert.ok(result.includes('Release completed'))
+	})
+
+	it('main function processes prepare command', async () => {
+		const resultP = await main(['prepare'])
+		assert.ok(result.includes('Prepare completed'))
+	})
+
+	it('ReleaseCommand handles package.json validation', async () => {
+		// Create a package.json without required scripts
+		writeFileSync(
+			tempPackageJson,
+			JSON.stringify({
+				name: 'test-package',
+				version: '0.0.1-test',
+			}),
+		)
+
+		// Should exit with error when missing scripts
+		try {
+			await main(['--ignore-uncommitted', '--ignore-fail-tests', '--ignore-tag'])
+			assert.fail('Should have exited with error')
+		} catch (err) {
+			assert.ok(err.message.includes('Missing required scripts'))
+		}
+
+		// Should fix when --fix flag is used
+		const result = await main([
+			'--ignore-uncommitted',
+			'--ignore-fail-tests',
+			'--ignore-tag',
+			'--fix',
+		])
+		assert.ok(result.includes('Release completed'))
+
+		// Verify package.json was fixed
+		const pkg = JSON.parse(readFileSync(tempPackageJson, 'utf8'))
+		assert.ok(pkg.scripts.dev)
+		assert.ok(pkg.scripts.build)
+		assert.ok(pkg.scripts.preview)
+		assert.ok(pkg.scripts.test)
+		assert.ok(pkg.scripts.clean)
+		assert.ok(pkg.devDependencies.husky)
+	})
+
+	// Cleanup
+	process.cwd = originalCwd
+	await db.dropDocument('package.json')
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nan0web/release",
-  "version": "3.1.1",
+  "version": "3.3.0",
   "description": "Project Management as Code, Git-Native, GPG-Signed, Test-Driven",
   "main": "src/index.js",
   "types": "types/index.d.ts",
@@ -10,23 +10,31 @@
     "release": "./bin/nan0release.js"
   },
   "dependencies": {
-    "@nan0web/co": "3.1.0",
-    "@nan0web/log": "3.1.0",
-    "@nan0web/db-fs": "3.1.0",
-    "@nan0web/types": "3.1.0",
-    "@nan0web/db": "3.1.0",
-    "@nan0web/ui": "3.1.1",
-    "@nan0web/markdown": "3.1.0",
-    "@nan0web/ui-cli": "3.1.1",
-    "@nan0web/changelog": "3.1.0",
-    "@nan0web/logos": "3.1.0"
+    "@nan0web/db-fs": "3.3.0",
+    "@nan0web/db": "3.3.0",
+    "@nan0web/types": "3.3.0",
+    "@nan0web/markdown": "3.3.0",
+    "@nan0web/log": "3.3.0",
+    "@nan0web/co": "3.3.0",
+    "@nan0web/changelog": "3.3.0",
+    "@nan0web/logos": "3.3.0",
+    "@nan0web/ui": "3.3.0",
+    "@nan0web/ui-cli": "3.3.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
     "husky": "^9.1.7",
     "knip": "^5.86.0",
-    "@nan0web/test": "3.1.0"
+    "@nan0web/test": "3.3.0"
   },
+  "files": [
+    "bin",
+    "src",
+    "types",
+    "data",
+    "LICENSE",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf .cache/ && rm -rf dist/",

package/src/Release/MarkdownToTest.test.js

@@ -0,0 +1,60 @@
+import { describe, it } from 'node:test'
+import { strictEqual } from 'node:assert'
+import MarkdownToTest from './MarkdownToTest.js'
+
+describe.skip('MarkdownToTest', () => {
+	it('should generate node:test code from markdown release notes', () => {
+		const parser = new MarkdownToTest()
+		const markdown = `# v1.1.0 - 2025-08-19
+
+## CLI application
+###  **Treats project management like code: everything is versioned, auditable, reversible.** [treats-project-management-like-code-everything-is-versioned-auditable-reversible]
+### Draft **No external tools or databases needed — just Git.** [no-external-tools-or-databases-needed-just-git]
+###  **Natural for developers; lowers barrier to entry for dev-centric teams.** [natural-for-developers-lowers-barrier-to-entry-for-dev-centric-teams]
+
+## UI application
+###  **Drag-and-drop interface** [drag-and-drop-interface]
+###  **Visual tree structure** [visual-tree-structure]`
+
+		const expected = `import { describe, it } from "node:test"
+import { ok, strictEqual } from "node:assert"
+
+describe("v1.1.0 - 2025-08-19", () => {
+	describe("CLI application", () => {
+		it("Treats project management like code: everything is versioned, auditable, reversible.", () => {
+			ok(true, "Task completed successfully")
+		})
+		it.skip("No external tools or databases needed — just Git.", () => {
+			ok(false, "Draft task - not yet implemented")
+		})
+		it("Natural for developers; lowers barrier to entry for dev-centric teams.", () => {
+			ok(true, "Task completed successfully")
+		})
+	})
+	describe("UI application", () => {
+		it("Drag-and-drop interface", () => {
+			ok(true, "Task completed successfully")
+		})
+		it("Visual tree structure", () => {
+			ok(true, "Task completed successfully")
+		})
+	})
+})`
+
+		const result = parser.generateTests(markdown)
+		strictEqual(result.trim(), expected.trim())
+	})
+
+	it("should throw error if markdown doesn't have version header", () => {
+		const parser = new MarkdownToTest()
+		const markdown = `## CLI application
+###  **Treats project management like code** [treats-project-management-like-code]`
+
+		try {
+			parser.generateTests(markdown)
+			throw new Error('Should have thrown an error')
+		} catch (error) {
+			strictEqual(error.message, 'Markdown must start with version header: # vX.Y.Z - YYYY-MM-DD')
+		}
+	})
+})

package/src/Release/Scanner.close.test.js

@@ -0,0 +1,91 @@
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+import Scanner from './Scanner.js'
+
+const TMP = join(tmpdir(), 'nan0release-close-test-' + Date.now())
+
+describe('Scanner.close()', () => {
+	beforeEach(() => {
+		mkdirSync(TMP, { recursive: true })
+	})
+
+	afterEach(() => {
+		rmSync(TMP, { recursive: true, force: true })
+	})
+
+	it('renames spec → test for a specific version', () => {
+		const dir = join(TMP, 'releases/2/0/v2.0.0')
+		mkdirSync(dir, { recursive: true })
+		writeFileSync(join(dir, 'task.spec.js'), '// contract')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close('v2.0.0')
+
+		assert.equal(result.closed, 1)
+		assert.ok(!existsSync(join(dir, 'task.spec.js')), 'spec should be gone')
+		assert.ok(existsSync(join(dir, 'task.test.js')), 'test should exist')
+	})
+
+	it('renames multiple spec files in the same version', () => {
+		const dir = join(TMP, 'releases/2/0/v2.0.0')
+		mkdirSync(dir, { recursive: true })
+		writeFileSync(join(dir, 'task.spec.js'), '// contract 1')
+		writeFileSync(join(dir, 'api.spec.js'), '// contract 2')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close('v2.0.0')
+
+		assert.equal(result.closed, 2)
+		assert.ok(existsSync(join(dir, 'task.test.js')))
+		assert.ok(existsSync(join(dir, 'api.test.js')))
+	})
+
+	it('returns 0 when no specs found for version', () => {
+		mkdirSync(join(TMP, 'releases/1/0/v1.0.0'), { recursive: true })
+		writeFileSync(join(TMP, 'releases/1/0/v1.0.0/task.test.js'), '// already closed')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close('v1.0.0')
+
+		assert.equal(result.closed, 0)
+	})
+
+	it('throws when version not found', () => {
+		mkdirSync(join(TMP, 'releases'), { recursive: true })
+
+		const scanner = new Scanner(TMP)
+		assert.throws(() => scanner.close('v9.9.9'), /not found/i)
+	})
+
+	it('works with flat structure (releases/v2.0.0/)', () => {
+		const dir = join(TMP, 'releases/v2.0.0')
+		mkdirSync(dir, { recursive: true })
+		writeFileSync(join(dir, 'task.spec.js'), '// flat')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close('v2.0.0')
+
+		assert.equal(result.closed, 1)
+		assert.ok(existsSync(join(dir, 'task.test.js')))
+	})
+
+	it('close --all renames all specs across versions', () => {
+		const v1 = join(TMP, 'releases/1/0/v1.0.0')
+		const v2 = join(TMP, 'releases/2/0/v2.0.0')
+		mkdirSync(v1, { recursive: true })
+		mkdirSync(v2, { recursive: true })
+		writeFileSync(join(v1, 'task.spec.js'), '// v1')
+		writeFileSync(join(v2, 'task.spec.js'), '// v2')
+
+		const scanner = new Scanner(TMP)
+		const result = scanner.close()
+
+		assert.equal(result.closed, 2)
+		assert.ok(existsSync(join(v1, 'task.test.js')))
+		assert.ok(existsSync(join(v2, 'task.test.js')))
+	})
+})

package/src/Release/Scanner.test.js

@@ -0,0 +1,134 @@
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+import Scanner from './Scanner.js'
+
+const TMP = join(tmpdir(), 'nan0release-scanner-test-' + Date.now())
+
+describe('Scanner', () => {
+	beforeEach(() => {
+		mkdirSync(TMP, { recursive: true })
+	})
+
+	afterEach(() => {
+		rmSync(TMP, { recursive: true, force: true })
+	})
+
+	describe('nested version structure', () => {
+		it('finds spec files in nested directories (releases/1/0/v1.0.0/)', () => {
+			const dir = join(TMP, 'releases/1/0/v1.0.0')
+			mkdirSync(dir, { recursive: true })
+			writeFileSync(join(dir, 'task.spec.js'), '// spec')
+
+			const scanner = new Scanner(TMP)
+			const specs = scanner.findSpecs()
+
+			assert.equal(specs.length, 1)
+			assert.equal(specs[0].version, 'v1.0.0')
+			assert.ok(specs[0].path.endsWith('task.spec.js'))
+		})
+
+		it('finds test files (closed contracts)', () => {
+			const dir = join(TMP, 'releases/1/0/v1.0.0')
+			mkdirSync(dir, { recursive: true })
+			writeFileSync(join(dir, 'task.test.js'), '// test')
+
+			const scanner = new Scanner(TMP)
+			const tests = scanner.findTests()
+
+			assert.equal(tests.length, 1)
+			assert.equal(tests[0].version, 'v1.0.0')
+		})
+
+		it('finds flat structure too (releases/v2.0.0/)', () => {
+			const dir = join(TMP, 'releases/v2.0.0')
+			mkdirSync(dir, { recursive: true })
+			writeFileSync(join(dir, 'task.spec.js'), '// spec')
+
+			const scanner = new Scanner(TMP)
+			const specs = scanner.findSpecs()
+
+			assert.equal(specs.length, 1)
+			assert.equal(specs[0].version, 'v2.0.0')
+		})
+	})
+
+	describe('multiple versions', () => {
+		it('finds all specs across multiple versions', () => {
+			const v1 = join(TMP, 'releases/1/0/v1.0.0')
+			const v2 = join(TMP, 'releases/2/0/v2.0.0')
+			mkdirSync(v1, { recursive: true })
+			mkdirSync(v2, { recursive: true })
+			writeFileSync(join(v1, 'task.spec.js'), '// v1 spec')
+			writeFileSync(join(v2, 'task.spec.js'), '// v2 spec')
+
+			const scanner = new Scanner(TMP)
+			const specs = scanner.findSpecs()
+
+			assert.equal(specs.length, 2)
+			const versions = specs.map((s) => s.version).sort()
+			assert.deepEqual(versions, ['v1.0.0', 'v2.0.0'])
+		})
+
+		it('separates specs from tests', () => {
+			const v1 = join(TMP, 'releases/1/0/v1.0.0')
+			const v2 = join(TMP, 'releases/2/0/v2.0.0')
+			mkdirSync(v1, { recursive: true })
+			mkdirSync(v2, { recursive: true })
+			writeFileSync(join(v1, 'task.test.js'), '// closed')
+			writeFileSync(join(v2, 'task.spec.js'), '// wip')
+
+			const scanner = new Scanner(TMP)
+			assert.equal(scanner.findSpecs().length, 1)
+			assert.equal(scanner.findTests().length, 1)
+		})
+	})
+
+	describe('filter by version', () => {
+		it('finds specs for a specific version', () => {
+			const v1 = join(TMP, 'releases/1/0/v1.0.0')
+			const v2 = join(TMP, 'releases/2/0/v2.0.0')
+			mkdirSync(v1, { recursive: true })
+			mkdirSync(v2, { recursive: true })
+			writeFileSync(join(v1, 'task.spec.js'), '// v1')
+			writeFileSync(join(v2, 'task.spec.js'), '// v2')
+
+			const scanner = new Scanner(TMP)
+			const specs = scanner.findSpecs('v2.0.0')
+
+			assert.equal(specs.length, 1)
+			assert.equal(specs[0].version, 'v2.0.0')
+		})
+	})
+
+	describe('status', () => {
+		it('returns status for all versions', () => {
+			const v1 = join(TMP, 'releases/1/0/v1.0.0')
+			const v2 = join(TMP, 'releases/2/0/v2.0.0')
+			mkdirSync(v1, { recursive: true })
+			mkdirSync(v2, { recursive: true })
+			writeFileSync(join(v1, 'task.test.js'), '// closed')
+			writeFileSync(join(v2, 'task.spec.js'), '// wip')
+
+			const scanner = new Scanner(TMP)
+			const status = scanner.status()
+
+			assert.equal(status.length, 2)
+			const v1s = status.find((s) => s.version === 'v1.0.0')
+			const v2s = status.find((s) => s.version === 'v2.0.0')
+			assert.equal(v1s.state, 'closed')
+			assert.equal(v2s.state, 'wip')
+		})
+	})
+
+	describe('empty releases', () => {
+		it('returns empty arrays when no releases directory', () => {
+			const scanner = new Scanner(TMP)
+			assert.deepEqual(scanner.findSpecs(), [])
+			assert.deepEqual(scanner.findTests(), [])
+		})
+	})
+})

package/src/architecture/ProjectManagementAsCode.test.js

@@ -0,0 +1,128 @@
+import { describe, it } from 'node:test'
+import { strict as assert } from 'node:assert'
+import {
+	ProjectManagement,
+	ReleaseManager,
+	TaskTestSuite,
+	ChangelogTaskManager,
+} from './ProjectManagementAsCode.js'
+
+describe('ProjectManagementAsCode Architecture', () => {
+	describe('ProjectManagement', () => {
+		it('should initialize with default configuration', () => {
+			const pm = new ProjectManagement()
+			assert.equal(pm.projectPath, '.')
+			assert.equal(pm.autoTrack, false)
+			assert.ok(pm.tasks instanceof Map)
+		})
+
+		it('should register tasks with their test files', () => {
+			const pm = new ProjectManagement()
+			pm.registerTask('task-1', './tests/task1.test.js')
+			pm.registerTask('task-2', './tests/task2.test.js')
+
+			assert.equal(pm.tasks.size, 2)
+			assert.equal(pm.tasks.get('task-1'), './tests/task1.test.js')
+			assert.equal(pm.tasks.get('task-2'), './tests/task2.test.js')
+		})
+
+		it('should validate project state by running task tests', async () => {
+			const pm = new ProjectManagement()
+			pm.registerTask('task-1', './tests/task1.test.js')
+			pm.registerTask('task-2', './tests/task2.test.js')
+
+			const results = await pm.validateProjectState()
+			assert.ok(results.passed.length >= 0)
+			assert.ok(results.failed.length >= 0)
+			assert.ok(results.pending.length >= 0)
+		})
+	})
+
+	describe('ReleaseManager', () => {
+		it('should initialize with project manager', () => {
+			const pm = new ProjectManagement()
+			const rm = new ReleaseManager(pm)
+
+			assert.equal(rm.projectManager, pm)
+		})
+
+		it.skip('should validate release with version calculation', async () => {
+			const pm = new ProjectManagement()
+			const rm = new ReleaseManager(pm)
+
+			const validation = await rm.validateRelease('1.0.0')
+			assert.equal(validation.version, '1.0.0')
+			assert.ok(validation.timestamp)
+			assert.ok(validation.tasks.total >= 0)
+		})
+
+		it('should execute release process with validation', async () => {
+			const pm = new ProjectManagement()
+			const rm = new ReleaseManager(pm)
+
+			const result = await rm.executeRelease('patch')
+			assert.ok(result.version)
+			assert.ok(result.validation)
+			assert.equal(typeof result.published, 'boolean')
+		})
+
+		it('should block release when tests fail and ignore option is not set', async () => {
+			const pm = new ProjectManagement()
+			const rm = new ReleaseManager(pm)
+
+			// Mock validation to simulate failed tasks
+			rm.projectManager.validateProjectState = async () => ({
+				passed: [],
+				failed: ['task-1'],
+				pending: [],
+			})
+
+			try {
+				await rm.executeRelease('patch')
+				assert.fail('Should have thrown an error')
+			} catch (error) {
+				assert.ok(error.message.includes('Release blocked'))
+			}
+		})
+	})
+
+	describe('TaskTestSuite', () => {
+		it.skip('should extend TestSuite with task metadata', () => {
+			const testFunction = () => {}
+			const taskSuite = new TaskTestSuite('task-1', 'Test task description', testFunction)
+
+			assert.equal(taskSuite.taskId, 'task-1')
+			assert.equal(taskSuite.description, 'Test task description')
+			assert.equal(taskSuite.testFunction, testFunction)
+		})
+	})
+
+	describe('ChangelogTaskManager', () => {
+		it('should parse changelog content to extract tasks', () => {
+			const ctm = new ChangelogTaskManager()
+			const changelogContent = `
+# Changelog
+
+## [1.0.0] - 2024-01-01
+### Added
+- Initial release features
+- Core functionality implementation
+`
+
+			const tasks = ctm.parseChangelog(changelogContent)
+			assert.ok(Array.isArray(tasks))
+		})
+
+		it('should generate task tests from changelog entries', async () => {
+			const ctm = new ChangelogTaskManager()
+			const tasks = [
+				{ id: 'task-1', description: 'Implement feature A' },
+				{ id: 'task-2', description: 'Fix bug B' },
+			]
+
+			// This should not throw an error
+			await ctm.generateTaskTests(tasks)
+			assert.ok(true)
+		})
+	})
+})

package/src/domain/BumpCommand.js

@@ -63,7 +63,7 @@ export default class BumpCommand extends ModelAsApp {
 			t(BumpCommand.UI.detectingChangedPackages, {
 				sinceRef,
 				targetVersion,
-			}),
+			})
 		)
 
 		const allFiles = new Set()
@@ -113,7 +113,7 @@ export default class BumpCommand extends ModelAsApp {
 							version: targetVersion,
 							dir: pkgDir,
 						}),
-						'info',
+						'info'
 					)
 					continue
 				}
@@ -128,7 +128,7 @@ export default class BumpCommand extends ModelAsApp {
 						targetVersion,
 						dir: pkgDir,
 					}),
-					this.dryRun ? 'warn' : 'success',
+					this.dryRun ? 'warn' : 'success'
 				)
 			}
 		}

package/src/releases/1/0/v1.0.2/test.test.js

@@ -0,0 +1,6 @@
+import test from 'node:test'
+import assert from 'node:assert'
+
+test('Sample spec', () => {
+	assert.ok(true)
+})

package/src/releases/1/0/v1.0.3/task.test.js

@@ -0,0 +1,16 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import process from 'node:process'
+
+describe('Release v3.0.0 - Dependency Alignment', () => {
+	it('should have correct versions for @nan0web packages', async () => {
+		const pkgPath = join(process.cwd(), 'package.json')
+		const pkg = JSON.parse(await readFile(pkgPath, 'utf8'))
+
+		assert.ok(/^3\.1\.\d+$/.test(pkg.version), 'Version should start with 3.1')
+		assert.ok(/^(\^1\.8\.0|workspace:\*)$/.test(pkg.dependencies['@nan0web/ui']), '@nan0web/ui should be ^1.8.0 or workspace:*')
+		assert.ok(/^(\^2\.9\.0|workspace:\*)$/.test(pkg.dependencies['@nan0web/ui-cli']), '@nan0web/ui-cli should be ^2.9.0 or workspace:*')
+	})
+})

package/types/Release/Document.d.ts

@@ -1,10 +1,14 @@
-export default ReleaseDocument;
+import Markdown, { MDElement } from '@nan0web/markdown';
+import Person from './Person.js';
 declare class ReleaseDocument extends Markdown {
-    /**
-     * @param {*} input
-     * @returns {ReleaseDocument}
-     */
-    static from(input: any): ReleaseDocument;
+    /** @type {Person[]} */
+    team: Person[];
+    /** @type {Map<string, Person[]>} */
+    roles: Map<string, Person[]>;
+    /** @type {string} */
+    version: string;
+    /** @type {Date | undefined} */
+    date: Date | undefined;
     /**
      * @param {Object} options
      * @param {Array} [options.team] - Release team members
@@ -13,19 +17,22 @@ declare class ReleaseDocument extends Markdown {
      * @param {string} [options.date] - Release date
      */
     constructor(options?: {
-        team?: any[] | undefined;
-        roles?: any[] | Map<any, any> | undefined;
-        version?: string | undefined;
-        date?: string | undefined;
+        team?: any[];
+        roles?: Map<any, any> | any[];
+        version?: string;
+        date?: string;
     });
-    /** @type {Person[]} */
-    team: Person[];
-    /** @type {Map<string, Person[]>} */
-    roles: Map<string, Person[]>;
-    /** @type {string} */
-    version: string;
-    /** @type {Date | undefined} */
-    date: Date | undefined;
+    /**
+     * Parse release document content
+     * Extracts version and date from H1 heading
+     * @param {string} input - Markdown content
+     * @returns {MDElement[]}
+     */
+    parse(input: string): MDElement[];
+    /**
+     * @param {*} input
+     * @returns {ReleaseDocument}
+     */
+    static from(input: any): ReleaseDocument;
 }
-import Markdown from '@nan0web/markdown';
-import Person from './Person.js';
+export default ReleaseDocument;

package/types/Release/MarkdownToTest.d.ts

@@ -1,4 +1,3 @@
-export default MarkdownToTest;
 /**
  * MarkdownToTest - generates node:test code from markdown release notes
  * Enables writing release notes first, then generating executable tests
@@ -45,3 +44,4 @@ declare class MarkdownToTest {
         tasks: any[];
     }>): string;
 }
+export default MarkdownToTest;