use super::*;
fn rust() -> LanguageId {
LanguageId::parse_language("rust").expect("a language id")
}
fn cpp() -> LanguageId {
LanguageId::parse_language("cpp").expect("a language id")
}
fn rust_capabilities() -> LanguageCapabilities {
LanguageCapabilities {
language: rust(),
file_extensions: &["rs"],
operations: &[AuthoringOperation::Create, AuthoringOperation::Modify],
fields: RegistrationField::ALL,
}
}
fn cpp_capabilities() -> LanguageCapabilities {
LanguageCapabilities {
language: cpp(),
file_extensions: &["cpp", "cc"],
operations: &[AuthoringOperation::Create, AuthoringOperation::Modify],
fields: &[
RegistrationField::Kind,
RegistrationField::Exports,
RegistrationField::NeedsRegistry,
],
}
}
fn request(language: LanguageId) -> FaceAuthoringRequest {
FaceAuthoringRequest {
language,
operation: AuthoringOperation::Create,
destination: "src/shop/panel/object/area/area.cpp".to_owned(),
parent: ParentReference::Named("::xirang::faces::shop__panel_Panel".to_owned()),
registration: RegistrationUpdate::new(),
source_context: SourceContext::new(),
}
}
#[test]
fn absent_and_explicitly_empty_are_different_states() {
let mut update = RegistrationUpdate::new();
update
.set_text(RegistrationField::SummaryEn, FieldUpdate::Clear)
.unwrap();
assert_eq!(
update.find_field(RegistrationField::SummaryEn),
FieldUpdate::Clear
);
assert_eq!(
update.find_field(RegistrationField::SummaryZh),
FieldUpdate::Keep
);
assert_ne!(
update.find_field(RegistrationField::SummaryEn),
update.find_field(RegistrationField::SummaryZh)
);
}
#[test]
fn list_fields_normalize_order_and_duplicates() {
let mut first = RegistrationUpdate::new();
first
.set_text(RegistrationField::Exports, FieldUpdate::Set("b, a"))
.unwrap();
let mut second = RegistrationUpdate::new();
second
.set_text(RegistrationField::Exports, FieldUpdate::Set("a,b,a"))
.unwrap();
assert_eq!(first, second);
assert_eq!(
first.find_field(RegistrationField::Exports),
FieldUpdate::Set("a,b")
);
}
#[test]
fn keeping_a_field_is_not_clearing_it() {
let mut kept = RegistrationUpdate::new();
kept.set_text(RegistrationField::NameEn, FieldUpdate::Keep)
.unwrap();
let mut cleared = RegistrationUpdate::new();
cleared
.set_text(RegistrationField::NameEn, FieldUpdate::Clear)
.unwrap();
assert_ne!(kept, cleared);
assert!(kept.is_empty(), "Keep names nothing");
assert_eq!(cleared.named().count(), 1, "Clear names one field");
}
#[test]
fn round_trip_comparison_is_semantic() {
let mut written = RegistrationUpdate::new();
written
.set_text(RegistrationField::Exports, FieldUpdate::Set("area, gauge"))
.unwrap();
let mut read_back = RegistrationUpdate::new();
read_back.set_normalized(
RegistrationField::Exports,
FieldUpdate::Set("area,gauge".to_owned()),
);
assert!(written.agrees_with(&read_back));
let mut changed = RegistrationUpdate::new();
changed.set_normalized(
RegistrationField::Exports,
FieldUpdate::Set("area".to_owned()),
);
assert!(!written.agrees_with(&changed));
}
#[test]
fn unsupported_fields_are_refused_by_name_with_a_reason() {
let mut update = RegistrationUpdate::new();
update
.set_text(RegistrationField::Flow, FieldUpdate::Set("a => b"))
.unwrap();
let mut request = request(cpp());
request.registration = update;
let error = validate_request(&request, &cpp_capabilities()).unwrap_err();
assert!(error.contains("cpp"), "{error}");
assert!(error.contains("flow"), "{error}");
assert!(error.contains("Rust expression"), "{error}");
assert!(
!error.contains("ANY"),
"a refusal must not suggest a default"
);
}
#[test]
fn the_same_field_passes_where_the_capability_table_carries_it() {
let mut update = RegistrationUpdate::new();
update
.set_text(RegistrationField::Flow, FieldUpdate::Set("a => b"))
.unwrap();
let mut request = request(rust());
request.registration = update;
assert!(validate_request(&request, &rust_capabilities()).is_ok());
}
#[test]
fn an_unimplemented_operation_is_refused_before_rendering() {
let capabilities = LanguageCapabilities {
operations: &[AuthoringOperation::Create],
..cpp_capabilities()
};
let mut request = request(cpp());
request.operation = AuthoringOperation::Modify;
let error = validate_request(&request, &capabilities).unwrap_err();
assert!(error.contains("modify"), "{error}");
assert!(error.contains("no adapter"), "{error}");
}
#[test]
fn a_table_for_another_language_is_refused() {
let error = validate_request(&request(rust()), &cpp_capabilities()).unwrap_err();
assert!(error.contains("describes `cpp`"), "{error}");
assert!(error.contains("targets `rust`"), "{error}");
}
#[test]
fn names_are_validated_at_the_field_boundary() {
let mut update = RegistrationUpdate::new();
assert!(
update
.set_text(RegistrationField::Module, FieldUpdate::Set("Bad-Name"))
.is_err()
);
assert!(
update
.set_text(RegistrationField::Kind, FieldUpdate::Set("lower"))
.is_err()
);
assert!(
update
.set_text(RegistrationField::NeedsRegistry, FieldUpdate::Set("yes"))
.is_err()
);
assert!(
update
.set_text(RegistrationField::SummaryEn, FieldUpdate::Set("two\nlines"))
.is_err()
);
}
#[test]
fn a_plan_with_no_changes_is_not_a_write() {
let same = PlannedFile {
path: "src/a.rs".to_owned(),
original: Some("same".to_owned()),
updated: "same".to_owned(),
edits: Vec::new(),
remove: false,
};
let created = PlannedFile {
path: "src/b.cpp".to_owned(),
original: None,
updated: String::new(),
edits: Vec::new(),
remove: false,
};
let plan = FaceAuthoringPlan {
language: cpp(),
operation: AuthoringOperation::Create,
files: vec![same.clone(), created.clone()],
diagnostics: Vec::new(),
obligations: Vec::new(),
};
assert!(!same.changes());
assert!(created.creates());
assert_eq!(plan.changed_files().count(), 1);
}