#![allow(
clippy::unwrap_used,
clippy::expect_used,
reason = "tests panic on purpose when something is wrong"
)]
mod common;
use common::{LIST, Shopping};
use paperpaw_native::signature::{public_key, sign};
use paperpaw_native::{Chip, Header, LINK_BASE};
use paperpaw_sdk::builtin::actions;
use paperpaw_sdk::native::{Fingerprint, Native, installed_code};
use paperpaw_sdk::{Id, Instant, Params, PluginKind, Storage};
const BUILD: Fingerprint = Fingerprint::of(paperpaw_sdk::native::INTERFACE, 0x4567_89ab_cdef);
const PAPERPAW: [u8; 32] = [5; 32];
fn native() -> Native {
let mut native = Native::new("code.ppn");
native.fingerprint = BUILD;
native
}
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
fn ppn() -> Vec<u8> {
let image = [0u8; 128];
let mut header = Header {
chip: Chip::Esp32C3,
fingerprint: BUILD.0,
base: LINK_BASE,
image_len: image.len() as u32,
code_at: 96,
entry: 0,
api: 32,
relocs: 0,
align: 16,
compiler: 1,
hot_at: 0,
hot_len: 0,
patches: 0,
needs_api: 0,
families: [0; 8],
interface: paperpaw_sdk::native::INTERFACE,
sha256: [0; 32],
};
let mut sha = header.digest();
sha.update(&image);
header.sha256 = sha.finish();
let mut file = header.to_bytes().to_vec();
file.extend_from_slice(&image);
file.extend_from_slice(&sign(&file, &PAPERPAW).to_bytes());
file
}
fn manifest(id: &str) -> String {
format!("[plugin]\nid = {id}\nname = {id}\nversion = 0.4.0\n")
}
fn page(id: &str, code: &[u8]) -> String {
let ini = manifest(id);
format!(
r#"{{"format": 2, "plugin": {{"id": "{id}", "name": "{id}",
"summary": "PaperPaw's own.", "group": "reading",
"author": "PaperPaw", "licence": "Apache-2.0", "kind": "code", "author_key": "{}",
"latest": {{"version": "0.4.0", "sdk": "0.4", "formats": 1, "size": {},
"files": [{{"path": "plugin.ini", "url": "{id}/0.4.0/plugin.ini",
"size": {}, "sha1": "{}"}}],
"builds": [{{"device": "x4", "abi": "{BUILD}", "url": "{id}/0.4.0/x4.ppn",
"size": {}, "sha256": "{}"}}]}}}}}}"#,
hex(&public_key(&PAPERPAW)),
ini.len(),
ini.len(),
paperpaw_digest::sha1::hex(ini.as_bytes()),
code.len(),
paperpaw_digest::sha256::hex(code),
)
}
fn page_url(id: &str) -> String {
format!("https://paperpaw.org/api/v1/plugins/{id}.json?device=x4&lang=en&abi={BUILD}")
}
fn offer() -> Shopping {
let mut shopping = Shopping::on(
Some("x4"),
Some(native()),
r#"{"format": 2, "plugins": []}"#,
);
shopping.now += 100;
shopping.kernel.open_screen(
Instant(shopping.now),
Id::new_static("store.offer"),
Params::new(),
);
shopping
}
fn offer_with_room(room: &str) -> Shopping {
let storage = common::Shared::default();
storage
.write(".paperpaw/code-room.txt", room.as_bytes())
.unwrap();
let mut shopping = Shopping::with(
Some("x4"),
Some(native()),
r#"{"format": 2, "plugins": []}"#,
storage,
);
shopping.now += 100;
shopping.kernel.open_screen(
Instant(shopping.now),
Id::new_static("store.offer"),
Params::new(),
);
shopping
}
#[test]
fn the_offer_says_a_full_install_gives_more_room_only_on_the_stock_layout() {
for (room, said) in [
("1126400 0 4096 83 0 0 3000000\n", true),
("1126400 0 4096 83 0 0 0\n", false),
("1126400 0 4096 83 0 0\n", false),
] {
let mut shopping = offer_with_room(room);
let shown = shopping.shown();
assert!(shown.contains("Reading statistics"), "{shown}");
assert_eq!(
shown.contains("paperpaw.org/flash"),
said,
"{room}: {shown}"
);
if said {
assert!(shown.contains("Room for plugins: 1.1 MB"), "{shown}");
assert!(shown.contains("about 2.9 MB"), "{shown}");
} else {
assert!(!shown.contains("Room for plugins"), "{room}: {shown}");
}
}
let shown = offer().shown();
assert!(!shown.contains("paperpaw.org/flash"), "{shown}");
}
fn serve(shopping: &mut Shopping, id: &str, code: &[u8]) {
shopping.serve(&page_url(id), page(id, code).as_bytes());
let files = "https://paperpaw.org/api/v1/plugins";
shopping.serve(
&format!("{files}/{id}/0.4.0/plugin.ini"),
manifest(id).as_bytes(),
);
shopping.serve(&format!("{files}/{id}/0.4.0/x4.ppn"), code);
}
#[test]
fn the_plugins_chosen_are_installed_and_said_once() {
let mut shopping = offer();
let shown = shopping.shown();
for name in [
"Reading statistics",
"Home widgets",
"Wireless library",
"Progress sync",
] {
assert!(shown.contains(name), "{shown}");
}
assert!(shown.contains("| Done"), "{shown}");
shopping.choose("Reading statistics");
shopping.choose("Wireless library");
shopping.run(actions::DOWN);
shopping.run(actions::DOWN);
let shown = shopping.shown();
assert!(shown.contains("Done"), "{shown}");
shopping.run(actions::CONFIRM);
let code = ppn();
serve(&mut shopping, "stats", &code);
assert!(
!shopping.shown().contains("Installed"),
"{}",
shopping.shown()
);
serve(&mut shopping, "calibre", &code);
for id in ["stats", "calibre"] {
let plugin = shopping.kernel.plugins().get(id).unwrap();
assert_eq!(plugin.kind, PluginKind::Code);
assert!(shopping.storage.exists(&format!("plugins/{id}/code.ppn")));
assert!(installed_code(&shopping.storage, id).is_some());
}
let shown = shopping.shown().replace(" | ", " ");
assert!(
shown.contains("Added: stats, calibre. They start the next time PaperPaw starts."),
"{shown}"
);
assert!(
!shopping
.storage
.exists(".paperpaw/plugins/store/queue-quiet.txt")
);
}
fn asked(shopping: &mut Shopping) -> Vec<String> {
shopping
.requests()
.into_iter()
.map(|call| call.url)
.collect()
}
#[test]
fn back_adds_those_chosen_and_nothing_else() {
let mut shopping = offer();
shopping.choose("Reading statistics");
shopping.run(actions::BACK);
assert_ne!(
shopping.kernel.active_screen().map(Id::as_str),
Some("store.offer")
);
assert_eq!(asked(&mut shopping), [page_url("stats")]);
assert!(
shopping
.storage
.exists(".paperpaw/plugins/store/offer-chosen.txt")
);
let shown = shopping.shown().replace(" | ", " ");
assert!(shown.contains("added in the background"), "{shown}");
let mut shopping = offer();
shopping.run(actions::BACK);
assert!(asked(&mut shopping).is_empty());
assert!(
!shopping
.storage
.exists(".paperpaw/plugins/store/offer-chosen.txt")
);
assert!(!shopping.storage.exists(".paperpaw/plugins/store/queue.txt"));
}
#[test]
fn the_headers_arrow_adds_those_chosen_too() {
let mut shopping = Shopping::touch_with(Some(native()), r#"{"format": 2, "plugins": []}"#);
shopping.now += 100;
shopping.kernel.open_screen(
Instant(shopping.now),
Id::new_static("store.offer"),
Params::new(),
);
let _ = shopping.shown();
let row = shopping
.kernel
.describe()
.into_iter()
.find(|p| p.label.starts_with("Wireless"))
.unwrap()
.area;
shopping.touch_at(i32::from(row.x) + 40, i32::from(row.y) + 20, false);
shopping.touch_at(30, 30, false);
assert_ne!(
shopping.kernel.active_screen().map(Id::as_str),
Some("store.offer")
);
let page = page_url("calibre").replace("device=x4&", "device=x4-pro&");
assert_eq!(asked(&mut shopping), [page]);
let queue = String::from_utf8(
paperpaw_sdk::read_file(&shopping.storage, ".paperpaw/plugins/store/queue.txt", 4096)
.unwrap(),
)
.unwrap();
assert_eq!(queue, "> ~calibre\n");
}
#[test]
fn done_with_nothing_chosen_adds_nothing() {
let mut shopping = offer();
for _ in 0..4 {
shopping.run(actions::DOWN);
}
shopping.run(actions::CONFIRM);
assert_ne!(
shopping.kernel.active_screen().map(Id::as_str),
Some("store.offer")
);
assert!(asked(&mut shopping).is_empty());
assert!(
!shopping
.storage
.exists(".paperpaw/plugins/store/offer-chosen.txt")
);
}
#[test]
fn one_that_cannot_come_is_named() {
let mut shopping = offer();
shopping.choose("Home widgets");
shopping.run(actions::DOWN);
shopping.run(actions::DOWN);
shopping.run(actions::DOWN);
shopping.run(actions::DOWN);
shopping.run(actions::CONFIRM);
let call = shopping.request(&page_url("widgets"));
shopping.answer(&call, 404, b"not found");
let shown = shopping.shown().replace(" | ", " ");
assert!(
shown.contains("Could not be added: Home widgets. They are in the Plugin store."),
"{shown}"
);
assert!(shopping.kernel.plugins().get("widgets").is_none());
}
#[test]
fn the_list_and_the_store_are_left_as_they_were() {
let mut shopping = offer();
assert!(shopping.requests().iter().all(|c| c.url != LIST));
}
struct BuiltInStats;
impl paperpaw_sdk::Plugin for BuiltInStats {
fn manifest(&self) -> paperpaw_sdk::Manifest {
paperpaw_sdk::Manifest::new(
Id::new_static("stats"),
"Reading statistics",
paperpaw_sdk::Version::new(0, 4, 0),
)
.description("Reading statistics.")
.uses(paperpaw_sdk::Uses::NOTHING)
}
fn register(&self, _: &mut paperpaw_sdk::Registrar) -> Result<(), paperpaw_sdk::RegisterError> {
Ok(())
}
}
#[test]
fn built_in_ones_are_switched_on() {
let mut kernel = paperpaw_core::Kernel::builder(common::DEVICE)
.storage(paperpaw_sdk::MemoryStorage::new())
.plugin(paperpaw_plugin_fonts_default::DefaultFontPacks)
.plugin(paperpaw_plugin_menu::Menu)
.plugin(paperpaw_plugin_store::Store)
.plugin_off(BuiltInStats)
.build()
.unwrap();
kernel.start(Instant(0));
kernel.open_screen(Instant(100), Id::new_static("store.offer"), Params::new());
kernel.render(&mut |_, _| {});
let shown: Vec<String> = kernel.describe().into_iter().map(|p| p.label).collect();
assert!(
shown.iter().any(|l| l.starts_with("Reading statistics")),
"{shown:?}"
);
assert!(
!shown.iter().any(|l| l.starts_with("Wireless")),
"{shown:?}"
);
kernel.run_action(Instant(200), actions::CONFIRM);
kernel.run_action(Instant(300), actions::DOWN);
kernel.run_action(Instant(400), actions::CONFIRM);
let stats = kernel.plugins().get("stats").unwrap();
assert!(stats.enabled, "{stats:?}");
assert!(
kernel
.take_io()
.iter()
.all(|io| !matches!(io, paperpaw_core::Io::Http(_)))
);
}
fn restarted(storage: common::Shared) -> paperpaw_core::Kernel {
let mut kernel = paperpaw_core::Kernel::builder(common::DEVICE)
.storage(storage)
.network(true)
.catalog_device("x4")
.code_plugins(native(), Box::new(common::NoCode))
.plugin(paperpaw_plugin_fonts_default::DefaultFontPacks)
.plugin(paperpaw_plugin_menu::Menu)
.plugin(paperpaw_plugin_store::Store)
.build()
.unwrap();
kernel.start(Instant(0));
kernel
}
#[test]
fn the_setups_plugins_go_on_after_a_restart_unasked_ones_do_not() {
let mut shopping = offer();
shopping.choose("Reading statistics");
for _ in 0..4 {
shopping.run(actions::DOWN);
}
shopping.run(actions::CONFIRM);
shopping.request(&page_url("stats"));
let storage = shopping.storage.clone();
let queue = String::from_utf8(
paperpaw_sdk::read_file(&storage, ".paperpaw/plugins/store/queue.txt", 4096).unwrap(),
)
.unwrap();
assert_eq!(queue, "> ~stats\n");
let mut kernel = restarted(storage.clone());
let asked: Vec<String> = kernel
.take_io()
.into_iter()
.filter_map(|io| match io {
paperpaw_core::Io::Http(call) => Some(call.url),
_ => None,
})
.collect();
assert_eq!(asked, [page_url("stats")], "the store not opened");
storage
.write(".paperpaw/plugins/store/queue.txt", b"> weather\n")
.unwrap();
let mut kernel = restarted(storage);
assert!(
kernel
.take_io()
.iter()
.all(|io| !matches!(io, paperpaw_core::Io::Http(_)))
);
}