#![allow(dead_code)]
use std::path::PathBuf;
use std::sync::{Arc, Mutex, PoisonError};
use tracing::field::{Field, Visit};
use tracing::subscriber::DefaultGuard;
use tracing::{Event, Level, Subscriber};
use tracing_subscriber::layer::{Context, SubscriberExt};
use tracing_subscriber::{Layer, registry};
use wiremock::MockServer;
use wiremock::matchers::{HeaderExactMatcher, header};
use rusteero::auth::AuthApi;
use rusteero::auth::Session;
use rusteero::auth::flow::LoginFlow;
use rusteero::storage::CredentialStore;
use rusteero::transport::Transport;
pub const TEST_TOKEN: &str = "test-token";
pub struct MockEero {
pub server: MockServer,
}
impl MockEero {
pub async fn start() -> Self {
Self {
server: MockServer::start().await,
}
}
#[must_use]
pub fn uri(&self) -> String {
self.server.uri()
}
#[must_use]
pub fn transport_anonymous(&self) -> Transport {
Transport::builder()
.base_url(self.uri())
.build()
.expect("a `MockServer`'s own URI is always a valid base URL")
}
#[must_use]
pub fn transport_with_token(&self, token: &str) -> Transport {
Transport::builder()
.base_url(self.uri())
.session(Some(Session::from_token(token)))
.build()
.expect("a `MockServer`'s own URI is always a valid base URL")
}
#[must_use]
pub fn transport_with_store(&self, token: &str, store: Arc<dyn CredentialStore>) -> Transport {
Transport::builder()
.base_url(self.uri())
.session(Some(Session::from_token(token)))
.store(Some(store))
.build()
.expect("a `MockServer`'s own URI is always a valid base URL")
}
#[must_use]
pub fn login_flow(&self) -> LoginFlow {
LoginFlow::with_transport(self.transport_anonymous())
}
#[must_use]
pub fn auth_api_with_token(&self, token: &str) -> AuthApi {
AuthApi::new(self.transport_with_token(token))
}
}
#[must_use]
pub fn session_cookie() -> HeaderExactMatcher {
session_cookie_for(TEST_TOKEN)
}
#[must_use]
pub fn session_cookie_for(token: &str) -> HeaderExactMatcher {
header("cookie", format!("s={token}"))
}
#[must_use]
pub fn user_token_header() -> HeaderExactMatcher {
user_token_header_for(TEST_TOKEN)
}
#[must_use]
pub fn user_token_header_for(token: &str) -> HeaderExactMatcher {
header("x-user-token", token)
}
#[must_use]
pub fn fixture(name: &str) -> String {
let path = fixture_path(name);
std::fs::read_to_string(&path)
.unwrap_or_else(|err| panic!("failed to read fixture {}: {err}", path.display()))
}
#[must_use]
pub fn fixture_json(name: &str) -> serde_json::Value {
serde_json::from_str(&fixture(name))
.unwrap_or_else(|err| panic!("fixture {name} is not valid JSON: {err}"))
}
fn fixture_path(name: &str) -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests")
.join("fixtures")
.join(name)
}
pub type LogRecord = (Level, String, String);
pub type LogFields = Vec<(String, String)>;
pub type LogGuard = DefaultGuard;
#[derive(Clone, Default)]
pub struct LogCapture {
records: Arc<Mutex<Vec<(LogRecord, LogFields)>>>,
}
impl LogCapture {
#[must_use]
pub fn records(&self) -> Vec<LogRecord> {
self.lock()
.iter()
.map(|(record, _)| record.clone())
.collect()
}
#[must_use]
pub fn entries(&self) -> Vec<(LogRecord, LogFields)> {
self.lock().clone()
}
#[must_use]
pub fn messages(&self, level: Level) -> Vec<String> {
self.lock()
.iter()
.filter(|((record_level, ..), _)| *record_level == level)
.map(|((.., message), _)| message.clone())
.collect()
}
#[must_use]
pub fn warnings(&self) -> Vec<String> {
self.messages(Level::WARN)
}
#[must_use]
pub fn errors(&self) -> Vec<String> {
self.messages(Level::ERROR)
}
#[must_use]
pub fn contains(&self, level: Level, needle: &str) -> bool {
self.lock().iter().any(|((record_level, _, message), _)| {
*record_level == level && message.contains(needle)
})
}
#[must_use]
pub fn count(&self, level: Level, needle: &str) -> usize {
self.lock()
.iter()
.filter(|((record_level, _, message), _)| {
*record_level == level && message.contains(needle)
})
.count()
}
#[must_use]
pub fn fields(&self, level: Level, needle: &str) -> Option<LogFields> {
self.lock()
.iter()
.find(|((record_level, _, message), _)| {
*record_level == level && message.contains(needle)
})
.map(|(_, fields)| fields.clone())
}
#[must_use]
pub fn field(&self, level: Level, needle: &str, name: &str) -> Option<String> {
self.fields(level, needle)?
.into_iter()
.find(|(field_name, _)| field_name == name)
.map(|(_, value)| value)
}
#[must_use]
pub fn mentions(&self, needle: &str) -> bool {
self.lock().iter().any(|((_, _, message), fields)| {
message.contains(needle) || fields.iter().any(|(_, value)| value.contains(needle))
})
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.lock().is_empty()
}
pub fn clear(&self) {
self.lock().clear();
}
fn lock(&self) -> std::sync::MutexGuard<'_, Vec<(LogRecord, LogFields)>> {
self.records.lock().unwrap_or_else(PoisonError::into_inner)
}
}
#[derive(Default)]
struct MessageVisitor {
message: String,
fields: LogFields,
}
impl Visit for MessageVisitor {
fn record_str(&mut self, field: &Field, value: &str) {
if field.name() == "message" {
value.clone_into(&mut self.message);
} else {
self.fields
.push((field.name().to_owned(), value.to_owned()));
}
}
fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
if field.name() == "message" {
self.message = format!("{value:?}");
} else {
self.fields
.push((field.name().to_owned(), format!("{value:?}")));
}
}
}
struct CaptureLayer {
records: Arc<Mutex<Vec<(LogRecord, LogFields)>>>,
}
impl<S: Subscriber> Layer<S> for CaptureLayer {
fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
let mut visitor = MessageVisitor::default();
event.record(&mut visitor);
let metadata = event.metadata();
self.records
.lock()
.unwrap_or_else(PoisonError::into_inner)
.push((
(
*metadata.level(),
metadata.target().to_owned(),
visitor.message,
),
visitor.fields,
));
}
}
#[must_use]
pub fn capture_logs() -> (LogGuard, LogCapture) {
static ANCHOR: std::sync::OnceLock<tracing::Dispatch> = std::sync::OnceLock::new();
ANCHOR.get_or_init(|| tracing::Dispatch::new(registry()));
let capture = LogCapture::default();
let subscriber = registry().with(CaptureLayer {
records: Arc::clone(&capture.records),
});
(tracing::subscriber::set_default(subscriber), capture)
}