@celilo/cli 3.1.0 → 4.1.0

package/src/templates/generator.test.ts

@@ -656,7 +656,7 @@ resource "proxmox_lxc" "container" {
       expect(out).toContain('  nameserver = "$self:lxc_nameserver"');
       expect(out).toContain('  lifecycle {');
       expect(out).toContain(
-        '    ignore_changes = [nameserver, network[0].hwaddr, rootfs[0].volume, ssh_public_keys]',
+        '    ignore_changes = [nameserver, network[0].hwaddr, ostemplate, rootfs[0].storage, ssh_public_keys]',
       );
       // Injected immediately after the opening line, before author attributes.
       const lines = out.split('\n');
@@ -673,10 +673,21 @@ resource "proxmox_lxc" "container" {
       expect(out).not.toContain('nameserver = "$self:lxc_nameserver"');
       expect(out).toContain('  lifecycle {');
       expect(out).toContain(
-        '    ignore_changes = [nameserver, network[0].hwaddr, rootfs[0].volume, ssh_public_keys]',
+        '    ignore_changes = [nameserver, network[0].hwaddr, ostemplate, rootfs[0].storage, ssh_public_keys]',
       );
     });
 
+    // celilo#1402: `ostemplate` and `rootfs[0].storage` are ForceNew and do
+    // NOT round-trip through `terraform import` — Proxmox reports neither. Drop
+    // them from the ignore list and every import of an existing container
+    // computes a REPLACE, which the post-import guard refuses, leaving the
+    // container redeployable by no route at all.
+    test('ignores the ForceNew attributes an import cannot recover', () => {
+      const out = injectProxmoxDns(LXC, true);
+      expect(out).toContain('ostemplate');
+      expect(out).toContain('rootfs[0].storage');
+    });
+
     test('is idempotent — already-injected content is returned unchanged', () => {
       const once = injectProxmoxDns(LXC, true);
       const twice = injectProxmoxDns(once, true);
@@ -737,7 +748,7 @@ resource "proxmox_lxc" "container" {
       ].join('\n');
       const out = injectProxmoxDns(mixed, true);
       expect(out).toContain(
-        'ignore_changes = [nameserver, network[0].hwaddr, rootfs[0].volume, ssh_public_keys]',
+        'ignore_changes = [nameserver, network[0].hwaddr, ostemplate, rootfs[0].storage, ssh_public_keys]',
       );
       expect(out).toContain('ignore_changes = [nameserver, network[0].macaddr, sshkeys, clone]');
     });
@@ -767,7 +778,7 @@ resource "proxmox_lxc" "container" {
       expect(out).toContain('    nameserver = "$self:lxc_nameserver"');
       expect(out).toContain('    lifecycle {');
       expect(out).toContain(
-        '      ignore_changes = [nameserver, network[0].hwaddr, rootfs[0].volume, ssh_public_keys]',
+        '      ignore_changes = [nameserver, network[0].hwaddr, ostemplate, rootfs[0].storage, ssh_public_keys]',
       );
     });
   });

package/src/templates/generator.ts

@@ -199,9 +199,17 @@ export function injectProxmoxDns(content: string, hasNameserver: boolean): strin
     // in-place UPDATE, never a destructive REPLACE. A non-existent attribute
     // here fails `terraform validate`, so each list is exactly the schema
     // attributes the resource actually has.
-    //   LXC (ISS-0055/0089): the create-time MAC + rootfs volume, plus
-    //   `ssh_public_keys` (ForceNew — a fleet-key rotation must not REPLACE the
-    //   container). `rootfs.size` is NOT ignored, so a disk grow still applies.
+    //   LXC (ISS-0055/0089): the create-time MAC, plus `ssh_public_keys`
+    //   (ForceNew — a fleet-key rotation must not REPLACE the container), plus
+    //   the two ForceNew attributes an IMPORT cannot recover: `ostemplate`
+    //   (Proxmox never reports the source template) and `rootfs[0].storage`
+    //   (import records the volume, not the config's storage name). Without
+    //   them every import of an existing container computes a REPLACE, the
+    //   post-import guard refuses it, and the container becomes redeployable
+    //   by no route at all (celilo#1402). `rootfs[0].volume` was listed here
+    //   and terraform reported it "Redundant ... has no effect" — it is
+    //   computed, never configured — so it is gone.
+    //   `rootfs.size` is NOT ignored, so a disk grow still applies.
     //   We do NOT ignore `target_node` — a node change is real (migration,
     //   ISS-0090), never silently dropped.
     //   VM (telmate 3.x proxmox_vm_qemu): `clone` (ForceNew clone source),
