@ktpartners/dgs-platform 2.6.3 → 2.7.0

package/deliver-great-systems/test/sync-workflow.test.cjs

@@ -0,0 +1,562 @@
+/**
+ * DGS Tools Tests - Sync Workflow Orchestration
+ *
+ * Tests for workflowPull, workflowPush, checkStaleState,
+ * suppression tracking, and first-run hint functions from sync.cjs.
+ * Uses isolated git fixture repos (not mocks) for realistic testing.
+ */
+
+const { describe, test, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const sync = require('../bin/lib/sync.cjs');
+
+// ─── Test Helpers ────────────────────────────────────────────────────────────
+
+/**
+ * Create a bare remote and a cloned local repo for realistic push/pull testing.
+ */
+function createGitFixture(tmpBase, name) {
+  const remotePath = path.join(tmpBase, `${name}-remote.git`);
+  fs.mkdirSync(remotePath, { recursive: true });
+  execSync('git init --bare', { cwd: remotePath, stdio: 'pipe' });
+
+  const localPath = path.join(tmpBase, name);
+  execSync(`git clone "${remotePath}" "${localPath}"`, { stdio: 'pipe' });
+
+  execSync('git config user.email "test@test.com"', { cwd: localPath, stdio: 'pipe' });
+  execSync('git config user.name "Test"', { cwd: localPath, stdio: 'pipe' });
+
+  fs.writeFileSync(path.join(localPath, 'README.md'), '# Test');
+  execSync('git add -A && git commit -m "Initial commit"', { cwd: localPath, stdio: 'pipe' });
+
+  const branch = execSync('git branch --show-current', { cwd: localPath, encoding: 'utf-8', stdio: 'pipe' }).trim();
+  execSync(`git push -u origin ${branch}`, { cwd: localPath, stdio: 'pipe' });
+
+  return { localPath, remotePath, branch };
+}
+
+/**
+ * Create a product directory (planning repo) with minimal DGS structure.
+ */
+function createProductFixture(tmpBase, configOverrides = {}) {
+  const { localPath, remotePath, branch } = createGitFixture(tmpBase, 'product');
+
+  fs.mkdirSync(path.join(localPath, '.planning'), { recursive: true });
+
+  const defaultConfig = { git: { sync_push: 'auto', sync_pull: 'auto' } };
+  const config = { ...defaultConfig, ...configOverrides };
+  if (configOverrides.git) {
+    config.git = { ...defaultConfig.git, ...configOverrides.git };
+  }
+
+  fs.writeFileSync(
+    path.join(localPath, '.planning', 'config.json'),
+    JSON.stringify(config, null, 2)
+  );
+
+  execSync('git add -A && git commit -m "Add planning structure"', { cwd: localPath, stdio: 'pipe' });
+  execSync(`git push origin ${branch}`, { cwd: localPath, stdio: 'pipe' });
+
+  return { productPath: localPath, remotePath, branch };
+}
+
+/**
+ * Push a new commit to a bare remote via a temporary second clone.
+ */
+function pushCommitToRemote(remotePath, branch, tmpBase, fileName, message) {
+  const clonePath = path.join(tmpBase, 'remote-push-clone-' + Date.now());
+  execSync(`git clone "${remotePath}" "${clonePath}"`, { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { cwd: clonePath, stdio: 'pipe' });
+  execSync('git config user.name "Test"', { cwd: clonePath, stdio: 'pipe' });
+  fs.writeFileSync(path.join(clonePath, fileName), `Content: ${message}`);
+  execSync(`git add -A && git commit -m "${message}"`, { cwd: clonePath, stdio: 'pipe' });
+  execSync(`git push origin ${branch}`, { cwd: clonePath, stdio: 'pipe' });
+  fs.rmSync(clonePath, { recursive: true, force: true });
+}
+
+/**
+ * Create a mock IO object with configurable prompt answers.
+ */
+function createMockIO(promptAnswers = []) {
+  const stderrLog = [];
+  const promptLog = [];
+  const answers = [...promptAnswers]; // copy to avoid mutation issues
+  return {
+    prompt: async (msg) => {
+      promptLog.push(msg);
+      return answers.shift() || '';
+    },
+    stderr: (msg) => stderrLog.push(msg),
+    stderrLog,
+    promptLog,
+  };
+}
+
+/**
+ * Clean up suppression temp files for a given direction.
+ */
+function cleanSuppression(direction) {
+  try { fs.unlinkSync(sync.getSuppressionFile(direction)); } catch {}
+}
+
+// ─── workflowPull ────────────────────────────────────────────────────────────
+
+describe('workflowPull', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-wfpull-'));
+    cleanSuppression('pull');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    cleanSuppression('pull');
+  });
+
+  test('returns skipped when cadencePull is false', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'auto',
+      cadencePull: false,
+      io: createMockIO(),
+    });
+    assert.strictEqual(result.action, 'skipped');
+  });
+
+  test('returns skipped when syncMode is off', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'off',
+      cadencePull: true,
+      io: createMockIO(),
+    });
+    assert.strictEqual(result.action, 'skipped');
+  });
+
+  test('pulls silently in auto mode', async () => {
+    const { productPath, remotePath, branch } = createProductFixture(tmpDir);
+    pushCommitToRemote(remotePath, branch, tmpDir, 'auto-pull.txt', 'Auto pull commit');
+
+    const io = createMockIO();
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'auto',
+      cadencePull: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'pulled');
+    assert.strictEqual(io.promptLog.length, 0, 'Should not prompt in auto mode');
+  });
+
+  test('returns pulled with summary when remote has new commits', async () => {
+    const { productPath, remotePath, branch } = createProductFixture(tmpDir);
+    pushCommitToRemote(remotePath, branch, tmpDir, 'new-commit.txt', 'New commit');
+
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'auto',
+      cadencePull: true,
+      io: createMockIO(),
+    });
+    assert.strictEqual(result.action, 'pulled');
+    assert.ok(result.message, 'Should have a summary message');
+  });
+
+  test('returns pulled with Already up to date when current', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+    // No new commits pushed to remote -- already current
+
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'auto',
+      cadencePull: true,
+      io: createMockIO(),
+    });
+    assert.strictEqual(result.action, 'pulled');
+  });
+
+  test('prompts in prompt mode and pulls on Yes', async () => {
+    const { productPath, remotePath, branch } = createProductFixture(tmpDir);
+    pushCommitToRemote(remotePath, branch, tmpDir, 'prompt-yes.txt', 'Prompt yes commit');
+
+    const io = createMockIO(['Y']);
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'prompt',
+      cadencePull: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'pulled');
+    assert.ok(io.promptLog.length > 0, 'Should have prompted');
+    assert.ok(io.promptLog[0].includes('[Y/n]'), 'Prompt should include [Y/n]');
+  });
+
+  test('skips pull on No answer in prompt mode', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+
+    const io = createMockIO(['n']);
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'prompt',
+      cadencePull: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'skipped');
+    assert.ok(result.message.includes('declined'), `Expected "declined" in message, got: ${result.message}`);
+  });
+
+  test('aborts on pull failure with diagnosis in auto mode', async () => {
+    const { productPath, remotePath, branch } = createProductFixture(tmpDir);
+
+    // Create diverged history: push a commit to remote AND create a different local commit
+    pushCommitToRemote(remotePath, branch, tmpDir, 'diverge-remote.txt', 'Remote diverge');
+
+    // Create a local commit that diverges from remote
+    fs.writeFileSync(path.join(productPath, 'diverge-local.txt'), 'local diverge');
+    execSync('git add -A && git commit -m "Local diverge"', { cwd: productPath, stdio: 'pipe' });
+
+    // Now fetch so origin/branch is known, then try to ff-only merge which will fail
+    const io = createMockIO();
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'auto',
+      cadencePull: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'aborted');
+    assert.ok(io.stderrLog.length > 0, 'Should have written diagnosis to stderr');
+  });
+
+  test('offers override on pull failure in prompt mode and user accepts', async () => {
+    const { productPath, remotePath, branch } = createProductFixture(tmpDir);
+
+    // Diverge history
+    pushCommitToRemote(remotePath, branch, tmpDir, 'diverge-remote2.txt', 'Remote diverge 2');
+    fs.writeFileSync(path.join(productPath, 'diverge-local2.txt'), 'local diverge 2');
+    execSync('git add -A && git commit -m "Local diverge 2"', { cwd: productPath, stdio: 'pipe' });
+
+    // First answer: 'Y' to pull, second answer: 'y' to override (continue without pulling)
+    const io = createMockIO(['Y', 'y']);
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'prompt',
+      cadencePull: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'skipped');
+    assert.ok(result.message.includes('continue'), `Expected "continue" in message, got: ${result.message}`);
+  });
+
+  test('override declined returns aborted', async () => {
+    const { productPath, remotePath, branch } = createProductFixture(tmpDir);
+
+    // Diverge history
+    pushCommitToRemote(remotePath, branch, tmpDir, 'diverge-remote3.txt', 'Remote diverge 3');
+    fs.writeFileSync(path.join(productPath, 'diverge-local3.txt'), 'local diverge 3');
+    execSync('git add -A && git commit -m "Local diverge 3"', { cwd: productPath, stdio: 'pipe' });
+
+    // First answer: 'Y' to pull, second answer: 'n' to decline override
+    const io = createMockIO(['Y', 'n']);
+    const result = await sync.workflowPull(productPath, {
+      syncMode: 'prompt',
+      cadencePull: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'aborted');
+  });
+});
+
+// ─── workflowPush ────────────────────────────────────────────────────────────
+
+describe('workflowPush', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-wfpush-'));
+    cleanSuppression('push');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    cleanSuppression('push');
+  });
+
+  test('returns skipped when cadencePush is false', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+    const result = await sync.workflowPush(productPath, {
+      syncMode: 'auto',
+      cadencePush: false,
+      io: createMockIO(),
+    });
+    assert.strictEqual(result.action, 'skipped');
+  });
+
+  test('returns skipped when syncMode is off', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+    const result = await sync.workflowPush(productPath, {
+      syncMode: 'off',
+      cadencePush: true,
+      io: createMockIO(),
+    });
+    assert.strictEqual(result.action, 'skipped');
+  });
+
+  test('pushes silently in auto mode', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+
+    // Create a local commit to push
+    fs.writeFileSync(path.join(productPath, 'auto-push.txt'), 'auto push');
+    execSync('git add -A && git commit -m "Auto push commit"', { cwd: productPath, stdio: 'pipe' });
+
+    const io = createMockIO();
+    const result = await sync.workflowPush(productPath, {
+      syncMode: 'auto',
+      cadencePush: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'pushed');
+    assert.strictEqual(io.promptLog.length, 0, 'Should not prompt in auto mode');
+  });
+
+  test('prompts in prompt mode and pushes on Yes', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+
+    fs.writeFileSync(path.join(productPath, 'prompt-push.txt'), 'prompt push');
+    execSync('git add -A && git commit -m "Prompt push commit"', { cwd: productPath, stdio: 'pipe' });
+
+    const io = createMockIO(['Y']);
+    const result = await sync.workflowPush(productPath, {
+      syncMode: 'prompt',
+      cadencePush: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'pushed');
+    assert.ok(io.promptLog.length > 0, 'Should have prompted');
+  });
+
+  test('skips push on No answer in prompt mode', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+
+    const io = createMockIO(['n']);
+    const result = await sync.workflowPush(productPath, {
+      syncMode: 'prompt',
+      cadencePush: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'skipped');
+    assert.ok(result.message.includes('declined'), `Expected "declined" in message, got: ${result.message}`);
+  });
+
+  test('returns warning on push failure without aborting', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+
+    // Create a local commit
+    fs.writeFileSync(path.join(productPath, 'fail-push.txt'), 'fail push');
+    execSync('git add -A && git commit -m "Fail push commit"', { cwd: productPath, stdio: 'pipe' });
+
+    // Break the remote by removing it and adding a non-existent URL
+    execSync('git remote remove origin', { cwd: productPath, stdio: 'pipe' });
+    execSync('git remote add origin /tmp/nonexistent-remote-' + Date.now(), { cwd: productPath, stdio: 'pipe' });
+
+    const io = createMockIO();
+    const result = await sync.workflowPush(productPath, {
+      syncMode: 'auto',
+      cadencePush: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'warning');
+    assert.ok(result.message.includes('Warning'), `Expected "Warning" in message, got: ${result.message}`);
+  });
+
+  test('mid-workflow push is silent (no prompt)', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+
+    fs.writeFileSync(path.join(productPath, 'mid-push.txt'), 'mid push');
+    execSync('git add -A && git commit -m "Mid push commit"', { cwd: productPath, stdio: 'pipe' });
+
+    const io = createMockIO();
+    const result = await sync.workflowPush(productPath, {
+      syncMode: 'prompt',
+      cadencePush: true,
+      midWorkflow: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'pushed');
+    assert.strictEqual(io.promptLog.length, 0, 'Mid-workflow push should not prompt');
+  });
+
+  test('push summary includes commit count', async () => {
+    const { productPath } = createProductFixture(tmpDir);
+
+    fs.writeFileSync(path.join(productPath, 'summary-push.txt'), 'summary push');
+    execSync('git add -A && git commit -m "Summary push commit"', { cwd: productPath, stdio: 'pipe' });
+
+    const io = createMockIO();
+    const result = await sync.workflowPush(productPath, {
+      syncMode: 'auto',
+      cadencePush: true,
+      io,
+    });
+    assert.strictEqual(result.action, 'pushed');
+    assert.ok(result.message.includes('commit'), `Expected "commit" in summary message, got: ${result.message}`);
+  });
+});
+
+// ─── Suppression Window ──────────────────────────────────────────────────────
+
+describe('Suppression window', () => {
+  beforeEach(() => {
+    cleanSuppression('pull');
+    cleanSuppression('push');
+  });
+
+  afterEach(() => {
+    cleanSuppression('pull');
+    cleanSuppression('push');
+  });
+
+  test('isWithinSuppressionWindow returns false initially', () => {
+    assert.strictEqual(sync.isWithinSuppressionWindow('pull'), false);
+    assert.strictEqual(sync.isWithinSuppressionWindow('push'), false);
+  });
+
+  test('recordPromptYes then isWithinSuppressionWindow returns true', () => {
+    sync.recordPromptYes('pull');
+    assert.strictEqual(sync.isWithinSuppressionWindow('pull'), true);
+    // Push should still be false
+    assert.strictEqual(sync.isWithinSuppressionWindow('push'), false);
+  });
+
+  test('suppression expires after window', () => {
+    // Write a timestamp that is older than the suppression window
+    const expiredTs = Date.now() - sync.SUPPRESSION_WINDOW_MS - 1000;
+    const dir = path.dirname(sync.getSuppressionFile('pull'));
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(sync.getSuppressionFile('pull'), String(expiredTs));
+
+    assert.strictEqual(sync.isWithinSuppressionWindow('pull'), false);
+  });
+
+  test('workflowPull auto-pulls when suppressed in prompt mode', async () => {
+    let tmpDir;
+    try {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-wfsup-'));
+      const { productPath, remotePath, branch } = createProductFixture(tmpDir);
+      pushCommitToRemote(remotePath, branch, tmpDir, 'suppressed.txt', 'Suppressed commit');
+
+      // Record a recent Yes answer to suppress the prompt
+      sync.recordPromptYes('pull');
+
+      const io = createMockIO();
+      const result = await sync.workflowPull(productPath, {
+        syncMode: 'prompt',
+        cadencePull: true,
+        io,
+      });
+      assert.strictEqual(result.action, 'pulled');
+      assert.strictEqual(io.promptLog.length, 0, 'Should not prompt when suppressed');
+    } finally {
+      if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
+
+// ─── Stale-State Detection ───────────────────────────────────────────────────
+
+describe('checkStaleState', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-stale-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('returns stale=false when up to date', () => {
+    const { productPath } = createProductFixture(tmpDir);
+
+    const result = sync.checkStaleState(productPath);
+    assert.strictEqual(result.stale, false);
+    assert.strictEqual(result.commitsBehind, 0);
+  });
+
+  test('returns stale=true with commitsBehind count', () => {
+    const { productPath, remotePath, branch } = createProductFixture(tmpDir);
+
+    // Push commits to remote from another clone
+    pushCommitToRemote(remotePath, branch, tmpDir, 'stale1.txt', 'Stale commit 1');
+    pushCommitToRemote(remotePath, branch, tmpDir, 'stale2.txt', 'Stale commit 2');
+
+    const result = sync.checkStaleState(productPath);
+    assert.strictEqual(result.stale, true);
+    assert.strictEqual(result.commitsBehind, 2);
+    assert.ok(result.branch, 'Should include branch name');
+  });
+
+  test('returns stale=false when no remote', () => {
+    // Create a product without a remote
+    const productPath = path.join(tmpDir, 'no-remote-product');
+    fs.mkdirSync(path.join(productPath, '.planning'), { recursive: true });
+    execSync('git init', { cwd: productPath, stdio: 'pipe' });
+    execSync('git config user.email "test@test.com"', { cwd: productPath, stdio: 'pipe' });
+    execSync('git config user.name "Test"', { cwd: productPath, stdio: 'pipe' });
+    fs.writeFileSync(path.join(productPath, 'README.md'), '# No Remote');
+    fs.writeFileSync(
+      path.join(productPath, '.planning', 'config.json'),
+      JSON.stringify({ git: { sync_push: 'off', sync_pull: 'off' } }, null, 2)
+    );
+    execSync('git add -A && git commit -m "Init"', { cwd: productPath, stdio: 'pipe' });
+
+    const result = sync.checkStaleState(productPath);
+    assert.strictEqual(result.stale, false);
+    assert.strictEqual(result.commitsBehind, 0);
+  });
+});
+
+// ─── First-Run Hint ──────────────────────────────────────────────────────────
+
+describe('First-run hint', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-hint-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('shouldShowFirstRunHint returns true when remote exists and sync is off', () => {
+    const { productPath } = createProductFixture(tmpDir, {
+      git: { sync_push: 'off', sync_pull: 'off' },
+    });
+
+    const result = sync.shouldShowFirstRunHint(productPath);
+    assert.strictEqual(result, true);
+  });
+
+  test('shouldShowFirstRunHint returns false after markFirstRunHintShown', () => {
+    const { productPath } = createProductFixture(tmpDir, {
+      git: { sync_push: 'off', sync_pull: 'off' },
+    });
+
+    // Initially should show
+    assert.strictEqual(sync.shouldShowFirstRunHint(productPath), true);
+
+    // Mark shown
+    sync.markFirstRunHintShown(productPath);
+
+    // Now should not show
+    assert.strictEqual(sync.shouldShowFirstRunHint(productPath), false);
+  });
+
+  test('shouldShowFirstRunHint returns false when sync is configured', () => {
+    const { productPath } = createProductFixture(tmpDir, {
+      git: { sync_push: 'prompt', sync_pull: 'prompt' },
+    });
+
+    const result = sync.shouldShowFirstRunHint(productPath);
+    assert.strictEqual(result, false);
+  });
+});