create-react-admin-template 0.0.0-stage → 0.1.0

package/template/tests/unit/config/scaffoldInit.test.mjs

@@ -0,0 +1,218 @@
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import {
+  copyFile,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  writeFile,
+} from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import { fileURLToPath } from 'node:url'
+import { fnInitializeScaffold } from '../../../tools/scaffold/init.mjs'
+
+const strProjectRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../../..'
+)
+const strInitializationScript = path.resolve(
+  strProjectRoot,
+  'tools/scaffold/init.mjs'
+)
+const strExampleConfigPath = path.resolve(
+  strProjectRoot,
+  'tools/scaffold/init.example.json'
+)
+
+const fnReadJson = async (strFilePath) =>
+  JSON.parse(await readFile(strFilePath, 'utf8'))
+
+const fnCreateProjectFixture = async (objTestContext) => {
+  const strFixtureRoot = await mkdtemp(
+    path.join(os.tmpdir(), 'react-admin-scaffold-init-')
+  )
+  objTestContext.after(() =>
+    rm(strFixtureRoot, { force: true, recursive: true })
+  )
+  await mkdir(path.resolve(strFixtureRoot, 'public'), { recursive: true })
+  await mkdir(path.resolve(strFixtureRoot, 'src/api/config'), {
+    recursive: true,
+  })
+  await Promise.all([
+    copyFile(
+      path.resolve(strProjectRoot, 'package.json'),
+      path.resolve(strFixtureRoot, 'package.json')
+    ),
+    copyFile(
+      path.resolve(strProjectRoot, 'public/runtime-config.json'),
+      path.resolve(strFixtureRoot, 'public/runtime-config.json')
+    ),
+    copyFile(
+      path.resolve(strProjectRoot, 'src/api/config/services.json'),
+      path.resolve(strFixtureRoot, 'src/api/config/services.json')
+    ),
+  ])
+  return strFixtureRoot
+}
+
+test('scaffold initializer previews all target changes without writing', async (objTestContext) => {
+  const strFixtureRoot = await fnCreateProjectFixture(objTestContext)
+  const arrTargetPaths = [
+    'package.json',
+    'public/runtime-config.json',
+    'src/api/config/services.json',
+  ]
+  const arrBefore = await Promise.all(
+    arrTargetPaths.map((strTargetPath) =>
+      readFile(path.resolve(strFixtureRoot, strTargetPath), 'utf8')
+    )
+  )
+
+  const objResult = await fnInitializeScaffold({
+    strConfigPath: strExampleConfigPath,
+    strProjectRoot: strFixtureRoot,
+  })
+
+  assert.equal(objResult.bWrite, false)
+  assert.deepEqual(
+    objResult.arrTargets.map((objTarget) => objTarget.bChanged),
+    [true, true, true]
+  )
+  assert.deepEqual(
+    await Promise.all(
+      arrTargetPaths.map((strTargetPath) =>
+        readFile(path.resolve(strFixtureRoot, strTargetPath), 'utf8')
+      )
+    ),
+    arrBefore
+  )
+})
+
+test('scaffold initializer writes only owned contracts and is idempotent', async (objTestContext) => {
+  const strFixtureRoot = await fnCreateProjectFixture(objTestContext)
+  const objConfig = await fnReadJson(strExampleConfigPath)
+
+  const objFirstResult = await fnInitializeScaffold({
+    bWrite: true,
+    strConfigPath: strExampleConfigPath,
+    strProjectRoot: strFixtureRoot,
+  })
+  const objPackage = await fnReadJson(
+    path.resolve(strFixtureRoot, 'package.json')
+  )
+
+  assert.equal(
+    objFirstResult.arrTargets.every((objTarget) => objTarget.bChanged),
+    true
+  )
+  assert.equal(objPackage.name, objConfig.package.name)
+  assert.equal(objPackage.description, objConfig.package.description)
+  assert.equal(objPackage.version, objConfig.package.version)
+  assert.equal(objPackage.scripts.dev, 'vite')
+  assert.deepEqual(
+    await fnReadJson(
+      path.resolve(strFixtureRoot, 'public/runtime-config.json')
+    ),
+    objConfig.runtimeConfig
+  )
+  assert.deepEqual(
+    await fnReadJson(
+      path.resolve(strFixtureRoot, 'src/api/config/services.json')
+    ),
+    objConfig.apiServices
+  )
+
+  const objSecondResult = await fnInitializeScaffold({
+    bWrite: true,
+    strConfigPath: strExampleConfigPath,
+    strProjectRoot: strFixtureRoot,
+  })
+
+  assert.equal(
+    objSecondResult.arrTargets.every((objTarget) => !objTarget.bChanged),
+    true
+  )
+})
+
+test('scaffold initializer rejects undeclared runtime fields before writing', async (objTestContext) => {
+  const strFixtureRoot = await fnCreateProjectFixture(objTestContext)
+  const strInvalidConfigPath = path.resolve(strFixtureRoot, 'invalid.json')
+  const objInvalidConfig = await fnReadJson(strExampleConfigPath)
+  objInvalidConfig.runtimeConfig.auth.strClientSecret = 'must-not-be-here'
+  await writeFile(
+    strInvalidConfigPath,
+    `${JSON.stringify(objInvalidConfig, null, 2)}\n`
+  )
+  const strRuntimeConfigPath = path.resolve(
+    strFixtureRoot,
+    'public/runtime-config.json'
+  )
+  const strBefore = await readFile(strRuntimeConfigPath, 'utf8')
+
+  await assert.rejects(
+    fnInitializeScaffold({
+      bWrite: true,
+      strConfigPath: strInvalidConfigPath,
+      strProjectRoot: strFixtureRoot,
+    }),
+    (objError) => {
+      assert.equal(objError.strCode, 'SCAFFOLD_INIT_CONFIG_INVALID')
+      assert.match(objError.message, /strClientSecret/)
+      return true
+    }
+  )
+  assert.equal(await readFile(strRuntimeConfigPath, 'utf8'), strBefore)
+})
+
+test('scaffold initializer keeps the existing project version for an older manifest', async (objTestContext) => {
+  const strFixtureRoot = await fnCreateProjectFixture(objTestContext)
+  const strConfigPath = path.resolve(strFixtureRoot, 'compatible.json')
+  const objConfig = await fnReadJson(strExampleConfigPath)
+  delete objConfig.package.version
+  await writeFile(strConfigPath, `${JSON.stringify(objConfig, null, 2)}\n`)
+  const objPackageBefore = await fnReadJson(
+    path.resolve(strFixtureRoot, 'package.json')
+  )
+
+  await fnInitializeScaffold({
+    bWrite: true,
+    strConfigPath,
+    strProjectRoot: strFixtureRoot,
+  })
+
+  const objPackageAfter = await fnReadJson(
+    path.resolve(strFixtureRoot, 'package.json')
+  )
+  assert.equal(objPackageAfter.version, objPackageBefore.version)
+})
+
+test('scaffold initializer CLI exposes stable usage and argument diagnostics', async () => {
+  const objPackage = await fnReadJson(
+    path.resolve(strProjectRoot, 'package.json')
+  )
+  const objHelpResult = spawnSync(
+    process.execPath,
+    [strInitializationScript, '--help'],
+    {
+      cwd: strProjectRoot,
+      encoding: 'utf8',
+    }
+  )
+  const objInvalidResult = spawnSync(
+    process.execPath,
+    [strInitializationScript, '--force'],
+    { cwd: strProjectRoot, encoding: 'utf8' }
+  )
+
+  assert.equal(
+    objPackage.scripts['scaffold:init'],
+    'node tools/scaffold/init.mjs'
+  )
+  assert.equal(objHelpResult.status, 0)
+  assert.match(objHelpResult.stdout, /默认只预览/)
+  assert.equal(objInvalidResult.status, 1)
+  assert.match(objInvalidResult.stderr, /SCAFFOLD_INIT_ARGUMENT_INVALID/)
+})

