openhandle 1.2.10

Official Rust SDK for the Openhandle social data API
Documentation
use serde::Deserialize;

use super::{Reference, resolve_reference};
use crate::errors::Error;

const FIXTURE: &str = include_str!("../../testdata/reference-conformance.json");

#[derive(Deserialize)]
struct Fixture {
    version: u32,
    cases: Vec<Case>,
}

#[derive(Deserialize)]
struct Case {
    name: String,
    platform: String,
    resource: String,
    input: Input,
    identifier: Option<String>,
    error: Option<String>,
}

#[derive(Deserialize)]
struct Input {
    kind: String,
    value: String,
}

#[test]
fn every_shared_reference_case_resolves_as_the_fixture_requires() {
    let fixture: Fixture = serde_json::from_str(FIXTURE).expect("fixture is valid JSON");
    assert_eq!(fixture.version, 1, "unexpected fixture version");
    assert!(!fixture.cases.is_empty(), "fixture has no cases");

    let mut failures = Vec::new();
    for case in &fixture.cases {
        let reference = match case.input.kind.as_str() {
            "raw" => Reference::Raw(case.input.value.clone()),
            "username" => Reference::Username(case.input.value.clone()),
            "id" => Reference::Id(case.input.value.clone()),
            "url" => Reference::Url(case.input.value.clone()),
            kind => panic!("{}: unknown reference kind {kind}", case.name),
        };
        let result = resolve_reference(&reference, &case.platform, &case.resource);
        let outcome = match (&result, &case.error, &case.identifier) {
            (Ok(identifier), None, Some(expected)) if identifier == expected => continue,
            (Err(error), Some(expected), _) if error_name(error) == expected => continue,
            (Ok(identifier), _, _) => format!("resolved to {identifier:?}"),
            (Err(error), _, _) => format!("failed with {} ({error})", error_name(error)),
        };
        failures.push(format!(
            "{}: {outcome}, want {}",
            case.name,
            case.error
                .clone()
                .or_else(|| case.identifier.clone())
                .unwrap_or_default()
        ));
    }
    assert!(
        failures.is_empty(),
        "reference conformance failures:\n{}",
        failures.join("\n")
    );
}

fn error_name(error: &Error) -> &'static str {
    match error {
        Error::ReferenceMismatch(_) => "reference_mismatch",
        Error::Reference(_) => "invalid_reference",
        _ => "unexpected_error",
    }
}