@dalzoubi/dev-agents-sync 1.0.0

package/tests/update.test.mjs

@@ -0,0 +1,322 @@
+/**
+ * tests/update.test.mjs
+ *
+ * Tests for the `update` subcommand.
+ *
+ * `update` reads the lockfile, resolves the latest tag within `range`,
+ * fetches that tag's dist, and rewrites managed files for the recorded targets.
+ * Unmanaged files at the same paths are NOT overwritten without --force.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  rmSync,
+  readdirSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { runUpdate } from '../src/commands/update.mjs';
+import { writeLockfile, readLockfile } from '../src/lockfile.mjs';
+import { hasMarker } from '../src/marker.mjs';
+
+// ---------------------------------------------------------------------------
+// Fixture helpers
+// ---------------------------------------------------------------------------
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURE_DIR = path.join(__dirname, 'fixtures', 'release-v1.0.0');
+
+function readFixtureContent(relativePath) {
+  return readFileSync(path.join(FIXTURE_DIR, relativePath), 'utf8');
+}
+
+/**
+ * Builds a FileMap from the fixture directory.
+ * Keys are relative paths using forward slashes.
+ */
+function buildFixtureFileMap() {
+  const map = {};
+  for (const target of ['claude', 'cursor']) {
+    const targetDir = path.join(FIXTURE_DIR, target);
+    if (!existsSync(targetDir)) continue;
+    collectFiles(targetDir, targetDir, map, target);
+  }
+  return map;
+}
+
+function collectFiles(baseDir, currentDir, map, prefix) {
+  const entries = readdirSync(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(baseDir, full, map, prefix);
+    } else {
+      const rel = path.relative(baseDir, full).replace(/\\/g, '/');
+      map[`${prefix}/${rel}`] = readFileSync(full, 'utf8');
+    }
+  }
+}
+
+/**
+ * A fetcher that returns v1.0.0 content for all tags (unit test simplification).
+ * The second fetcher simulates v1.2.0 with slightly different content.
+ */
+function makeV100Fetcher() {
+  return async (_repo, _tag, _token) => buildFixtureFileMap();
+}
+
+function makeV120Fetcher() {
+  // Same files but with v1.2.0 marker for simulation
+  return async (_repo, _tag, _token) => {
+    const base = buildFixtureFileMap();
+    const updated = {};
+    for (const [key, content] of Object.entries(base)) {
+      updated[key] = content.replace(
+        /<!-- managed-by: dev-agents-sync v[\d.]+ -->/,
+        '<!-- managed-by: dev-agents-sync v1.2.0 -->',
+      );
+    }
+    return updated;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeTmpDir() {
+  return mkdtempSync(path.join(tmpdir(), 'das-update-test-'));
+}
+
+/** Sets up a consumer repo that has already run init (has lockfile + managed files). */
+async function setupInitializedRepo(consumerDir, opts = {}) {
+  const {
+    targets = ['claude'],
+    resolvedVersion = '1.0.0',
+    range = '^1',
+    managedContent = null,
+  } = opts;
+
+  // Write lockfile
+  writeLockfile(consumerDir, {
+    source: 'github:dalzoubi/dev-agents',
+    range,
+    resolvedVersion,
+    targets,
+    lastUpdated: '2026-04-01T00:00:00Z',
+  });
+
+  // Write some managed files
+  if (targets.includes('claude')) {
+    const agentsDir = path.join(consumerDir, '.claude', 'agents');
+    mkdirSync(agentsDir, { recursive: true });
+    const content = managedContent || readFixtureContent('claude/agents/define.md');
+    writeFileSync(path.join(agentsDir, 'define.md'), content, 'utf8');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Basic update behavior
+// ---------------------------------------------------------------------------
+
+describe('update — basic behavior', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('reads the lockfile and updates resolvedVersion to the latest matching tag', async () => {
+    await setupInitializedRepo(consumerDir, { targets: ['claude'], resolvedVersion: '1.0.0' });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeV120Fetcher(),
+      availableTags: ['v1.0.0', 'v1.1.0', 'v1.2.0', 'v2.0.0'],
+    });
+
+    const lockfile = readLockfile(consumerDir);
+    assert.equal(lockfile.resolvedVersion, '1.2.0');
+  });
+
+  it('updates lastUpdated timestamp after a successful update', async () => {
+    await setupInitializedRepo(consumerDir, { resolvedVersion: '1.0.0' });
+    const before = new Date('2026-04-01T00:00:00Z').getTime();
+
+    await runUpdate(consumerDir, {
+      fetcher: makeV120Fetcher(),
+      availableTags: ['v1.0.0', 'v1.2.0'],
+    });
+
+    const lockfile = readLockfile(consumerDir);
+    assert.ok(lockfile.lastUpdated, 'lastUpdated must be present after update');
+    // lastUpdated should be a valid ISO date string
+    assert.ok(!isNaN(Date.parse(lockfile.lastUpdated)), 'lastUpdated must be a valid date');
+  });
+
+  it('rewrites managed files with new content from the resolved version', async () => {
+    await setupInitializedRepo(consumerDir, { targets: ['claude'], resolvedVersion: '1.0.0' });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeV120Fetcher(),
+      availableTags: ['v1.0.0', 'v1.2.0'],
+    });
+
+    const written = readFileSync(path.join(consumerDir, '.claude', 'agents', 'define.md'), 'utf8');
+    // The v1.2.0 fetcher replaces the marker version
+    assert.ok(
+      written.includes('v1.2.0') || hasMarker(written),
+      'rewritten file must still have managed-by marker',
+    );
+  });
+
+  it('only regenerates targets recorded in the lockfile (claude-only stays claude-only)', async () => {
+    await setupInitializedRepo(consumerDir, { targets: ['claude'], resolvedVersion: '1.0.0' });
+
+    await runUpdate(consumerDir, {
+      fetcher: makeV120Fetcher(),
+      availableTags: ['v1.0.0', 'v1.2.0'],
+    });
+
+    // .cursor/ must NOT be created even though fetcher has cursor files
+    assert.ok(
+      !existsSync(path.join(consumerDir, '.cursor')),
+      '.cursor/ must not be created when lockfile targets is ["claude"]',
+    );
+  });
+
+  it('exits 0 with "already up to date" when no upgrade is available', async () => {
+    await setupInitializedRepo(consumerDir, { targets: ['claude'], resolvedVersion: '1.2.0' });
+
+    let result;
+    await assert.doesNotReject(async () => {
+      result = await runUpdate(consumerDir, {
+        fetcher: makeV100Fetcher(),
+        availableTags: ['v1.0.0', 'v1.1.0', 'v1.2.0'],
+      });
+    });
+
+    // Result should indicate up to date (either via a field or a logged message)
+    assert.ok(
+      result?.upToDate === true ||
+        result?.message?.toLowerCase().includes('up to date') ||
+        result?.alreadyCurrent === true,
+      `expected up-to-date indicator, got: ${JSON.stringify(result)}`,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Preserves unmanaged files
+// ---------------------------------------------------------------------------
+
+describe('update — preserves unmanaged files', () => {
+  let consumerDir;
+
+  beforeEach(() => {
+    consumerDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmSync(consumerDir, { recursive: true, force: true });
+  });
+
+  it('does not overwrite an unmanaged file at a managed path (exit 1)', async () => {
+    await setupInitializedRepo(consumerDir, { targets: ['claude'], resolvedVersion: '1.0.0' });
+
+    // Replace the managed file with an unmanaged one (strip the marker)
+    writeFileSync(
+      path.join(consumerDir, '.claude', 'agents', 'define.md'),
+      '# My custom content — no marker',
+      'utf8',
+    );
+
+    let exitCode;
+    try {
+      await runUpdate(consumerDir, {
+        fetcher: makeV120Fetcher(),
+        availableTags: ['v1.0.0', 'v1.2.0'],
+      });
+      exitCode = 0;
+    } catch (err) {
+      exitCode = err.exitCode;
+    }
+
+    assert.equal(exitCode, 1, 'expected exit code 1 when unmanaged collision found during update');
+  });
+
+  it('--force overwrites unmanaged files during update', async () => {
+    await setupInitializedRepo(consumerDir, { targets: ['claude'], resolvedVersion: '1.0.0' });
+
+    writeFileSync(
+      path.join(consumerDir, '.claude', 'agents', 'define.md'),
+      '# No marker here',
+      'utf8',
+    );
+
+    await assert.doesNotReject(
+      runUpdate(consumerDir, {
+        force: true,
+        fetcher: makeV120Fetcher(),
+        availableTags: ['v1.0.0', 'v1.2.0'],
+      }),
+    );
+
+    const content = readFileSync(
+      path.join(consumerDir, '.claude', 'agents', 'define.md'),
+      'utf8',
+    );
+    assert.ok(hasMarker(content), 'force-overwritten file must now have the managed-by marker');
+  });
+
+  it('leaves files outside managed paths completely untouched', async () => {
+    await setupInitializedRepo(consumerDir, { targets: ['claude'], resolvedVersion: '1.0.0' });
+
+    // A completely unrelated file in .claude/
+    const customFile = path.join(consumerDir, '.claude', 'my-custom-skill.md');
+    mkdirSync(path.join(consumerDir, '.claude'), { recursive: true });
+    writeFileSync(customFile, '# My Custom Skill\nNot managed.', 'utf8');
+
+    await runUpdate(consumerDir, {
+      fetcher: makeV120Fetcher(),
+      availableTags: ['v1.0.0', 'v1.2.0'],
+    });
+
+    // Custom file must still exist with original content
+    assert.ok(existsSync(customFile), 'unrelated custom file must not be deleted');
+    const content = readFileSync(customFile, 'utf8');
+    assert.equal(content, '# My Custom Skill\nNot managed.');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lockfile is required
+// ---------------------------------------------------------------------------
+
+describe('update — lockfile required', () => {
+  it('throws an actionable error when no lockfile exists', async () => {
+    const emptyDir = makeTmpDir();
+    try {
+      await assert.rejects(
+        runUpdate(emptyDir, {
+          fetcher: makeV100Fetcher(),
+          availableTags: ['v1.0.0'],
+        }),
+        /lockfile|\.dev-agents-sync|init/i,
+      );
+    } finally {
+      rmSync(emptyDir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/writer-normalize.test.mjs

@@ -0,0 +1,99 @@
+/**
+ * tests/writer-normalize.test.mjs
+ *
+ * Tests for normalizeFileMap's tolerance + visibility behavior.
+ *
+ * The function still accepts un-prefixed first segments that map onto a
+ * known target subdir (claude/agents, claude/commands, cursor/rules) but
+ * must emit a stderr warning when an unrecognized key is silently dropped,
+ * so content-loss is observable during development.
+ *
+ * (Slice 4 will pin the fetcher to prefixed shape and remove this tolerance.)
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { normalizeFileMap } from '../src/writer.mjs';
+
+describe('normalizeFileMap — tolerance + visibility', () => {
+  it('passes through already-prefixed keys untouched', () => {
+    const out = normalizeFileMap({
+      'claude/agents/define.md': 'A',
+      'cursor/rules/x.mdc': 'B',
+    });
+    assert.equal(out['claude/agents/define.md'], 'A');
+    assert.equal(out['cursor/rules/x.mdc'], 'B');
+  });
+
+  it('infers prefix for known un-prefixed first segments', () => {
+    const out = normalizeFileMap({
+      'agents/define.md': 'A',
+      'rules/x.mdc': 'B',
+    });
+    assert.equal(out['claude/agents/define.md'], 'A');
+    assert.equal(out['cursor/rules/x.mdc'], 'B');
+  });
+
+  it('drops unrecognized keys and emits a stderr warning naming the key', () => {
+    const origWrite = process.stderr.write.bind(process.stderr);
+    let captured = '';
+    // Intercept stderr writes for the duration of this test.
+    process.stderr.write = (chunk, ...rest) => {
+      captured += typeof chunk === 'string' ? chunk : chunk.toString();
+      return true;
+    };
+    try {
+      const out = normalizeFileMap({
+        'foo/bar.md': 'should-be-dropped',
+        'claude/agents/keep.md': 'kept',
+      });
+
+      assert.equal(
+        out['foo/bar.md'],
+        undefined,
+        'unrecognized key must not appear in output',
+      );
+      assert.equal(out['claude/agents/keep.md'], 'kept');
+
+      assert.ok(
+        captured.includes('warn:'),
+        `expected stderr warning, got: ${JSON.stringify(captured)}`,
+      );
+      assert.ok(
+        captured.includes('dev-agents-sync'),
+        `warning must be tagged with the package name: ${captured}`,
+      );
+      assert.ok(
+        captured.includes("'foo/bar.md'"),
+        `warning must name the dropped key: ${captured}`,
+      );
+    } finally {
+      process.stderr.write = origWrite;
+    }
+  });
+
+  it('does not warn for recognized keys', () => {
+    const origWrite = process.stderr.write.bind(process.stderr);
+    let captured = '';
+    process.stderr.write = (chunk) => {
+      captured += typeof chunk === 'string' ? chunk : chunk.toString();
+      return true;
+    };
+    try {
+      normalizeFileMap({
+        'claude/agents/define.md': 'A',
+        'agents/test.md': 'B',
+        'cursor/rules/r.mdc': 'C',
+        'rules/s.mdc': 'D',
+      });
+      assert.equal(
+        captured,
+        '',
+        `expected no stderr output for recognized keys, got: ${captured}`,
+      );
+    } finally {
+      process.stderr.write = origWrite;
+    }
+  });
+});