package/template/tests/unit/config/scaffoldProject.test.mjs

@@ -0,0 +1,378 @@
+import assert from 'node:assert/strict'
+import {
+  access,
+  cp,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  writeFile,
+} from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import { fnAddScaffoldCapability } from '../../../tools/scaffold/add-capability.mjs'
+import { fnCreateScaffoldProject } from '../../../tools/scaffold/create-project.mjs'
+
+const strProjectRoot = path.resolve(import.meta.dirname, '../../..')
+
+const fnPathExists = async (strFilePath) =>
+  access(strFilePath)
+    .then(() => true)
+    .catch(() => false)
+
+const fnReadJson = async (strFilePath) =>
+  JSON.parse(await readFile(strFilePath, 'utf8'))
+
+test('core profile removes optional source while preserving installable capabilities', async (objTestContext) => {
+  const strTemporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), 'react-admin-core-project-')
+  )
+  objTestContext.after(() => rm(strTemporaryRoot, { recursive: true }))
+  const strTargetRoot = path.join(strTemporaryRoot, 'project')
+
+  const objResult = await fnCreateScaffoldProject({
+    bInstall: false,
+    strTargetRoot,
+    strTemplateRoot: strProjectRoot,
+  })
+
+  assert.equal(objResult.strProfile, 'core')
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/components/AppTable')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(
+      path.join(strTargetRoot, 'src/components/SensitiveData')
+    ),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/dataMasking')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/components/FilePreview')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(
+      path.join(strTargetRoot, 'src/config/advancedTableLicense.ts')
+    ),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/auditLogs')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/api/activity')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/authentication')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/featureFlags')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/reporting')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/optionalEditors')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/realtimeCollaboration')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/tenantWorkspace')),
+    false
+  )
+  assert.equal(
+    await fnPathExists(
+      path.join(strTargetRoot, 'src/features/featureTemplate')
+    ),
+    false
+  )
+  assert.equal(
+    await fnPathExists(
+      path.join(strTargetRoot, 'tools/scaffold/templates/feature/index.ts')
+    ),
+    true
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/components/AppPageForm')),
+    true
+  )
+
+  const [objPackage, objManifest, objState, strCoreLockfile] =
+    await Promise.all([
+      fnReadJson(path.join(strTargetRoot, 'package.json')),
+      fnReadJson(
+        path.join(strTargetRoot, 'tools/component-governance/manifest.json')
+      ),
+      fnReadJson(path.join(strTargetRoot, '.scaffold-state.json')),
+      readFile(path.join(strTargetRoot, 'pnpm-lock.yaml'), 'utf8'),
+    ])
+  assert.equal(objPackage.dependencies.handsontable, undefined)
+  assert.equal(objPackage.dependencies['@uiw/react-codemirror'], undefined)
+  assert.equal(objPackage.pnpm.allowedDeprecatedVersions, undefined)
+  assert.equal(
+    objPackage.pnpm.overrides['brace-expansion@>=2.0.0 <2.1.4'],
+    undefined
+  )
+  assert.equal(objPackage.pnpm.overrides['exceljs>uuid'], undefined)
+  assert.equal(objPackage.scripts['scaffold:create'], undefined)
+  assert.equal(await fnPathExists(path.join(strTargetRoot, 'packages')), false)
+  assert.deepEqual(
+    objManifest.components.map(({ name }) => name),
+    ['AppPageForm']
+  )
+  assert.deepEqual(objManifest.thirdParty, [])
+  assert.deepEqual(objState.arrActiveCapabilities, [])
+  assert.equal(objState.strTemplateId, 'enterprise-react-admin')
+  assert.equal(objState.strTemplateVersion, '0.1.0')
+  assert.doesNotMatch(strCoreLockfile, /^ {6}handsontable:$/m)
+  assert.doesNotMatch(strCoreLockfile, /^ {2}exceljs>uuid:/m)
+  assert.doesNotMatch(
+    strCoreLockfile,
+    /^ {2}brace-expansion@>=2\.0\.0 <2\.1\.4:/m
+  )
+  assert.match(strCoreLockfile, /^ {6}prettier:$/m)
+
+  await fnAddScaffoldCapability({
+    bInstall: false,
+    strCapability: 'advancedTable',
+    strTargetRoot,
+    strTemplateRoot: strProjectRoot,
+  })
+
+  const [objAddedPackage, objAddedManifest, objAddedState, strAddedLockfile] =
+    await Promise.all([
+      fnReadJson(path.join(strTargetRoot, 'package.json')),
+      fnReadJson(
+        path.join(strTargetRoot, 'tools/component-governance/manifest.json')
+      ),
+      fnReadJson(path.join(strTargetRoot, '.scaffold-state.json')),
+      readFile(path.join(strTargetRoot, 'pnpm-lock.yaml'), 'utf8'),
+    ])
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/components/AppTable')),
+    true
+  )
+  assert.equal(
+    await fnPathExists(
+      path.join(strTargetRoot, 'src/components/SensitiveData')
+    ),
+    true
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/dataMasking')),
+    true
+  )
+  assert.equal(
+    await fnPathExists(
+      path.join(strTargetRoot, 'src/components/AppTable/config/license.ts')
+    ),
+    true
+  )
+  assert.equal(objAddedPackage.dependencies.handsontable, '^18.0.0')
+  assert.equal(objAddedPackage.pnpm.allowedDeprecatedVersions.fstream, '1.0.12')
+  assert.equal(objAddedPackage.pnpm.overrides['exceljs>uuid'], '11.1.1')
+  assert.ok(objAddedManifest.components.some(({ name }) => name === 'AppTable'))
+  assert.deepEqual(objAddedState.arrActiveCapabilities, ['advancedTable'])
+  assert.match(strAddedLockfile, /^ {6}handsontable:$/m)
+  assert.match(strAddedLockfile, /^ {2}exceljs>uuid: 11\.1\.1$/m)
+  await assert.rejects(
+    fnAddScaffoldCapability({
+      bInstall: false,
+      strCapability: 'advancedTable',
+      strTargetRoot,
+      strTemplateRoot: strProjectRoot,
+    }),
+    /已经启用/
+  )
+
+  await fnAddScaffoldCapability({
+    bInstall: false,
+    strCapability: 'advancedAuthentication',
+    strTargetRoot,
+    strTemplateRoot: strProjectRoot,
+  })
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/authentication')),
+    true
+  )
+  assert.deepEqual(
+    (await fnReadJson(path.join(strTargetRoot, '.scaffold-state.json')))
+      .arrActiveCapabilities,
+    ['advancedAuthentication', 'advancedTable']
+  )
+
+  await fnAddScaffoldCapability({
+    bInstall: false,
+    strCapability: 'filePreview',
+    strTargetRoot,
+    strTemplateRoot: strProjectRoot,
+  })
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/components/FilePreview')),
+    true
+  )
+
+  await fnAddScaffoldCapability({
+    bInstall: false,
+    strCapability: 'tenantWorkspace',
+    strTargetRoot,
+    strTemplateRoot: strProjectRoot,
+  })
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/tenantWorkspace')),
+    true
+  )
+  assert.equal(
+    await fnPathExists(
+      path.join(strTargetRoot, 'src/features/featureTemplate')
+    ),
+    false
+  )
+  assert.deepEqual(
+    (await fnReadJson(path.join(strTargetRoot, '.scaffold-state.json')))
+      .arrActiveCapabilities,
+    [
+      'advancedAuthentication',
+      'advancedTable',
+      'filePreview',
+      'tenantWorkspace',
+    ]
+  )
+})
+
+test('full profile keeps every maintained capability', async (objTestContext) => {
+  const strTemporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), 'react-admin-full-project-')
+  )
+  objTestContext.after(() => rm(strTemporaryRoot, { recursive: true }))
+  const strTargetRoot = path.join(strTemporaryRoot, 'project')
+
+  await fnCreateScaffoldProject({
+    bInstall: false,
+    strProfile: 'full',
+    strTargetRoot,
+    strTemplateRoot: strProjectRoot,
+  })
+
+  const objState = await fnReadJson(
+    path.join(strTargetRoot, '.scaffold-state.json')
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/components/AppTable')),
+    true
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/auditLogs')),
+    true
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/components/FilePreview')),
+    true
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/authentication')),
+    true
+  )
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/tenantWorkspace')),
+    true
+  )
+  assert.deepEqual(objState.arrActiveCapabilities, [
+    'activityStatus',
+    'advancedAuthentication',
+    'advancedTable',
+    'auditLogs',
+    'featureFlags',
+    'filePreview',
+    'optionalEditors',
+    'realtimeCollaboration',
+    'reporting',
+    'tenantWorkspace',
+  ])
+})
+
+test('generated projects exclude maintainer state and empty directories', async (objTestContext) => {
+  const strTemporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), 'react-admin-clean-project-')
+  )
+  objTestContext.after(() => rm(strTemporaryRoot, { recursive: true }))
+  const strTemplateRoot = path.join(strTemporaryRoot, 'template')
+  const strTargetRoot = path.join(strTemporaryRoot, 'project')
+  const arrRequiredTemplatePaths = [
+    'package.json',
+    'pnpm-lock.yaml',
+    'scaffold.template.json',
+    'tools/component-governance/manifest.json',
+    'tools/scaffold/capability-catalog.json',
+  ]
+
+  await Promise.all(
+    arrRequiredTemplatePaths.map(async (strRelativePath) => {
+      const strTargetPath = path.join(strTemplateRoot, strRelativePath)
+      await mkdir(path.dirname(strTargetPath), { recursive: true })
+      await cp(path.join(strProjectRoot, strRelativePath), strTargetPath)
+    })
+  )
+  await Promise.all([
+    mkdir(path.join(strTemplateRoot, '.artifacts'), { recursive: true }),
+    mkdir(path.join(strTemplateRoot, '.claude'), { recursive: true }),
+    mkdir(path.join(strTemplateRoot, '.gstack'), { recursive: true }),
+    mkdir(path.join(strTemplateRoot, '.husky/_'), { recursive: true }),
+    mkdir(path.join(strTemplateRoot, '.tanstack'), { recursive: true }),
+    mkdir(path.join(strTemplateRoot, 'src/removed/empty'), { recursive: true }),
+  ])
+  await Promise.all([
+    writeFile(path.join(strTemplateRoot, '.artifacts/report.txt'), 'local'),
+    writeFile(path.join(strTemplateRoot, '.claude/settings.json'), '{}'),
+    writeFile(path.join(strTemplateRoot, '.eslintcache'), 'local'),
+    writeFile(path.join(strTemplateRoot, '.gstack/session.json'), '{}'),
+    writeFile(path.join(strTemplateRoot, '.husky/_/h'), 'generated'),
+    writeFile(path.join(strTemplateRoot, 'AGENTS.md'), 'local'),
+    writeFile(path.join(strTemplateRoot, 'CLAUDE.md'), 'local'),
+    writeFile(path.join(strTemplateRoot, 'src/.DS_Store'), 'local'),
+    writeFile(path.join(strTemplateRoot, 'src/index.ts'), 'export {}\n'),
+  ])
+
+  await fnCreateScaffoldProject({
+    bInstall: false,
+    strTargetRoot,
+    strTemplateRoot,
+  })
+
+  for (const strRelativePath of [
+    '.artifacts',
+    '.claude',
+    '.eslintcache',
+    '.gstack',
+    '.husky/_',
+    '.tanstack',
+    'AGENTS.md',
+    'CLAUDE.md',
+    'src/.DS_Store',
+    'src/removed',
+  ]) {
+    assert.equal(
+      await fnPathExists(path.join(strTargetRoot, strRelativePath)),
+      false,
+      `${strRelativePath} should not be generated`
+    )
+  }
+  assert.equal(
+    await fnPathExists(path.join(strTargetRoot, 'src/index.ts')),
+    true
+  )
+})

