mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 18:04:48 +00:00
update: inspect a release the app offers on its own thread, not in offer (#1149)
This commit is contained in:
+347
-43
@@ -86,7 +86,7 @@ type Found = Result<Option<(Release, bool)>, String>;
|
||||
type InstallProbe = Arc<dyn Fn(&'static App, &Release) -> bool + Send + Sync>;
|
||||
|
||||
/// Whether this copy can install `release` itself. It reads the installed files, which can take
|
||||
/// long on slow storage, so the check's thread calls it, never a frame.
|
||||
/// long on slow storage, so the check's thread and the offer's thread call it, never a frame.
|
||||
fn can_install_itself(app: &'static App, release: &Release) -> bool {
|
||||
self_update::is_self_updating(app) && self_update::release_installs(app, release)
|
||||
}
|
||||
@@ -149,7 +149,19 @@ pub struct Updater {
|
||||
requested: bool,
|
||||
started: bool,
|
||||
check: Option<Receiver<Found>>,
|
||||
/// Replaces [`can_install_itself`] on the check's thread (tests).
|
||||
/// A release the app offered ([`Self::offer`]) while its thread reads whether this copy can
|
||||
/// install it itself; `tick` opens the prompt with the answer.
|
||||
offered: Option<Receiver<(Release, bool)>>,
|
||||
/// The newest release offered while `offered` was still being inspected; it is inspected
|
||||
/// next, in place of the earlier one.
|
||||
next_offer: Option<Release>,
|
||||
/// An installation failed while `offered` was still being inspected: its answer opens no
|
||||
/// prompt over the one that says why the installation failed.
|
||||
offer_outdated: bool,
|
||||
/// The app's context, from the first frame or check that passed it, so that the offer's
|
||||
/// thread can ask for a frame once it has answered.
|
||||
repaint: Option<egui::Context>,
|
||||
/// Replaces [`can_install_itself`] on the check's and the offer's thread (tests).
|
||||
probe: Option<InstallProbe>,
|
||||
/// Whether the copy could install the release that is installing itself, as the prompt that
|
||||
/// started the installation said. A failed installation reopens the prompt with it.
|
||||
@@ -195,6 +207,10 @@ impl Updater {
|
||||
requested: false,
|
||||
started: false,
|
||||
check: None,
|
||||
offered: None,
|
||||
next_offer: None,
|
||||
offer_outdated: false,
|
||||
repaint: None,
|
||||
probe: None,
|
||||
installing_itself: false,
|
||||
install: None,
|
||||
@@ -250,8 +266,8 @@ impl Updater {
|
||||
self
|
||||
}
|
||||
|
||||
/// Replaces [`can_install_itself`], which the check's thread calls for a release it found
|
||||
/// (tests).
|
||||
/// Replaces [`can_install_itself`], which the check's thread calls for a release it found and
|
||||
/// the offer's thread for a release the app offered (tests).
|
||||
#[cfg(test)]
|
||||
fn with_probe(mut self, probe: InstallProbe) -> Self {
|
||||
self.probe = Some(probe);
|
||||
@@ -343,16 +359,68 @@ impl Updater {
|
||||
self.close_wanted = true;
|
||||
}
|
||||
|
||||
/// Opens the startup prompt for a release the app found itself. After a failed update the
|
||||
/// prompt says why it failed, like the one a check opens. Opening the prompt sets
|
||||
/// [`Self::status`] to [`Status::Idle`]. It reads the installed files on the calling thread to
|
||||
/// decide whether the prompt offers Update and Restart; a release found by a check is
|
||||
/// inspected on the check's thread instead.
|
||||
/// Offers a release the app found itself: the startup prompt opens at a later [`Self::tick`],
|
||||
/// once a thread of its own has read the installed files to decide whether the prompt offers
|
||||
/// Update and Restart, as a check does for a release it finds. After a failed update the
|
||||
/// prompt says why it failed, like the one a check opens. An offer sets [`Self::status`] to
|
||||
/// [`Status::Idle`] when it is made, and a requested check that answers afterwards reports as
|
||||
/// usual. A later offer replaces one that has not opened yet; while an inspection runs, only
|
||||
/// the newest offer waits for the next one, so one thread at most reads the files. An offer
|
||||
/// closes the prompt for an earlier release, which calls off a Save and Update that has not
|
||||
/// started its installation yet. An offer still being inspected when an installation fails
|
||||
/// opens no prompt.
|
||||
pub fn offer(&mut self, release: Release) {
|
||||
if self.install.is_some() || self.installed || self.read_choice() {
|
||||
return;
|
||||
}
|
||||
self.status = Status::Idle;
|
||||
// The prompt for an earlier release closes while this one is inspected: nothing installs
|
||||
// the earlier release from it, and a save it asked for installs nothing.
|
||||
self.prompt = None;
|
||||
if self.offered.is_some() {
|
||||
self.next_offer = Some(release);
|
||||
return;
|
||||
}
|
||||
self.inspect_offer(release);
|
||||
}
|
||||
|
||||
/// Starts the thread that reads whether this copy can install the offered `release` itself.
|
||||
fn inspect_offer(&mut self, release: Release) {
|
||||
self.offer_outdated = false;
|
||||
let (tx, rx) = channel();
|
||||
let (probe, app, repaint) = (self.probe.clone(), self.app, self.repaint.clone());
|
||||
// Kept for the prompt in case the thread cannot start.
|
||||
let fallback = release.clone();
|
||||
let spawned = std::thread::Builder::new().name("update-offer".into()).spawn(move || {
|
||||
let inspect = || match &probe {
|
||||
Some(probe) => probe(app, &release),
|
||||
None => can_install_itself(app, &release),
|
||||
};
|
||||
// A panicking inspection offers Download rather than nothing.
|
||||
let installs_itself = std::panic::catch_unwind(std::panic::AssertUnwindSafe(inspect)).unwrap_or(false);
|
||||
let _ = tx.send((release, installs_itself));
|
||||
if let Some(ctx) = repaint {
|
||||
ctx.request_repaint();
|
||||
}
|
||||
});
|
||||
match spawned {
|
||||
Ok(_) => self.offered = Some(rx),
|
||||
Err(e) => {
|
||||
// Without the thread the prompt offers Download, without reading the files here.
|
||||
log::warn!("{} couldn't inspect the install for an offered update ({e})", self.app.name);
|
||||
self.offered = None;
|
||||
self.open_offer(fallback, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Opens the prompt for an offered release once its thread has answered, unless an
|
||||
/// installation started or the launcher took the app over meanwhile. The status stays as a
|
||||
/// requested check left it.
|
||||
fn finish_offer(&mut self, release: Release, installs_itself: bool) {
|
||||
// The launcher may have pinned the app while the files were read, as during a check.
|
||||
if self.install.is_none() && !self.installed && !self.read_choice() {
|
||||
let installs_itself = can_install_itself(self.app, &release);
|
||||
self.open_offer(release, installs_itself);
|
||||
self.status = Status::Idle;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -372,7 +440,15 @@ impl Updater {
|
||||
self.prompt.is_some()
|
||||
}
|
||||
|
||||
/// Keeps the first context passed in for the offer's thread (`repaint`).
|
||||
fn remember(&mut self, ctx: &egui::Context) {
|
||||
if self.repaint.is_none() {
|
||||
self.repaint = Some(ctx.clone());
|
||||
}
|
||||
}
|
||||
|
||||
fn begin(&mut self, ctx: &egui::Context, requested: bool) {
|
||||
self.remember(ctx);
|
||||
if self.install.is_some() || self.installed {
|
||||
if requested {
|
||||
self.status = self.pending_status();
|
||||
@@ -480,6 +556,8 @@ impl Updater {
|
||||
match answer {
|
||||
Ok(Some((release, installs_itself))) => {
|
||||
match &mut self.prompt {
|
||||
// An offer still being inspected opens its own prompt, with the failure's reason.
|
||||
None if self.offered.is_some() => {}
|
||||
None => self.open_offer(release, installs_itself),
|
||||
// A prompt the app opened before (`offer`) says why the last update failed.
|
||||
Some(prompt) => {
|
||||
@@ -501,9 +579,10 @@ impl Updater {
|
||||
}
|
||||
}
|
||||
|
||||
/// Picks up a finished check or installation. Call once per frame, before [`Self::show`]. It
|
||||
/// keeps the UI awake while either is running.
|
||||
/// Picks up a finished check, offer or installation. Call once per frame, before
|
||||
/// [`Self::show`]. It keeps the UI awake while any of them is running.
|
||||
pub fn tick(&mut self, ctx: &egui::Context) {
|
||||
self.remember(ctx);
|
||||
if let Some(rx) = &self.check {
|
||||
match rx.try_recv() {
|
||||
Ok(answer) => {
|
||||
@@ -517,6 +596,36 @@ impl Updater {
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(rx) = &self.offered {
|
||||
let answer = match rx.try_recv() {
|
||||
Ok(answer) => Some(answer),
|
||||
Err(TryRecvError::Empty) => {
|
||||
ctx.request_repaint_after(Duration::from_millis(100));
|
||||
None
|
||||
}
|
||||
Err(TryRecvError::Disconnected) => {
|
||||
log::warn!("{} stopped inspecting the install for an offered update", self.app.name);
|
||||
self.offered = None;
|
||||
None
|
||||
}
|
||||
};
|
||||
if let Some((release, installs_itself)) = answer {
|
||||
self.offered = None;
|
||||
// A newer offer replaces this one before its prompt opens, and an installation
|
||||
// that failed meanwhile keeps its own prompt.
|
||||
let outdated = std::mem::take(&mut self.offer_outdated);
|
||||
if self.next_offer.is_none() && !outdated {
|
||||
self.finish_offer(release, installs_itself);
|
||||
}
|
||||
}
|
||||
// The newer offer that waited for this inspection is inspected now.
|
||||
if self.offered.is_none()
|
||||
&& let Some(release) = self.next_offer.take()
|
||||
{
|
||||
self.inspect_offer(release);
|
||||
ctx.request_repaint_after(Duration::from_millis(100));
|
||||
}
|
||||
}
|
||||
if let Some((rx, _)) = &self.install {
|
||||
let outcome = match rx.try_recv() {
|
||||
Ok(outcome) => Some(outcome),
|
||||
@@ -552,6 +661,12 @@ impl Updater {
|
||||
if matches!(self.status, Status::Installing) {
|
||||
self.status = Status::Idle;
|
||||
}
|
||||
// An offer made before the installation started, still being inspected or
|
||||
// waiting for it, would replace the prompt that says why: it opens nothing.
|
||||
if self.offered.is_some() {
|
||||
self.offer_outdated = true;
|
||||
}
|
||||
self.next_offer = None;
|
||||
// The prompt may have been dismissed meanwhile: bring it back with the reason.
|
||||
if self.prompt.is_none()
|
||||
&& let Some(release) = release
|
||||
@@ -860,6 +975,27 @@ mod tests {
|
||||
assert!(updater.check.is_none(), "the check has reported");
|
||||
}
|
||||
|
||||
/// Waits for each offer's thread to answer on its channel (it always sends one), then hands
|
||||
/// the answer to `tick` as a frame would, until no offer is left to inspect.
|
||||
pub(super) fn settle_offer(updater: &mut Updater) {
|
||||
while let Some(rx) = updater.offered.take() {
|
||||
let (tx, answer) = channel();
|
||||
if let Ok(offered) = rx.recv() {
|
||||
assert!(tx.send(offered).is_ok());
|
||||
}
|
||||
drop(tx);
|
||||
updater.offered = Some(answer);
|
||||
updater.tick(&egui::Context::default());
|
||||
}
|
||||
assert!(updater.next_offer.is_none(), "every offer has answered");
|
||||
}
|
||||
|
||||
/// Offers [`newer`] as the app would and waits for its prompt.
|
||||
pub(super) fn offer_now(updater: &mut Updater) {
|
||||
updater.offer(newer());
|
||||
settle_offer(updater);
|
||||
}
|
||||
|
||||
/// #391: Download opens only a safe web link, whoever built the `Release`.
|
||||
#[test]
|
||||
fn download_opens_only_a_safe_release_page() {
|
||||
@@ -1063,6 +1199,126 @@ mod tests {
|
||||
assert_eq!(*calls.lock().unwrap_or_else(PoisonError::into_inner), 1, "the frame did not inspect the install again");
|
||||
}
|
||||
|
||||
/// A release the app offers itself is inspected on a thread of its own, as one a check finds
|
||||
/// is: `offer` and a frame that runs while reading the installed files is stalled return at
|
||||
/// once, and the prompt opens with the thread's answer at the frame after it answers.
|
||||
#[test]
|
||||
fn a_stalled_offer_inspection_does_not_block_a_frame() {
|
||||
let ctx = egui::Context::default();
|
||||
let (seen_tx, seen) = channel();
|
||||
let (resume, resumed) = channel::<()>();
|
||||
let resumed = Mutex::new(resumed);
|
||||
let calls = Arc::new(Mutex::new(0_u32));
|
||||
let probe_calls = Arc::clone(&calls);
|
||||
let mut u = updater(Ok(None)).with_probe(Arc::new(move |_, _| {
|
||||
*probe_calls.lock().unwrap_or_else(PoisonError::into_inner) += 1;
|
||||
let _ = seen_tx.send(());
|
||||
// Stalled until the test lets it go, like a read on storage that does not answer.
|
||||
let _ = resumed.lock().unwrap_or_else(PoisonError::into_inner).recv();
|
||||
true
|
||||
}));
|
||||
u.offer(newer());
|
||||
assert!(u.prompt.is_none(), "offer returns before the install is inspected");
|
||||
assert!(seen.recv().is_ok(), "the offer's thread inspects the install");
|
||||
u.tick(&ctx);
|
||||
assert!(u.prompt.is_none(), "no prompt while the inspection is stalled");
|
||||
assert!(u.offered.is_some(), "the offer is still being inspected");
|
||||
|
||||
assert!(resume.send(()).is_ok());
|
||||
settle_offer(&mut u);
|
||||
assert!(u.prompt.as_ref().is_some_and(|p| p.is_self_updating), "the prompt offers Update and Restart");
|
||||
assert_eq!(u.status(), &Status::Idle);
|
||||
assert_eq!(*calls.lock().unwrap_or_else(PoisonError::into_inner), 1, "the frame did not inspect the install again");
|
||||
}
|
||||
|
||||
/// Offers made while a slow inspection runs start no thread of their own: the newest waits for
|
||||
/// it, is inspected next, and its prompt opens in place of the earlier ones.
|
||||
#[test]
|
||||
fn offers_during_a_stalled_inspection_wait_for_it() {
|
||||
let (seen_tx, seen) = channel();
|
||||
let (resume, resumed) = channel::<()>();
|
||||
let resumed = Mutex::new(resumed);
|
||||
let inspected = Arc::new(Mutex::new(Vec::new()));
|
||||
let log = Arc::clone(&inspected);
|
||||
let mut u = updater(Ok(None)).with_probe(Arc::new(move |_: &'static App, release: &Release| {
|
||||
log.lock().unwrap_or_else(PoisonError::into_inner).push(release.tag.clone());
|
||||
let _ = seen_tx.send(());
|
||||
let _ = resumed.lock().unwrap_or_else(PoisonError::into_inner).recv();
|
||||
true
|
||||
}));
|
||||
let tagged = |tag: &str| Release { tag: tag.into(), ..newer() };
|
||||
u.offer(tagged("v9.0.0"));
|
||||
assert!(seen.recv().is_ok(), "the first offer is being inspected");
|
||||
u.offer(tagged("v9.0.1"));
|
||||
u.offer(tagged("v9.0.2"));
|
||||
// One go-ahead per offer, so that a thread started for each would not stall the test.
|
||||
for _ in 0..3 {
|
||||
assert!(resume.send(()).is_ok());
|
||||
}
|
||||
settle_offer(&mut u);
|
||||
let inspected = inspected.lock().unwrap_or_else(PoisonError::into_inner).clone();
|
||||
assert_eq!(inspected, ["v9.0.0", "v9.0.2"], "one inspection at a time, and only the newest offer waits");
|
||||
assert_eq!(u.prompt.as_ref().map(|p| p.release.tag.as_str()), Some("v9.0.2"));
|
||||
}
|
||||
|
||||
/// A requested check that answers while an offer is inspected keeps its answer when the
|
||||
/// offer's prompt opens.
|
||||
#[test]
|
||||
fn an_offer_opening_after_a_requested_check_keeps_its_answer() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.check_now(&ctx);
|
||||
u.offer(newer());
|
||||
settle(&mut u, &ctx);
|
||||
assert_eq!(u.status(), &Status::UpToDate);
|
||||
settle_offer(&mut u);
|
||||
assert!(u.prompt_open());
|
||||
assert_eq!(u.status(), &Status::UpToDate, "the offer's prompt does not close the check's result");
|
||||
}
|
||||
|
||||
/// An installation that starts while an offer is inspected keeps the offer's prompt from
|
||||
/// opening over it.
|
||||
#[test]
|
||||
fn an_offer_answering_during_an_install_opens_no_prompt() {
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
let (_tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
settle_offer(&mut u);
|
||||
assert!(!u.prompt_open());
|
||||
}
|
||||
|
||||
/// An installation that fails while an offer made before it is still inspected keeps the
|
||||
/// prompt that says why: the offer's answer, and an offer waiting for it, open nothing.
|
||||
#[test]
|
||||
fn an_offer_answering_after_a_failed_install_keeps_the_failure() {
|
||||
let ctx = egui::Context::default();
|
||||
let (seen_tx, seen) = channel();
|
||||
let (resume, resumed) = channel::<()>();
|
||||
let resumed = Mutex::new(resumed);
|
||||
let mut u = updater(Ok(None)).with_probe(Arc::new(move |_: &'static App, _: &Release| {
|
||||
let _ = seen_tx.send(());
|
||||
let _ = resumed.lock().unwrap_or_else(PoisonError::into_inner).recv();
|
||||
true
|
||||
}));
|
||||
u.offer(newer());
|
||||
assert!(seen.recv().is_ok(), "the offer is being inspected");
|
||||
u.offer(Release { tag: "v9.0.2".into(), ..newer() });
|
||||
let (tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
assert!(tx.send(Err("disk full".into())).is_ok());
|
||||
u.tick(&ctx);
|
||||
assert_eq!(prompt_message(&u), "disk full");
|
||||
for _ in 0..2 {
|
||||
assert!(resume.send(()).is_ok());
|
||||
}
|
||||
settle_offer(&mut u);
|
||||
assert_eq!(prompt_message(&u), "disk full", "the failure's prompt stays open");
|
||||
u.offer(newer());
|
||||
settle_offer(&mut u);
|
||||
assert_eq!(prompt_message(&u), "", "a later offer opens its own prompt");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failed_install_returns_to_the_prompt_even_after_it_was_dismissed() {
|
||||
let ctx = egui::Context::default();
|
||||
@@ -1110,14 +1366,14 @@ mod tests {
|
||||
}
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
u.request_install(&ctx, false);
|
||||
let mut u = u.with_translator(shout);
|
||||
let message = |u: &Updater| u.prompt.as_ref().and_then(StartupPrompt::message).unwrap_or_default();
|
||||
assert!(message(&u).starts_with("SAVE OR CLOSE"), "{}", message(&u));
|
||||
// And the prompts it opens later.
|
||||
u.prompt = None;
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
u.request_install(&ctx, false);
|
||||
assert!(message(&u).starts_with("SAVE OR CLOSE"), "{}", message(&u));
|
||||
}
|
||||
@@ -1161,14 +1417,14 @@ mod tests {
|
||||
u.check_now(&ctx);
|
||||
assert!(u.check.is_none(), "no check after an install");
|
||||
u.offer(newer());
|
||||
assert!(!u.prompt_open(), "no second offer after an install");
|
||||
assert!(u.offered.is_none() && !u.prompt_open(), "no second offer after an install");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_install_waits_while_the_app_holds_unsaved_work() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
u.request_install(&ctx, false);
|
||||
assert!(u.install.is_none(), "nothing is scheduled while there is unsaved work");
|
||||
assert!(u.prompt.as_ref().is_some_and(|p| !p.is_installing && p.message().is_some()));
|
||||
@@ -1186,7 +1442,7 @@ mod tests {
|
||||
}
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None)).with_translator(translate);
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
u.request_install(&ctx, false);
|
||||
let message = |u: &Updater| u.prompt.as_ref().and_then(StartupPrompt::message).unwrap_or_default();
|
||||
assert!(message(&u).starts_with("Save or close"), "{}", message(&u));
|
||||
@@ -1214,7 +1470,7 @@ mod tests {
|
||||
}
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let (tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
assert!(tx.send(Ok(Restart::scheduled())).is_ok());
|
||||
@@ -1234,7 +1490,7 @@ mod tests {
|
||||
fn a_finished_install_keeps_asking_to_close_until_the_app_can() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let (tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
assert!(tx.send(Ok(Restart::scheduled())).is_ok());
|
||||
@@ -1300,7 +1556,7 @@ mod tests {
|
||||
/// An updater whose install has finished and waits for the app to close.
|
||||
fn installed(ctx: &egui::Context) -> Updater {
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let (tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
assert!(tx.send(Ok(Restart::scheduled())).is_ok());
|
||||
@@ -1314,7 +1570,7 @@ mod tests {
|
||||
fn save_and_update_saves_first_and_then_installs() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
click_save(&mut u, &ctx);
|
||||
assert!(u.take_save_request(), "the click asks the app to save");
|
||||
assert!(!u.take_save_request(), "once");
|
||||
@@ -1332,7 +1588,7 @@ mod tests {
|
||||
fn a_note_from_an_earlier_click_goes_when_the_save_starts() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
u.request_install(&ctx, false);
|
||||
assert!(prompt_message(&u).starts_with("Save or close"));
|
||||
click_save(&mut u, &ctx);
|
||||
@@ -1344,7 +1600,7 @@ mod tests {
|
||||
fn a_failed_save_says_why_and_calls_the_install_off() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
click_save(&mut u, &ctx);
|
||||
u.save_stopped(Some("disk full".into()));
|
||||
assert!(!saving(&u));
|
||||
@@ -1360,7 +1616,7 @@ mod tests {
|
||||
fn a_save_that_leaves_work_unsaved_goes_back_to_the_note() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
click_save(&mut u, &ctx);
|
||||
assert!(u.take_save_request());
|
||||
u.save_stopped(None);
|
||||
@@ -1375,7 +1631,7 @@ mod tests {
|
||||
fn work_that_can_no_longer_be_saved_stops_the_saving() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
click_save(&mut u, &ctx);
|
||||
frame_saving(&mut u, &ctx, false, false, Vec::new());
|
||||
assert!(!saving(&u));
|
||||
@@ -1386,7 +1642,7 @@ mod tests {
|
||||
#[test]
|
||||
fn a_late_save_stopped_changes_nothing() {
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
u.save_stopped(Some("disk full".into()));
|
||||
assert_eq!(prompt_message(&u), "");
|
||||
}
|
||||
@@ -1396,13 +1652,13 @@ mod tests {
|
||||
fn dismissing_during_the_save_forgets_the_install() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
click_save(&mut u, &ctx);
|
||||
let escape = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE };
|
||||
frame_saving(&mut u, &ctx, false, true, vec![escape]);
|
||||
assert!(!u.prompt_open());
|
||||
assert!(!u.take_save_request());
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
self_updating(&mut u);
|
||||
frame_saving(&mut u, &ctx, true, false, Vec::new());
|
||||
assert!(u.prompt.as_ref().is_some_and(|p| !p.is_installing));
|
||||
@@ -1414,9 +1670,9 @@ mod tests {
|
||||
fn a_new_offer_during_the_save_installs_nothing() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
click_save(&mut u, &ctx);
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
self_updating(&mut u);
|
||||
frame_saving(&mut u, &ctx, true, false, Vec::new());
|
||||
assert!(u.prompt.as_ref().is_some_and(|p| !p.is_installing));
|
||||
@@ -1424,12 +1680,46 @@ mod tests {
|
||||
assert!(!u.take_save_request());
|
||||
}
|
||||
|
||||
/// A save that ends while a newer offer is still inspected installs nothing either: the save
|
||||
/// was asked for the earlier release.
|
||||
#[test]
|
||||
fn a_save_ending_while_a_new_offer_is_inspected_installs_nothing() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
offer_now(&mut u);
|
||||
click_save(&mut u, &ctx);
|
||||
assert!(u.take_save_request());
|
||||
u.offer(newer());
|
||||
assert!(!u.prompt_open(), "the earlier release's prompt closes while the new one is inspected");
|
||||
frame_saving(&mut u, &ctx, true, false, Vec::new());
|
||||
assert!(u.install.is_none());
|
||||
settle_offer(&mut u);
|
||||
assert!(u.prompt.as_ref().is_some_and(|p| !p.is_installing && !p.is_saving));
|
||||
assert_eq!(prompt_message(&u), "", "{}", prompt_message(&u));
|
||||
assert!(u.install.is_none());
|
||||
}
|
||||
|
||||
/// The prompt for an earlier release cannot install it while a newer offer is inspected.
|
||||
#[test]
|
||||
fn a_new_offer_closes_the_prompt_for_the_earlier_release() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
offer_now(&mut u);
|
||||
self_updating(&mut u);
|
||||
u.offer(Release { tag: "v9.0.2".into(), ..newer() });
|
||||
u.request_install(&ctx, true);
|
||||
assert!(!u.prompt_open(), "nothing is left to click for the earlier release");
|
||||
assert!(u.install.is_none());
|
||||
settle_offer(&mut u);
|
||||
assert_eq!(u.prompt.as_ref().map(|p| p.release.tag.as_str()), Some("v9.0.2"));
|
||||
}
|
||||
|
||||
/// The button only shows with unsaved work, in an app that can save it. `show_if` never offers it.
|
||||
#[test]
|
||||
fn the_button_needs_both_unsaved_work_and_an_app_that_can_save() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
self_updating(&mut u);
|
||||
let offered = |u: &Updater| u.prompt.as_ref().is_some_and(|p| p.offer_save);
|
||||
frame_saving(&mut u, &ctx, false, true, Vec::new());
|
||||
@@ -1521,7 +1811,7 @@ mod tests {
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let starts = Arc::new(AtomicUsize::new(0));
|
||||
let counter = Arc::clone(&starts);
|
||||
let (tx, rx) = channel();
|
||||
@@ -1553,7 +1843,7 @@ mod tests {
|
||||
use std::sync::atomic::Ordering;
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let (starts, restart) = counted_restart();
|
||||
let (tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
@@ -1843,7 +2133,7 @@ mod tests {
|
||||
fn a_requested_check_during_an_update_says_where_it_is() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut u = updater(Ok(Some(newer())));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let (tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
for _ in 0..2 {
|
||||
@@ -1872,7 +2162,7 @@ mod tests {
|
||||
let ctx = egui::Context::default();
|
||||
for answer in [Ok(None), Err("offline".to_owned()), Ok(Some((newer(), false)))] {
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
u.check_now(&ctx);
|
||||
assert_eq!(u.status(), &Status::Checking);
|
||||
let (check_tx, check_rx) = channel();
|
||||
@@ -1887,7 +2177,7 @@ mod tests {
|
||||
assert_eq!(u.status(), &Status::Ready, "after {answer:?}");
|
||||
|
||||
let mut u = updater(Ok(None));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
u.check_now(&ctx);
|
||||
let (check_tx, check_rx) = channel();
|
||||
u.check = Some(check_rx);
|
||||
@@ -1923,7 +2213,7 @@ mod tests {
|
||||
fn a_requested_check_finds_a_helper_failure_while_the_app_still_runs() {
|
||||
let ctx = egui::Context::default();
|
||||
let (_dir, paths, mut u) = with_records("0.1.0");
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let (tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
assert!(tx.send(Ok(Restart::scheduled())).is_ok());
|
||||
@@ -1960,7 +2250,7 @@ mod tests {
|
||||
use std::sync::atomic::Ordering;
|
||||
let ctx = egui::Context::default();
|
||||
let (_dir, paths, mut u) = with_records("0.1.0");
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let (tx, rx) = channel();
|
||||
u.install = Some((rx, newer()));
|
||||
assert!(tx.send(Ok(Restart::scheduled())).is_ok());
|
||||
@@ -1996,11 +2286,11 @@ mod tests {
|
||||
self_update::record_failure(&paths, "disk full");
|
||||
start_answered(&mut u, &ctx, Ok(None));
|
||||
assert_eq!(u.status(), &Status::InstallFailed("disk full".into()));
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
assert_eq!(u.prompt.as_ref().and_then(StartupPrompt::message).as_deref(), Some("The update could not be installed: disk full"));
|
||||
assert_eq!(u.status(), &Status::Idle, "the prompt carries the reason");
|
||||
u.prompt = None;
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
assert_eq!(u.prompt.as_ref().and_then(StartupPrompt::message), None, "the reason is shown once");
|
||||
}
|
||||
|
||||
@@ -2011,16 +2301,30 @@ mod tests {
|
||||
let ctx = egui::Context::default();
|
||||
let (_dir, paths, mut u) = with_records("0.1.0");
|
||||
self_update::record_failure(&paths, "disk full");
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
assert_eq!(u.prompt.as_ref().and_then(StartupPrompt::message), None, "the failure is not read before the check at start");
|
||||
start_answered(&mut u, &ctx, Ok(Some(newer())));
|
||||
assert_eq!(u.status(), &Status::Idle, "the prompt carries the reason");
|
||||
assert_eq!(u.prompt.as_ref().and_then(StartupPrompt::message).as_deref(), Some("The update could not be installed: disk full"));
|
||||
u.prompt = None;
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
assert_eq!(u.prompt.as_ref().and_then(StartupPrompt::message), None, "the reason is shown once");
|
||||
}
|
||||
|
||||
/// A check at start that finds the release while the app's own offer is still inspected leaves
|
||||
/// the prompt to the offer, which says why the last update failed.
|
||||
#[test]
|
||||
fn a_check_answering_during_an_offer_leaves_the_prompt_to_the_offer() {
|
||||
let ctx = egui::Context::default();
|
||||
let (_dir, paths, mut u) = with_records("0.1.0");
|
||||
self_update::record_failure(&paths, "disk full");
|
||||
u.offer(newer());
|
||||
start_answered(&mut u, &ctx, Ok(Some(newer())));
|
||||
settle_offer(&mut u);
|
||||
assert_eq!(u.status(), &Status::Idle, "the prompt carries the reason");
|
||||
assert_eq!(u.prompt.as_ref().and_then(StartupPrompt::message).as_deref(), Some("The update could not be installed: disk full"));
|
||||
}
|
||||
|
||||
/// An installation that finishes after the updater was dropped and whose helper cannot start,
|
||||
/// or that failed, is recorded, and the next start says why.
|
||||
#[test]
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use super::tests::{newer, settle};
|
||||
use super::tests::{newer, offer_now, settle, settle_offer};
|
||||
use super::*;
|
||||
use crate::suite::PHOTOCRAFT;
|
||||
|
||||
@@ -33,7 +33,7 @@ fn a_pinned_app_is_not_prompted_and_the_network_is_not_asked() {
|
||||
assert_eq!(u.status(), &Status::Managed, "{track:?}");
|
||||
assert_eq!(u.managed(), Some(&Choice::Managed(track.clone())));
|
||||
u.offer(newer());
|
||||
assert!(!u.prompt_open(), "an offer is held too: {track:?}");
|
||||
assert!(u.offered.is_none() && !u.prompt_open(), "an offer is held too: {track:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -86,7 +86,7 @@ fn a_prompt_opened_before_the_pin_cannot_install_the_stable_release() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = dir.path().join("versions.json");
|
||||
let mut u = Updater::new(&PHOTOCRAFT, "0.13.0").with_source(Arc::new(|| Ok(Some(newer())))).with_pins_path(&path);
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
assert!(u.prompt_open());
|
||||
let mut pins = Pins::default();
|
||||
pins.set(PHOTOCRAFT.id, &crate::pins::VersionTrack::Pinned("v0.13.0".into()));
|
||||
@@ -96,13 +96,27 @@ fn a_prompt_opened_before_the_pin_cannot_install_the_stable_release() {
|
||||
assert!(!u.prompt_open());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_pin_made_while_an_offer_is_inspected_holds_the_offer() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = dir.path().join("versions.json");
|
||||
let mut u = Updater::new(&PHOTOCRAFT, "0.13.0").with_source(Arc::new(|| Ok(Some(newer())))).with_pins_path(&path);
|
||||
u.offer(newer());
|
||||
let mut pins = Pins::default();
|
||||
pins.set(PHOTOCRAFT.id, &crate::pins::VersionTrack::Pinned("v0.13.0".into()));
|
||||
pins.save(&path).unwrap();
|
||||
settle_offer(&mut u);
|
||||
assert!(!u.prompt_open(), "no prompt for the stable release once the launcher pinned the app");
|
||||
assert!(u.managed().is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_check_after_the_pin_closes_a_prompt_opened_before_it() {
|
||||
let ctx = egui::Context::default();
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = dir.path().join("versions.json");
|
||||
let mut u = Updater::new(&PHOTOCRAFT, "0.13.0").with_source(Arc::new(|| Ok(Some(newer())))).with_pins_path(&path);
|
||||
u.offer(newer());
|
||||
offer_now(&mut u);
|
||||
let mut pins = Pins::default();
|
||||
pins.set(PHOTOCRAFT.id, &crate::pins::VersionTrack::Nightly);
|
||||
pins.save(&path).unwrap();
|
||||
|
||||
Reference in New Issue
Block a user