use crate::error::ResolveError;
use crate::types::{PositionMatch, ResolvedIdentity};
#[async_trait::async_trait]
pub trait Resolver: Send + Sync {
async fn resolve(&self, query: &str) -> Result<ResolvedIdentity, ResolveError>;
async fn resolve_object(&self, object_raw: &str) -> Result<ResolvedIdentity, ResolveError> {
self.resolve(object_raw).await
}
}
#[async_trait::async_trait]
pub trait PositionResolver: Send + Sync {
async fn resolve_position(
&self,
ra_deg: f64,
dec_deg: f64,
radius_deg: f64,
limit: usize,
) -> Result<Vec<PositionMatch>, ResolveError>;
}
#[derive(Clone, Copy, Debug, Default)]
pub struct OfflineResolver;
#[async_trait::async_trait]
impl Resolver for OfflineResolver {
async fn resolve(&self, _query: &str) -> Result<ResolvedIdentity, ResolveError> {
Err(ResolveError::Disabled)
}
}
#[cfg(any(test, feature = "test-util"))]
#[derive(Debug, Default)]
pub struct FakeResolver {
responses: std::collections::HashMap<String, ResolvedIdentity>,
errors: std::collections::HashMap<String, ResolveError>,
default_error: Option<ResolveError>,
call_count: std::sync::atomic::AtomicUsize,
}
#[cfg(any(test, feature = "test-util"))]
impl FakeResolver {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn with_response(mut self, query: &str, identity: ResolvedIdentity) -> Self {
self.responses.insert(crate::normalize::normalize(query), identity);
self
}
#[must_use]
pub fn with_error(mut self, query: &str, error: ResolveError) -> Self {
self.errors.insert(crate::normalize::normalize(query), error);
self
}
#[must_use]
pub fn with_default_error(mut self, error: ResolveError) -> Self {
self.default_error = Some(error);
self
}
#[must_use]
pub fn call_count(&self) -> usize {
self.call_count.load(std::sync::atomic::Ordering::Relaxed)
}
}
#[cfg(any(test, feature = "test-util"))]
impl Clone for FakeResolver {
fn clone(&self) -> Self {
Self {
responses: self.responses.clone(),
errors: self.errors.clone(),
default_error: self.default_error.clone(),
call_count: std::sync::atomic::AtomicUsize::new(0),
}
}
}
#[cfg(any(test, feature = "test-util"))]
#[async_trait::async_trait]
impl Resolver for FakeResolver {
async fn resolve(&self, query: &str) -> Result<ResolvedIdentity, ResolveError> {
self.call_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let key = crate::normalize::normalize(query);
if let Some(err) = self.errors.get(&key) {
return Err(err.clone());
}
if let Some(identity) = self.responses.get(&key) {
return Ok(identity.clone());
}
Err(self.default_error.clone().unwrap_or_else(|| ResolveError::NotFound(query.to_owned())))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::{AliasKind, ObjectType, ResolvedAlias, TargetSource};
fn sample_identity() -> ResolvedIdentity {
ResolvedIdentity {
simbad_oid: Some(1_575_544),
primary_designation: "M 31".to_owned(),
common_name: Some("Andromeda Galaxy".to_owned()),
object_type: ObjectType::Galaxy,
otype_raw: "G".to_owned(),
ra_deg: 10.684_708,
dec_deg: 41.268_75,
v_mag: Some(3.44),
aliases: vec![
ResolvedAlias::new("M 31", AliasKind::Designation),
ResolvedAlias::new("NGC 224", AliasKind::Designation),
ResolvedAlias::new("Andromeda Galaxy", AliasKind::CommonName),
],
source: TargetSource::Resolved,
}
}
#[tokio::test]
async fn fake_resolver_returns_canned_response() {
let resolver = FakeResolver::new().with_response("M31", sample_identity());
let got = resolver.resolve("M 31").await.unwrap();
assert_eq!(got.primary_designation, "M 31");
assert_eq!(got.object_type, ObjectType::Galaxy);
assert_eq!(got.otype_raw, "G");
assert_eq!(got.simbad_oid, Some(1_575_544));
}
#[tokio::test]
async fn fake_resolver_unknown_is_not_found() {
let resolver = FakeResolver::new();
let err = resolver.resolve("does-not-exist").await.unwrap_err();
assert!(matches!(err, ResolveError::NotFound(_)));
}
#[tokio::test]
async fn fake_resolver_canned_error() {
let resolver = FakeResolver::new()
.with_error("M31", ResolveError::Ambiguous { query: "M31".to_owned(), count: 2 });
let err = resolver.resolve("M 31").await.unwrap_err();
assert!(matches!(err, ResolveError::Ambiguous { count: 2, .. }));
}
#[tokio::test]
async fn fake_resolver_default_error_simulates_offline() {
let resolver =
FakeResolver::new().with_default_error(ResolveError::Network("down".to_owned()));
let err = resolver.resolve("anything").await.unwrap_err();
assert!(matches!(err, ResolveError::Network(_)));
}
#[tokio::test]
async fn resolve_object_defaults_to_resolve() {
let resolver = FakeResolver::new().with_response("M31", sample_identity());
let got = resolver.resolve_object("M 31").await.unwrap();
assert_eq!(got.primary_designation, "M 31");
}
#[tokio::test]
async fn fake_resolver_call_count_increments() {
let resolver = FakeResolver::new().with_response("M31", sample_identity());
assert_eq!(resolver.call_count(), 0);
let _ = resolver.resolve("M 31").await;
let _ = resolver.resolve("m31").await;
assert_eq!(resolver.call_count(), 2);
}
#[tokio::test]
async fn fake_resolver_clone_resets_call_counter() {
let resolver = FakeResolver::new().with_response("M31", sample_identity());
let _ = resolver.resolve("M 31").await;
assert_eq!(resolver.call_count(), 1);
let cloned = resolver.clone();
assert_eq!(cloned.call_count(), 0);
let got = cloned.resolve("M 31").await.unwrap();
assert_eq!(got.primary_designation, "M 31");
assert_eq!(cloned.call_count(), 1);
assert_eq!(resolver.call_count(), 1, "clone's calls do not affect the original");
}
#[tokio::test]
async fn offline_resolver_always_disabled() {
let resolver = OfflineResolver;
let err = resolver.resolve("M 31").await.unwrap_err();
assert_eq!(err, ResolveError::Disabled);
}
struct FakePositionResolver;
#[async_trait::async_trait]
impl PositionResolver for FakePositionResolver {
async fn resolve_position(
&self,
_ra_deg: f64,
_dec_deg: f64,
_radius_deg: f64,
limit: usize,
) -> Result<Vec<PositionMatch>, ResolveError> {
let identity = sample_identity();
let matches: Vec<PositionMatch> =
std::iter::once(PositionMatch { identity, separation_deg: 0.01 })
.take(limit)
.collect();
Ok(matches)
}
}
#[tokio::test]
async fn position_resolver_is_object_safe_and_callable() {
let resolver: Box<dyn PositionResolver> = Box::new(FakePositionResolver);
let matches = resolver.resolve_position(10.68, 41.27, 0.5, 5).await.unwrap();
assert_eq!(matches.len(), 1);
assert!((matches[0].separation_deg - 0.01).abs() < 1e-9);
}
}