671 lines
24 KiB
Rust
671 lines
24 KiB
Rust
//! The logic to generate Sliding Sync list requests.
|
|
//!
|
|
//! Depending on the [`SlidingSyncMode`], the generated requests aren't the
|
|
//! same.
|
|
//!
|
|
//! In [`SlidingSyncMode::Selective`], it's pretty straightforward:
|
|
//!
|
|
//! * There is a set of ranges,
|
|
//! * Each request asks to load the particular ranges.
|
|
//!
|
|
//! In [`SlidingSyncMode::PagingFullSync`]:
|
|
//!
|
|
//! * There is a `batch_size`,
|
|
//! * Each request asks to load a new successive range containing exactly
|
|
//! `batch_size` rooms.
|
|
//!
|
|
//! In [`SlidingSyncMode::GrowingFullSync]:
|
|
//!
|
|
//! * There is a `batch_size`,
|
|
//! * Each request asks to load a new range, always starting from 0, but where
|
|
//! the end is incremented by `batch_size` everytime.
|
|
//!
|
|
//! The number of rooms to load is capped by the
|
|
//! [`SlidingSyncList::maximum_number_of_rooms`], i.e. the real number of
|
|
//! rooms it is possible to load. This value comes from the server.
|
|
//!
|
|
//! The number of rooms to load can _also_ be capped by the
|
|
//! [`SlidingSyncList::full_sync_maximum_number_of_rooms_to_fetch`], i.e. a
|
|
//! user-specified limit representing the maximum number of rooms the user
|
|
//! actually wants to load.
|
|
|
|
use std::cmp::min;
|
|
|
|
use eyeball::unique::Observable;
|
|
use ruma::{api::client::sync::sync_events::v4, assign, OwnedRoomId, UInt};
|
|
use tracing::{error, instrument};
|
|
|
|
use super::{Error, SlidingSyncList, SlidingSyncState};
|
|
|
|
/// The kind of request generator.
|
|
#[derive(Debug)]
|
|
enum GeneratorKind {
|
|
// Growing-mode (see [`SlidingSyncMode`]).
|
|
GrowingFullSync {
|
|
// Number of fetched rooms.
|
|
number_of_fetched_rooms: u32,
|
|
// Size of the batch, used to grow the range to fetch more rooms.
|
|
batch_size: u32,
|
|
// Maximum number of rooms to fetch (see
|
|
// [`SlidingSyncList::full_sync_maximum_number_of_rooms_to_fetch`]).
|
|
maximum_number_of_rooms_to_fetch: Option<u32>,
|
|
// Whether all rooms have been loaded.
|
|
fully_loaded: bool,
|
|
},
|
|
|
|
// Paging-mode (see [`SlidingSyncMode`]).
|
|
PagingFullSync {
|
|
// Number of fetched rooms.
|
|
number_of_fetched_rooms: u32,
|
|
// Size of the batch, used to grow the range to fetch more rooms.
|
|
batch_size: u32,
|
|
// Maximum number of rooms to fetch (see
|
|
// [`SlidingSyncList::full_sync_maximum_number_of_rooms_to_fetch`]).
|
|
maximum_number_of_rooms_to_fetch: Option<u32>,
|
|
// Whether all romms have been loaded.
|
|
fully_loaded: bool,
|
|
},
|
|
|
|
// Selective-mode (see [`SlidingSyncMode`]).
|
|
Selective,
|
|
}
|
|
|
|
/// A request generator for [`SlidingSyncList`].
|
|
#[derive(Debug)]
|
|
pub(in super::super) struct SlidingSyncListRequestGenerator {
|
|
/// The parent [`SlidingSyncList`] object that has created this request
|
|
/// generator.
|
|
list: SlidingSyncList,
|
|
/// The current range used by this request generator.
|
|
ranges: Vec<(UInt, UInt)>,
|
|
/// The kind of request generator.
|
|
kind: GeneratorKind,
|
|
}
|
|
|
|
impl SlidingSyncListRequestGenerator {
|
|
/// Create a new request generator configured for paging-mode.
|
|
pub(super) fn new_with_paging_full_sync(list: SlidingSyncList) -> Self {
|
|
let batch_size = list.full_sync_batch_size;
|
|
let maximum_number_of_rooms_to_fetch = list.full_sync_maximum_number_of_rooms_to_fetch;
|
|
// If a range exists, let's consider it's been used to load existing room. So
|
|
// let's start from the end of the range. It can be useful when we resume a sync
|
|
// for example. Otherwise let's use the default value.
|
|
let number_of_fetched_rooms = list
|
|
.ranges
|
|
.read()
|
|
.unwrap()
|
|
.first()
|
|
.map(|(_start, end)| u32::try_from(*end).unwrap().saturating_add(1))
|
|
.unwrap_or_default();
|
|
|
|
Self {
|
|
list,
|
|
ranges: Vec::new(),
|
|
kind: GeneratorKind::PagingFullSync {
|
|
number_of_fetched_rooms,
|
|
batch_size,
|
|
maximum_number_of_rooms_to_fetch,
|
|
fully_loaded: false,
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Create a new request generator configured for growing-mode.
|
|
pub(super) fn new_with_growing_full_sync(list: SlidingSyncList) -> Self {
|
|
let batch_size = list.full_sync_batch_size;
|
|
let maximum_number_of_rooms_to_fetch = list.full_sync_maximum_number_of_rooms_to_fetch;
|
|
// If a range exists, let's consider it's been used to load existing room. So
|
|
// let's start from the end of the range. It can be useful when we resume a sync
|
|
// for example. Otherwise let's use the default value.
|
|
let number_of_fetched_rooms = list
|
|
.ranges
|
|
.read()
|
|
.unwrap()
|
|
.first()
|
|
.map(|(_start, end)| u32::try_from(*end).unwrap().saturating_add(1))
|
|
.unwrap_or_default();
|
|
|
|
Self {
|
|
list,
|
|
ranges: Vec::new(),
|
|
kind: GeneratorKind::GrowingFullSync {
|
|
number_of_fetched_rooms,
|
|
batch_size,
|
|
maximum_number_of_rooms_to_fetch,
|
|
fully_loaded: false,
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Create a new request generator configured for selective-mode.
|
|
pub(super) fn new_selective(list: SlidingSyncList) -> Self {
|
|
Self { list, ranges: Vec::new(), kind: GeneratorKind::Selective }
|
|
}
|
|
|
|
/// Build a [`SyncRequestList`][v4::SyncRequestList].
|
|
#[instrument(skip(self), fields(name = self.list.name, ranges = ?&self.ranges))]
|
|
fn build_request(&self) -> v4::SyncRequestList {
|
|
let sort = self.list.sort.clone();
|
|
let required_state = self.list.required_state.clone();
|
|
let timeline_limit = **self.list.timeline_limit.read().unwrap();
|
|
let filters = self.list.filters.clone();
|
|
|
|
assign!(v4::SyncRequestList::default(), {
|
|
ranges: self.ranges.clone(),
|
|
room_details: assign!(v4::RoomDetailsConfig::default(), {
|
|
required_state,
|
|
timeline_limit,
|
|
}),
|
|
sort,
|
|
filters,
|
|
})
|
|
}
|
|
|
|
// Handle the response from the server.
|
|
#[instrument(skip_all, fields(name = self.list.name, rooms_count, has_ops = !ops.is_empty()))]
|
|
pub(in super::super) fn handle_response(
|
|
&mut self,
|
|
maximum_number_of_rooms: u32,
|
|
ops: &Vec<v4::SyncOp>,
|
|
updated_rooms: &Vec<OwnedRoomId>,
|
|
) -> Result<bool, Error> {
|
|
let response =
|
|
self.list.handle_response(maximum_number_of_rooms, ops, &self.ranges, updated_rooms)?;
|
|
|
|
self.update_state(maximum_number_of_rooms);
|
|
|
|
Ok(response)
|
|
}
|
|
|
|
/// Update the state of the generator.
|
|
fn update_state(&mut self, maximum_number_of_rooms: u32) {
|
|
let Some(range_end) = self.ranges.first().map(|(_start, end)| u32::try_from(*end).unwrap()) else {
|
|
error!(name = self.list.name, "The request generator must have a range.");
|
|
|
|
return;
|
|
};
|
|
|
|
match &mut self.kind {
|
|
GeneratorKind::PagingFullSync {
|
|
number_of_fetched_rooms,
|
|
fully_loaded,
|
|
maximum_number_of_rooms_to_fetch,
|
|
..
|
|
}
|
|
| GeneratorKind::GrowingFullSync {
|
|
number_of_fetched_rooms,
|
|
fully_loaded,
|
|
maximum_number_of_rooms_to_fetch,
|
|
..
|
|
} => {
|
|
// Calculate the maximum bound for the range.
|
|
// At this step, the server has given us a maximum number of rooms for this
|
|
// list. That's our `range_maximum`.
|
|
let mut range_maximum = maximum_number_of_rooms;
|
|
|
|
// But maybe the user has defined a maximum number of rooms to fetch? In this
|
|
// case, let's take the minimum of the two.
|
|
if let Some(maximum_number_of_rooms_to_fetch) = maximum_number_of_rooms_to_fetch {
|
|
range_maximum = min(range_maximum, *maximum_number_of_rooms_to_fetch);
|
|
}
|
|
|
|
// Finally, ranges are inclusive!
|
|
range_maximum = range_maximum.saturating_sub(1);
|
|
|
|
// Now, we know what the maximum bound for the range is.
|
|
|
|
// The current range hasn't reached its maximum, let's continue.
|
|
if range_end < range_maximum {
|
|
// Update the _list range_ to cover from 0 to `range_end`.
|
|
// The list range is different from the request generator (this) range.
|
|
self.list.set_range(0, range_end);
|
|
|
|
// Update the number of fetched rooms forward. Do not forget that ranges are
|
|
// inclusive, so let's add 1.
|
|
*number_of_fetched_rooms = range_end.saturating_add(1);
|
|
|
|
// The list is still not fully loaded.
|
|
*fully_loaded = false;
|
|
|
|
// Finally, let's update the list' state.
|
|
Observable::update_eq(&mut self.list.state.write().unwrap(), |state| {
|
|
*state = SlidingSyncState::PartiallyLoaded;
|
|
});
|
|
}
|
|
// Otherwise the current range has reached its maximum, we switched to `FullyLoaded`
|
|
// mode.
|
|
else {
|
|
// The range is covering the entire list, from 0 to its maximum.
|
|
self.list.set_range(0, range_maximum);
|
|
|
|
// The number of fetched rooms is set to the maximum too.
|
|
*number_of_fetched_rooms = range_maximum;
|
|
|
|
// And we update the `fully_loaded` marker.
|
|
*fully_loaded = true;
|
|
|
|
// Finally, let's update the list' state.
|
|
Observable::update_eq(&mut self.list.state.write().unwrap(), |state| {
|
|
*state = SlidingSyncState::FullyLoaded;
|
|
});
|
|
}
|
|
}
|
|
|
|
GeneratorKind::Selective => {
|
|
// Selective mode always loads everything.
|
|
Observable::update_eq(&mut self.list.state.write().unwrap(), |state| {
|
|
*state = SlidingSyncState::FullyLoaded;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
fn is_fully_loaded(&self) -> bool {
|
|
match self.kind {
|
|
GeneratorKind::PagingFullSync { fully_loaded, .. }
|
|
| GeneratorKind::GrowingFullSync { fully_loaded, .. } => fully_loaded,
|
|
GeneratorKind::Selective => true,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn create_range(
|
|
start: u32,
|
|
desired_size: u32,
|
|
maximum_number_of_rooms_to_fetch: Option<u32>,
|
|
maximum_number_of_rooms: Option<u32>,
|
|
) -> Option<(UInt, UInt)> {
|
|
// Calculate the range.
|
|
// The `start` bound is given. Let's calculate the `end` bound.
|
|
|
|
// The `end`, by default, is `start` + `desired_size`.
|
|
let mut end = start + desired_size;
|
|
|
|
// But maybe the user has defined a maximum number of rooms to fetch? In this
|
|
// case, take the minimum of the two.
|
|
if let Some(maximum_number_of_rooms_to_fetch) = maximum_number_of_rooms_to_fetch {
|
|
end = min(end, maximum_number_of_rooms_to_fetch);
|
|
}
|
|
|
|
// But there is more! The server can tell us what is the maximum number of rooms
|
|
// fulfilling a particular list. For example, if the server says there is 42
|
|
// rooms for a particular list, with a `start` of 40 and a `batch_size` of 20,
|
|
// the range must be capped to `[40; 46]`; the range `[40; 60]` would be invalid
|
|
// and could be rejected by the server.
|
|
if let Some(maximum_number_of_rooms) = maximum_number_of_rooms {
|
|
end = min(end, maximum_number_of_rooms);
|
|
}
|
|
|
|
// Finally, because the bounds of the range are inclusive, 1 is subtracted.
|
|
end = end.saturating_sub(1);
|
|
|
|
// Make sure `start` is smaller than `end`. It can happen if `start` is greater
|
|
// than `maximum_number_of_rooms_to_fetch` or `maximum_number_of_rooms`.
|
|
if start > end {
|
|
return None;
|
|
}
|
|
|
|
Some((start.into(), end.into()))
|
|
}
|
|
|
|
impl Iterator for SlidingSyncListRequestGenerator {
|
|
type Item = v4::SyncRequestList;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
match self.kind {
|
|
// Cases where all rooms have been fully loaded.
|
|
GeneratorKind::PagingFullSync { fully_loaded: true, .. }
|
|
| GeneratorKind::GrowingFullSync { fully_loaded: true, .. }
|
|
| GeneratorKind::Selective => {
|
|
// Let's copy all the ranges from the parent `SlidingSyncList`, and build a
|
|
// request for them.
|
|
self.ranges = self.list.ranges.read().unwrap().clone();
|
|
|
|
// Here we go.
|
|
Some(self.build_request())
|
|
}
|
|
|
|
GeneratorKind::PagingFullSync {
|
|
number_of_fetched_rooms,
|
|
batch_size,
|
|
maximum_number_of_rooms_to_fetch,
|
|
..
|
|
} => {
|
|
// In paging-mode, range starts at the number of fetched rooms. Since ranges are
|
|
// inclusive, and since the number of fetched rooms starts at 1,
|
|
// not at 0, there is no need to add 1 here.
|
|
let range_start = number_of_fetched_rooms;
|
|
let range_desired_size = batch_size;
|
|
|
|
// Create a new range, and use it as the current set of ranges.
|
|
self.ranges = vec![create_range(
|
|
range_start,
|
|
range_desired_size,
|
|
maximum_number_of_rooms_to_fetch,
|
|
self.list.maximum_number_of_rooms(),
|
|
)?];
|
|
|
|
// Here we go.
|
|
Some(self.build_request())
|
|
}
|
|
|
|
GeneratorKind::GrowingFullSync {
|
|
number_of_fetched_rooms,
|
|
batch_size,
|
|
maximum_number_of_rooms_to_fetch,
|
|
..
|
|
} => {
|
|
// In growing-mode, range always starts from 0. However, the end is growing by
|
|
// adding `batch_size` to the previous number of fetched rooms.
|
|
let range_start = 0;
|
|
let range_desired_size = number_of_fetched_rooms.saturating_add(batch_size);
|
|
|
|
self.ranges = vec![create_range(
|
|
range_start,
|
|
range_desired_size,
|
|
maximum_number_of_rooms_to_fetch,
|
|
self.list.maximum_number_of_rooms(),
|
|
)?];
|
|
|
|
// Here we go.
|
|
Some(self.build_request())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use ruma::uint;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_create_range_from() {
|
|
// From 0, we want 100 items.
|
|
assert_eq!(create_range(0, 100, None, None), Some((uint!(0), uint!(99))));
|
|
|
|
// From 100, we want 100 items.
|
|
assert_eq!(create_range(100, 100, None, None), Some((uint!(100), uint!(199))));
|
|
|
|
// From 0, we want 100 items, but there is a maximum number of rooms to fetch
|
|
// defined at 50.
|
|
assert_eq!(create_range(0, 100, Some(50), None), Some((uint!(0), uint!(49))));
|
|
|
|
// From 49, we want 100 items, but there is a maximum number of rooms to fetch
|
|
// defined at 50. There is 1 item to load.
|
|
assert_eq!(create_range(49, 100, Some(50), None), Some((uint!(49), uint!(49))));
|
|
|
|
// From 50, we want 100 items, but there is a maximum number of rooms to fetch
|
|
// defined at 50.
|
|
assert_eq!(create_range(50, 100, Some(50), None), None);
|
|
|
|
// From 0, we want 100 items, but there is a maximum number of rooms defined at
|
|
// 50.
|
|
assert_eq!(create_range(0, 100, None, Some(50)), Some((uint!(0), uint!(49))));
|
|
|
|
// From 49, we want 100 items, but there is a maximum number of rooms defined at
|
|
// 50. There is 1 item to load.
|
|
assert_eq!(create_range(49, 100, None, Some(50)), Some((uint!(49), uint!(49))));
|
|
|
|
// From 50, we want 100 items, but there is a maximum number of rooms defined at
|
|
// 50.
|
|
assert_eq!(create_range(50, 100, None, Some(50)), None);
|
|
|
|
// From 0, we want 100 items, but there is a maximum number of rooms to fetch
|
|
// defined at 75, and a maximum number of rooms defined at 50.
|
|
assert_eq!(create_range(0, 100, Some(75), Some(50)), Some((uint!(0), uint!(49))));
|
|
|
|
// From 0, we want 100 items, but there is a maximum number of rooms to fetch
|
|
// defined at 50, and a maximum number of rooms defined at 75.
|
|
assert_eq!(create_range(0, 100, Some(50), Some(75)), Some((uint!(0), uint!(49))));
|
|
}
|
|
|
|
macro_rules! assert_request_and_response {
|
|
(
|
|
list = $list:ident,
|
|
generator = $generator:ident,
|
|
maximum_number_of_rooms = $maximum_number_of_rooms:expr,
|
|
$(
|
|
next => {
|
|
ranges = $( [ $range_start:literal ; $range_end:literal ] ),+ ,
|
|
is_fully_loaded = $is_fully_loaded:expr,
|
|
list_state = $list_state:ident,
|
|
}
|
|
),*
|
|
$(,)*
|
|
) => {
|
|
// That's the initial state.
|
|
assert_eq!($list.state(), SlidingSyncState::NotLoaded);
|
|
|
|
$(
|
|
{
|
|
// Generate a new request.
|
|
let request = $generator.next().unwrap();
|
|
|
|
assert_eq!(request.ranges, [ $( (uint!( $range_start ), uint!( $range_end )) ),* ]);
|
|
|
|
// Fake a response.
|
|
let _ = $generator.handle_response($maximum_number_of_rooms, &vec![], &vec![]);
|
|
|
|
assert_eq!($generator.is_fully_loaded(), $is_fully_loaded);
|
|
assert_eq!($list.state(), SlidingSyncState::$list_state);
|
|
}
|
|
)*
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_generator_paging_full_sync() {
|
|
let list = SlidingSyncList::builder()
|
|
.sync_mode(crate::SlidingSyncMode::PagingFullSync)
|
|
.name("testing")
|
|
.full_sync_batch_size(10)
|
|
.build()
|
|
.unwrap();
|
|
let mut generator = list.request_generator();
|
|
|
|
assert_request_and_response! {
|
|
list = list,
|
|
generator = generator,
|
|
maximum_number_of_rooms = 25,
|
|
next => {
|
|
ranges = [0; 9],
|
|
is_fully_loaded = false,
|
|
list_state = PartiallyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [10; 19],
|
|
is_fully_loaded = false,
|
|
list_state = PartiallyLoaded,
|
|
},
|
|
// The maximum number of rooms is reached!
|
|
next => {
|
|
ranges = [20; 24],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
// Now it's fully loaded, so the same request must be produced everytime.
|
|
next => {
|
|
ranges = [0; 24], // the range starts at 0 now!
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [0; 24],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_generator_paging_full_sync_with_a_maximum_number_of_rooms_to_fetch() {
|
|
let list = SlidingSyncList::builder()
|
|
.sync_mode(crate::SlidingSyncMode::PagingFullSync)
|
|
.name("testing")
|
|
.full_sync_batch_size(10)
|
|
.full_sync_maximum_number_of_rooms_to_fetch(22)
|
|
.build()
|
|
.unwrap();
|
|
let mut generator = list.request_generator();
|
|
|
|
assert_request_and_response! {
|
|
list = list,
|
|
generator = generator,
|
|
maximum_number_of_rooms = 25,
|
|
next => {
|
|
ranges = [0; 9],
|
|
is_fully_loaded = false,
|
|
list_state = PartiallyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [10; 19],
|
|
is_fully_loaded = false,
|
|
list_state = PartiallyLoaded,
|
|
},
|
|
// The maximum number of rooms to fetch is reached!
|
|
next => {
|
|
ranges = [20; 21],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
// Now it's fully loaded, so the same request must be produced everytime.
|
|
next => {
|
|
ranges = [0; 21], // the range starts at 0 now!
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [0; 21],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_generator_growing_full_sync() {
|
|
let list = SlidingSyncList::builder()
|
|
.sync_mode(crate::SlidingSyncMode::GrowingFullSync)
|
|
.name("testing")
|
|
.full_sync_batch_size(10)
|
|
.build()
|
|
.unwrap();
|
|
let mut generator = list.request_generator();
|
|
|
|
assert_request_and_response! {
|
|
list = list,
|
|
generator = generator,
|
|
maximum_number_of_rooms = 25,
|
|
next => {
|
|
ranges = [0; 9],
|
|
is_fully_loaded = false,
|
|
list_state = PartiallyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [0; 19],
|
|
is_fully_loaded = false,
|
|
list_state = PartiallyLoaded,
|
|
},
|
|
// The maximum number of rooms is reached!
|
|
next => {
|
|
ranges = [0; 24],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
// Now it's fully loaded, so the same request must be produced everytime.
|
|
next => {
|
|
ranges = [0; 24],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [0; 24],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_generator_growing_full_sync_with_a_maximum_number_of_rooms_to_fetch() {
|
|
let list = SlidingSyncList::builder()
|
|
.sync_mode(crate::SlidingSyncMode::GrowingFullSync)
|
|
.name("testing")
|
|
.full_sync_batch_size(10)
|
|
.full_sync_maximum_number_of_rooms_to_fetch(22)
|
|
.build()
|
|
.unwrap();
|
|
let mut generator = list.request_generator();
|
|
|
|
assert_request_and_response! {
|
|
list = list,
|
|
generator = generator,
|
|
maximum_number_of_rooms = 25,
|
|
next => {
|
|
ranges = [0; 9],
|
|
is_fully_loaded = false,
|
|
list_state = PartiallyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [0; 19],
|
|
is_fully_loaded = false,
|
|
list_state = PartiallyLoaded,
|
|
},
|
|
// The maximum number of rooms is reached!
|
|
next => {
|
|
ranges = [0; 21],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
// Now it's fully loaded, so the same request must be produced everytime.
|
|
next => {
|
|
ranges = [0; 21],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [0; 21],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_generator_selective() {
|
|
let list = SlidingSyncList::builder()
|
|
.sync_mode(crate::SlidingSyncMode::Selective)
|
|
.name("testing")
|
|
.ranges(vec![(0u32, 10), (42, 153)])
|
|
.build()
|
|
.unwrap();
|
|
let mut generator = list.request_generator();
|
|
|
|
assert_request_and_response! {
|
|
list = list,
|
|
generator = generator,
|
|
maximum_number_of_rooms = 25,
|
|
// The maximum number of rooms is reached directly!
|
|
next => {
|
|
ranges = [0; 10], [42; 153],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
// Now it's fully loaded, so the same request must be produced everytime.
|
|
next => {
|
|
ranges = [0; 10], [42; 153],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
},
|
|
next => {
|
|
ranges = [0; 10], [42; 153],
|
|
is_fully_loaded = true,
|
|
list_state = FullyLoaded,
|
|
}
|
|
};
|
|
}
|
|
}
|