package/template/tests/unit/config/scaffoldTransaction.test.mjs

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict'
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  rm,
+  writeFile,
+} from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import {
+  fnCommitCreatedDirectoriesTransaction,
+  fnCommitFileReplacementTransaction,
+} from '../../../tools/scaffold/workspace-transaction.mjs'
+
+const fnCreateFixture = async (objTestContext) => {
+  const strFixtureRoot = await mkdtemp(
+    path.join(os.tmpdir(), 'react-admin-workspace-transaction-')
+  )
+  objTestContext.after(() =>
+    rm(strFixtureRoot, { force: true, recursive: true })
+  )
+  return strFixtureRoot
+}
+
+test('created-directory transaction rejects targets outside owned directories', async (objTestContext) => {
+  const strFixtureRoot = await fnCreateFixture(objTestContext)
+  const strOwnedDirectory = path.resolve(strFixtureRoot, 'owned')
+  const strOutsideFile = path.resolve(strFixtureRoot, 'outside.ts')
+
+  await assert.rejects(
+    fnCommitCreatedDirectoriesTransaction({
+      arrDirectoryPaths: [strOwnedDirectory],
+      arrFiles: [{ strContent: 'unsafe', strTargetPath: strOutsideFile }],
+      fnCreateError: (objError) => objError,
+    }),
+    /不属于事务目录/
+  )
+  await assert.rejects(readFile(strOutsideFile, 'utf8'), { code: 'ENOENT' })
+})
+
+test('replacement transaction restores earlier files when a later target fails', async (objTestContext) => {
+  const strFixtureRoot = await fnCreateFixture(objTestContext)
+  const strExistingFile = path.resolve(strFixtureRoot, 'existing.json')
+  const strMissingFile = path.resolve(strFixtureRoot, 'missing.json')
+  await mkdir(strFixtureRoot, { recursive: true })
+  await writeFile(strExistingFile, 'before')
+
+  await assert.rejects(
+    fnCommitFileReplacementTransaction({
+      arrPlans: [
+        {
+          nMode: 0o644,
+          strContent: 'after',
+          strTargetPath: strExistingFile,
+        },
+        {
+          nMode: 0o644,
+          strContent: 'new',
+          strTargetPath: strMissingFile,
+        },
+      ],
+      fnCreateError: (objError) => objError,
+      strTransactionName: 'test-transaction',
+    })
+  )
+
+  assert.equal(await readFile(strExistingFile, 'utf8'), 'before')
+  assert.equal(
+    (await readdir(strFixtureRoot)).some((strName) =>
+      strName.includes('test-transaction')
+    ),
+    false
+  )
+})