aria2-core 0.3.14

aria2-rust core download engine: multi-protocol segmented downloads, rate limiting, configuration, session persistence, and BitTorrent seeding
Documentation
use super::*;
use std::time::Duration;

#[test]
fn admission_respects_capacity_and_completion_releases_a_slot() {
    let now = Instant::now();
    let mut scheduler = WorkScheduler::new();
    for value in 1..=3 {
        scheduler
            .enqueue(WorkItem::new(WorkId::new(value), value, 3))
            .unwrap();
    }

    let mut admitted = scheduler.admit(2, now);
    assert_eq!(admitted.len(), 2);
    assert_eq!(scheduler.in_flight_count(), 2);
    let first = admitted.remove(0);
    scheduler.complete(first).unwrap();

    let next = scheduler.admit(2, now);
    assert_eq!(next.len(), 1);
    assert_eq!(next[0].payload(), &3);
}

#[test]
fn retry_waits_until_deadline_and_exhausts_total_attempts() {
    let now = Instant::now();
    let id = WorkId::new(7);
    let mut scheduler = WorkScheduler::new();
    scheduler
        .enqueue(WorkItem::new(id, "fake payload", 2))
        .unwrap();

    let first = scheduler.admit(1, now).pop().unwrap();
    assert_eq!(first.attempt(), 1);
    assert!(matches!(
        scheduler
            .fail(first, Some(now + Duration::from_secs(2)))
            .unwrap(),
        RetryOutcome::Scheduled
    ));
    assert!(scheduler.admit(1, now + Duration::from_secs(1)).is_empty());
    assert_eq!(
        scheduler.next_retry_deadline(),
        Some(now + Duration::from_secs(2))
    );

    let second = scheduler
        .admit(1, now + Duration::from_secs(2))
        .pop()
        .unwrap();
    assert_eq!(second.attempt(), 2);
    assert!(matches!(
        scheduler
            .fail(second, Some(now + Duration::from_secs(3)))
            .unwrap(),
        RetryOutcome::Exhausted("fake payload")
    ));
    assert_eq!(scheduler.state(id), Some(WorkState::Failed));
    assert_eq!(scheduler.failed_count(), 1);
}

#[test]
fn requeue_before_execution_does_not_consume_attempt_budget() {
    let now = Instant::now();
    let id = WorkId::new(9);
    let mut scheduler = WorkScheduler::new();
    scheduler.enqueue(WorkItem::new(id, 42, 1)).unwrap();

    let lease = scheduler.admit(1, now).pop().unwrap();
    scheduler.requeue_unstarted(lease).unwrap();
    let admitted = scheduler.admit(1, now).pop().unwrap();

    assert_eq!(admitted.attempt(), 1);
    assert_eq!(admitted.payload(), &42);
}

#[test]
fn successful_sub_work_preserves_only_previously_failed_attempts() {
    let now = Instant::now();
    let id = WorkId::new(10);
    let mut scheduler = WorkScheduler::new();
    scheduler.enqueue(WorkItem::new(id, 42, 3)).unwrap();

    let first = scheduler.admit(1, now).pop().unwrap();
    scheduler
        .fail(first, Some(now))
        .expect("first attempt can retry");
    let second = scheduler.admit(1, now).pop().unwrap();
    scheduler.reschedule_after_success(second).unwrap();
    let third = scheduler.admit(1, now).pop().unwrap();

    assert_eq!(third.attempt(), 2);
    assert_eq!(third.payload(), &42);
}

#[test]
fn adapter_classified_capacity_retry_does_not_consume_attempt_budget() {
    let now = Instant::now();
    let id = WorkId::new(12);
    let mut scheduler = WorkScheduler::new();
    scheduler.enqueue(WorkItem::new(id, 42, 1)).unwrap();

    let first = scheduler.admit(1, now).pop().unwrap();
    scheduler.retry_without_consuming_attempt(first).unwrap();
    let admitted = scheduler.admit(1, now).pop().unwrap();

    assert_eq!(admitted.attempt(), 1);
    assert_eq!(admitted.payload(), &42);
}

