use atelier_core::action::validate::{
run_validation_actions, CorrectTypeReferences, NoUnresolvedReferences,
};
use atelier_core::builder::{
ModelBuilder, ShapeTraits, SimpleShapeBuilder, StructureBuilder, TraitBuilder,
};
use atelier_core::model::Model;
use atelier_core::Version;
use pretty_assertions::assert_eq;
use std::convert::TryInto;
fn make_model() -> Model {
ModelBuilder::new(Version::V10, "smithy.example")
.uses("foo.baz#Bar")
.structure(
StructureBuilder::new("MyStructure")
.member("a", "MyString")
.member("b", "smithy.example#MyString")
.member("d", "foo.baz#Bar")
.member("e", "foo.baz#MyString")
.member("f", "String")
.member("g", "MyBoolean")
.apply_trait(TraitBuilder::new("documentation"))
.into(),
)
.simple_shape(SimpleShapeBuilder::string("MyString"))
.simple_shape(SimpleShapeBuilder::boolean("MyBoolean"))
.try_into()
.unwrap()
}
#[test]
fn test_correct_type_references() {
let expected = [
"smithy.example#MyStructure member e\'s type (foo.baz#MyString) cannot be resolved to a shape in this model.",
"The simple shape (smithy.example#MyString) is simply a synonym, did you mean to add any constraint traits?",
"The simple shape (smithy.example#MyBoolean) is simply a synonym, did you mean to add any constraint traits?",
];
let model: Model = make_model();
let result = run_validation_actions(
&mut [Box::new(CorrectTypeReferences::default())],
&model,
false,
);
assert!(result.is_ok());
let actual = result.unwrap();
println!("{:#?}", actual);
assert_eq!(actual.len(), expected.len());
let actual: Vec<String> = actual
.iter()
.map(|issue| issue.message())
.cloned()
.collect();
println!("{:#?}", actual);
for message in &expected {
assert!(actual.contains(&message.to_string()));
}
}
#[test]
fn test_unresolved_references() {
let expected = ["The model has an unresolved reference to shape 'foo.baz#Bar'"];
let model: Model = ModelBuilder::new(Version::V10, "smithy.example")
.uses("foo.baz#Bar")
.simple_shape(SimpleShapeBuilder::boolean("MyBoolean"))
.try_into()
.unwrap();
let result = run_validation_actions(
&mut [Box::new(NoUnresolvedReferences::default())],
&model,
false,
);
assert!(result.is_ok());
let actual = result.unwrap();
println!("{:#?}", actual);
assert_eq!(actual.len(), expected.len());
let actual: Vec<String> = actual
.iter()
.map(|issue| issue.message())
.cloned()
.collect();
println!("{:#?}", actual);
for message in &expected {
assert!(actual.contains(&message.to_string()));
}
}