@celilo/cli 2.1.0 → 2.2.1

package/src/services/consumer-cleanup.test.ts

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import type { DbClient } from '../db/client';
 import type { ModuleManifest } from '../manifest/schema';
 import { setupTestDatabaseAt } from '../test-utils/database';
+import { resetTestDbPath } from '../test-utils/db-path';
 import {
   type CleanupTarget,
   type ProviderRow,
@@ -216,7 +217,7 @@ describe('runConsumerCleanup — the paused skip is reported, not silent', () =>
   });
   afterEach(() => {
     db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     rmSync(dir, { recursive: true, force: true });
   });
 
@@ -285,7 +286,7 @@ describe('runConsumerCleanup — dispatch', () => {
   });
   afterEach(() => {
     db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     rmSync(dir, { recursive: true, force: true });
   });
 

package/src/services/container-service.test.ts

@@ -10,6 +10,7 @@ import { eq } from 'drizzle-orm';
 import { closeDb, createDbClient } from '../db/client';
 import { runMigrations } from '../db/migrate';
 import { containerServices } from '../db/schema';
+import { resetTestDbPath } from '../test-utils/db-path';
 import {
   addContainerService,
   getContainerService,
@@ -53,7 +54,7 @@ describe('container-service', () => {
     }
 
     // Clear environment variables
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     process.env.CELILO_MASTER_KEY_PATH = undefined;
   });
 

package/src/services/control-plane-bootstrap.test.ts

@@ -15,8 +15,9 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { eq } from 'drizzle-orm';
 import type { DbClient } from '../db/client';
-import { systemConfig } from '../db/schema';
+import { capabilities, modules, systemConfig } from '../db/schema';
 import { setupTestDatabaseAt } from '../test-utils/database';
