Skip to content

Commit de1b8fb

Browse files
0xNeshi0xNeshi
committed
test: rely solely on assert_next for assertions
1 parent 59c4739 commit de1b8fb

File tree

3 files changed

+104
-62
lines changed

3 files changed

+104
-62
lines changed

‎src/event_scanner.rs‎

Lines changed: 68 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -46,14 +46,75 @@ impl From<Vec<Log>> for EventScannerMessage {
4646
}
4747
}
4848

49-
impl<'a, T: SolEvent + 'a, I: IntoIterator<Item = &'a T> + Clone> PartialEq<I>
50-
for EventScannerMessage
51-
{
52-
fn eq(&self, other: &I) -> bool {
49+
impl<'a, T: SolEvent + 'a> PartialEq<Vec<T>> for EventScannerMessage {
50+
fn eq(&self, other: &Vec<T>) -> bool {
51+
self.eq(&other.as_slice())
52+
}
53+
}
54+
55+
impl<'a, T: SolEvent + 'a> PartialEq<&Vec<T>> for EventScannerMessage {
56+
fn eq(&self, other: &&Vec<T>) -> bool {
57+
self.eq(&other.as_slice())
58+
}
59+
}
60+
61+
impl<'a, T: SolEvent + 'a, const N: usize> PartialEq<&[T; N]> for EventScannerMessage {
62+
fn eq(&self, other: &&[T; N]) -> bool {
63+
self.eq(&other.as_slice())
64+
}
65+
}
66+
67+
impl<'a, T: SolEvent + 'a> PartialEq<&[T]> for EventScannerMessage {
68+
fn eq(&self, other: &&[T]) -> bool {
69+
if let EventScannerMessage::Data(logs) = self {
70+
logs.iter().map(|l| l.data().clone()).eq(other.into_iter().map(|e| e.encode_log_data()))
71+
} else {
72+
false
73+
}
74+
}
75+
}
76+
77+
#[derive(Debug)]
78+
pub struct LogMetadata<E: SolEvent> {
79+
pub event: E,
80+
pub address: alloy::primitives::Address,
81+
pub tx_hash: alloy::primitives::B256,
82+
}
83+
84+
impl<'a, E: SolEvent + 'a> PartialEq<Vec<LogMetadata<E>>> for EventScannerMessage {
85+
fn eq(&self, other: &Vec<LogMetadata<E>>) -> bool {
86+
self.eq(&other.as_slice())
87+
}
88+
}
89+
90+
impl<'a, E: SolEvent + 'a> PartialEq<&Vec<LogMetadata<E>>> for EventScannerMessage {
91+
fn eq(&self, other: &&Vec<LogMetadata<E>>) -> bool {
92+
self.eq(&other.as_slice())
93+
}
94+
}
95+
96+
impl<'a, E: SolEvent + 'a, const N: usize> PartialEq<&[LogMetadata<E>; N]> for EventScannerMessage {
97+
fn eq(&self, other: &&[LogMetadata<E>; N]) -> bool {
98+
self.eq(&other.as_slice())
99+
}
100+
}
101+
102+
impl<'a, E: SolEvent + 'a> PartialEq<&[LogMetadata<E>]> for EventScannerMessage {
103+
fn eq(&self, other: &&[LogMetadata<E>]) -> bool {
53104
if let EventScannerMessage::Data(logs) = self {
54-
logs.iter()
55-
.map(|l| l.data().clone())
56-
.eq(other.clone().into_iter().map(|e| e.encode_log_data()))
105+
let log_data = logs
106+
.iter()
107+
.map(|l| {
108+
let address = l.address();
109+
let tx_hash = l.transaction_hash.unwrap();
110+
(l.inner.data.clone(), address, tx_hash)
111+
})
112+
.collect::<Vec<_>>();
113+
let expected = other
114+
.into_iter()
115+
.map(|e| (e.event.encode_log_data(), e.address, e.tx_hash))
116+
.collect::<Vec<_>>();
117+
log_data == expected
57118
} else {
58119
false
59120
}

‎tests/latest_events/basic.rs‎

Lines changed: 31 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -9,11 +9,10 @@ use alloy::{
99
};
1010

1111
use crate::{
12-
assert_next_logs,
12+
assert_next,
1313
common::{TestCounter, build_provider, deploy_counter, setup_scanner, spawn_anvil},
14-
macros::LogMetadata,
1514
};
16-
use event_scanner::event_filter::EventFilter;
15+
use event_scanner::{event_filter::EventFilter, event_scanner::LogMetadata};
1716

1817
macro_rules! increase {
1918
($contract: expr) => {{
@@ -64,7 +63,8 @@ async fn scan_latest_exact_count_returns_last_events_in_order() -> anyhow::Resul
6463
// Ask for the latest 5
6564
client.scan_latest(5).await?;
6665

67-
assert_next_logs!(stream, expected);
66+
assert_next!(stream, expected);
67+
assert_next!(stream, None);
6868

6969
Ok(())
7070
}
@@ -86,7 +86,8 @@ async fn scan_latest_fewer_available_than_count_returns_all() -> anyhow::Result<
8686

8787
let expected = &expected;
8888

89-
assert_next_logs!(stream, expected);
89+
assert_next!(stream, expected);
90+
assert_next!(stream, None);
9091

9192
Ok(())
9293
}
@@ -100,7 +101,8 @@ async fn scan_latest_no_events_returns_empty() -> anyhow::Result<()> {
100101
client.scan_latest(5).await?;
101102

102103
let expected: &[LogMetadata<TestCounter::CountIncreased>] = &[];
103-
assert_next_logs!(stream, expected);
104+
assert_next!(stream, expected);
105+
assert_next!(stream, None);
104106

105107
Ok(())
106108
}
@@ -138,7 +140,8 @@ async fn scan_latest_respects_range_subset() -> anyhow::Result<()> {
138140

139141
client.scan_latest_in_range(10, start, end).await?;
140142

141-
assert_next_logs!(stream, expected);
143+
assert_next!(stream, expected);
144+
assert_next!(stream, None);
142145

143146
Ok(())
144147
}
@@ -170,8 +173,11 @@ async fn scan_latest_multiple_listeners_to_same_event_receive_same_results() ->
170173

171174
client.scan_latest(5).await?;
172175

173-
assert_next_logs!(stream1, expected);
174-
assert_next_logs!(stream2, expected);
176+
assert_next!(stream1, expected);
177+
assert_next!(stream1, None);
178+
179+
assert_next!(stream2, expected);
180+
assert_next!(stream2, None);
175181

176182
Ok(())
177183
}
@@ -208,10 +214,12 @@ async fn scan_latest_different_filters_receive_different_results() -> anyhow::Re
208214
client.scan_latest(3).await?;
209215

210216
let expected = &inc_log_meta;
211-
assert_next_logs!(stream_inc, expected);
217+
assert_next!(stream_inc, expected);
218+
assert_next!(stream_inc, None);
212219

213220
let expected = &dec_log_meta;
214-
assert_next_logs!(stream_dec, expected);
221+
assert_next!(stream_dec, expected);
222+
assert_next!(stream_dec, None);
215223

216224
Ok(())
217225
}
@@ -221,13 +229,13 @@ async fn scan_latest_mixed_events_and_filters_return_correct_streams() -> anyhow
221229
let setup = setup_scanner(None, None, None).await?;
222230
let contract = setup.contract;
223231
let mut client = setup.client;
224-
let mut inc_stream = setup.stream; // CountIncreased by default
232+
let mut stream_inc = setup.stream; // CountIncreased by default
225233

226234
// Add a CountDecreased listener
227235
let filter_dec = EventFilter::new()
228236
.with_contract_address(*contract.address())
229237
.with_event(TestCounter::CountDecreased::SIGNATURE);
230-
let mut dec_stream = client.create_event_stream(filter_dec);
238+
let mut stream_dec = client.create_event_stream(filter_dec);
231239

232240
// Sequence: inc(1), inc(2), dec(1), inc(2), dec(1)
233241
let mut inc_log_meta = Vec::new();
@@ -248,10 +256,12 @@ async fn scan_latest_mixed_events_and_filters_return_correct_streams() -> anyhow
248256
client.scan_latest(2).await?;
249257

250258
let expected = &inc_log_meta;
251-
assert_next_logs!(inc_stream, expected);
259+
assert_next!(stream_inc, expected);
260+
assert_next!(stream_inc, None);
252261

253262
let expected = &dec_log_meta;
254-
assert_next_logs!(dec_stream, expected);
263+
assert_next!(stream_dec, expected);
264+
assert_next!(stream_dec, None);
255265

256266
Ok(())
257267
}
@@ -284,7 +294,8 @@ async fn scan_latest_cross_contract_filtering() -> anyhow::Result<()> {
284294

285295
client.scan_latest(5).await?;
286296

287-
assert_next_logs!(stream_a, &a_log_meta);
297+
assert_next!(stream_a, &a_log_meta);
298+
assert_next!(stream_a, None);
288299

289300
Ok(())
290301
}
@@ -321,7 +332,8 @@ async fn scan_latest_large_gaps_and_empty_ranges() -> anyhow::Result<()> {
321332

322333
client.scan_latest_in_range(5, start, end).await?;
323334

324-
assert_next_logs!(stream, &log_meta);
335+
assert_next!(stream, &log_meta);
336+
assert_next!(stream, None);
325337

326338
Ok(())
327339
}
@@ -357,7 +369,8 @@ async fn scan_latest_boundary_range_single_block() -> anyhow::Result<()> {
357369
tx_hash: receipt_blocks[1].0,
358370
}];
359371

360-
assert_next_logs!(stream, expected);
372+
assert_next!(stream, expected);
373+
assert_next!(stream, None);
361374

362375
Ok(())
363376
}

