jettypod 4.1.2 → 4.1.4

package/features/git-hooks/steps.js

@@ -1,196 +0,0 @@
-const { Given, When, Then } = require('@cucumber/cucumber');
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const sqlite3 = require('sqlite3').verbose();
-
-const testDir = path.join('/tmp', 'jettypod-hooks-test-' + Date.now());
-const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
-let originalDir;
-
-// Helper to ensure NODE_ENV=test is always set for test execSync calls
-function testExecSync(command, options = {}) {
-  const env = { ...process.env, NODE_ENV: 'test', ...options.env };
-  return execSync(command, { ...options, env });
-}
-
-Given('I have initialized jettypod with git', function () {
-  originalDir = process.cwd();
-  // SAFETY: Only delete if testDir is in /tmp
-  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  execSync('git init', { stdio: 'pipe' });
-  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-  execSync('git config user.name "Test"', { stdio: 'pipe' });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-
-  // Verify hooks installed
-  const hookPath = path.join(testDir, '.git', 'hooks', 'post-commit');
-  this.hooksInstalled = fs.existsSync(hookPath);
-});
-
-Given('I create a work item via work commands', function () {
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test Feature"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-  this.workItemId = 1;
-});
-
-Given('I start work on the item', function () {
-  const jettypodPath = path.join(__dirname, '../../jettypod.js');
-  const workDir = process.cwd();
-  const workItemId = this.workItemId || 1;
-
-  testExecSync(`node ${jettypodPath} work start ${workItemId}`, { cwd: workDir, stdio: 'pipe' });
-});
-
-When('I commit changes', function () {
-  fs.writeFileSync('test.txt', 'test content');
-  execSync('git add .', { stdio: 'pipe' });
-  execSync('git commit -m "test commit"', { stdio: 'pipe' });
-});
-
-Then('the work item status updates automatically', function () {
-  const dbPath = path.join(testDir, '.jettypod', dbFileName);
-  const db = new sqlite3.Database(dbPath);
-
-  return new Promise((resolve) => {
-    db.get(`SELECT status FROM work_items WHERE id = ?`, [this.workItemId], (err, row) => {
-      db.close();
-      // Should be in_progress (updated by post-commit hook)
-      assert(row.status === 'in_progress' || row.status === 'backlog',
-        `Expected in_progress or backlog, got ${row.status}`);
-      resolve();
-    });
-  });
-});
-
-Then('the current work file still exists', function () {
-  const currentWorkPath = path.join(testDir, '.jettypod', 'current-work.json');
-  assert(fs.existsSync(currentWorkPath), 'Current work file should still exist');
-
-  // Cleanup
-  if (fs.existsSync(testDir)) {
-    process.chdir(originalDir);
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-});
-
-Given('I have a work item with status {string}', function (status) {
-  originalDir = process.cwd();
-  // SAFETY: Only delete if testDir is in /tmp
-  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  execSync('git init', { stdio: 'pipe' });
-  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-  execSync('git config user.name "Test"', { stdio: 'pipe' });
-
-  // Make initial commit so branch exists
-  fs.writeFileSync('README.md', '# Test');
-  execSync('git add .', { stdio: 'pipe' });
-  execSync('git commit -m "Initial commit"', { stdio: 'pipe' });
-
-  // Store default branch name
-  this.defaultBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
-
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work status 1 ${status}`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-
-  this.workItemId = 1;
-  this.initialStatus = status;
-});
-
-Given('the work item is set as current work', function () {
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start ${this.workItemId}`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-});
-
-Given('I am on a feature branch', function () {
-  // Make initial commit on main so it exists
-  fs.writeFileSync('init.txt', 'init');
-  execSync('git add .', { stdio: 'pipe' });
-  execSync('git commit -m "initial commit"', { stdio: 'pipe' });
-
-  // Now create feature branch
-  execSync('git checkout -b feature/test', { stdio: 'pipe' });
-});
-
-When('I make my first commit', function () {
-  fs.writeFileSync('test.txt', 'test');
-  execSync('git add .', { stdio: 'pipe' });
-  execSync('git commit -m "first commit"', { stdio: 'pipe' });
-});
-
-When('I merge to main', function () {
-  // Commit on feature branch
-  fs.writeFileSync('feature.txt', 'feature');
-  execSync('git add .', { stdio: 'pipe' });
-  execSync('git commit -m "feature commit"', { stdio: 'pipe' });
-
-  // Switch to default branch and merge
-  execSync(`git checkout ${this.defaultBranch}`, { stdio: 'pipe' });
-  execSync('git merge feature/test --no-edit', { stdio: 'pipe' });
-});
-
-Then('the work item status should be {string}', function (expectedStatus) {
-  const dbPath = path.join(testDir, '.jettypod', dbFileName);
-
-  return new Promise((resolve) => {
-    // Give the post-merge hook time to complete
-    setTimeout(() => {
-      const db = new sqlite3.Database(dbPath);
-      db.get(`SELECT status FROM work_items WHERE id = ?`, [this.workItemId], (err, row) => {
-        db.close();
-        assert.strictEqual(row.status, expectedStatus);
-
-        // Cleanup
-        if (fs.existsSync(testDir)) {
-          process.chdir(originalDir);
-          fs.rmSync(testDir, { recursive: true, force: true });
-        }
-
-        resolve();
-      });
-    }, 50); // Small delay to ensure hook completes
-  });
-});
-
-Given('no work item is set as current', function () {
-  originalDir = process.cwd();
-  // SAFETY: Only delete if testDir is in /tmp
-  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  execSync('git init', { stdio: 'pipe' });
-  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-  execSync('git config user.name "Test"', { stdio: 'pipe' });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-});
-
-When('I make a commit', function () {
-  fs.writeFileSync('test.txt', 'test');
-  execSync('git add .', { stdio: 'pipe' });
-  execSync('git commit -m "test"', { stdio: 'pipe' });
-});
-
-Then('no errors occur', function () {
-  // If we got here, no errors occurred
-  assert(true);
-
-  // Cleanup
-  if (fs.existsSync(testDir)) {
-    process.chdir(originalDir);
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-});

package/features/jettypod-update-command.feature

@@ -1,46 +0,0 @@
-Feature: JettyPod update command
-  Self-updating jettypod and skills refresh with a single command
-
-  Epic: JettyPod and Skills Auto-Update
-  Approach: Full self-update - Check npm, update jettypod, refresh skills
-
-Scenario: User runs jettypod update when new version is available
-  Given jettypod version 3.0.0 is installed
-  And npm registry has version 3.1.0 available
-  When I run update command "jettypod update"
-  Then jettypod checks npm registry for latest version
-  And jettypod shows "New version available: 3.1.0 (current: 3.0.0)"
-  And jettypod downloads and installs version 3.1.0
-  And skills are refreshed in current project
-  And jettypod shows "✅ JettyPod updated to 3.1.0"
-
-Scenario: User runs jettypod update when already on latest version
-  Given jettypod version 3.1.0 is installed
-  And npm registry has version 3.1.0 available
-  When I run update command "jettypod update"
-  Then jettypod checks npm registry for latest version
-  And jettypod shows "Already on latest version: 3.1.0"
-  And skills are refreshed in current project
-
-Scenario: User runs jettypod update without internet connection
-  Given jettypod is installed
-  And there is no internet connection
-  When I run update command "jettypod update"
-  Then jettypod shows "Cannot check for updates: network error"
-  And skills are still refreshed in current project using existing jettypod
-
-Scenario: Command rename - jettypod without init creates new project
-  Given I am in a directory without .claude/
-  When I run update command "jettypod"
-  Then jettypod initializes the project
-  And .claude/ directory is created
-  And CLAUDE.md is created
-  And skills are installed
-
-Scenario: Backwards compatibility - jettypod init still works
-  Given I am in a directory without .claude/
-  When I run update command "jettypod init"
-  Then jettypod initializes the project
-  And .claude/ directory is created
-  And CLAUDE.md is created
-  And skills are installed

package/features/mode-prompts/index.js

@@ -1,95 +0,0 @@
-const readline = require('readline');
-const fs = require('fs');
-const path = require('path');
-const sqlite3 = require('sqlite3').verbose();
-
-/**
- * Prompt user for work item status update
- * @param {Object} currentWork - Current work item with id, title, and status
- * @returns {Promise<string|null>} New status or null if skipped
- * @throws {Error} If currentWork is invalid or missing required fields
- */
-function promptForStatusUpdate(currentWork) {
-  // Validate input
-  if (!currentWork || typeof currentWork !== 'object') {
-    return Promise.reject(new Error('Invalid currentWork: must be an object'));
-  }
-
-  if (!currentWork.id || !currentWork.title || !currentWork.status) {
-    return Promise.reject(new Error('Invalid currentWork: missing id, title, or status'));
-  }
-
-  return new Promise((resolve, reject) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-
-    console.log(`\nCurrent work: [#${currentWork.id}] ${currentWork.title} (${currentWork.status})`);
-    rl.question('Update status? [in_progress/blocked/done/skip]: ', (answer) => {
-      rl.close();
-
-      const status = answer.trim();
-      if (status === 'skip' || status === '') {
-        resolve(null);
-      } else if (['in_progress', 'blocked', 'done', 'todo', 'backlog'].includes(status)) {
-        resolve(status);
-      } else {
-        console.log('Invalid status, skipping update');
-        resolve(null);
-      }
-    });
-  });
-}
-
-/**
- * Update work item status in database and current work file
- * Uses shared updateStatus from work-tracking for consistency and epic auto-close logic
- * @param {number} workItemId - ID of work item to update
- * @param {string} newStatus - New status value
- * @returns {Promise<void>}
- * @throws {Error} If workItemId is invalid, newStatus is invalid, database not found, or file operations fail
- */
-async function updateWorkItemStatus(workItemId, newStatus) {
-  // Validate inputs
-  if (!workItemId || isNaN(workItemId) || workItemId < 1) {
-    return Promise.reject(new Error('Invalid work item ID'));
-  }
-
-  const validStatuses = ['in_progress', 'blocked', 'done', 'todo', 'backlog', 'cancelled'];
-  if (!newStatus || !validStatuses.includes(newStatus)) {
-    return Promise.reject(new Error(`Invalid status: ${newStatus}`));
-  }
-
-  const jettypodDir = path.join(process.cwd(), '.jettypod');
-  const { getDbPath } = require('../../lib/database');
-  const dbPath = getDbPath();
-  const currentWorkPath = path.join(jettypodDir, 'current-work.json');
-
-  // Check database exists
-  if (!fs.existsSync(dbPath)) {
-    return Promise.reject(new Error('Work database not found. Run: jettypod init'));
-  }
-
-  // Use shared updateStatus from work-tracking (includes epic auto-close logic)
-  const { updateStatus } = require('../work-tracking');
-  await updateStatus(workItemId, newStatus);
-
-  // Update current work file if it exists
-  if (fs.existsSync(currentWorkPath)) {
-    try {
-      const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
-      currentWork.status = newStatus;
-      fs.writeFileSync(currentWorkPath, JSON.stringify(currentWork, null, 2));
-    } catch (fileErr) {
-      return Promise.reject(new Error(`Failed to update current work file: ${fileErr.message}`));
-    }
-  }
-
-  console.log(`✓ Work item #${workItemId} status updated to ${newStatus}`);
-}
-
-module.exports = {
-  promptForStatusUpdate,
-  updateWorkItemStatus
-};

package/features/mode-prompts/simple-steps.js

@@ -1,44 +0,0 @@
-const { Given, When, Then } = require('@cucumber/cucumber');
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-const testDir = path.join('/tmp', 'mode-prompts-' + Date.now());
-let originalDir;
-
-Given('I have jettypod with a work item in progress', function () {
-  originalDir = process.cwd();
-  // SAFETY: Only delete if testDir is in /tmp
-  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  execSync('git init', { stdio: 'pipe' });
-  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-  execSync('git config user.name "Test"', { stdio: 'pipe' });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start 1`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-});
-
-When('I check current work exists', function () {
-  const currentWorkPath = path.join(testDir, '.jettypod', 'current-work.json');
-  this.currentWorkExists = fs.existsSync(currentWorkPath);
-  if (this.currentWorkExists) {
-    this.currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
-  }
-});
-
-Then('the work item has a status', function () {
-  assert(this.currentWorkExists, 'Current work file should exist');
-  assert(this.currentWork.status, 'Work item should have a status');
-
-  // Cleanup
-  if (fs.existsSync(testDir)) {
-    process.chdir(originalDir);
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-});

package/features/mode-prompts/simple-test.feature

@@ -1,9 +0,0 @@
-Feature: Mode Change Prompts
-  As a developer
-  I want to update work status when switching modes
-  So my work state stays current
-
-  Scenario: Integration - mode change with work item present
-    Given I have jettypod with a work item in progress
-    When I check current work exists
-    Then the work item has a status

package/features/mode-prompts/validation.test.js

@@ -1,120 +0,0 @@
-// Unit tests for mode-prompts validation logic
-// These test the error handling and validation without user interaction
-
-const { VALID_STATUSES } = require('../../lib/constants');
-
-describe('Mode Prompts - Validation', () => {
-  describe('promptForStatusUpdate validation', () => {
-    test('should validate currentWork is an object', () => {
-      const invalidInputs = [null, undefined, 'string', 123, [], true];
-      invalidInputs.forEach(input => {
-        const isValid = !!(input && typeof input === 'object' && !Array.isArray(input));
-        expect(isValid).toBe(false);
-      });
-    });
-
-    test('should validate currentWork has required fields', () => {
-      const invalidObjects = [
-        {},
-        { id: 1 },
-        { id: 1, title: 'Test' },
-        { title: 'Test', status: 'todo' },
-        { id: 1, status: 'todo' }
-      ];
-
-      invalidObjects.forEach(obj => {
-        const hasRequired = !!(obj.id && obj.title && obj.status);
-        expect(hasRequired).toBe(false);
-      });
-    });
-
-    test('should accept valid currentWork objects', () => {
-      const validObjects = [
-        { id: 1, title: 'Test', status: 'todo' },
-        { id: 2, title: 'Feature', status: 'in_progress', type: 'feature' }
-      ];
-
-      validObjects.forEach(obj => {
-        const hasRequired = !!(obj.id && obj.title && obj.status);
-        expect(hasRequired).toBe(true);
-      });
-    });
-
-    test('should validate status values', () => {
-      const validStatuses = ['in_progress', 'blocked', 'done', 'todo', 'backlog'];
-      const invalidStatuses = ['invalid', 'foo', '', null, undefined];
-
-      validStatuses.forEach(status => {
-        expect(validStatuses.includes(status)).toBe(true);
-      });
-
-      invalidStatuses.forEach(status => {
-        const isValid = !!(status && validStatuses.includes(status));
-        expect(isValid).toBe(false);
-      });
-    });
-
-    test('should accept skip or empty as null', () => {
-      const nullInputs = ['skip', ''];
-      nullInputs.forEach(input => {
-        const shouldBeNull = input === 'skip' || input === '';
-        expect(shouldBeNull).toBe(true);
-      });
-    });
-  });
-
-  describe('updateWorkItemStatus validation', () => {
-    test('should validate work item ID is numeric', () => {
-      const invalidIds = [null, undefined, 'abc', '', {}, []];
-      invalidIds.forEach(id => {
-        const isValid = !!(id && !isNaN(id) && id >= 1);
-        expect(isValid).toBe(false);
-      });
-    });
-
-    test('should validate work item ID is positive', () => {
-      expect(!!(0 && !isNaN(0) && 0 >= 1)).toBe(false);
-      expect(!!(-1 && !isNaN(-1) && -1 >= 1)).toBe(false);
-    });
-
-    test('should accept valid work item IDs', () => {
-      const validIds = [1, 2, 100, 999];
-      validIds.forEach(id => {
-        const isValid = id && !isNaN(id) && id >= 1;
-        expect(isValid).toBe(true);
-      });
-    });
-
-    test('should validate status is in valid statuses', () => {
-      const validStatuses = ['in_progress', 'blocked', 'done', 'todo', 'backlog', 'cancelled'];
-      const invalidStatuses = ['invalid', 'foo', '', null, undefined];
-
-      validStatuses.forEach(status => {
-        expect(validStatuses.includes(status)).toBe(true);
-      });
-
-      invalidStatuses.forEach(status => {
-        const isValid = !!(status && validStatuses.includes(status));
-        expect(isValid).toBe(false);
-      });
-    });
-  });
-
-  describe('Database path validation', () => {
-    test('should check jettypod directory exists', () => {
-      const fs = require('fs');
-      const path = require('path');
-
-      const nonExistentPath = '/nonexistent/path/.jettypod';
-      expect(fs.existsSync(nonExistentPath)).toBe(false);
-    });
-
-    test('should check database file exists', () => {
-      const fs = require('fs');
-      const path = require('path');
-
-      const nonExistentDb = '/nonexistent/path/.jettypod/work.db';
-      expect(fs.existsSync(nonExistentDb)).toBe(false);
-    });
-  });
-});

package/features/multiple-claude-instances.feature

@@ -1,121 +0,0 @@
-@multiple-instances
-Feature: Multiple Claude Code instances coordination
-  Commit queue system ensures safe, ordered pushes to main when multiple
-  Claude Code instances work in the same directory simultaneously
-
-  Approach: Commit Queue System
-
-Scenario: Single Claude instance pushes to main without queue
-  Given I am a Claude Code instance with completed work
-  And I have committed my changes locally
-  And the push queue is empty
-  And main branch has no new commits
-  When I attempt to push to main
-  Then I push directly to main
-  And I do not create a queue entry
-
-Scenario: First Claude instance creates queue entry when main is ahead
-  Given I am a Claude Code instance with completed work
-  And I have committed my changes locally
-  And the push queue is empty
-  And main branch has 2 new commits since my work started
-  When I attempt to push to main
-  Then I create a queue entry at position 1
-  And I see "Added to push queue (position 1)"
-  And I rebase my commits on top of main
-  And I push to main
-  And I remove my queue entry
-
-Scenario: Second Claude waits for first to complete
-  Given Claude instance A is at position 1 in the push queue
-  And I am a Claude Code instance with completed work
-  And I have committed my changes locally
-  When I attempt to push to main
-  Then I create a queue entry at position 2
-  And I see "Added to push queue (position 2, waiting for 1 commit ahead)"
-  And I do not push yet
-  And I wait for position 1 to complete
-
-Scenario: Queue processes sequentially when first completes
-  Given Claude instance A is at position 1 and is pushing
-  And I am at position 2 in the queue
-  When Claude instance A completes their push
-  Then I move to position 1
-  And I rebase my commits on top of the updated main
-  And I push to main
-  And I remove my queue entry
-
-# SPEED MODE: Only happy path above
-# STABLE MODE: Error handling, edge cases, validation scenarios below
-
-Scenario: Queue file corrupted or contains invalid JSON
-  Given the push queue file exists but contains invalid JSON
-  When I attempt to push to main
-  Then I should see an error message about corrupted queue file
-  And the system should initialize a new empty queue
-  And I should be able to push successfully
-
-Scenario: Queue file cannot be written due to permissions
-  Given the .jettypod directory has no write permissions
-  When I attempt to push to main
-  Then I should see an error about insufficient permissions
-  And the system should provide guidance to fix permissions
-  And the push should not proceed
-
-Scenario: Git rebase fails with conflicts
-  Given I am at position 1 in the queue
-  And my changes conflict with changes on main
-  When I attempt to rebase on main
-  Then I should see a clear error about rebase conflicts
-  And I should receive guidance on how to resolve conflicts
-  And my queue entry should remain until conflicts are resolved
-
-Scenario: Git fetch fails due to network issues
-  Given I am checking if main has moved ahead
-  When git fetch fails due to network connectivity
-  Then I should see an error about network failure
-  And the system should suggest retry or check connectivity
-  And the push should not proceed
-
-Scenario: Git push fails after successful rebase
-  Given I have successfully rebased on main
-  When git push fails due to remote rejection
-  Then I should see a clear error message
-  And my queue entry should remain for retry
-  And the system should not corrupt the queue state
-
-Scenario: Invalid queue entry with missing fields
-  Given the queue contains an entry with missing instanceId
-  When the queue processor attempts to process entries
-  Then invalid entries should be removed from queue
-  And valid entries should continue processing
-  And a warning should be logged about invalid entries
-
-Scenario: Stale queue entry from crashed instance
-  Given a queue entry has been waiting for over 1 hour
-  And the instance that created it is no longer running
-  When queue cleanup runs
-  Then the stale entry should be removed
-  And subsequent entries should advance in position
-  And a notification should be logged
-
-Scenario: Multiple instances try to write queue simultaneously
-  Given two Claude instances both try to add queue entries at same time
-  When concurrent queue writes occur
-  Then both entries should be successfully added
-  And no queue corruption should occur
-  And positions should be correctly assigned
-
-Scenario: Empty commit SHA provided to queue
-  Given I attempt to add a queue entry with empty commit SHA
-  When validation runs
-  Then I should see an error about invalid commit SHA
-  And no queue entry should be created
-  And guidance should be provided
-
-Scenario: Queue position monitoring with removed entries
-  Given I am at position 3 in the queue
-  When entry at position 1 is removed (not completed normally)
-  Then I should move to position 2
-  And I should be notified of position change
-  And queue integrity should be maintained