logos-messaging/libchat
1
0
Fork 0
mirror of https://github.com/logos-messaging/libchat.git synced 2026-08-12 01:53:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: clear duplicate tests

Browse Source
This commit is contained in:
kaichaosun 2026-08-11 13:41:35 +08:00
parent 659ba28e2e
commit 6367aaa6ac
No known key found for this signature in database
GPG Key ID: 223E0F992F4F03BF
2 changed files with 0 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
crates/generic-chat/src/client.rs
View File

@ -1016,26 +1016,6 @@ mod sender_check_tests {
}
}
/// The hint names a device the claimed account endorses, so it resolves the
/// same way a delivered message's sender would.
#[test]
fn missing_message_hint_resolves_a_verified_author() {
let account = key();
let device = key();
let dir = FakeDir::with_devices(&account, &[&device]);
let cred = DelegateCredential::associated(&device, &hex::encode(account.as_ref()));
let (message_id, sender) = only_missing(missing_events(vec![gap(&hex_cred(cred))], &dir));
assert_eq!(message_id, "msg-id");
assert_eq!(
sender,
Some(MessageSender {
account: Some(local_id(&account)),
local_identity: local_id(&device),
})
);
}
/// An account claim the directory contradicts drops a *delivered* message,
/// but a gap is still worth reporting: the hint keeps the device and
/// forgoes the account, since nothing about an unseen message is verifiable

206
crates/generic-chat/tests/group_v2_missing.rs
View File