‎tests/macros.rs‎

Lines changed: 5 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -1,47 +1,15 @@
1-
use alloy::{
2-
primitives::{Address, B256},
3-
sol_types::SolEvent,
4-
};
5-
use event_scanner::event_scanner::EventScannerMessage;
6-
71
#[macro_export]
82
macro_rules! assert_next {
9-
($stream: expr, $expected: expr) => {
3+
($stream: expr, None) => {
104
let message = tokio_stream::StreamExt::next(&mut $stream).await;
11-
if let Some(msg) = message {
12-
assert_eq!(msg, $expected);
13-
} else {
14-
panic!("Expected EventScannerMessage::Data, got: {message:?}");
15-
}
5+
assert!(message.is_none())
166
};
17-
}
18-
19-
pub struct LogMetadata<E: SolEvent> {
20-
pub event: E,
21-
pub address: Address,
22-
pub tx_hash: B256,
23-
}
24-
25-
#[macro_export]
26-
macro_rules! assert_next_logs {
277
($stream: expr, $expected: expr) => {
288
let message = tokio_stream::StreamExt::next(&mut $stream).await;
29-
if let Some(event_scanner::event_scanner::EventScannerMessage::Data(logs)) = message {
30-
let log_data = logs
31-
.into_iter()
32-
.map(|l| {
33-
let address = l.address();
34-
let tx_hash = l.transaction_hash.unwrap();
35-
(l.inner.data, address, tx_hash)
36-
})
37-
.collect::<Vec<_>>();
38-
let expected = $expected
39-
.iter()
40-
.map(|e| (e.event.encode_log_data(), e.address, e.tx_hash))
41-
.collect::<Vec<_>>();
42-
assert_eq!(log_data, expected);
9+
if let Some(msg) = message {
10+
assert_eq!(msg, $expected)
4311
} else {
44-
panic!("Expected EventScannerMessage::Data, got: {message:?}");
12+
panic!("Expected EventScannerMessage::Data, got: {message:?}")
4513
}
4614
};
4715
}

0 commit comments

Comments
 (0)