Files
frid/crates/music-dht/src/podcast/state_tests.rs
T
sanapachandClaude Opus 5.5 085bff6191 Harden podcast sync registers, versions and snapshots
- Order subscription and share registers by a per-podcast Lamport
  generation before hlc_ms (next_podcast_generation), so clock skew
  cannot undo an observed unsubscribe or share decision.
- share=false is register state, not a compactable tombstone.
- Add podcast_feed_aliases_added so refreshes can sync aliases without
  touching the registers; SubscriptionRecord::feed_urls keeps the current
  feed URL resolvable beyond the alias bound.
- Carry progress_generation on queue items for handoff.
- Distinguish self-reported and relayed peer versions, and gate
  PairRequest by an optional inviter version in InviteWire.
- Give each podcast snapshot section its own byte budget, drop channel
  descriptions from snapshots and allow a caller-provided budget.
- Reject one-slash http(s) typos in FeedUrl::from_user_input.
- Pin that malformed ids and feed URLs reject the whole message.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 16:10:33 +02:00

700 lines
24 KiB
Rust

use std::collections::BTreeMap;
use super::*;
use crate::podcast::{EpisodeIdentityHints, EpisodeMeta, EpisodeType, resolve_episode_ids};
fn permutations<T: Clone>(items: &[T]) -> Vec<Vec<T>> {
if items.len() <= 1 {
return vec![items.to_vec()];
}
let mut out = Vec::new();
for index in 0..items.len() {
let mut rest = items.to_vec();
let head = rest.remove(index);
for mut tail in permutations(&rest) {
tail.insert(0, head.clone());
out.push(tail);
}
}
out
}
fn feed_url(path: &str) -> FeedUrl {
FeedUrl::parse(&format!("https://example.test/{path}")).unwrap()
}
fn podcast_id() -> PodcastId {
PodcastId::from_feed_url(&feed_url("feed"))
}
fn episode_id(guid: &str) -> EpisodeId {
EpisodeId::from_guid(&podcast_id(), guid).unwrap()
}
fn progress(
generation: u64,
hlc_ms: i64,
device: &str,
op: &str,
position_ms: i64,
status: ProgressStatus,
session: &str,
) -> ProgressRecord {
ProgressRecord {
episode_id: episode_id("e1"),
podcast_id: podcast_id(),
position_ms,
status,
generation,
session_id: session.to_string(),
hlc_ms,
device_id: device.to_string(),
op_id: op.to_string(),
}
}
fn fold<T: Clone>(items: &[T], merge: impl Fn(&T, &T) -> PodcastResult<T>) -> T {
let mut iter = items.iter();
let first = iter.next().expect("non-empty").clone();
iter.fold(first, |acc, item| merge(&acc, item).unwrap())
}
fn assert_converges<T: Clone + PartialEq + std::fmt::Debug>(
items: &[T],
merge: impl Fn(&T, &T) -> PodcastResult<T> + Copy,
) -> T {
let reference = fold(items, merge);
for order in permutations(items) {
assert_eq!(fold(&order, merge), reference, "order: {order:?}");
}
// Merge laws on every pair and triple.
for a in items {
assert_eq!(
merge(&merge(a, a).unwrap(), a).unwrap(),
merge(a, a).unwrap()
);
for b in items {
assert_eq!(merge(a, b).unwrap(), merge(b, a).unwrap());
for c in items {
assert_eq!(
merge(&merge(a, b).unwrap(), c).unwrap(),
merge(a, &merge(b, c).unwrap()).unwrap()
);
}
}
}
reference
}
#[test]
fn progress_converges_for_every_permutation() {
use ProgressStatus::*;
let ops = [
progress(1, 100, "dev-a", "dev-a:1", 10_000, InProgress, "s1"),
progress(1, 160, "dev-a", "dev-a:2", 70_000, InProgress, "s1"),
progress(2, 150, "dev-b", "dev-b:1", 0, InProgress, "s2"),
progress(2, 150, "dev-c", "dev-c:1", 5_000, InProgress, "s3"),
progress(2, 140, "dev-b", "dev-b:2", 0, Completed, "s2"),
// Duplicate delivery of the same operation.
progress(1, 160, "dev-a", "dev-a:2", 70_000, InProgress, "s1"),
];
let winner = assert_converges(&ops, merge_progress);
assert_eq!(winner.op_id, "dev-c:1");
}
#[test]
fn late_old_generation_checkpoint_loses() {
use ProgressStatus::*;
// Device A keeps checkpointing session s1 (generation 3) with a clock far
// ahead; device B explicitly seeks back (generation 4) with a slow clock.
let seek_back = progress(4, 1_000, "dev-b", "dev-b:9", 60_000, InProgress, "s2");
let late = progress(
3, 9_000_000, "dev-a", "dev-a:50", 3_000_000, InProgress, "s1",
);
for order in [[&seek_back, &late], [&late, &seek_back]] {
let merged = merge_progress(order[0], order[1]).unwrap();
assert_eq!(merged, seek_back);
}
assert!(seek_back.supersedes(&late));
assert!(!late.supersedes(&seek_back));
}
#[test]
fn restart_beats_later_checkpoint_of_the_old_session() {
use ProgressStatus::*;
let checkpoint = progress(2, 100, "dev-a", "dev-a:1", 2_400_000, InProgress, "s1");
let generation = ProgressRecord::explicit_generation(Some(checkpoint.generation));
assert_eq!(generation, 3);
let restart = progress(generation, 110, "dev-a", "dev-a:2", 0, InProgress, "s2");
// A checkpoint of s1 that was queued before the restart and delivered
// later, even stamped after the restart.
let late = progress(2, 120, "dev-a", "dev-a:3", 2_460_000, InProgress, "s1");
let merged = assert_converges(&[checkpoint, restart.clone(), late], merge_progress);
assert_eq!(merged, restart);
assert_eq!(merged.resume_position_ms(), 0);
}
#[test]
fn progress_is_not_the_maximum_position() {
use ProgressStatus::*;
let ahead = progress(1, 100, "dev-a", "dev-a:1", 3_000_000, InProgress, "s1");
let back = progress(2, 101, "dev-a", "dev-a:2", 60_000, InProgress, "s1");
assert_eq!(merge_progress(&ahead, &back).unwrap().position_ms, 60_000);
}
#[test]
fn concurrent_offline_sessions_converge_and_keep_both_sessions() {
use ProgressStatus::*;
// Both devices last saw generation 5 and start listening offline.
let generation = ProgressRecord::explicit_generation(Some(5));
let a_start = progress(
generation, 200, "dev-a", "dev-a:1", 300_000, InProgress, "sa",
);
let a_cp = progress(
generation, 300, "dev-a", "dev-a:2", 900_000, InProgress, "sa",
);
let b_start = progress(
generation, 210, "dev-b", "dev-b:1", 300_000, InProgress, "sb",
);
let b_cp = progress(
generation, 280, "dev-b", "dev-b:2", 1_500_000, InProgress, "sb",
);
let merged = assert_converges(&[a_start, a_cp.clone(), b_start, b_cp], merge_progress);
// Deterministic: the latest write of the shared generation wins.
assert_eq!(merged, a_cp);
let session = |id: &str, device: &str, listened: i64, completed: bool| ListenSession {
session_id: id.to_string(),
episode_id: episode_id("e1"),
podcast_id: podcast_id(),
device_id: device.to_string(),
started_at_ms: 200,
ended_at_ms: 300,
start_position_ms: 300_000,
end_position_ms: 900_000,
listened_ms: listened,
completed,
};
let sessions = [
session("sa", "dev-a", 600_000, false),
session("sb", "dev-b", 1_200_000, true),
session("sb", "dev-b", 1_200_000, true),
];
let mut set: BTreeMap<String, ListenSession> = BTreeMap::new();
for order in permutations(&sessions) {
set.clear();
for item in order {
let merged = match set.get(&item.session_id) {
Some(current) => merge_listen_session(current, &item).unwrap(),
None => item.clone(),
};
set.insert(item.session_id.clone(), merged);
}
assert_eq!(set.len(), 2);
assert_eq!(completed_listen_count(set.values()), 1);
}
}
#[test]
fn listen_session_versions_only_grow() {
let base = ListenSession {
session_id: "s".to_string(),
episode_id: episode_id("e1"),
podcast_id: podcast_id(),
device_id: "dev-a".to_string(),
started_at_ms: 1_000,
ended_at_ms: 2_000,
start_position_ms: 0,
end_position_ms: 60_000,
listened_ms: 60_000,
completed: false,
};
let longer = ListenSession {
ended_at_ms: 3_000,
end_position_ms: 120_000,
listened_ms: 120_000,
..base.clone()
};
let finished = ListenSession {
ended_at_ms: 3_500,
end_position_ms: 3_600_000,
listened_ms: 125_000,
completed: true,
..base.clone()
};
let merged = assert_converges(
&[base.clone(), longer, finished.clone(), base.clone()],
merge_listen_session,
);
assert_eq!(merged, finished);
assert!(merged.should_record());
assert_eq!(completed_listen_count([&merged, &merged, &finished]), 1);
let mut other_episode = base.clone();
other_episode.episode_id = episode_id("e2");
assert!(merge_listen_session(&base, &other_episode).is_err());
let short = ListenSession {
listened_ms: MIN_RECORDED_EPISODE_LISTEN_MS - 1,
..base.clone()
};
assert!(!short.should_record());
assert!(
ListenSession {
listened_ms: MIN_RECORDED_EPISODE_LISTEN_MS,
..base
}
.should_record()
);
}
#[test]
fn completion_criterion() {
// 60 min episode: tail is 30 s.
assert!(!reaches_completion(3_569_999, Some(3_600_000)));
assert!(reaches_completion(3_570_000, Some(3_600_000)));
// 5 min episode: tail is 5 % = 15 s.
assert!(!reaches_completion(284_999, Some(300_000)));
assert!(reaches_completion(285_000, Some(300_000)));
assert!(!reaches_completion(1_000_000, None));
assert!(!reaches_completion(1_000_000, Some(0)));
}
fn podcast_meta(title: &str, url: &str) -> PodcastMeta {
PodcastMeta {
feed_url: feed_url(url),
title: title.to_string(),
author: None,
description: None,
link: None,
image_url: None,
}
}
fn subscription(
subscribed: bool,
hlc_ms: i64,
op: &str,
title: &str,
url: &str,
) -> SubscriptionRecord {
let mut record = SubscriptionRecord {
podcast_id: podcast_id(),
subscribed,
podcast: podcast_meta(title, url),
feed_aliases: Vec::new(),
generation: 1,
hlc_ms,
op_id: op.to_string(),
};
record.normalize();
record
}
fn with_generation<T: Clone>(record: &T, set: impl Fn(&mut T)) -> T {
let mut record = record.clone();
set(&mut record);
record
}
#[test]
fn subscriptions_converge_for_every_permutation() {
let ops = [
// Same podcast added on two devices.
subscription(true, 100, "dev-a:1", "Show", "feed"),
subscription(true, 101, "dev-b:1", "Show (B)", "feed"),
// Unsubscribed on A while B was offline.
subscription(false, 200, "dev-a:2", "Show", "feed"),
// B comes back and re-delivers its old state after the feed moved.
subscription(true, 150, "dev-b:2", "Show", "moved"),
subscription(true, 101, "dev-b:1", "Show (B)", "feed"),
];
let merged = assert_converges(&ops, merge_subscription);
assert!(
!merged.subscribed,
"unsubscribe survives the offline device"
);
assert_eq!(merged.op_id, "dev-a:2");
assert!(merged.feed_aliases.contains(&feed_url("moved")));
assert!(merged.feed_aliases.contains(&feed_url("feed")));
merged.validate().unwrap();
}
#[test]
fn resubscribing_keeps_progress_and_history() {
use ProgressStatus::*;
let mut progress_register = BTreeMap::new();
let saved = progress(4, 500, "dev-a", "dev-a:5", 1_234_000, InProgress, "s1");
progress_register.insert(saved.episode_id.clone(), saved.clone());
let subscribed = subscription(true, 100, "dev-a:1", "Show", "feed");
let unsubscribed = subscription(false, 600, "dev-a:6", "Show", "feed");
let again = subscription(true, 700, "dev-b:1", "Show", "feed");
let merged = fold(&[subscribed, unsubscribed, again], merge_subscription);
assert!(merged.subscribed);
assert_eq!(progress_register.get(&saved.episode_id), Some(&saved));
}
fn share(shared: bool, hlc_ms: i64, op: &str) -> ShareRecord {
ShareRecord {
podcast_id: podcast_id(),
shared,
generation: 1,
hlc_ms,
op_id: op.to_string(),
}
}
#[test]
fn shares_converge_and_false_is_never_beaten_by_a_stale_true() {
let ops = [
share(true, 100, "dev-a:1"),
share(false, 200, "dev-a:2"),
share(true, 150, "dev-b:1"),
share(false, 200, "dev-a:2"),
];
let merged = assert_converges(&ops, merge_share);
assert!(!merged.shared, "late stale share cannot republish");
}
#[test]
fn effective_share_rules() {
let subscribed = subscription(true, 100, "dev-a:1", "Show", "feed");
let shared = share(true, 150, "dev-a:2");
assert!(effective_share(Some(&subscribed), Some(&shared)));
assert!(!effective_share(Some(&subscribed), None));
assert!(!effective_share(None, Some(&shared)));
// New subscriptions are private: a share decision older than the
// latest subscription write does not apply.
let resubscribed = subscription(true, 300, "dev-a:4", "Show", "feed");
assert!(!effective_share(Some(&resubscribed), Some(&shared)));
// Unsubscribing revokes publication even if a stale share wins.
let unsubscribed = subscription(false, 200, "dev-a:3", "Show", "feed");
let stale = share(true, 250, "dev-b:1");
assert!(!effective_share(Some(&unsubscribed), Some(&stale)));
}
#[test]
fn clock_skew_cannot_undo_an_observed_unsubscribe() {
// Device A's clock runs ten minutes ahead. B sees A's subscription, then
// the user unsubscribes on B.
let sub_a = subscription(true, 1_000_600_000, "dev-a:1", "Show", "feed");
assert_eq!(next_podcast_generation(None, None), 1);
let generation = next_podcast_generation(Some(&sub_a), None);
assert_eq!(generation, 2);
let unsub_b = with_generation(
&subscription(false, 1_000_060_000, "dev-b:1", "Show", "feed"),
|r| r.generation = generation,
);
let merged = assert_converges(&[sub_a.clone(), unsub_b.clone()], merge_subscription);
assert!(!merged.subscribed, "the later unsubscribe wins");
// Concurrent writes (same generation) still fall back to the clock.
let concurrent = with_generation(&unsub_b, |r| r.generation = 1);
assert!(merge_subscription(&sub_a, &concurrent).unwrap().subscribed);
}
#[test]
fn share_after_subscribe_applies_despite_clock_skew() {
let sub_a = subscription(true, 1_000_600_000, "dev-a:1", "Show", "feed");
let share_b = with_generation(&share(true, 1_000_060_000, "dev-b:1"), |r| {
r.generation = next_podcast_generation(Some(&sub_a), None)
});
assert!(effective_share(Some(&sub_a), Some(&share_b)));
// Unsubscribe written after the share (higher generation) revokes it,
// and so does a later re-subscription until the user shares again.
let unsub = with_generation(&subscription(false, 1, "dev-a:2", "Show", "feed"), |r| {
r.generation = next_podcast_generation(Some(&sub_a), Some(&share_b))
});
assert!(!effective_share(Some(&unsub), Some(&share_b)));
let resub = with_generation(&subscription(true, 2, "dev-a:3", "Show", "feed"), |r| {
r.generation = next_podcast_generation(Some(&unsub), Some(&share_b))
});
assert!(!effective_share(Some(&resub), Some(&share_b)));
let reshare = with_generation(&share(true, 3, "dev-a:4"), |r| {
r.generation = next_podcast_generation(Some(&resub), Some(&share_b))
});
assert!(effective_share(Some(&resub), Some(&reshare)));
// Revoking (shared = false) with a higher generation wins over every
// stale true, in any order.
let revoke = with_generation(&share(false, 0, "dev-b:2"), |r| {
r.generation = next_podcast_generation(Some(&resub), Some(&reshare))
});
let merged = assert_converges(&[share_b, reshare, revoke.clone()], merge_share);
assert_eq!(merged, revoke);
}
#[test]
fn current_feed_url_stays_resolvable_beyond_the_alias_bound() {
let mut record = subscription(true, 1, "dev-a:1", "Show", "feed");
record.add_feed_aliases(
&(0..=crate::podcast::MAX_FEED_ALIASES)
.map(|i| feed_url(&format!("a{i}")))
.collect::<Vec<_>>(),
);
record.podcast.feed_url = FeedUrl::parse("https://z.test/current").unwrap();
record.normalize();
assert!(!record.feed_aliases.contains(&record.podcast.feed_url));
let urls = record.feed_urls();
assert!(urls.contains(&record.podcast.feed_url));
assert!(urls.contains(&feed_url("feed")), "origin is kept");
let known: Vec<(&PodcastId, &FeedUrl)> =
urls.iter().map(|url| (&record.podcast_id, url)).collect();
assert_eq!(
crate::podcast::resolve_podcast_id(&record.podcast.feed_url, known),
podcast_id()
);
}
#[test]
fn handoff_receiver_continues_with_the_carried_generation() {
use ProgressStatus::*;
// Sender A plays session s1 at generation 5 with a fast clock; its
// progress operations have not reached B when the handoff arrives.
let a_checkpoint = progress(5, 9_000_000, "dev-a", "dev-a:9", 600_000, InProgress, "s1");
let carried = Some(a_checkpoint.generation);
let b_local = Some(2);
let generation = ProgressRecord::explicit_generation(b_local.max(carried));
assert_eq!(generation, 6);
let b_start = progress(
generation, 1_000, "dev-b", "dev-b:1", 600_000, InProgress, "s2",
);
let b_pause = progress(
generation, 2_000, "dev-b", "dev-b:2", 660_000, InProgress, "s2",
);
// Without the carried generation B would write generation 3 and lose
// every write to A's older checkpoint.
let uninformed = progress(
ProgressRecord::explicit_generation(b_local),
2_000,
"dev-b",
"dev-b:2",
660_000,
InProgress,
"s2",
);
assert!(a_checkpoint.supersedes(&uninformed));
let merged = assert_converges(&[a_checkpoint, b_start, b_pause.clone()], merge_progress);
assert_eq!(merged, b_pause);
assert_eq!(merged.resume_position_ms(), 660_000);
}
#[test]
fn coalescing_keeps_the_superseding_record_not_the_last_queued() {
use ProgressStatus::*;
// "Mark played" (explicit, generation 5) during a session, followed in
// the outgoing log by a checkpoint of the old session (generation 3).
let mark_played = progress(5, 100, "dev-a", "dev-a:7", 0, Completed, "mark");
let late_checkpoint = progress(3, 101, "dev-a", "dev-a:8", 30_000, InProgress, "s1");
let pending = [mark_played.clone(), late_checkpoint.clone()];
// Keep only records that no other pending record supersedes.
let kept: Vec<&ProgressRecord> = pending
.iter()
.filter(|record| !pending.iter().any(|other| other.supersedes(record)))
.collect();
assert_eq!(kept, vec![&mark_played]);
// Dropping by sequence order would have published the wrong state.
assert_ne!(pending.last(), Some(&mark_played));
assert_eq!(fold(&pending, merge_progress), mark_played);
}
/// Minimal client store used to show that whole operation sets converge and
/// that publisher metadata never reaches personal progress.
#[derive(Debug, Default, Clone, PartialEq)]
struct Store {
subscriptions: BTreeMap<PodcastId, SubscriptionRecord>,
shares: BTreeMap<PodcastId, ShareRecord>,
progress: BTreeMap<EpisodeId, ProgressRecord>,
sessions: BTreeMap<String, ListenSession>,
catalog: BTreeMap<EpisodeId, EpisodeMeta>,
}
#[derive(Debug, Clone)]
enum Op {
Subscription(SubscriptionRecord),
Share(ShareRecord),
Progress(ProgressRecord),
Session(ListenSession),
/// Local RSS refresh: title and audio URL changed at the publisher.
Rss {
title: &'static str,
audio_url: &'static str,
},
}
fn upsert<K: Ord + Clone, V: Clone>(
map: &mut BTreeMap<K, V>,
key: K,
value: &V,
merge: impl Fn(&V, &V) -> PodcastResult<V>,
) {
let merged = match map.get(&key) {
Some(current) => merge(current, value).unwrap(),
None => value.clone(),
};
map.insert(key, merged);
}
impl Store {
fn apply(&mut self, op: &Op) {
match op {
Op::Subscription(record) => upsert(
&mut self.subscriptions,
record.podcast_id.clone(),
record,
merge_subscription,
),
Op::Share(record) => upsert(
&mut self.shares,
record.podcast_id.clone(),
record,
merge_share,
),
Op::Progress(record) => upsert(
&mut self.progress,
record.episode_id.clone(),
record,
merge_progress,
),
Op::Session(session) => upsert(
&mut self.sessions,
session.session_id.clone(),
session,
merge_listen_session,
),
Op::Rss { title, audio_url } => {
let hints = EpisodeIdentityHints {
guid: Some("e1".to_string()),
enclosure_url: Some(audio_url.to_string()),
link: None,
published_at_ms: Some(1_000),
title: Some(title.to_string()),
};
let id = resolve_episode_ids(&podcast_id(), None, &[hints], &[])[0]
.clone()
.unwrap();
// Metadata only: last refresh on this device wins locally.
let meta = EpisodeMeta {
episode_id: id.clone(),
podcast_id: podcast_id(),
guid: Some("e1".to_string()),
title: title.to_string(),
description: None,
season: None,
episode_number: None,
episode_type: EpisodeType::Full,
published_at_ms: Some(1_000),
duration_ms: None,
audio_url: audio_url.to_string(),
mime: None,
byte_len: None,
image_url: None,
link: None,
};
self.catalog.insert(id, meta);
}
}
}
fn personal(&self) -> Store {
Store {
catalog: BTreeMap::new(),
..self.clone()
}
}
}
#[test]
fn whole_operation_sets_converge_and_rss_never_touches_progress() {
use ProgressStatus::*;
let session = ListenSession {
session_id: "s2".to_string(),
episode_id: episode_id("e1"),
podcast_id: podcast_id(),
device_id: "dev-b".to_string(),
started_at_ms: 10,
ended_at_ms: 20,
start_position_ms: 0,
end_position_ms: 400_000,
listened_ms: 400_000,
completed: false,
};
let ops = [
Op::Subscription(subscription(true, 100, "dev-a:1", "Show", "feed")),
Op::Share(share(true, 120, "dev-a:2")),
Op::Progress(progress(
1, 130, "dev-a", "dev-a:3", 900_000, InProgress, "s1",
)),
Op::Progress(progress(
2, 125, "dev-b", "dev-b:1", 400_000, InProgress, "s2",
)),
Op::Session(session),
Op::Rss {
title: "Old title",
audio_url: "https://cdn.test/old.mp3",
},
Op::Rss {
title: "New title",
audio_url: "https://cdn.test/new.mp3",
},
];
let mut reference: Option<Store> = None;
for order in permutations(&ops) {
let mut store = Store::default();
for op in &order {
store.apply(op);
}
// One episode id across both metadata versions.
assert_eq!(store.catalog.len(), 1);
let progress = store.progress.values().next().unwrap();
assert_eq!(progress.op_id, "dev-b:1");
assert_eq!(progress.position_ms, 400_000);
let personal = store.personal();
match &reference {
Some(reference) => assert_eq!(&personal, reference),
None => reference = Some(personal),
}
}
}
#[test]
fn validation_bounds() {
use ProgressStatus::*;
let ok = progress(1, 1, "dev-a", "dev-a:1", 0, NotStarted, "s");
ok.validate().unwrap();
let mut bad = ok.clone();
bad.position_ms = -1;
assert!(bad.validate().is_err());
let mut bad = ok.clone();
bad.session_id = String::new();
assert!(bad.validate().is_err());
let mut bad = ok;
bad.device_id = "d".repeat(crate::podcast::MAX_TOKEN_BYTES + 1);
assert!(bad.validate().is_err());
let mut record = subscription(true, 1, "dev-a:1", "Show", "feed");
record.feed_aliases = (0..=crate::podcast::MAX_FEED_ALIASES + 1)
.map(|i| feed_url(&format!("alias-{i}")))
.collect();
assert!(record.validate().is_err());
record.normalize();
record.validate().unwrap();
}
#[test]
fn progress_json_shape() {
let record = progress(
3,
42,
"dev-a",
"dev-a:7",
1_000,
ProgressStatus::InProgress,
"s",
);
let json = serde_json::to_value(&record).unwrap();
assert_eq!(json["status"], "in_progress");
assert_eq!(json["generation"], 3);
assert_eq!(
serde_json::from_value::<ProgressRecord>(json).unwrap(),
record
);
}