105 lines
2.7 KiB
Rust
105 lines
2.7 KiB
Rust
use std::time::Duration;
|
|
|
|
use radicle::test::arbitrary;
|
|
use radicle_core::RepoId;
|
|
|
|
use crate::fetcher::state::Enqueue;
|
|
use crate::fetcher::test::queue::helpers::*;
|
|
use crate::fetcher::QueuedFetch;
|
|
|
|
#[test]
|
|
fn zero_timeout_accepted() {
|
|
let mut queue = create_queue(10);
|
|
let item = QueuedFetch {
|
|
rid: arbitrary::gen(1),
|
|
refs_at: vec![],
|
|
timeout: Duration::ZERO,
|
|
};
|
|
assert_eq!(queue.enqueue(item), Enqueue::Queued);
|
|
}
|
|
|
|
#[test]
|
|
fn max_timeout_accepted() {
|
|
let mut queue = create_queue(10);
|
|
let item = QueuedFetch {
|
|
rid: arbitrary::gen(1),
|
|
refs_at: vec![],
|
|
timeout: Duration::MAX,
|
|
};
|
|
assert_eq!(queue.enqueue(item), Enqueue::Queued);
|
|
}
|
|
|
|
#[test]
|
|
fn empty_refs_at_items_can_be_equal() {
|
|
let rid: RepoId = arbitrary::gen(1);
|
|
let timeout = Duration::from_secs(30);
|
|
|
|
let item1 = QueuedFetch {
|
|
rid,
|
|
refs_at: vec![],
|
|
timeout,
|
|
};
|
|
let item2 = QueuedFetch {
|
|
rid,
|
|
refs_at: vec![],
|
|
timeout,
|
|
};
|
|
|
|
assert_eq!(item1, item2);
|
|
}
|
|
|
|
#[test]
|
|
fn merge_preserves_position_in_queue() {
|
|
let mut queue = create_queue(10);
|
|
|
|
let rid_first: RepoId = arbitrary::gen(1);
|
|
let rid_second: RepoId = arbitrary::gen(2);
|
|
let rid_third: RepoId = arbitrary::gen(3);
|
|
|
|
// Enqueue three items
|
|
let _ = queue.enqueue(QueuedFetch {
|
|
rid: rid_first,
|
|
refs_at: vec![],
|
|
timeout: Duration::from_secs(30),
|
|
});
|
|
let _ = queue.enqueue(QueuedFetch {
|
|
rid: rid_second,
|
|
refs_at: vec![],
|
|
timeout: Duration::from_secs(30),
|
|
});
|
|
let _ = queue.enqueue(QueuedFetch {
|
|
rid: rid_third,
|
|
refs_at: vec![],
|
|
timeout: Duration::from_secs(30),
|
|
});
|
|
|
|
// Merge into the second item
|
|
let result = queue.enqueue(QueuedFetch {
|
|
rid: rid_second,
|
|
refs_at: vec![arbitrary::gen(1)],
|
|
timeout: Duration::from_secs(60),
|
|
});
|
|
assert_eq!(result, Enqueue::Merged);
|
|
|
|
// Order should be preserved: first, second (merged), third
|
|
assert_eq!(queue.dequeue().unwrap().rid, rid_first);
|
|
assert_eq!(queue.dequeue().unwrap().rid, rid_second);
|
|
assert_eq!(queue.dequeue().unwrap().rid, rid_third);
|
|
}
|
|
|
|
#[test]
|
|
fn capacity_takes_precedence_over_merge_for_new_items() {
|
|
let mut queue = create_queue(2);
|
|
|
|
// Fill to capacity with unique items
|
|
let _ = queue.enqueue(create_fetch());
|
|
let _ = queue.enqueue(create_fetch());
|
|
|
|
// New item (different rid) should be rejected
|
|
let new_item = create_fetch();
|
|
match queue.enqueue(new_item.clone()) {
|
|
Enqueue::CapacityReached(returned) => assert_eq!(returned, new_item),
|
|
_ => panic!("Expected CapacityReached"),
|
|
}
|
|
}
|