+import { resetTestDbPath } from '../test-utils/db-path';
 import {
   type ControlPlaneBootstrapOptions,
   bootstrapControlPlane,
@@ -58,7 +59,7 @@ describe('bootstrapControlPlane', () => {
 
   afterEach(() => {
     db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     try {
       rmSync(dir, { recursive: true, force: true });
     } catch {
@@ -88,6 +89,126 @@ describe('bootstrapControlPlane', () => {
     expect(configValue(db, 'ssh.public_key')).toBe(PUBLIC_KEY);
   });
 
+  test('hands discovery every address a deployed resolver advertises (celilo#1239)', async () => {
+    // The recurrence gate's second half: the refusal only works if bootstrap
+    // actually tells discovery what to refuse. Seed capability rows the way a
+    // deployed resolver provider (technitium) and its secondary
+    // (knot-unbound-secondary) write them, including the CIDR suffix IPAM
+    // resolves target_ip to. Selection is by the declared `fleet_resolver`
+    // marker in the data, never the capability name.
+    const [module] = db
+      .insert(modules)
+      .values({
+        id: 'technitium',
+        name: 'technitium',
+        version: '1.0.0',
+        manifestData: {},
+        sourcePath: '/test/technitium',
+      })
+      .returning()
+      .all();
+    db.insert(capabilities)
+      .values([
+        {
+          moduleId: module.id,
+          capabilityName: 'dns_internal',
+          version: '1.0.0',
+          data: {
+            fleet_resolver: true,
+            server: { ip: '10.0.10.13', internal_ip: '192.168.0.151/24' },
+          },
+        },
+        {
+          moduleId: module.id,
+          capabilityName: 'dns_internal_secondary',
+          version: '1.0.0',
+          data: { fleet_resolver: true, server: { ip: '10.0.20.14' } },
+        },
+      ])
+      .run();
+
+    const seen: string[][] = [];
+    await run({
+      discoverDnsImpl: (fleetResolverIps) => {
+        seen.push([...fleetResolverIps]);
+        return DNS;
+      },
+    });
+
+    expect(seen).toHaveLength(1);
+    expect(seen[0].sort()).toEqual(['10.0.10.13', '192.168.0.151/24', '10.0.20.14'].sort());
+  });
+
+  test('a resolver capability without the declared marker is not a fleet resolver', async () => {
+    // Selection is by the DECLARED marker, not the capability name. A row
+    // named like a resolver but not declaring fleet_resolver must be ignored,
+    // otherwise renaming this to a name check would pass every other test
+    // here and silently re-open celilo#1239 to name-shaped drift.
+    const [module] = db
+      .insert(modules)
+      .values({
+        id: 'technitium',
+        name: 'technitium',
+        version: '1.0.0',
+        manifestData: {},
+        sourcePath: '/test/technitium',
+      })
+      .returning()
+      .all();
+    db.insert(capabilities)
+      .values({
+        moduleId: module.id,
+        capabilityName: 'dns_internal',
+        version: '1.0.0',
+        data: { server: { ip: '10.0.10.13', internal_ip: '192.168.0.151/24' } },
+      })
+      .run();
+
+    const seen: string[][] = [];
+    await run({
+      discoverDnsImpl: (fleetResolverIps) => {
+        seen.push([...fleetResolverIps]);
+        return DNS;
+      },
+    });
+
+    expect(seen).toEqual([[]]);
+  });
+
+  test('a capability of any name declaring the marker is a fleet resolver', async () => {
+    // The other half of the same proof: a NEW resolver provider needs no core
+    // change. Its capability name is irrelevant; the declaration is what counts.
+    const [module] = db
+      .insert(modules)
+      .values({
+        id: 'technitium',
+        name: 'technitium',
+        version: '1.0.0',
+        manifestData: {},
+        sourcePath: '/test/technitium',
+      })
+      .returning()
+      .all();
+    db.insert(capabilities)
+      .values({
+        moduleId: module.id,
+        capabilityName: 'some_future_resolver',
+        version: '1.0.0',
+        data: { fleet_resolver: true, server: { ip: '10.0.30.15' } },
+      })
+      .run();
+
+    const seen: string[][] = [];
+    await run({
+      discoverDnsImpl: (fleetResolverIps) => {
+        seen.push([...fleetResolverIps]);
+        return DNS;
+      },
+    });
+
+    expect(seen).toEqual([['10.0.30.15']]);
+  });
+
   test('returns what each step found, so the caller renders and this does not', async () => {
     const result = await run();
 

package/src/services/control-plane-bootstrap.ts

@@ -34,6 +34,7 @@
 import { type Bus, defineEvents, openBus } from '@celilo/event-bus';
 import { getEventBusPath } from '../config/paths';
 import type { DbClient } from '../db/client';
+import { capabilities } from '../db/schema';
 import { type DnsServers, discoverDns } from './dns-discovery';
 import { type FleetFinding, checkDispatcher } from './fleet-checks';
 import { type FleetKey, ensureFleetKey } from './fleet-key';
@@ -50,10 +51,55 @@ import { initializeSystem } from './system-init';
 const DISPATCHER_ATTEMPTS = 5;
 const DISPATCHER_INTERVAL_MS = 1_000;
 
+/**
+ * The marker a resolver provider declares in its capability data to say "the
+ * addresses I advertise are a resolver celilo itself deployed". Core reads
+ * this declaration and names no capability (module-business-barrier Scan B).
+ * Declared today by knot-unbound-internal, knot-unbound-secondary and
+ * technitium (celilo#1239).
+ */
+const FLEET_RESOLVER_MARKER = 'fleet_resolver';
+
+/** The declared shape of a resolver capability's data. Values checked before use. */
+type ResolverCapabilityData = {
+  fleet_resolver?: unknown;
+  server?: { ip?: unknown; internal_ip?: unknown };
+};
+
+/**
+ * Every address a deployed resolver provider advertises for itself.
+ *
+ * A capability row counts when its data declares {@link FLEET_RESOLVER_MARKER};
+ * the capability NAME is irrelevant to this selection, so a new resolver
+ * provider needs no core change. Discovery hands the addresses to
+ * {@link discoverDns} so a resolv.conf the provider's own aspect wrote is
+ * refused rather than adopted as the fleet's upstream (celilo#1239). Addresses
+ * come from the declared data only (`server.ip`, `server.internal_ip`). Values
+ * may carry a CIDR suffix; discovery normalises both sides before comparing.
+ */
+export function fleetResolverAddresses(db: DbClient): string[] {
+  const addresses: string[] = [];
+  const rows = db.select({ data: capabilities.data }).from(capabilities).all();
+  for (const row of rows) {
+    const data = row.data as ResolverCapabilityData | undefined;
+    if (data?.[FLEET_RESOLVER_MARKER] !== true) continue;
+    for (const value of [data.server?.ip, data.server?.internal_ip]) {
+      if (typeof value === 'string' && value.length > 0) {
+        addresses.push(value);
+      }
+    }
+  }
+  return addresses;
+}
+
 export interface ControlPlaneBootstrapOptions {
   db: DbClient;
-  /** Injectable so tests drive the whole sequence without a host or a bus. */
-  discoverDnsImpl?: () => DnsServers;
+  /**
+   * Injectable so tests drive the whole sequence without a host or a bus.
+   * Receives the addresses of resolvers celilo itself deployed, which the
+   * discovery must refuse (celilo#1239).
+   */
+  discoverDnsImpl?: (fleetResolverIps: readonly string[]) => DnsServers;
   ensureFleetKeyImpl?: () => FleetKey;
   discoverNetworkImpl?: (db: DbClient) => NetworkDiscoveryResult;
   /**
@@ -152,7 +198,8 @@ export async function bootstrapControlPlane(
 ): Promise<ControlPlaneBootstrapResult> {
   const {
     db,
-    discoverDnsImpl = discoverDns,
+    discoverDnsImpl = (fleetResolverIps: readonly string[]): DnsServers =>
+      discoverDns(undefined, { fleetResolverIps }),
     ensureFleetKeyImpl = ensureFleetKey,
     discoverNetworkImpl = discoverAndRecordNetwork,
     probeDispatcher = probeOwnDispatcher,
@@ -160,7 +207,7 @@ export async function bootstrapControlPlane(
     dispatcherAttempts = DISPATCHER_ATTEMPTS,
   } = options;
 
-  const dns = discoverDnsImpl();
+  const dns = discoverDnsImpl(fleetResolverAddresses(db));
   const fleetKey = ensureFleetKeyImpl();
 
   initializeSystem(db, {

package/src/services/cross-module-read.test.ts

@@ -15,6 +15,7 @@ import { closeDb, getDb } from '../db/client';
 import { runMigrations } from '../db/migrate';
 import { modules } from '../db/schema';
 import type { ModuleManifest } from '../manifest/schema';
+import { resetTestDbPath } from '../test-utils/db-path';
 import {
   type CrossModuleIndex,
   applyCrossModuleWriteRoot,
@@ -70,7 +71,7 @@ describe('materializeCrossModuleRoot', () => {
 
   afterEach(() => {
     closeDb();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     process.env.CELILO_DATA_DIR = undefined;
     try {
       rmSync(dir, { recursive: true, force: true });

package/src/services/deploy-preflight.ts

@@ -174,8 +174,14 @@ export async function runPreflight(
     for (const variable of manifest.variables.owns) {
       if (!variable.required) continue;
 
-      // Infrastructure/terraform variables are auto-derived during deploy
-      if (variable.source === 'infrastructure' || variable.source === 'terraform') {
+      // Infrastructure/terraform variables are auto-derived during deploy;
+      // hook-owned variables are discovered by the module's own hooks at
+      // runtime (hook-owned-state D2). None of the three is operator input.
+      if (
+        variable.source === 'infrastructure' ||
+        variable.source === 'terraform' ||
+        variable.source === 'hook'
+      ) {
         continue;
       }
 

package/src/services/deploy-validation.test.ts

@@ -21,6 +21,7 @@ import { join } from 'node:path';
 import { type DbClient, getDb } from '../db/client';
 import { modules, secrets } from '../db/schema';
 import type { ModuleManifest } from '../manifest/schema';
+import { resetTestDbPath } from '../test-utils/db-path';
 import { findMissingSecrets } from './config-interview';
 import { findMissingBuildArtifacts, findMissingRequiredVariables } from './deploy-validation';
 
@@ -89,7 +90,7 @@ describe('findMissingRequiredVariables (deploy path)', () => {
 
   afterEach(() => {
     rmSync(tempDir, { recursive: true, force: true });
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
   });
 
   // The bug we're guarding against: the deploy used to drop type +
@@ -129,6 +130,28 @@ describe('findMissingRequiredVariables (deploy path)', () => {
     expect(missing[0].value_label).toBeUndefined();
   });
 
+  // Hook-owned-state task 2.3 (design D2): a `source: hook` variable is
+  // discovered by the module's own hook at runtime. It is never operator
+  // input, so an unwritten one must not read as missing configuration — not
+  // for the interview, and not as a deploy-blocking error.
+  test('a source: hook variable is never reported missing, even required and unwritten', async () => {
+    const manifest = {
+      celilo_contract: '1.0',
+      variables: {
+        owns: [
+          {
+            name: 'public_ip',
+            type: 'string',
+            required: true,
+            source: 'hook',
+          },
+        ],
+      },
+    } as unknown as ModuleManifest;
+    const missing = await findMissingRequiredVariables('testmod', manifest, db);
+    expect(missing).toEqual([]);
+  });
+
   test('configured secrets are not reported as missing', async () => {
     db.insert(secrets)
       .values({
@@ -188,7 +211,7 @@ describe('findMissingSecrets (shared)', () => {
 
   afterEach(() => {
     rmSync(tempDir, { recursive: true, force: true });
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
   });
 
   test('accepts loose unknown[] declares (manifest read off disk)', async () => {

package/src/services/deploy-validation.ts

@@ -430,6 +430,14 @@ export async function findMissingRequiredVariables(
         continue; // These are auto-populated from Terraform outputs
       }
 
+      // Hook-owned variables are discovered by the module's own hooks at
+      // runtime (hook-owned-state D2). An unwritten one is not a missing
+      // configuration value — prompting for it or failing validation would
+      // ask the operator to guess what a hook has not learned yet.
+      if (variable.source === 'hook') {
+        continue;
+      }
+
       // Check if variable is configured
       let isConfigured = false;
 

package/src/services/dns-discovery.test.ts

@@ -90,4 +90,58 @@ describe('discoverDns', () => {
   test('returns the public fallback on a host with no resolver files at all', () => {
     expect(discoverDns(host({}))).toEqual({ primary: '1.1.1.1', fallback: '1.1.1.1' });
   });
+
+  // The recurrence gate for celilo#1239 (bead ce-dxr8). The dns-client-config
+  // aspect of a deployed dns_internal provider rewrites /etc/resolv.conf to
+  // name that provider. Discovery reading the file back adopts the fleet's own
+  // resolver as the fleet's upstream and writes it into dns.primary /
+  // dns.fallback, where it reaches every LXC's permanent birth nameserver
+  // line. Proven to fail against the accepting implementation first.
+  describe('refusing resolvers celilo itself installed', () => {
+    // technitium's advertised dns_internal addresses: its dmz zone address and
+    // (once advertised) the firewall ingress `internal`-zone systems use.
+    const FLEET = ['10.0.10.13', '192.168.0.151'];
+
+    test('refuses a resolv.conf naming a deployed dns_internal provider address', () => {
+      const servers = discoverDns(host({ [ETC]: `nameserver ${FLEET[0]}\n` }), {
+        fleetResolverIps: FLEET,
+      });
+      expect(servers).toEqual({ primary: '1.1.1.1', fallback: '1.1.1.1' });
+    });
+
+    test('keeps the real upstreams beside a refused fleet resolver', () => {
+      const servers = discoverDns(host({ [ETC]: `nameserver ${FLEET[0]}\nnameserver 9.9.9.9\n` }), {
+        fleetResolverIps: FLEET,
+      });
+      expect(servers).toEqual({ primary: '9.9.9.9', fallback: '1.1.1.1' });
+    });
+
+    test('falls through to /etc/resolv.conf when the systemd file holds only fleet resolvers', () => {
+      const servers = discoverDns(
+        host({
+          [SYSTEMD]: `nameserver ${FLEET[0]}\n`,
+          [ETC]: 'nameserver 9.9.9.9\n',
+        }),
+        { fleetResolverIps: FLEET },
+      );
+      expect(servers).toEqual({ primary: '9.9.9.9', fallback: '1.1.1.1' });
+    });
+
+    test('matches a capability address that carries a CIDR suffix', () => {
+      // Capability data advertises `192.168.0.151/24` (server.ip resolves from
+      // target_ip); the resolv.conf entry is the bare address.
+      const servers = discoverDns(host({ [ETC]: `nameserver ${FLEET[1]}\n` }), {
+        fleetResolverIps: [`${FLEET[1]}/24`],
+      });
+      expect(servers).toEqual({ primary: '1.1.1.1', fallback: '1.1.1.1' });
+    });
+
+    test('accepts a private upstream that is not a fleet resolver', () => {
+      // A home-lab upstream on the operator's own network is legitimate. The
+      // refusal is scoped to resolvers celilo deployed, not to privateness.
+      expect(
+        discoverDns(host({ [ETC]: 'nameserver 192.168.0.1\n' }), { fleetResolverIps: FLEET }),
+      ).toEqual({ primary: '192.168.0.1', fallback: '1.1.1.1' });
+    });
+  });
 });

package/src/services/dns-discovery.ts

@@ -72,18 +72,60 @@ export type ResolverFileReader = (path: string) => string | null;
 const readResolverFile: ResolverFileReader = (path) =>
   existsSync(path) ? readFileSync(path, 'utf-8') : null;
 
+/** Options for {@link discoverDns}. */
+export interface DiscoverDnsOptions {
+  /**
+   * Addresses of resolvers celilo itself deployed, as advertised in the
+   * capability data of providers that declare the `fleet_resolver` marker
+   * (`server.ip`, `server.internal_ip`). Entries may carry a CIDR suffix.
+   */
+  fleetResolverIps?: readonly string[];
+}
+
+/** Strip a CIDR suffix: `192.168.0.151/24` → `192.168.0.151`. */
+export function bareIp(address: string): string {
+  return address.split('/')[0];
+}
+
+/**
+ * Drop nameservers that are resolvers celilo itself installed.
+ *
+ * A deployed dns_internal provider's base-module aspect rewrites this box's
+ * `/etc/resolv.conf` to name that provider. Reading the file back afterwards
+ * adopts the fleet's own resolver as the fleet's upstream and writes it into
+ * `dns.primary` / `dns.fallback` (celilo#1239), where it reaches every LXC's
+ * permanent birth nameserver line. A resolver answering the fleet is not an
+ * upstream for the fleet; refusing it here is what keeps discovery honest
+ * once the aspect has run.
+ */
+export function excludeFleetResolvers(
+  nameservers: string[],
+  fleetResolverIps: readonly string[] = [],
+): string[] {
+  if (fleetResolverIps.length === 0) return nameservers;
+  const fleet = new Set(fleetResolverIps.map(bareIp));
+  return nameservers.filter((ns) => !fleet.has(ns));
+}
+
 /**
  * Read this box's upstream resolvers.
  *
- * Takes the systemd file only when it yielded a real server. `/etc/resolv.conf`
- * is the last resort and whatever it gives is accepted, including the fallback,
- * because there is nothing further to consult.
+ * Loopback stubs and resolvers celilo itself installed ({@link DiscoverDnsOptions.fleetResolverIps})
+ * are refused, so a file holding only refused entries falls through to the
+ * next one. `/etc/resolv.conf` is the last resort and whatever survives the
+ * refusal is accepted, including the public fallback, because there is
+ * nothing further to consult.
  */
-export function discoverDns(read: ResolverFileReader = readResolverFile): DnsServers {
+export function discoverDns(
+  read: ResolverFileReader = readResolverFile,
+  options: DiscoverDnsOptions = {},
+): DnsServers {
   for (const path of RESOLVER_FILES) {
     const contents = read(path);
     if (contents === null) continue;
-    const servers = chooseDns(parseNameservers(contents));
+    const servers = chooseDns(
+      excludeFleetResolvers(parseNameservers(contents), options.fleetResolverIps),
+    );
     if (servers.primary !== PUBLIC_FALLBACK || path === '/etc/resolv.conf') {
       return servers;
     }

package/src/services/dns-internal-records.test.ts

@@ -8,6 +8,7 @@ import { eq } from 'drizzle-orm';
 import type { DbClient } from '../db/client';
 import { dnsInternalRecords, modules } from '../db/schema';
 import { setupTestDatabaseAt } from '../test-utils/database';
+import { resetTestDbPath } from '../test-utils/db-path';
 import {
   listDnsInternalRecords,
   listViewOverrides,
@@ -42,7 +43,7 @@ describe('dns-internal-records ledger', () => {
   });
   afterEach(() => {
     db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     try {
       rmSync(dir, { recursive: true, force: true });
     } catch {
@@ -248,7 +249,7 @@ describe('provider cascade (celilo#1010)', () => {
 
   afterEach(() => {
     db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     rmSync(dir, { recursive: true, force: true });
   });
 

package/src/services/dns-provider-backfill.test.ts

@@ -6,6 +6,7 @@ import type { DnsRecordRequest, HookLogger } from '@celilo/capabilities';
 import { closeDb, getDb } from '../db/client';
 import { runMigrations } from '../db/migrate';
 import { capabilities, moduleConfigs, modules, webRoutes } from '../db/schema';
+import { resetTestDbPath } from '../test-utils/db-path';
 import { backfillWebRouteDns } from './dns-provider-backfill';
 
 const silentLogger: HookLogger = {
@@ -26,7 +27,7 @@ describe('backfillWebRouteDns (ISS-0029)', () => {
 
   afterEach(() => {
     closeDb();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     try {
       rmSync(dir, { recursive: true, force: true });
     } catch {

package/src/services/dns-registrations.test.ts

@@ -14,6 +14,7 @@ import type { DnsRegistrarCapability } from '@celilo/capabilities';
 import { eq } from 'drizzle-orm';
 import { type DbClient, getDb } from '../db/client';
 import { modules } from '../db/schema';
+import { resetTestDbPath } from '../test-utils/db-path';
 import {
   listDnsRegistrations,
   recordDnsRegistration,
@@ -44,7 +45,7 @@ describe('dns_registrations ledger', () => {
 
   afterEach(() => {
     rmSync(tempDir, { recursive: true, force: true });
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
   });
 
   test('record + list roundtrip; a re-assert is an upsert, not a second row', () => {

package/src/services/ensure-interview.test.ts

@@ -8,6 +8,7 @@ import { moduleConfigs, modules, secrets } from '../db/schema';
 import type { Ensure } from '../manifest/schema';
 import { decryptSecret } from '../secrets/encryption';
 import { getOrCreateMasterKey } from '../secrets/master-key';
+import { resetTestDbPath } from '../test-utils/db-path';
 import {
   findEnsureOnProvider,
   interviewForEnsureInputs,
@@ -56,7 +57,7 @@ describe('interviewForEnsureInputs', () => {
 
   afterEach(() => {
     rmSync(tempDir, { recursive: true, force: true });
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
   });
 
   test('appends to array config and sets secret object key', async () => {
@@ -185,7 +186,7 @@ describe('findEnsureOnProvider', () => {
 
   afterEach(() => {
     rmSync(tempDir, { recursive: true, force: true });
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
   });
 
   test('finds ensure by id on a registered provider', () => {

package/src/services/fleet-checks.test.ts

@@ -14,6 +14,7 @@ import {
 } from '../db/schema';
 import type { ModuleManifest } from '../manifest/schema';
 import { setupTestDatabaseAt } from '../test-utils/database';
+import { resetTestDbPath } from '../test-utils/db-path';
 import { ensureInboundSubscriber, ensureSweepSubscriber } from './alerting/monitors';
 import { ensureBackupSweepSubscriber } from './backup-sweep';
 import { getDaemonUnitPath } from './events-daemon';
@@ -269,7 +270,7 @@ describe('checkSubscribers + checkCapabilityProviders', () => {
   afterEach(() => {
     bus.close();
     db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     process.env.EVENT_BUS_DB = undefined;
     try {
       rmSync(dir, { recursive: true, force: true });
@@ -978,7 +979,7 @@ describe('runFleetChecks includes host liveness (#728)', () => {
   afterEach(() => {
     bus.close();
     db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
+    resetTestDbPath();
     process.env.EVENT_BUS_DB = undefined;
     try {
       rmSync(dir, { recursive: true, force: true });