simpler test validation

Author: cijothomas

.cspell.json

@@ -64,6 +64,7 @@
         "shoppingcart",
         "struct",
         "Tescher",
+        "testcontainers",
         "testresults",
         "thiserror",
         "tracerprovider",

opentelemetry-otlp/tests/integration_test/Cargo.toml

@@ -14,6 +14,7 @@ testcontainers = { version = "0.23.1", features = ["http_wait"]}
 once_cell.workspace = true
 anyhow = "1.0.94"
 ctor = "0.2.9"
+uuid = { version = "1.3", features = ["v4"] }
 tracing-subscriber = { workspace = true, features = ["env-filter","registry", "std", "fmt"] }
 tracing = {workspace = true}
 

opentelemetry-otlp/tests/integration_test/src/logs_asserter.rs

@@ -1,7 +1,6 @@
 use anyhow::Result;
 use opentelemetry_proto::tonic::logs::v1::{LogRecord, LogsData, ResourceLogs};
-use std::{fs::File, io::Read};
-use tracing::info;
+use std::fs::File;
 
 // Given two ResourceLogs, assert that they are equal except for the timestamps
 pub struct LogsAsserter {
@@ -99,12 +98,8 @@ impl std::fmt::Debug for LogRecordWrapper {
 
 // read a file contains ResourceSpans in json format
 pub fn read_logs_from_json(file: File) -> Result<Vec<ResourceLogs>> {
-    // print file contents
-    let mut contents = String::new();
-    let mut reader = std::io::BufReader::new(&file);
-    reader.read_to_string(&mut contents)?;
-    info!(file_contents = contents);
+    let reader = std::io::BufReader::new(file);
 
-    let log_data: LogsData = serde_json::from_str(&contents)?;
+    let log_data: LogsData = serde_json::from_reader(reader)?;
     Ok(log_data.resource_logs)
 }

opentelemetry-otlp/tests/integration_test/tests/logs.rs

@@ -2,14 +2,12 @@
 
 use anyhow::Result;
 use ctor::dtor;
-use integration_test_runner::logs_asserter::{read_logs_from_json, LogsAsserter};
 use integration_test_runner::test_utils;
 use opentelemetry_otlp::LogExporter;
 use opentelemetry_sdk::logs::LoggerProvider;
 use opentelemetry_sdk::{logs as sdklogs, Resource};
 use std::fs::File;
-use std::os::unix::fs::MetadataExt;
-use tracing::info;
+use std::io::Read;
 
 fn init_logs() -> Result<sdklogs::LoggerProvider> {
     let exporter_builder = LogExporter::builder();
@@ -68,43 +66,46 @@ mod logtests {
         Ok(())
     }
 
-    // #[ignore = "TODO: [Fix Me] Failing on CI. Needs to be investigated and resolved."]
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
     #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
     pub async fn logs_batch() -> Result<()> {
         use integration_test_runner::test_utils;
         use opentelemetry_appender_tracing::layer;
         use tracing::info;
         use tracing_subscriber::layer::SubscriberExt;
+        use uuid::Uuid;
 
         use crate::{assert_logs_results, init_logs};
         test_utils::start_collector_container().await?;
 
         let logger_provider = init_logs().unwrap();
         let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider);
         let subscriber = tracing_subscriber::registry().with(layer);
+        // generate a random uuid and store it to expected guid
+        let expected_uuid = Uuid::new_v4().to_string();
         {
             let _guard = tracing::subscriber::set_default(subscriber);
-            info!(target: "my-target", "hello from {}. My price is {}.", "banana", 2.99);
+            info!(target: "my-target",  uuid = expected_uuid, "hello from {}. My price is {}.", "banana", 2.99);
         }
 
         let _ = logger_provider.shutdown();
 
-        tokio::time::sleep(Duration::from_secs(10)).await;
+        tokio::time::sleep(Duration::from_secs(5)).await;
 
-        assert_logs_results(test_utils::LOGS_FILE, "expected/logs.json")?;
+        assert_logs_results(test_utils::LOGS_FILE, expected_uuid.as_str())?;
 
         Ok(())
     }
 
-    //#[ignore = "TODO: [Fix Me] Failing on CI. Needs to be investigated and resolved."]
     #[test]
     #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
     pub fn logs_batch_non_tokio_main() -> Result<()> {
         // Initialize the logger provider inside a tokio runtime
         // as this allows tonic client to capture the runtime,
         // but actual export occurs from the dedicated std::thread
         // created by BatchLogProcessor.
+
+        use uuid::Uuid;
         let rt = tokio::runtime::Runtime::new()?;
         let logger_provider = rt.block_on(async {
             // While we're here setup our collector container too, as this needs tokio to run
@@ -115,30 +116,27 @@ mod logtests {
         info!("LoggerProvider created");
         let layer = OpenTelemetryTracingBridge::new(&logger_provider);
         let subscriber = tracing_subscriber::registry().with(layer);
+        // generate a random uuid and store it to expected guid
+        let expected_uuid = Uuid::new_v4().to_string();
         {
             let _guard = tracing::subscriber::set_default(subscriber);
-            info!(target: "my-target", "hello from {}. My price is {}.", "banana", 2.99);
+            info!(target: "my-target", uuid = expected_uuid, "hello from {}. My price is {}.", "banana", 2.99);
         }
         let _ = logger_provider.shutdown();
-        info!("Sleeping for 10 seconds to allow collector to store logs to file");
-        std::thread::sleep(Duration::from_secs(10));
-        assert_logs_results(test_utils::LOGS_FILE, "expected/logs.json")?;
+        info!("Sleeping for 5 seconds to allow collector to store logs to file");
+        std::thread::sleep(Duration::from_secs(5));
+        assert_logs_results(test_utils::LOGS_FILE, expected_uuid.as_str())?;
 
         Ok(())
     }
 }
 
-pub fn assert_logs_results(result: &str, expected: &str) -> Result<()> {
-    info!("Reading expected logs");
-    let left = read_logs_from_json(File::open(expected)?)?;
-    info!("Reading actual logs");
-    let right = read_logs_from_json(File::open(result)?)?;
-
-    info!("Checking actual logs file size");
-    assert!(File::open(result).unwrap().metadata().unwrap().size() > 0);
-
-    LogsAsserter::new(left, right).assert();
-
+pub fn assert_logs_results(result: &str, expected_content: &str) -> Result<()> {
+    let file = File::open(result)?;
+    let mut contents = String::new();
+    let mut reader = std::io::BufReader::new(&file);
+    reader.read_to_string(&mut contents)?;
+    assert!(contents.contains(expected_content));
     Ok(())
 }
 

opentelemetry-otlp/tests/integration_test/tests/metrics.rs

@@ -191,7 +191,7 @@ pub fn validate_metrics_against_results(scope_name: &str) -> Result<()> {
 #[cfg(test)]
 #[cfg(not(feature = "hyper-client"))]
 #[cfg(not(feature = "reqwest-client"))]
-mod tests {
+mod metrictests {
 
     use super::*;
     use opentelemetry::metrics::MeterProvider;
@@ -246,7 +246,6 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    // #[ignore] // skip when running unit test
     async fn test_histogram() -> Result<()> {
         _ = setup_metrics_test().await;
         const METER_NAME: &str = "test_histogram_meter";
@@ -263,7 +262,6 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    // #[ignore] // skip when running unit test
     async fn test_up_down_counter() -> Result<()> {
         _ = setup_metrics_test().await;
         const METER_NAME: &str = "test_up_down_meter";