@@ -212,7 +220,7 @@ export function injectProxmoxDns(content: string, hasNameserver: boolean): strin
     const ignore =
       resourceType === 'proxmox_vm_qemu'
         ? 'nameserver, network[0].macaddr, sshkeys, clone'
-        : 'nameserver, network[0].hwaddr, rootfs[0].volume, ssh_public_keys';
+        : 'nameserver, network[0].hwaddr, ostemplate, rootfs[0].storage, ssh_public_keys';
     injected.push(`${inner}  ignore_changes = [${ignore}]`);
     injected.push(`${inner}}`);
     return injected.join('\n');

package/src/variables/context.ts

@@ -423,8 +423,21 @@ async function assembleResolutionContext(
         const deployedZone = machineRow.zone ?? zone;
         const machineIdentity = resolveMachineIdentityAddress(machineRow, deployedZone);
         if (!machineIdentity) {
+          // Distinguish "no such interface" from "the interface is there under
+          // a stale zone label" — the second is what a zone-model change
+          // produces, and its remediation is a re-classification, not new
+          // hardware (celilo#1382).
+          const { diffInterfaceZones, explainMissingZoneInterface } = await import(
+            '../services/machine-interface-zones'
+          );
+          const { detectZoneFromIp } = await import('../services/zone-detector');
+          const changes = await diffInterfaceZones(machineRow.interfaces, detectZoneFromIp);
           throw new Error(
-            `Machine '${infraSelection.machineId}' for module '${moduleId}' has no non-loopback interface in zone '${deployedZone}'`,
+            `Machine '${machineRow.hostname}' for module '${moduleId}' ${explainMissingZoneInterface(
+              machineRow.interfaces,
+              deployedZone,
+              changes,
+            )}`,
           );
         }
         upsertDeployedSystem(db, moduleId, {

package/src/services/static-content-converge.test.ts

@@ -1,516 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { eq } from 'drizzle-orm';
-import type { DbClient } from '../db/client';
-import { moduleConfigs, modules, webRoutes } from '../db/schema';
-import { setupTestDatabaseAt } from '../test-utils/database';
-import { resetTestDbPath } from '../test-utils/db-path';
-import {
-  ansibleTreeMentions,
-  buildStaticContentPlan,
-  planStaticContent,
-  resolveStaticContentRetention,
-  staticContentVarsPath,
-  staticContentVarsYaml,
-  writeStaticContentVars,
-} from './static-content-converge';
-
-const HASH1 = 'a'.repeat(64);
-const HASH2 = 'b'.repeat(64);
-
-describe('planStaticContent — the declared release set (D10 task 4.1)', () => {
-  let dir: string;
-  let db: DbClient;
-
-  beforeEach(async () => {
-    dir = mkdtempSync(join(tmpdir(), 'static-converge-'));
-    const dbPath = join(dir, 'celilo.db');
-    process.env.CELILO_DB_PATH = dbPath;
-    db = await setupTestDatabaseAt(dbPath);
-
-    // Two installed modules with real web roots on disk.
-    writeSite('lunacycle', '<html>luna</html>');
-    writeSite('hello-foo', '<html>foo</html>');
-    db.insert(modules)
-      .values({
-        id: 'lunacycle',
-        name: 'Lunacycle',
-        version: '1.0.0',
-        manifestData: {},
-        sourcePath: join(dir, 'modules', 'lunacycle'),
-      })
-      .onConflictDoNothing()
-      .run();
-    db.insert(modules)
-      .values({
-        id: 'hello-foo',
-        name: 'Hello Foo',
-        version: '0.1.2',
-        manifestData: {},
-        sourcePath: join(dir, 'modules', 'hello-foo'),
-      })
-      .onConflictDoNothing()
-      .run();
-  });
-
-  afterEach(() => {
-    db.$client.close();
-    resetTestDbPath();
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
-  });
-
-  function writeSite(moduleId: string, html: string): string {
-    const webRoot = join(dir, 'modules', moduleId, 'site', 'dist');
-    mkdirSync(webRoot, { recursive: true });
-    writeFileSync(join(webRoot, 'index.html'), html, 'utf-8');
-    return webRoot;
-  }
-
-  function insertRoute(route: {
-    slug: string;
-    moduleId: string;
-    hostname: string;
-    path?: string;
-    type?: 'static' | 'reverse_proxy';
-    contentHash?: string | null;
-  }) {
-    db.insert(webRoutes)
-      .values({
-        slug: route.slug,
-        moduleId: route.moduleId,
-        type: route.type ?? 'static',
-        path: route.path ?? '/',
-        hostname: route.hostname,
-        websocket: false,
-        contentHash: route.contentHash ?? HASH1,
-      })
-      .run();
-  }
-
-  it('groups by slug across hostnames and derives the source dir', () => {
-    insertRoute({ slug: 'lunacycle', moduleId: 'lunacycle', hostname: 'lunacycle.net' });
-    insertRoute({
-      slug: 'lunacycle',
-      moduleId: 'lunacycle',
-      hostname: 'www.example.com',
-      path: '/x',
-    });
-    insertRoute({
-      slug: 'hello-foo',
-      moduleId: 'hello-foo',
-      hostname: 'www.example.com',
-      path: '/foo',
-    });
-
-    const releases = planStaticContent(db);
-
-    // Reverse-proxy rows and rows without a hash are not releases.
-    expect(releases).toHaveLength(2);
-    const luna = releases.find((r) => r.slug === 'lunacycle');
-    expect(luna?.hostnames).toEqual(['lunacycle.net', 'www.example.com']);
-    expect(luna?.sourceDir).toBe(join(dir, 'modules', 'lunacycle', 'site', 'dist'));
-    expect(luna?.contentHash).toBe(HASH1);
-  });
-
-  it('a slug claimed by two modules is a contradiction, not a merge', () => {
-    insertRoute({ slug: 'about', moduleId: 'lunacycle', hostname: 'a.example.com' });
-    insertRoute({ slug: 'about', moduleId: 'hello-foo', hostname: 'b.example.com' });
-
-    expect(() => planStaticContent(db)).toThrow(/claimed by 2 modules/);
-  });
-
-  it('rows sharing a slug must share a hash', () => {
-    insertRoute({ slug: 'lunacycle', moduleId: 'lunacycle', hostname: 'lunacycle.net' });
-    insertRoute({
-      slug: 'lunacycle',
-      moduleId: 'lunacycle',
-      hostname: 'www.example.com',
-      path: '/x',
-      contentHash: HASH2,
-    });
-
-    expect(() => planStaticContent(db)).toThrow(/content hashes/);
-  });
-
-  it('a missing web root fails loudly instead of converging an empty release', () => {
-    insertRoute({ slug: 'lunacycle', moduleId: 'lunacycle', hostname: 'lunacycle.net' });
-    rmSync(join(dir, 'modules', 'lunacycle', 'site', 'dist'), { recursive: true, force: true });
-
-    expect(() => planStaticContent(db)).toThrow(/no built site/);
-  });
-
-  function pause(moduleId: string) {
-    db.update(modules).set({ state: 'PAUSED' }).where(eq(modules.id, moduleId)).run();
-  }
-
-  it("a paused module's slug is left alone, even one that would throw, and the rest converge (celilo#1383)", () => {
-    insertRoute({ slug: 'lunacycle', moduleId: 'lunacycle', hostname: 'lunacycle.net' });
-    insertRoute({
-      slug: 'lunacycle',
-      moduleId: 'lunacycle',
-      hostname: 'www.lunacycle.net',
-      contentHash: HASH2,
-    });
-    rmSync(join(dir, 'modules', 'lunacycle', 'site', 'dist'), { recursive: true, force: true });
-    insertRoute({
-      slug: 'hello-foo',
-      moduleId: 'hello-foo',
-      hostname: 'www.example.com',
-      path: '/foo',
-    });
-    pause('lunacycle');
-
-    expect(planStaticContent(db).map((r) => r.slug)).toEqual(['hello-foo']);
-  });
-
-  it('a paused module that is publishing (an unpause redeploy) still converges its own slug', () => {
-    insertRoute({ slug: 'lunacycle', moduleId: 'lunacycle', hostname: 'lunacycle.net' });
-    pause('lunacycle');
-
-    expect(planStaticContent(db, 'lunacycle').map((r) => r.slug)).toEqual(['lunacycle']);
-  });
-
-  it('a slug shared by a paused and an active module is still a contradiction', () => {
-    insertRoute({ slug: 'about', moduleId: 'lunacycle', hostname: 'a.example.com' });
-    insertRoute({ slug: 'about', moduleId: 'hello-foo', hostname: 'b.example.com' });
-    pause('lunacycle');
-
-    expect(() => planStaticContent(db)).toThrow(/claimed by 2 modules/);
-  });
-});
-
-describe('resolveStaticContentRetention — operator config with a default', () => {
-  let dir: string;
-  let db: DbClient;
-
-  beforeEach(async () => {
-    dir = mkdtempSync(join(tmpdir(), 'static-retention-'));
-    process.env.CELILO_DB_PATH = join(dir, 'celilo.db');
-    db = await setupTestDatabaseAt(join(dir, 'celilo.db'));
-    db.insert(modules)
-      .values({
-        id: 'caddy',
-        name: 'Caddy',
-        version: '2.3.8',
-        manifestData: {
-          variables: { owns: [{ name: 'static_release_retention', default: 5 }] },
-        },
-        sourcePath: join(dir, 'modules', 'caddy'),
-      })
-      .onConflictDoNothing()
-      .run();
-  });
-
-  afterEach(() => {
-    db.$client.close();
-    resetTestDbPath();
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
-  });
-
-  it('operator config wins over the manifest default', () => {
-    db.insert(moduleConfigs)
-      .values({ moduleId: 'caddy', key: 'static_release_retention', value: '2', valueJson: '2' })
-      .run();
-    expect(resolveStaticContentRetention(db, 'caddy')).toBe(2);
-  });
-
-  it('falls back to the manifest default, then the constant', () => {
-    expect(resolveStaticContentRetention(db, 'caddy')).toBe(5);
-
-    db.update(modules).set({ manifestData: {} }).where(eq(modules.id, 'caddy')).run();
-    expect(resolveStaticContentRetention(db, 'caddy')).toBe(5);
-  });
-
-  it('rejects a retention that cannot keep the current release', () => {
-    db.insert(moduleConfigs)
-      .values({ moduleId: 'caddy', key: 'static_release_retention', value: '0', valueJson: '0' })
-      .run();
-    expect(() => resolveStaticContentRetention(db, 'caddy')).toThrow(/positive integer/);
-  });
-});
-
-describe('staticContentVarsYaml — deterministic desired state', () => {
-  it('carries slug, content_hash, hostnames and the derived source dir, keyed by slug', () => {
-    const yaml = staticContentVarsYaml({
-      retention: 3,
-      releases: [
-        {
-          slug: 'hello-foo',
-          contentHash: HASH2,
-          hostnames: ['www.example.com'],
-          sourceDir: '/data/modules/hello-foo/site/dist',
-        },
-        {
-          slug: 'lunacycle',
-          contentHash: HASH1,
-          hostnames: ['lunacycle.net', 'www.example.com'],
-          sourceDir: '/data/modules/lunacycle/site/dist',
-        },
-      ],
-    });
-
-    expect(yaml).toContain('static_release_retention: 3');
-    expect(yaml).toContain('slug: lunacycle');
-    expect(yaml).toContain(`content_hash: ${HASH1}`);
-    expect(yaml).toContain('source_dir: /data/modules/lunacycle/site/dist');
-    // Deterministic: same input, same bytes — the idempotence of the WRITE
-    // depends on it.
-    expect(yaml).toBe(
-      staticContentVarsYaml({
-        retention: 3,
-        releases: [
-          {
-            slug: 'hello-foo',
-            contentHash: HASH2,
-            hostnames: ['www.example.com'],
-            sourceDir: '/data/modules/hello-foo/site/dist',
-          },
-          {
-            slug: 'lunacycle',
-            contentHash: HASH1,
-            hostnames: ['lunacycle.net', 'www.example.com'],
-            sourceDir: '/data/modules/lunacycle/site/dist',
-          },
-        ],
-      }),
-    );
-  });
-});
-
-describe('the state web overlay (celilo#1265)', () => {
-  let dir: string;
-  let db: DbClient;
-
-  beforeEach(async () => {
-    dir = mkdtempSync(join(tmpdir(), 'static-converge-'));
-    const dbPath = join(dir, 'celilo.db');
-    process.env.CELILO_DB_PATH = dbPath;
-    db = await setupTestDatabaseAt(dbPath);
-    writeSite('lunacycle', '<html>luna</html>');
-    db.insert(modules)
-      .values({
-        id: 'lunacycle',
-        name: 'Lunacycle',
-        version: '1.0.0',
-        manifestData: {},
-        sourcePath: join(dir, 'modules', 'lunacycle'),
-      })
-      .onConflictDoNothing()
-      .run();
-  });
-
-  afterEach(() => {
-    db.$client.close();
-    resetTestDbPath();
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
-  });
-
-  function writeSite(moduleId: string, html: string): string {
-    const webRoot = join(dir, 'modules', moduleId, 'site', 'dist');
-    mkdirSync(webRoot, { recursive: true });
-    writeFileSync(join(webRoot, 'index.html'), html, 'utf-8');
-    return webRoot;
-  }
-
-  function insertRoute(route: { slug: string; moduleId: string; hostname: string }) {
-    db.insert(webRoutes)
-      .values({
-        slug: route.slug,
-        moduleId: route.moduleId,
-        type: 'static',
-        path: '/',
-        hostname: route.hostname,
-        websocket: false,
-        contentHash: HASH1,
-      })
-      .run();
-  }
-
-  it('a release with a state overlay carries its directory; one without does not', () => {
-    insertRoute({ slug: 'lunacycle', moduleId: 'lunacycle', hostname: 'lunacycle.net' });
-
-    // No overlay in state: the release names no overlay_dir, and the converge
-    // role has nothing second to copy.
-    const bare = planStaticContent(db);
-    expect(bare).toHaveLength(1);
-    expect(bare[0]?.overlayDir).toBeUndefined();
-    expect(staticContentVarsYaml({ retention: 1, releases: bare })).not.toContain('overlay_dir');
-
-    // The hook wrote generated files into `<module>/state/site`: the converge
-    // must copy them over the release, or a rebuilt host loses the file.
-    const overlay = join(dir, 'modules', 'lunacycle', 'state', 'site');
-    mkdirSync(overlay, { recursive: true });
-    writeFileSync(join(overlay, 'ca.crt'), '---CERT---', 'utf-8');
-
-    const overlaid = planStaticContent(db);
-    expect(overlaid[0]?.overlayDir).toBe(overlay);
-    const yaml = staticContentVarsYaml({ retention: 1, releases: overlaid });
-    expect(yaml).toContain('overlay_dir:');
-  });
-});
-
-describe('writeStaticContentVars — lands in the generated inventory', () => {
-  let dir: string;
-  let db: DbClient;
-
-  beforeEach(async () => {
-    dir = mkdtempSync(join(tmpdir(), 'static-vars-'));
-    process.env.CELILO_DB_PATH = join(dir, 'celilo.db');
-    db = await setupTestDatabaseAt(join(dir, 'celilo.db'));
-    mkdirSync(join(dir, 'modules', 'caddy', 'site', 'dist'), { recursive: true });
-    writeFileSync(
-      join(dir, 'modules', 'caddy', 'site', 'dist', 'index.html'),
-      '<html>caddy</html>',
-      'utf-8',
-    );
-    db.insert(modules)
-      .values({
-        id: 'caddy',
-        name: 'Caddy',
-        version: '2.3.8',
-        manifestData: {},
-        sourcePath: join(dir, 'modules', 'caddy'),
-      })
-      .onConflictDoNothing()
-      .run();
-  });
-
-  afterEach(() => {
-    db.$client.close();
-    resetTestDbPath();
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
-  });
-
-  it('writes the vars file and never writes into a module tree (task 4.7)', async () => {
-    db.insert(webRoutes)
-      .values({
-        slug: 'caddy',
-        moduleId: 'caddy',
-        type: 'static',
-        path: '/',
-        hostname: 'www.example.com',
-        websocket: false,
-        contentHash: HASH1,
-      })
-      .run();
-
-    const moduleTreeBefore = readFileSync(
-      join(dir, 'modules', 'caddy', 'site', 'dist', 'index.html'),
-      'utf-8',
-    );
-    const result = await writeStaticContentVars(
-      db,
-      'caddy',
-      join(dir, 'modules', 'caddy', 'generated'),
-    );
-
-    expect(result.success).toBe(true);
-    const varsPath = staticContentVarsPath(join(dir, 'modules', 'caddy', 'generated'));
-    expect(existsSync(varsPath)).toBe(true);
-    expect(readFileSync(varsPath, 'utf-8')).toContain('slug: caddy');
-
-    // Task 4.7: the converge path is read-only over the module tree. The
-    // clientConfig write into it is celilo#1018 and belongs to that thread —
-    // THIS path must not add a second writer.
-    expect(readFileSync(join(dir, 'modules', 'caddy', 'site', 'dist', 'index.html'), 'utf-8')).toBe(
-      moduleTreeBefore,
-    );
-  });
-
-  it('buildStaticContentPlan carries the resolved retention alongside the releases', async () => {
-    db.insert(webRoutes)
-      .values({
-        slug: 'caddy',
-        moduleId: 'caddy',
-        type: 'static',
-        path: '/',
-        hostname: 'www.example.com',
-        websocket: false,
-        contentHash: HASH1,
-      })
-      .run();
-
-    const plan = buildStaticContentPlan(db, 'caddy');
-    expect(plan.retention).toBe(5);
-    expect(plan.releases).toHaveLength(1);
-  });
-});
-
-describe('the stale-project guard reaches the whole generated tree (celilo#1248)', () => {
-  let dir: string;
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), 'static-guard-reach-'));
-  });
-  afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  it('sees a converge that lives in a role task file, not in playbook.yml', () => {
-    // Mirror DERIVED from the real module, never hand-written: a hand-built
-    // tree would give confident reach data about a world that does not exist,
-    // which is the same bug one level up.
-    const real = resolve(import.meta.dir, '../../../..', 'modules/caddy/ansible');
-    cpSync(real, join(dir, 'ansible'), { recursive: true });
-
-    // The premise this guards. caddy's playbook is a thin hosts/vars/roles
-    // stanza; if it ever DOES name static_releases, this test stops proving
-    // anything and should be re-derived rather than deleted.
-    const playbook = readFileSync(join(dir, 'ansible/playbook.yml.tpl'), 'utf-8');
-    expect(playbook).not.toContain('static_releases');
-
-    expect(ansibleTreeMentions(join(dir, 'ansible'), 'static_releases')).toBe(true);
-  });
-
-  it('still refuses a project that mentions the var nowhere', () => {
-    // A pre-converge generated project. Hand-built deliberately, and it has to
-    // be: no deploy on today's code can produce a tree without the role tasks,
-    // so this legacy shape is the fixture and not a shortcut.
-    mkdirSync(join(dir, 'ansible/roles/caddy/tasks'), { recursive: true });
-    writeFileSync(
-      join(dir, 'ansible/playbook.yml'),
-      '---\n- hosts: caddy\n  roles:\n    - caddy\n',
-    );
-    writeFileSync(
-      join(dir, 'ansible/roles/caddy/tasks/main.yml'),
-      '---\n- name: install\n  debug: {}\n',
-    );
-
-    expect(ansibleTreeMentions(join(dir, 'ansible'), 'static_releases')).toBe(false);
-  });
-
-  it('ignores non-text files rather than reading assets as utf-8', () => {
-    mkdirSync(join(dir, 'ansible/files'), { recursive: true });
-    writeFileSync(join(dir, 'ansible/files/logo.png'), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
-    writeFileSync(join(dir, 'ansible/site.yml'), 'vars:\n  static_releases: []\n');
-
-    expect(ansibleTreeMentions(join(dir, 'ansible'), 'static_releases')).toBe(true);
-    expect(ansibleTreeMentions(join(dir, 'ansible'), 'PNG')).toBe(false);
-  });
-});