jettypod 4.1.2 → 4.1.4

package/features/step_definitions/multiple-claude-instances.steps.js

@@ -1,621 +0,0 @@
-const { Given, When, Then, Before, After } = require('@cucumber/cucumber');
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const pushQueue = require('../../lib/push-queue');
-const gitCoordinator = require('../../lib/git-coordinator');
-
-// Test state
-let testState = {
-  queueFile: null,
-  testDir: null,
-  instanceId: null,
-  commitSha: null,
-  queuePosition: null,
-  mainCommitCount: 0
-};
-
-Before({ tags: '@multiple-instances' }, function () {
-  // Setup test environment
-  testState.testDir = fs.mkdtempSync(path.join(__dirname, '../../test-tmp/queue-test-'));
-  testState.queueFile = path.join(testState.testDir, '.jettypod/push-queue.json');
-  testState.instanceId = `test-instance-${Date.now()}`;
-
-  // Create .jettypod directory
-  fs.mkdirSync(path.join(testState.testDir, '.jettypod'), { recursive: true });
-
-  // Initialize empty queue
-  fs.writeFileSync(testState.queueFile, JSON.stringify({ queue: [] }));
-
-  // Setup git repo
-  process.chdir(testState.testDir);
-  execSync('git init');
-  execSync('git config user.email "test@test.com"');
-  execSync('git config user.name "Test User"');
-  execSync('touch README.md');
-  execSync('git add .');
-  execSync('git commit -m "Initial commit"');
-});
-
-After({ tags: '@multiple-instances' }, function () {
-  // Cleanup test directory
-  if (testState.testDir && fs.existsSync(testState.testDir)) {
-    // Restore permissions if they were changed
-    if (testState.permissionError && testState.queueFile && fs.existsSync(testState.queueFile)) {
-      try {
-        fs.chmodSync(testState.queueFile, 0o644);
-      } catch (err) {
-        // Ignore chmod errors during cleanup
-      }
-    }
-    fs.rmSync(testState.testDir, { recursive: true, force: true });
-  }
-  testState = {
-    queueFile: null,
-    testDir: null,
-    instanceId: null,
-    commitSha: null,
-    queuePosition: null,
-    mainCommitCount: 0
-  };
-});
-
-Given('I am a Claude Code instance with completed work', function () {
-  // Create a test file representing completed work
-  fs.writeFileSync(path.join(testState.testDir, 'work.txt'), 'completed work');
-});
-
-Given('I have committed my changes locally', function () {
-  execSync('git add .');
-  execSync('git commit -m "Complete work"');
-  testState.commitSha = execSync('git rev-parse HEAD').toString().trim();
-});
-
-Given('the push queue is empty', function () {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  assert.strictEqual(queue.queue.length, 0);
-});
-
-Given('main branch has no new commits', function () {
-  // In test, we're already on main and it hasn't moved
-  testState.mainCommitCount = execSync('git rev-list --count HEAD').toString().trim();
-});
-
-Given('main branch has {int} new commits since my work started', function (count) {
-  // Simulate main moving ahead
-  for (let i = 0; i < count; i++) {
-    fs.writeFileSync(path.join(testState.testDir, `file${i}.txt`), `content ${i}`);
-    execSync('git add .');
-    execSync(`git commit -m "Remote commit ${i + 1}"`);
-  }
-  testState.mainCommitCount = parseInt(execSync('git rev-list --count HEAD').toString().trim());
-});
-
-Given('Claude instance A is at position {int} in the push queue', function (position) {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  queue.queue.push({
-    instanceId: 'claude-instance-a',
-    position: position,
-    commitSha: 'abc123',
-    timestamp: Date.now()
-  });
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue, null, 2));
-});
-
-Given('Claude instance A is at position {int} and is pushing', function (position) {
-  // Mark instance A as actively pushing
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const entry = queue.queue.find(e => e.instanceId === 'claude-instance-a');
-  entry.status = 'pushing';
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue, null, 2));
-});
-
-When('I attempt to push to main', function () {
-  // This would trigger the queue coordination logic
-  // Use the pushQueue module to test error handling
-  try {
-    const queue = pushQueue.getQueue();
-    testState.queueReadSuccess = true;
-
-    if (queue.length === 0 && testState.mainCommitCount === 1) {
-      // Direct push scenario
-      testState.pushMethod = 'direct';
-    } else {
-      // Queue entry scenario - use pushQueue.addToQueue()
-      try {
-        const position = pushQueue.addToQueue(testState.instanceId, testState.commitSha || 'abc123');
-        testState.queuePosition = position;
-        testState.pushMethod = 'queued';
-      } catch (addErr) {
-        testState.addToQueueError = addErr;
-        testState.pushMethod = 'failed';
-      }
-    }
-  } catch (err) {
-    testState.queueReadError = err;
-    testState.pushMethod = 'failed';
-  }
-});
-
-When('Claude instance A completes their push', function () {
-  // Simulate instance A finishing
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  queue.queue = queue.queue.filter(e => e.instanceId !== 'claude-instance-a');
-
-  // Update positions
-  queue.queue.forEach((entry, index) => {
-    entry.position = index + 1;
-  });
-
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue, null, 2));
-});
-
-Then('I push directly to main', function () {
-  assert.strictEqual(testState.pushMethod, 'direct');
-});
-
-Then('I do not create a queue entry', function () {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const myEntry = queue.queue.find(e => e.instanceId === testState.instanceId);
-  assert.strictEqual(myEntry, undefined);
-});
-
-Then('I create a queue entry at position {int}', function (position) {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const myEntry = queue.queue.find(e => e.instanceId === testState.instanceId);
-  assert.ok(myEntry);
-  assert.strictEqual(myEntry.position, position);
-});
-
-Then('I see {string}', function (message) {
-  // In real implementation, this would be console output
-  // For test, just verify the queue state matches the message
-  assert.ok(testState.queuePosition !== null);
-});
-
-Then('I rebase my commits on top of main', function () {
-  // Simulate rebase (in test, just verify we would do it)
-  assert.ok(testState.mainCommitCount > 1 || testState.queuePosition === 1);
-});
-
-Then('I push to main', function () {
-  // Verify we would push
-  assert.ok(testState.pushMethod === 'direct' || testState.queuePosition === 1);
-});
-
-Then('I remove my queue entry', function () {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const myEntry = queue.queue.find(e => e.instanceId === testState.instanceId);
-  // Entry should be removed after push
-  assert.strictEqual(myEntry, undefined);
-});
-
-Then('I do not push yet', function () {
-  assert.ok(testState.queuePosition > 1);
-});
-
-Then('I wait for position {int} to complete', function (position) {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const aheadOfMe = queue.queue.filter(e => e.position < testState.queuePosition);
-  assert.ok(aheadOfMe.length > 0);
-});
-
-Then('I move to position {int}', function (position) {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const myEntry = queue.queue.find(e => e.instanceId === testState.instanceId);
-  assert.strictEqual(myEntry.position, position);
-});
-
-// STABLE MODE: Error handling and edge case step definitions
-
-Given('the push queue file exists but contains invalid JSON', function () {
-  fs.writeFileSync(testState.queueFile, '{ invalid json content }');
-  testState.queueCorrupted = true;
-});
-
-Given('the .jettypod directory has no write permissions', function () {
-  // Make the queue file read-only to trigger permission errors
-  fs.chmodSync(testState.queueFile, 0o444); // Read-only file
-  testState.permissionError = true;
-});
-
-Given('my changes conflict with changes on main', function () {
-  // Create a file that will conflict
-  fs.writeFileSync(path.join(testState.testDir, 'conflict.txt'), 'my version');
-  execSync('git add .');
-  execSync('git commit -m "My conflicting change"');
-
-  // Go back and create conflicting change on main
-  execSync('git reset --hard HEAD~1');
-  fs.writeFileSync(path.join(testState.testDir, 'conflict.txt'), 'main version');
-  execSync('git add .');
-  execSync('git commit -m "Main conflicting change"');
-
-  testState.hasConflict = true;
-});
-
-Given('I am checking if main has moved ahead', function () {
-  testState.checkingMain = true;
-});
-
-When('git fetch fails due to network connectivity', function () {
-  testState.networkError = true;
-  testState.pushMethod = 'failed'; // Push should not proceed
-  // Simulate network error - in production checkMainAhead() would throw with network error
-});
-
-When('I attempt to rebase on main', function () {
-  // In test environment, simulate rebase by checking for conflict scenario
-  // Real implementation would call gitCoordinator.rebaseOnMain()
-
-  if (testState.hasConflict) {
-    // Simulate the error that would be thrown by rebaseOnMain()
-    const conflictError = new Error('Rebase conflicts - manual resolution required');
-    testState.rebaseError = conflictError;
-    testState.hasConflictError = true;
-  } else {
-    // Try actual rebase if no conflict scenario
-    try {
-      // Note: In production, this calls git rebase which will detect real conflicts
-      // In test, we simulate since test git repo doesn't have proper remotes
-      testState.rebaseSuccess = true;
-    } catch (err) {
-      testState.rebaseError = err;
-    }
-  }
-});
-
-Given('I have successfully rebased on main', function () {
-  testState.rebaseSuccess = true;
-});
-
-When('git push fails due to remote rejection', function () {
-  testState.pushRejected = true;
-  // Simulate push rejection - actual error detection is in pushDirectlyToMain
-});
-
-Given('the queue contains an entry with missing instanceId', function () {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  queue.queue.push({
-    // Missing instanceId
-    commitSha: 'abc123',
-    position: 1,
-    timestamp: Date.now()
-  });
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue, null, 2));
-  testState.invalidEntry = true;
-});
-
-When('the queue processor attempts to process entries', function () {
-  testState.processingQueue = true;
-  // Actually call getQueue to test invalid entry filtering
-  try {
-    const queue = pushQueue.getQueue();
-    testState.processedQueue = queue;
-  } catch (err) {
-    testState.processingError = err;
-  }
-});
-
-Given('a queue entry has been waiting for over 1 hour', function () {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const oneHourAgo = Date.now() - (60 * 60 * 1000 + 1);
-
-  // Add stale entry at position 1
-  queue.queue.push({
-    instanceId: 'stale-instance',
-    commitSha: 'abc123',
-    position: 1,
-    timestamp: oneHourAgo,
-    status: 'waiting'
-  });
-
-  // Add fresh entry at position 2 (should advance to position 1 after cleanup)
-  queue.queue.push({
-    instanceId: 'fresh-instance',
-    commitSha: 'def456',
-    position: 2,
-    timestamp: Date.now(),
-    status: 'waiting'
-  });
-
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue, null, 2));
-  testState.hasStaleEntry = true;
-});
-
-Given('the instance that created it is no longer running', function () {
-  testState.instanceDead = true;
-});
-
-When('queue cleanup runs', function () {
-  // Save current directory and switch to test directory
-  const originalCwd = process.cwd();
-  process.chdir(testState.testDir);
-
-  try {
-    // Call the actual cleanup function (1 hour = 3600000ms)
-    const removedCount = pushQueue.cleanupStaleEntries(3600000);
-    testState.cleanupRan = true;
-    testState.removedStaleCount = removedCount;
-  } finally {
-    // Restore original directory
-    process.chdir(originalCwd);
-  }
-});
-
-Given('two Claude instances both try to add queue entries at same time', function () {
-  testState.concurrentWrites = true;
-});
-
-When('concurrent queue writes occur', function () {
-  // Simulate concurrent writes
-  const queue1 = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const queue2 = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-
-  queue1.queue.push({ instanceId: 'instance-1', commitSha: 'sha1', position: 1, timestamp: Date.now() });
-  queue2.queue.push({ instanceId: 'instance-2', commitSha: 'sha2', position: 1, timestamp: Date.now() });
-
-  // Both write - last write wins in simple implementation
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue1, null, 2));
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue2, null, 2));
-
-  testState.concurrentWritesDone = true;
-});
-
-Given('I attempt to add a queue entry with empty commit SHA', function () {
-  testState.emptyCommitSha = true;
-});
-
-When('validation runs', function () {
-  testState.validationRan = true;
-  // Actually call addToQueue with empty commit SHA to test validation
-  try {
-    pushQueue.addToQueue(testState.instanceId, '');
-    testState.validationPassed = true;
-  } catch (err) {
-    testState.validationError = err;
-  }
-});
-
-Given('I am at position {int} in the queue', function (position) {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-
-  // Add entries before me
-  for (let i = 1; i < position; i++) {
-    queue.queue.push({
-      instanceId: `instance-${i}`,
-      commitSha: `sha${i}`,
-      position: i,
-      timestamp: Date.now()
-    });
-  }
-
-  // Add my entry
-  queue.queue.push({
-    instanceId: testState.instanceId,
-    commitSha: testState.commitSha,
-    position: position,
-    timestamp: Date.now()
-  });
-
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue, null, 2));
-  testState.queuePosition = position;
-});
-
-When('entry at position {int} is removed \\(not completed normally)', function (position) {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  queue.queue = queue.queue.filter(e => e.position !== position);
-
-  // Recompute positions
-  queue.queue.forEach((entry, index) => {
-    entry.position = index + 1;
-  });
-
-  fs.writeFileSync(testState.queueFile, JSON.stringify(queue, null, 2));
-  testState.entryRemoved = position;
-});
-
-Then('I should see an error message about corrupted queue file', function () {
-  assert.ok(testState.queueCorrupted);
-  // Verify that getQueue recovered from corruption
-  assert.ok(testState.queueReadSuccess, 'Queue should have been recovered');
-  testState.errorMessageShown = 'corrupted queue';
-});
-
-Then('the system should initialize a new empty queue', function () {
-  // The queue was reinitialized during getQueue() call
-  // This is verified by successful recovery in previous step
-  testState.queueReinitialized = true;
-});
-
-Then('I should be able to push successfully', function () {
-  // Verify we can now add to queue after recovery
-  const position = pushQueue.addToQueue(testState.instanceId, 'abc123');
-  assert.ok(position > 0, 'Should be able to add to queue after recovery');
-  testState.pushSuccessAfterError = true;
-});
-
-Then('I should see an error about insufficient permissions', function () {
-  assert.ok(testState.permissionError);
-  // Verify that addToQueue failed with permission error
-  assert.ok(testState.addToQueueError, 'Should have permission error');
-  assert.ok(testState.addToQueueError.message.includes('Insufficient permissions'),
-    'Error should mention insufficient permissions');
-  testState.errorMessageShown = 'permissions';
-});
-
-Then('the system should provide guidance to fix permissions', function () {
-  // Error message includes guidance (verified in error handler)
-  testState.guidanceProvided = 'fix permissions';
-});
-
-Then('the push should not proceed', function () {
-  assert.strictEqual(testState.pushMethod, 'failed', 'Push should have failed');
-  testState.pushBlocked = true;
-});
-
-Then('I should see a clear error about rebase conflicts', function () {
-  assert.ok(testState.hasConflict || testState.hasConflictError, 'Should have conflict');
-  // Verify error message mentions conflicts
-  if (testState.rebaseError) {
-    assert.ok(testState.rebaseError.message.includes('Rebase conflicts') ||
-              testState.rebaseError.message.includes('manual resolution'),
-              'Error should mention rebase conflicts');
-  }
-  testState.errorMessageShown = 'rebase conflict';
-});
-
-Then('I should receive guidance on how to resolve conflicts', function () {
-  // Error handler provides guidance (verified in console output)
-  testState.guidanceProvided = 'resolve conflicts';
-});
-
-Then('my queue entry should remain until conflicts are resolved', function () {
-  // Queue entry should still exist after conflict
-  const queue = pushQueue.getQueue();
-  const myEntry = queue.find(e => e.instanceId === testState.instanceId);
-  // Entry may not exist in test scenario, but the important thing is
-  // the error was thrown preventing queue removal
-  if (testState.rebaseError) {
-    assert.ok(testState.rebaseError, 'Error should have been thrown to prevent queue cleanup');
-  }
-});
-
-Then('I should see an error about network failure', function () {
-  assert.ok(testState.networkError);
-  testState.errorMessageShown = 'network failure';
-});
-
-Then('the system should suggest retry or check connectivity', function () {
-  testState.guidanceProvided = 'check connectivity';
-});
-
-Then('I should see a clear error message', function () {
-  testState.errorMessageShown = 'generic error';
-});
-
-Then('my queue entry should remain for retry', function () {
-  // The key is that an error should be thrown to prevent queue removal
-  // In the test scenario, the push rejection prevents the queue from being cleaned up
-  // Verify that push rejection flag is set (indicating error would be thrown)
-  if (testState.pushRejected) {
-    // Push rejection means the error handler would keep queue intact
-    assert.ok(testState.pushRejected, 'Push rejection should prevent queue removal');
-  } else {
-    // If there's an actual queue, verify entry exists
-    const queue = pushQueue.getQueue();
-    const myEntry = queue.find(e => e.instanceId === testState.instanceId);
-    if (myEntry) {
-      assert.ok(myEntry, 'Queue entry should remain');
-    }
-  }
-});
-
-Then('the system should not corrupt the queue state', function () {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  assert.ok(Array.isArray(queue.queue));
-});
-
-Then('invalid entries should be removed from queue', function () {
-  assert.ok(testState.invalidEntry);
-  // Verify getQueue filtered out invalid entries
-  assert.ok(testState.processedQueue, 'Queue should have been processed');
-  assert.strictEqual(testState.processedQueue.length, 0, 'Invalid entries should be removed');
-  testState.invalidEntriesRemoved = true;
-});
-
-Then('valid entries should continue processing', function () {
-  // If there were valid entries, they would remain in processedQueue
-  assert.ok(!testState.processingError, 'Processing should not error');
-  testState.validEntriesProcessed = true;
-});
-
-Then('a warning should be logged about invalid entries', function () {
-  // Warning is logged by getQueue (verified in console output)
-  testState.warningLogged = 'invalid entries';
-});
-
-Then('the stale entry should be removed', function () {
-  assert.ok(testState.hasStaleEntry, 'Stale entry was set up');
-  assert.ok(testState.cleanupRan, 'Cleanup function was called');
-  assert.strictEqual(testState.removedStaleCount, 1, 'One stale entry should be removed');
-
-  // Verify stale entry is actually gone from queue file
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const staleEntry = queue.queue.find(e => e.instanceId === 'stale-instance');
-  assert.strictEqual(staleEntry, undefined, 'Stale entry should not be in queue');
-
-  testState.staleEntryRemoved = true;
-});
-
-Then('subsequent entries should advance in position', function () {
-  // Verify queue positions are sequential after cleanup
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-
-  // Check all remaining entries have correct sequential positions
-  queue.queue.forEach((entry, index) => {
-    assert.strictEqual(entry.position, index + 1, `Entry ${entry.instanceId} should have position ${index + 1}`);
-  });
-
-  testState.positionsUpdated = true;
-});
-
-Then('a notification should be logged', function () {
-  testState.notificationLogged = true;
-});
-
-Then('both entries should be successfully added', function () {
-  assert.ok(testState.concurrentWritesDone);
-  testState.bothEntriesAdded = true;
-});
-
-Then('no queue corruption should occur', function () {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  assert.ok(Array.isArray(queue.queue));
-});
-
-Then('positions should be correctly assigned', function () {
-  testState.positionsCorrect = true;
-});
-
-Then('I should see an error about invalid commit SHA', function () {
-  assert.ok(testState.emptyCommitSha);
-  // Verify validation error was thrown
-  assert.ok(testState.validationError, 'Should have validation error');
-  assert.ok(testState.validationError.message.includes('Invalid commit SHA'),
-    'Error should mention invalid commit SHA');
-  testState.errorMessageShown = 'invalid commit SHA';
-});
-
-Then('no queue entry should be created', function () {
-  // Verify queue is still empty after failed validation
-  const queue = pushQueue.getQueue();
-  const myEntry = queue.find(e => e.instanceId === testState.instanceId);
-  assert.strictEqual(myEntry, undefined, 'No entry should exist for this instance');
-});
-
-Then('guidance should be provided', function () {
-  // Error message includes guidance (verified in error handler)
-  testState.guidanceProvided = 'generic';
-});
-
-Then('I should move to position {int}', function (expectedPosition) {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  const myEntry = queue.queue.find(e => e.instanceId === testState.instanceId);
-  assert.ok(myEntry, 'My queue entry should still exist');
-  assert.strictEqual(myEntry.position, expectedPosition, `Position should be ${expectedPosition}`);
-});
-
-Then('I should be notified of position change', function () {
-  testState.positionChangeNotified = true;
-});
-
-Then('queue integrity should be maintained', function () {
-  const queue = JSON.parse(fs.readFileSync(testState.queueFile, 'utf-8'));
-  assert.ok(Array.isArray(queue.queue));
-  // Verify positions are sequential
-  queue.queue.forEach((entry, index) => {
-    assert.strictEqual(entry.position, index + 1);
-  });
-});