Function test_retry_task

src/task_manager.rs:450–517

()

    #[tokio::test]
    async fn test_retry_task() {
        // Set up test environment
        let (config, test_repo, ctx) = setup_test_environment().await.unwrap();
        let repo_root = test_repo.path().to_path_buf();

        // Create a completed task to retry
        let task_id = "abcd1234".to_string();
        let task_dir_path = config.task_dir(&task_id);
        let instructions_path = task_dir_path.join("instructions.md");

        let completed_task = Task {
            id: task_id.clone(),
            repo_root: repo_root.clone(),
            name: "original-task".to_string(),
            task_type: "generic".to_string(),
            instructions_file: instructions_path.to_string_lossy().to_string(),
            branch_name: format!("tsk/{task_id}"),
            status: TaskStatus::Complete,
            copied_repo_path: Some(task_dir_path.join("repo")),
            ..Task::test_default()
        };

        // Set up task directory with instructions
        let instructions_content =
            "# Original Task Instructions\n\nThis is the original task content.";
        setup_task_directory(&config, &task_id, instructions_content)
            .await
            .unwrap();

        // Add task via storage API
        let storage = ctx.task_storage();
        storage.add_task(completed_task).await.unwrap();

        // Create TaskManager and retry the task
        let task_manager = TaskManager::new(&ctx).unwrap();

        let result = task_manager
            .retry_task(&task_id, false, RetryOverrides::default(), &ctx)
            .await;
        assert!(result.is_ok(), "Failed to retry task: {result:?}");
        let new_task_id = result.unwrap();

        // Verify new task ID format (8 characters)
        assert_eq!(new_task_id.len(), 8);

        // Verify task was added to storage
        let new_task = task_manager
            .task_storage
            .get_task(&new_task_id)
            .await
            .unwrap();
        assert!(new_task.is_some());
        let new_task = new_task.unwrap();
        // Since we removed the "retry-" prefix, name should be the same as original
        assert_eq!(new_task.name, "original-task");
        assert_eq!(new_task.task_type, "generic");
        assert_eq!(new_task.agent, "claude".to_string());
        assert_eq!(new_task.status, TaskStatus::Queued);