Skip to content

Commit c9a18c0

Browse files
AlenarAlenar
committed
test: use memory logger for tests than needs to check log content
instead of logging to a file, which can cause issue in some context (i.e: the log file doens't seems to always be correctly flushed).
1 parent 7b33255 commit c9a18c0

File tree

14 files changed

+260
-393
lines changed

14 files changed

+260
-393
lines changed

‎mithril-aggregator/src/artifact_builder/cardano_database_artifacts/ancillary.rs‎

Lines changed: 12 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -275,33 +275,25 @@ mod tests {
275275

276276
#[tokio::test]
277277
async fn upload_ancillary_archive_should_log_upload_errors() {
278-
let log_path = TempDir::create(
279-
"ancillary",
280-
"upload_ancillary_archive_should_log_upload_errors",
281-
)
282-
.join("test.log");
283-
278+
let (logger, log_inspector) = TestLogger::memory();
284279
let mut uploader = MockAncillaryFileUploader::new();
285280
uploader
286281
.expect_upload()
287282
.return_once(|_, _| Err(anyhow!("Failure while uploading...")));
288283

289-
{
290-
let builder = AncillaryArtifactBuilder::new(
291-
vec![Arc::new(uploader)],
292-
Arc::new(DumbSnapshotter::default()),
293-
CardanoNetwork::DevNet(123),
294-
TestLogger::file(&log_path),
295-
)
296-
.unwrap();
284+
let builder = AncillaryArtifactBuilder::new(
285+
vec![Arc::new(uploader)],
286+
Arc::new(DumbSnapshotter::default()),
287+
CardanoNetwork::DevNet(123),
288+
logger,
289+
)
290+
.unwrap();
297291

298-
let _ = builder
299-
.upload_ancillary_archive(&FileArchive::dummy())
300-
.await;
301-
}
292+
let _ = builder
293+
.upload_ancillary_archive(&FileArchive::dummy())
294+
.await;
302295

303-
let logs = std::fs::read_to_string(&log_path).unwrap();
304-
assert!(logs.contains("Failure while uploading..."));
296+
assert!(log_inspector.contains_log("Failure while uploading..."));
305297
}
306298

307299
#[tokio::test]

‎mithril-aggregator/src/artifact_builder/cardano_database_artifacts/digest.rs‎

Lines changed: 17 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -444,36 +444,30 @@ mod tests {
444444
#[tokio::test]
445445
async fn upload_digest_file_should_log_upload_errors() {
446446
let temp_dir = TempDir::create("digest", current_function!());
447-
let log_path = temp_dir.join("test.log");
448-
447+
let (logger, log_inspector) = TestLogger::memory();
449448
let mut uploader = MockDigestFileUploader::new();
450449
uploader
451450
.expect_upload()
452451
.return_once(|_, _| Err(anyhow!("Failure while uploading...")));
453452

454-
{
455-
let builder = DigestArtifactBuilder::new(
456-
SanitizedUrlWithTrailingSlash::parse("https://aggregator/").unwrap(),
457-
vec![Arc::new(uploader)],
458-
DigestSnapshotter {
459-
file_archiver: Arc::new(FileArchiver::new_for_test(
460-
temp_dir.join("verification"),
461-
)),
462-
target_location: temp_dir.clone(),
463-
compression_algorithm: CompressionAlgorithm::Gzip,
464-
},
465-
CardanoNetwork::DevNet(123),
466-
PathBuf::from("/tmp/whatever"),
467-
Arc::new(MockImmutableFileDigestMapper::new()),
468-
TestLogger::file(&log_path),
469-
)
470-
.unwrap();
453+
let builder = DigestArtifactBuilder::new(
454+
SanitizedUrlWithTrailingSlash::parse("https://aggregator/").unwrap(),
455+
vec![Arc::new(uploader)],
456+
DigestSnapshotter {
457+
file_archiver: Arc::new(FileArchiver::new_for_test(temp_dir.join("verification"))),
458+
target_location: temp_dir.clone(),
459+
compression_algorithm: CompressionAlgorithm::Gzip,
460+
},
461+
CardanoNetwork::DevNet(123),
462+
PathBuf::from("/tmp/whatever"),
463+
Arc::new(MockImmutableFileDigestMapper::new()),
464+
logger,
465+
)
466+
.unwrap();
471467

472-
let _ = builder.upload_digest_file(&FileArchive::dummy()).await;
473-
}
468+
let _ = builder.upload_digest_file(&FileArchive::dummy()).await;
474469

475-
let logs = std::fs::read_to_string(&log_path).unwrap();
476-
assert!(logs.contains("Failure while uploading..."));
470+
assert!(log_inspector.contains_log("Failure while uploading..."));
477471
}
478472

479473
#[tokio::test]

‎mithril-aggregator/src/artifact_builder/cardano_database_artifacts/immutable.rs‎

Lines changed: 15 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -695,8 +695,6 @@ mod tests {
695695
}
696696

697697
mod upload {
698-
use mithril_common::test_utils::TempDir;
699-
700698
use super::MockImmutableFilesUploader;
701699

702700
use super::*;
@@ -715,36 +713,28 @@ mod tests {
715713

716714
#[tokio::test]
717715
async fn upload_immutable_archives_should_log_upload_errors() {
718-
let log_path = TempDir::create(
719-
"immutable",
720-
"upload_immutable_archives_should_log_upload_errors",
721-
)
722-
.join("test.log");
723-
716+
let (logger, log_inspector) = TestLogger::memory();
724717
let mut uploader = MockImmutableFilesUploader::new();
725718
uploader
726719
.expect_batch_upload()
727720
.return_once(|_, _| Err(anyhow!("Failure while uploading...")));
728721

729-
{
730-
let builder = ImmutableArtifactBuilder::new(
731-
get_builder_work_dir("upload_immutable_archives_should_log_upload_errors"),
732-
vec![Arc::new(uploader)],
733-
Arc::new(MockSnapshotter::new()),
734-
TestLogger::file(&log_path),
735-
)
736-
.unwrap();
722+
let builder = ImmutableArtifactBuilder::new(
723+
get_builder_work_dir("upload_immutable_archives_should_log_upload_errors"),
724+
vec![Arc::new(uploader)],
725+
Arc::new(MockSnapshotter::new()),
726+
logger,
727+
)
728+
.unwrap();
737729

738-
let _ = builder
739-
.upload_immutable_archives(
740-
&[PathBuf::from("01.tar.gz"), PathBuf::from("02.tar.gz")],
741-
CompressionAlgorithm::Gzip,
742-
)
743-
.await;
744-
}
730+
let _ = builder
731+
.upload_immutable_archives(
732+
&[PathBuf::from("01.tar.gz"), PathBuf::from("02.tar.gz")],
733+
CompressionAlgorithm::Gzip,
734+
)
735+
.await;
745736

746-
let logs = std::fs::read_to_string(&log_path).unwrap();
747-
assert!(logs.contains("Failure while uploading..."));
737+
assert!(log_inspector.contains_log("Failure while uploading..."));
748738
}
749739

750740
#[tokio::test]

‎mithril-aggregator/src/lib.rs‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -70,14 +70,15 @@ static GLOBAL: Jemalloc = Jemalloc;
7070

7171
#[cfg(test)]
7272
pub(crate) mod test_tools {
73-
use std::fs::File;
7473
use std::io;
7574
use std::sync::Arc;
7675

7776
use slog::{Drain, Logger};
7877
use slog_async::Async;
7978
use slog_term::{CompactFormat, PlainDecorator};
8079

80+
use mithril_common::test_utils::{MemoryDrainForTest, MemoryDrainForTestInspector};
81+
8182
pub struct TestLogger;
8283

8384
impl TestLogger {
@@ -92,8 +93,9 @@ pub(crate) mod test_tools {
9293
Self::from_writer(slog_term::TestStdoutWriter)
9394
}
9495

95-
pub fn file(filepath: &std::path::Path) -> Logger {
96-
Self::from_writer(File::create(filepath).unwrap())
96+
pub fn memory() -> (Logger, MemoryDrainForTestInspector) {
97+
let (drain, inspector) = MemoryDrainForTest::new();
98+
(Logger::root(drain.fuse(), slog::o!()), inspector)
9799
}
98100
}
99101
}

‎mithril-aggregator/src/runtime/error.rs‎

Lines changed: 24 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -92,20 +92,11 @@ impl From<StdError> for RuntimeError {
9292
#[cfg(test)]
9393
mod tests {
9494
use anyhow::anyhow;
95-
use std::path::Path;
96-
97-
use mithril_common::test_utils::TempDir;
9895

9996
use crate::test_tools::TestLogger;
10097

10198
use super::*;
10299

103-
/// Separate function so the logger is dropped and flushed before the assertion.
104-
fn write_log(log_file: &Path, error: &RuntimeError) {
105-
let logger = TestLogger::file(log_file);
106-
error.write_to_log(&logger);
107-
}
108-
109100
fn nested_error_debug_string(error: &RuntimeError) -> String {
110101
let error = match error {
111102
RuntimeError::KeepState { nested_error, .. } => nested_error,
@@ -122,28 +113,21 @@ mod tests {
122113

123114
#[test]
124115
fn log_critical_without_nested_error() {
125-
let log_file = TempDir::create(
126-
"aggregator_runtime_error",
127-
"log_critical_without_nested_error",
128-
)
129-
.join("file.log");
116+
let (logger, log_inspector) = TestLogger::memory();
130117

131118
let error = RuntimeError::Critical {
132119
message: "Critical error".to_string(),
133120
nested_error: None,
134121
};
135-
write_log(&log_file, &error);
122+
error.write_to_log(&logger);
136123

137-
let log_content = std::fs::read_to_string(&log_file).unwrap();
138-
assert!(log_content.contains(&format!("{error}")));
139-
assert!(!log_content.contains("nested_error"));
124+
assert!(log_inspector.contains_log(&format!("{error}")));
125+
assert!(!log_inspector.contains_log("nested_error"));
140126
}
141127

142128
#[test]
143129
fn log_critical_with_nested_error() {
144-
let log_file =
145-
TempDir::create("aggregator_runtime_error", "log_critical_with_nested_error")
146-
.join("file.log");
130+
let (logger, log_inspector) = TestLogger::memory();
147131

148132
let error = RuntimeError::Critical {
149133
message: "Critical error".to_string(),
@@ -153,39 +137,29 @@ mod tests {
153137
.context("Critical nested error"),
154138
),
155139
};
156-
write_log(&log_file, &error);
140+
error.write_to_log(&logger);
157141

158-
let log_content = std::fs::read_to_string(&log_file).unwrap();
159-
assert!(log_content.contains(&format!("{error}")));
160-
assert!(log_content.contains(&nested_error_debug_string(&error)));
142+
assert!(log_inspector.contains_log(&format!("{error}")));
143+
assert!(log_inspector.contains_log(&nested_error_debug_string(&error)));
161144
}
162145

163146
#[test]
164147
fn log_keep_state_without_nested_error() {
165-
let log_file = TempDir::create(
166-
"aggregator_runtime_error",
167-
"log_keep_state_without_nested_error",
168-
)
169-
.join("file.log");
148+
let (logger, log_inspector) = TestLogger::memory();
170149

171150
let error = RuntimeError::KeepState {
172151
message: "KeepState error".to_string(),
173152
nested_error: None,
174153
};
175-
write_log(&log_file, &error);
154+
error.write_to_log(&logger);
176155

177-
let log_content = std::fs::read_to_string(&log_file).unwrap();
178-
assert!(log_content.contains(&format!("{error}")));
179-
assert!(!log_content.contains("nested_error"));
156+
assert!(log_inspector.contains_log(&format!("{error}")));
157+
assert!(!log_inspector.contains_log("nested_error"));
180158
}
181159

182160
#[test]
183161
fn log_keep_state_with_nested_error() {
184-
let log_file = TempDir::create(
185-
"aggregator_runtime_error",
186-
"log_keep_state_with_nested_error",
187-
)
188-
.join("file.log");
162+
let (logger, log_inspector) = TestLogger::memory();
189163

190164
let error = RuntimeError::KeepState {
191165
message: "KeepState error".to_string(),
@@ -195,36 +169,29 @@ mod tests {
195169
.context("KeepState nested error"),
196170
),
197171
};
198-
write_log(&log_file, &error);
172+
error.write_to_log(&logger);
199173

200-
let log_content = std::fs::read_to_string(&log_file).unwrap();
201-
assert!(log_content.contains(&format!("{error}")));
202-
assert!(log_content.contains(&nested_error_debug_string(&error)));
174+
assert!(log_inspector.contains_log(&format!("{error}")));
175+
assert!(log_inspector.contains_log(&nested_error_debug_string(&error)));
203176
}
204177

205178
#[test]
206179
fn log_reinit_without_nested_error() {
207-
let log_file = TempDir::create(
208-
"aggregator_runtime_error",
209-
"log_reinit_without_nested_error",
210-
)
211-
.join("file.log");
180+
let (logger, log_inspector) = TestLogger::memory();
212181

213182
let error = RuntimeError::ReInit {
214183
message: "ReInit error".to_string(),
215184
nested_error: None,
216185
};
217-
write_log(&log_file, &error);
186+
error.write_to_log(&logger);
218187

219-
let log_content = std::fs::read_to_string(&log_file).unwrap();
220-
assert!(log_content.contains(&format!("{error}")));
221-
assert!(!log_content.contains("nested_error"));
188+
assert!(log_inspector.contains_log(&format!("{error}")));
189+
assert!(!log_inspector.contains_log("nested_error"));
222190
}
223191

224192
#[test]
225193
fn log_reinit_with_nested_error() {
226-
let log_file = TempDir::create("aggregator_runtime_error", "log_reinit_with_nested_error")
227-
.join("file.log");
194+
let (logger, log_inspector) = TestLogger::memory();
228195

229196
let error = RuntimeError::ReInit {
230197
message: "ReInit error".to_string(),
@@ -234,10 +201,9 @@ mod tests {
234201
.context("ReInit nested error"),
235202
),
236203
};
237-
write_log(&log_file, &error);
204+
error.write_to_log(&logger);
238205

239-
let log_content = std::fs::read_to_string(&log_file).unwrap();
240-
assert!(log_content.contains(&format!("{error}")));
241-
assert!(log_content.contains(&nested_error_debug_string(&error)));
206+
assert!(log_inspector.contains_log(&format!("{error}")));
207+
assert!(log_inspector.contains_log(&nested_error_debug_string(&error)));
242208
}
243209
}

0 commit comments

Comments
 (0)