@ -1,206 +0,0 @@
//! A GroupV2 message lost in transit reaches the application as
//! [`Event::MessageMissing`].
//!
//! Saro and Raya share a group over the in-process bus, with Raya's transport
//! wrapped so one inbound payload can be swallowed. Saro sends three messages;
//! Raya never receives the second, and the third's causal history reveals it.
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use components::EphemeralRegistry;
use crossbeam_channel::{Receiver, Sender, unbounded};
use libchat::ChatStorage;
use logos_account::TestLogosAccount;
use logos_generic_chat::{
AddressedEnvelope, ChatClient, ChatClientBuilder, DelegateSigner, DeliveryService, Event,
GroupMetadata, GroupV2Config, InProcessDelivery, MessageBus, Transport,
};
/// Millisecond GroupV2 timers so the de-mls commit/consensus dance completes in
/// test time; the library defaults wait 60s before committing an add.
fn fast_group_v2_config() -> GroupV2Config {
GroupV2Config {
commit_inactivity_duration: Duration::from_millis(50),
freeze_duration: Duration::from_millis(20),
voting_delay: Duration::from_millis(30),
election_voting_delay: Duration::from_millis(30),
consensus_timeout: Duration::from_millis(150),
proposal_expiration: Duration::from_millis(2000),
..GroupV2Config::default()
}
}
/// An [`InProcessDelivery`] whose inbound stream can be told to swallow the
/// next payload, simulating a frame the transport never delivered.
///
/// The filter sits on the receiving side only: the payload is published to the
/// bus as usual and simply never reaches this client's core.
#[derive(Debug)]
struct LossyDelivery {
inner: InProcessDelivery,
drop_next: Arc<AtomicBool>,
}
impl LossyDelivery {
fn new(bus: MessageBus) -> (Self, Arc<AtomicBool>) {
let drop_next = Arc::new(AtomicBool::new(false));
let delivery = Self {
inner: InProcessDelivery::new(bus),
drop_next: Arc::clone(&drop_next),
};
(delivery, drop_next)
}
}
impl DeliveryService for LossyDelivery {
type Error = <InProcessDelivery as DeliveryService>::Error;
fn publish(&mut self, envelope: AddressedEnvelope) -> Result<(), Self::Error> {
self.inner.publish(envelope)
}
fn subscribe(&mut self, delivery_address: &str) -> Result<(), Self::Error> {
self.inner.subscribe(delivery_address)
}
}
impl Transport for LossyDelivery {
fn inbound(&mut self) -> Receiver<Vec<u8>> {
let source = self.inner.inbound();
let (tx, rx): (Sender<Vec<u8>>, Receiver<Vec<u8>>) = unbounded();
let drop_next = Arc::clone(&self.drop_next);
// Relay every payload through, minus the one the test armed a drop for.
std::thread::spawn(move || {
for payload in source {
if drop_next.swap(false, Ordering::SeqCst) {
continue;
}
if tx.send(payload).is_err() {
return; // client gone
}
}
});
rx
}
}
/// Mint an account and delegate, publish the endorsing bundle, and build a
/// client on `transport`. Returns the account address peers invite by.
fn create_client<T: Transport + Send + 'static>(
mut reg: EphemeralRegistry,
transport: T,
) -> (
ChatClient<T, EphemeralRegistry, ChatStorage>,
Receiver<Event>,
String,
) {
let account = TestLogosAccount::new();
let delegate = DelegateSigner::random();
account
.add_delegate_signer(&mut reg, delegate.public_key())
.unwrap();
let (client, events) = ChatClientBuilder::new(account.address())
.ident(delegate)
.transport(transport)
.registration(reg)
.group_v2_config(fast_group_v2_config())
.build()
.expect("client create");
let addr = client.addr().to_string();
(client, events, addr)
}
/// Wait until an event matching `f` arrives, skipping unrelated events (group
/// protocol traffic can interleave observations); panic after `timeout`.
fn wait_for_event<F, T>(events: &Receiver<Event>, label: &str, timeout: Duration, mut f: F) -> T
where
F: FnMut(&Event) -> Option<T>,
{
let deadline = std::time::Instant::now() + timeout;
loop {
let remaining = deadline
.checked_duration_since(std::time::Instant::now())
.unwrap_or_else(|| panic!("timed out waiting for {label}"));
match events.recv_timeout(remaining) {
Ok(event) => {
if let Some(out) = f(&event) {
return out;
}
}
Err(_) => panic!("timed out waiting for {label}"),
}
}
}
fn wait_for_message(events: &Receiver<Event>, content: &[u8]) {
let label = format!("MessageReceived({})", String::from_utf8_lossy(content));
wait_for_event(events, &label, Duration::from_secs(10), |e| match e {
Event::MessageReceived { content: got, .. } if got == content => Some(()),
_ => None,
})
}
#[test]
fn a_dropped_group_v2_message_is_reported_to_the_application() {
let bus = MessageBus::default();
let reg = EphemeralRegistry::new();
let (mut saro, _saro_events, saro_addr) =
create_client(reg.clone(), InProcessDelivery::new(bus.clone()));
let (lossy, drop_next) = LossyDelivery::new(bus.clone());
let (_raya, raya_events, raya_addr) = create_client(reg.clone(), lossy);
let convo_id = saro
.create_group_conversation(&[&raya_addr], GroupMetadata::new("", ""))
.expect("saro create group");
wait_for_event(
&raya_events,
"raya ConversationStarted",
Duration::from_secs(10),
|e| match e {
Event::ConversationStarted { convo_id, .. } => Some(convo_id.to_string()),
_ => None,
},
);
// M1 arrives normally, which also proves the group is live on both sides.
saro.send_message(&convo_id, b"first").expect("send m1");
wait_for_message(&raya_events, b"first");
// Let the group go quiet, so the payload the drop swallows is M2 and not a
// straggler of the join dance.
std::thread::sleep(Duration::from_millis(300));
while raya_events.try_recv().is_ok() {}
// M2 is published but never reaches Raya's core.
drop_next.store(true, Ordering::SeqCst);
saro.send_message(&convo_id, b"second").expect("send m2");
// M3 is delivered; its causal history references the dropped M2.
saro.send_message(&convo_id, b"third").expect("send m3");
let (message_id, sender_hint) = wait_for_event(
&raya_events,
"raya MessageMissing",
Duration::from_secs(10),
|e| match e {
Event::MessageMissing {
convo_id: id,
message_id,
sender_hint,
} if **id == *convo_id => Some((message_id.clone(), sender_hint.clone())),
_ => None,
},
);
assert!(!message_id.is_empty(), "the gap must identify a message");
let sender_hint = sender_hint.expect("the referencing peer named an author");
assert_eq!(
sender_hint.account.as_ref().map(|a| a.as_str()),
Some(saro_addr.as_str()),
"the missing message should be attributed to Saro"
);
}