#[test]
fn changing_source_starts_a_fresh_attempt_budget() {
    let now = Instant::now();
    let id = WorkId::new(13);
    let mut scheduler = WorkScheduler::new();
    scheduler.enqueue(WorkItem::new(id, 42, 2)).unwrap();

    let first = scheduler.admit(1, now).pop().unwrap();
    scheduler.fail(first, Some(now)).unwrap();
    let second = scheduler.admit(1, now).pop().unwrap();
    scheduler.retry_with_fresh_attempt_budget(second).unwrap();
    let admitted = scheduler.admit(1, now).pop().unwrap();

    assert_eq!(admitted.attempt(), 1);
    assert_eq!(admitted.payload(), &42);
}

#[test]
fn duplicate_ids_are_rejected_and_cancel_prevents_new_admission() {
    let now = Instant::now();
    let mut scheduler = WorkScheduler::new();
    let id = WorkId::new(11);
    scheduler.enqueue(WorkItem::new(id, (), 1)).unwrap();
    assert_eq!(
        scheduler.enqueue(WorkItem::new(id, (), 1)),
        Err(WorkScheduleError::DuplicateId(id))
    );
    scheduler.cancel();
    assert!(scheduler.admit(1, now).is_empty());
    assert_eq!(scheduler.state(id), Some(WorkState::Cancelled));
    assert!(scheduler.is_finished());
}

#[test]
fn adapter_eligibility_skips_a_blocked_item_without_reordering_it() {
    let now = Instant::now();
    let blocked = WorkId::new(21);
    let eligible = WorkId::new(22);
    let mut scheduler = WorkScheduler::new();
    scheduler.enqueue(WorkItem::new(blocked, false, 0)).unwrap();
    scheduler.enqueue(WorkItem::new(eligible, true, 0)).unwrap();

    let lease = scheduler
        .admit_one_where(1, now, |is_eligible| *is_eligible)
        .unwrap();

    assert_eq!(lease.id(), eligible);
    assert!(scheduler.is_scheduled(blocked));
    assert!(scheduler.is_scheduled(eligible));
}

#[test]
fn externally_completed_pending_work_is_removed_from_ready_and_retry_queues() {
    let now = Instant::now();
    let ready_id = WorkId::new(31);
    let delayed_id = WorkId::new(32);
    let mut scheduler = WorkScheduler::new();
    scheduler.enqueue(WorkItem::new(delayed_id, (), 0)).unwrap();

    let lease = scheduler.admit(1, now).pop().unwrap();
    scheduler
        .fail(lease, Some(now + Duration::from_secs(10)))
        .unwrap();
    scheduler.enqueue(WorkItem::new(ready_id, (), 0)).unwrap();
    assert!(scheduler.complete_pending(ready_id));
    assert!(scheduler.complete_pending(delayed_id));
    assert_eq!(scheduler.state(ready_id), Some(WorkState::Completed));
    assert_eq!(scheduler.state(delayed_id), Some(WorkState::Completed));
    assert!(scheduler.is_finished());
}

#[test]
fn terminal_work_ids_can_be_reused_without_retaining_scheduler_state() {
    let now = Instant::now();
    let id = WorkId::new(41);
    let mut scheduler = WorkScheduler::new();
    scheduler.enqueue(WorkItem::new(id, (), 1)).unwrap();
    let lease = scheduler.admit(1, now).pop().unwrap();
    scheduler.complete(lease).unwrap();

    assert!(!scheduler.is_scheduled(id));
    assert_eq!(scheduler.state(id), Some(WorkState::Completed));
    scheduler.enqueue(WorkItem::new(id, (), 1)).unwrap();
    assert!(scheduler.is_scheduled(id));
}

#[test]
fn discarding_pending_work_preserves_active_leases() {
    let now = Instant::now();
    let active_id = WorkId::new(51);
    let pending_id = WorkId::new(52);
    let mut scheduler = WorkScheduler::new();
    scheduler.enqueue(WorkItem::new(active_id, (), 1)).unwrap();
    scheduler.enqueue(WorkItem::new(pending_id, (), 1)).unwrap();
    let lease = scheduler.admit(1, now).pop().unwrap();

    scheduler.discard_pending();

    assert!(scheduler.is_scheduled(active_id));
    assert!(!scheduler.is_scheduled(pending_id));
    assert_eq!(scheduler.in_flight_count(), 1);
    scheduler.complete(lease).unwrap();
    assert!(scheduler.is_finished());
}