use rpki::rtr::error_type::{
    ERROR_CODE_VERSION_SPECS, ErrorCode, ErrorCodeDisposition, ErrorCodeVersionSpec,
};

#[test]
fn error_code_version_specs_match_rfc_and_draft_table() {
    use ErrorCode::*;
    use ErrorCodeDisposition::*;

    let expected = [
        ErrorCodeVersionSpec {
            code: CorruptData,
            min_version: 0,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: InternalError,
            min_version: 0,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: NoDataAvailable,
            min_version: 0,
            max_version: 2,
            disposition: NonFatal,
        },
        ErrorCodeVersionSpec {
            code: InvalidRequest,
            min_version: 0,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: UnsupportedProtocolVersion,
            min_version: 0,
            max_version: 1,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: UnsupportedProtocolVersion,
            min_version: 2,
            max_version: 2,
            disposition: NonFatal,
        },
        ErrorCodeVersionSpec {
            code: UnsupportedPduType,
            min_version: 0,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: WithdrawalOfUnknownRecord,
            min_version: 0,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: DuplicateAnnouncement,
            min_version: 0,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: UnexpectedProtocolVersion,
            min_version: 1,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: AspaProviderListError,
            min_version: 2,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: TransportFailed,
            min_version: 2,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: OrderingError,
            min_version: 2,
            max_version: 2,
            disposition: Fatal,
        },
        ErrorCodeVersionSpec {
            code: CacheRestart,
            min_version: 2,
            max_version: 2,
            disposition: NonFatal,
        },
        ErrorCodeVersionSpec {
            code: CacheShutdown,
            min_version: 2,
            max_version: 2,
            disposition: Fatal,
        },
    ];

    assert_eq!(ERROR_CODE_VERSION_SPECS, &expected);
}

#[test]
fn error_code_definition_scope_is_version_sensitive() {
    assert!(ErrorCode::DuplicateAnnouncement.is_defined_in_version(0));
    assert!(!ErrorCode::UnexpectedProtocolVersion.is_defined_in_version(0));
    assert!(ErrorCode::UnexpectedProtocolVersion.is_defined_in_version(1));
    assert!(!ErrorCode::AspaProviderListError.is_defined_in_version(1));
    assert!(ErrorCode::CacheShutdown.is_defined_in_version(2));
}

#[test]
fn error_code_disposition_is_version_sensitive() {
    assert_eq!(
        ErrorCode::NoDataAvailable.disposition_in_version(0),
        Some(ErrorCodeDisposition::NonFatal)
    );
    assert_eq!(
        ErrorCode::UnsupportedProtocolVersion.disposition_in_version(1),
        Some(ErrorCodeDisposition::Fatal)
    );
    assert_eq!(
        ErrorCode::UnsupportedProtocolVersion.disposition_in_version(2),
        Some(ErrorCodeDisposition::NonFatal)
    );
    assert_eq!(
        ErrorCode::CacheRestart.disposition_in_version(2),
        Some(ErrorCodeDisposition::NonFatal)
    );
    assert_eq!(ErrorCode::CacheRestart.disposition_in_version(1), None);
    assert_eq!(
        ErrorCode::CacheShutdown.disposition_in_version(2),
        Some(ErrorCodeDisposition::Fatal)
    );
}

#[test]
fn raw_error_code_registry_mapping_accepts_defined_codes_only() {
    assert_eq!(ErrorCode::try_from(12), Ok(ErrorCode::CacheRestart));
    assert_eq!(ErrorCode::try_from(13), Ok(ErrorCode::CacheShutdown));
    assert!(ErrorCode::try_from(14).is_err());
    assert!(ErrorCode::try_from(255).is_err());
}