archives/steamos-manager
archives/steamos-manager
2
0
Fork 1
mirror of https://gitlab.steamos.cloud/holo/steamos-manager.git synced 2025-07-07 15:10:29 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

testing: Refactor interface comparison code out for future use

Browse source
This commit is contained in:
Vicki Pfau 2024-08-01 21:55:00 -07:00
parent 428350b4c7
commit 5ddb709f0b
2 changed files with 188 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

106
src/manager/user.rs
View file

@ -395,14 +395,10 @@ mod test {
use crate::daemon::user::UserContext;
use crate::testing;
use std::collections::{HashMap, HashSet};
use std::iter::zip;
use std::time::Duration;
use tokio::fs::read;
use tokio::sync::mpsc::unbounded_channel;
use tokio::time::sleep;
use zbus::{Connection, Interface};
use zbus_xml::{Method, Node, Property};
use zbus::Connection;
struct TestHandle {
_handle: testing::TestHandle,
@ -429,96 +425,22 @@ mod test {
})
}
fn collect_methods<'a>(methods: &'a [Method<'a>]) -> HashMap<String, &'a Method<'a>> {
let mut map = HashMap::new();
for method in methods.iter() {
map.insert(method.name().to_string(), method);
}
map
}
fn collect_properties<'a>(props: &'a [Property<'a>]) -> HashMap<String, &'a Property<'a>> {
let mut map = HashMap::new();
for prop in props.iter() {
map.insert(prop.name().to_string(), prop);
}
map
}
#[tokio::test]
async fn interface_matches() {
let test = start().await.expect("start");
let manager_ref = test
.connection
.object_server()
.interface::<_, SteamOSManager>("/com/steampowered/SteamOSManager1")
.await
.expect("interface");
let manager = manager_ref.get().await;
let mut remote_interface_string = String::from(
"<node name=\"/\" xmlns:doc=\"http://www.freedesktop.org/dbus/1.0/doc.dtd\">",
);
manager.introspect_to_writer(&mut remote_interface_string, 0);
remote_interface_string.push_str("</node>");
let remote_interfaces =
Node::from_reader::<&[u8]>(remote_interface_string.as_bytes()).expect("from_reader");
let remote_interface: Vec<_> = remote_interfaces
.interfaces()
.iter()
.filter(|iface| iface.name() == "com.steampowered.SteamOSManager1.Manager")
.collect();
assert_eq!(remote_interface.len(), 1);
let remote_interface = remote_interface[0];
let remote_methods = collect_methods(remote_interface.methods());
let remote_method_names: HashSet<&String> = remote_methods.keys().collect();
let remote_properties = collect_properties(remote_interface.properties());
let remote_property_names: HashSet<&String> = remote_properties.keys().collect();
let local_interface_string = read("com.steampowered.SteamOSManager1.Manager.xml")
.await
.expect("read");
let local_interfaces =
Node::from_reader::<&[u8]>(local_interface_string.as_ref()).expect("from_reader");
let local_interface: Vec<_> = local_interfaces
.interfaces()
.iter()
.filter(|iface| iface.name() == "com.steampowered.SteamOSManager1.Manager")
.collect();
assert_eq!(local_interface.len(), 1);
let local_interface = local_interface[0];
let local_methods = collect_methods(local_interface.methods());
let local_method_names: HashSet<&String> = local_methods.keys().collect();
let local_properties = collect_properties(local_interface.properties());
let local_property_names: HashSet<&String> = local_properties.keys().collect();
for key in local_method_names.union(&remote_method_names) {
let local_method = local_methods.get(*key).expect(key);
let remote_method = remote_methods.get(*key).expect(key);
assert_eq!(local_method.name(), remote_method.name());
assert_eq!(
local_method.args().len(),
remote_method.args().len(),
"Testing {:?} against {:?}",
local_method,
remote_method
);
for (local_arg, remote_arg) in
zip(local_method.args().iter(), remote_method.args().iter())
{
assert_eq!(local_arg.direction(), remote_arg.direction());
assert_eq!(local_arg.ty(), remote_arg.ty());
}
}
for key in local_property_names.union(&remote_property_names) {
let local_property = local_properties.get(*key).expect(key);
let remote_property = remote_properties.get(*key).expect(key);
assert_eq!(local_property.name(), remote_property.name());
assert_eq!(local_property.ty(), remote_property.ty());
assert_eq!(local_property.access(), remote_property.access());
}
let remote = testing::InterfaceIntrospection::from_remote::<SteamOSManager, _>(
&test.connection,
"/com/steampowered/SteamOSManager1",
)
.await
.expect("remote");
let local = testing::InterfaceIntrospection::from_local(
"com.steampowered.SteamOSManager1.Manager.xml",
"com.steampowered.SteamOSManager1.Manager",
)
.await
.expect("local");
assert!(remote.compare(&local));
}
}