use super::*;
#[test]
fn test_absent_or_empty_type_names_rejected() {
for (name_label, name) in [("absent", None), ("empty", Some(String::new()))] {
let mut message = proto3_file("test.proto");
message.message_type.push(DescriptorProto {
name: name.clone(),
..Default::default()
});
let mut nested_message = proto3_file("test.proto");
nested_message.message_type.push(DescriptorProto {
name: Some("Parent".to_string()),
nested_type: vec![DescriptorProto {
name: name.clone(),
..Default::default()
}],
..Default::default()
});
let mut top_level_enum = proto3_file("test.proto");
top_level_enum.enum_type.push(EnumDescriptorProto {
name: name.clone(),
..Default::default()
});
let mut nested_enum = proto3_file("test.proto");
nested_enum.message_type.push(DescriptorProto {
name: Some("Parent".to_string()),
enum_type: vec![EnumDescriptorProto {
name: name.clone(),
..Default::default()
}],
..Default::default()
});
let cases = [
("top-level message", message, "message.name"),
("nested message", nested_message, "message.name"),
("top-level enum", top_level_enum, "enum.name"),
("nested enum", nested_enum, "enum.name"),
];
for (shape, file, want) in cases {
let result = generate(
&[file],
&["test.proto".to_string()],
&CodeGenConfig::default(),
);
assert!(
matches!(result, Err(CodeGenError::MissingField(field)) if field == want),
"{shape} with an {name_label} name: expected MissingField({want}), got: {:?}",
result.map(|files| files.len())
);
}
}
}
#[test]
fn test_reserved_field_name_rejected() {
let field = make_field(
"__buffa_cached_size",
1,
Label::LABEL_OPTIONAL,
Type::TYPE_INT32,
);
let msg = DescriptorProto {
name: Some("BadMessage".to_string()),
field: vec![field],
..Default::default()
};
let mut file = proto3_file("test.proto");
file.package = Some("my.pkg".to_string());
file.message_type = vec![msg];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
assert!(result.is_err());
let err = result.unwrap_err();
assert!(
err.to_string().contains("__buffa_cached_size"),
"error should mention the field name: {err}"
);
assert!(
err.to_string().contains("my.pkg.BadMessage"),
"error should mention the message name: {err}"
);
}
fn prefix_fixture() -> FileDescriptorProto {
let mut file = proto3_file("test.proto");
file.package = Some("my.pkg".to_string());
file.enum_type.push(EnumDescriptorProto {
name: Some("Status".to_string()),
value: vec![enum_value("STATUS_UNKNOWN", 0), enum_value("STATUS_OK", 1)],
..Default::default()
});
file.message_type.push(DescriptorProto {
name: Some("User".to_string()),
nested_type: vec![DescriptorProto {
name: Some("Inner".to_string()),
..Default::default()
}],
enum_type: vec![EnumDescriptorProto {
name: Some("Kind".to_string()),
value: vec![enum_value("KIND_UNSPECIFIED", 0)],
..Default::default()
}],
..Default::default()
});
file.message_type.push(DescriptorProto {
name: Some("Account".to_string()),
field: vec![
FieldDescriptorProto {
name: Some("owner".to_string()),
number: Some(1),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_MESSAGE),
type_name: Some(".my.pkg.User".to_string()),
json_name: Some("owner".to_string()),
..Default::default()
},
FieldDescriptorProto {
name: Some("status".to_string()),
number: Some(2),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_ENUM),
type_name: Some(".my.pkg.Status".to_string()),
json_name: Some("status".to_string()),
..Default::default()
},
FieldDescriptorProto {
name: Some("inner".to_string()),
number: Some(3),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_MESSAGE),
type_name: Some(".my.pkg.User.Inner".to_string()),
json_name: Some("inner".to_string()),
..Default::default()
},
FieldDescriptorProto {
name: Some("primary".to_string()),
number: Some(4),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_MESSAGE),
type_name: Some(".my.pkg.User".to_string()),
oneof_index: Some(0),
json_name: Some("primary".to_string()),
..Default::default()
},
],
oneof_decl: vec![OneofDescriptorProto {
name: Some("sel".to_string()),
..Default::default()
}],
..Default::default()
});
file
}
#[test]
fn test_type_name_prefix_declarations_and_references() {
let config = CodeGenConfig {
type_name_prefix: "Rpc".to_string(),
generate_json: true,
generate_text: true,
lazy_views: true,
..CodeGenConfig::default()
};
let files = generate(&[prefix_fixture()], &["test.proto".to_string()], &config)
.expect("should generate");
let content = joined(&files);
assert!(
content.contains("pub struct RpcUser"),
"top-level struct must be prefixed: {content}"
);
assert!(
content.contains("pub struct RpcAccount"),
"top-level struct must be prefixed: {content}"
);
assert!(
content.contains("pub enum RpcStatus"),
"top-level enum must be prefixed: {content}"
);
assert!(
content.contains("pub struct RpcInner"),
"nested struct must be prefixed: {content}"
);
assert!(
content.contains("pub enum RpcKind"),
"nested enum must be prefixed: {content}"
);
assert!(
content.contains("pub struct RpcUserView"),
"view struct must be prefixed: {content}"
);
assert!(
content.contains("RpcUserOwnedView"),
"owned-view wrapper must be prefixed: {content}"
);
assert!(
content.contains("lazy_view::RpcUserLazyView"),
"top-level lazy-view re-export must be prefixed: {content}"
);
assert!(
content.contains("lazy_view::user::RpcInnerLazyView"),
"nested lazy-view re-export must be prefixed: {content}"
);
assert!(
!content.contains("::UserLazyView") && !content.contains("::InnerLazyView"),
"unprefixed lazy-view re-exports must not be emitted: {content}"
);
assert!(
content.contains("MessageField<RpcUser, ::buffa::Inline<RpcUser>>"),
"message field must reference prefixed type: {content}"
);
assert!(
content.contains("EnumValue<RpcStatus>"),
"enum field must reference prefixed type: {content}"
);
assert!(
content.contains("user::RpcInner"),
"nested reference must keep the proto-derived module and prefix \
only the type: {content}"
);
assert!(
!content.contains("pub struct User"),
"unprefixed struct must not be declared: {content}"
);
assert!(
!content.contains("pub enum Status"),
"unprefixed enum must not be declared: {content}"
);
for f in &files {
syn::parse_file(&f.content)
.unwrap_or_else(|e| panic!("generated file {} must parse: {e}\n{}", f.name, f.content));
}
}
#[test]
fn test_type_name_prefix_does_not_touch_modules_or_wkt() {
let mut file = prefix_fixture();
file.dependency
.push("google/protobuf/timestamp.proto".to_string());
file.message_type[1].field.push(FieldDescriptorProto {
name: Some("created".to_string()),
number: Some(5),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_MESSAGE),
type_name: Some(".google.protobuf.Timestamp".to_string()),
json_name: Some("created".to_string()),
..Default::default()
});
let mut ts_file = proto3_file("google/protobuf/timestamp.proto");
ts_file.package = Some("google.protobuf".to_string());
ts_file.message_type.push(DescriptorProto {
name: Some("Timestamp".to_string()),
field: vec![
make_field("seconds", 1, Label::LABEL_OPTIONAL, Type::TYPE_INT64),
make_field("nanos", 2, Label::LABEL_OPTIONAL, Type::TYPE_INT32),
],
..Default::default()
});
let config = CodeGenConfig {
type_name_prefix: "Rpc".to_string(),
..CodeGenConfig::default()
};
let files =
generate(&[ts_file, file], &["test.proto".to_string()], &config).expect("should generate");
let content = joined(&files);
assert!(
content.contains("pub mod user"),
"nested-types module must keep the proto-derived name: {content}"
);
assert!(
!content.contains("pub mod rpc_user"),
"module name must not be prefixed: {content}"
);
assert!(
content.contains("buffa_types::google::protobuf::Timestamp"),
"WKT reference must stay extern and unprefixed: {content}"
);
assert!(
!content.contains("RpcTimestamp"),
"extern types must not be prefixed: {content}"
);
}
#[test]
fn test_type_name_prefix_invalid_rejected() {
for bad in [
"1Rpc", "Rpc-", "Rpc ", " Rpc", "Rp.c", "rpc", "rpcUser", "_Rpc", "Rpc_", "X_",
] {
let config = CodeGenConfig {
type_name_prefix: bad.to_string(),
..CodeGenConfig::default()
};
let result = generate(&[prefix_fixture()], &["test.proto".to_string()], &config);
let err = result.expect_err("invalid prefix must be rejected");
assert!(
matches!(err, CodeGenError::InvalidTypeNamePrefix { .. }),
"expected InvalidTypeNamePrefix for '{bad}', got: {err}"
);
assert!(
err.to_string().contains("type_name_prefix"),
"error should name the offending option: {err}"
);
}
}
#[test]
fn test_type_name_prefix_pascal_case_accepted() {
for good in ["Rpc", "RpcV2", "X"] {
let config = CodeGenConfig {
type_name_prefix: good.to_string(),
..CodeGenConfig::default()
};
let files = generate(&[prefix_fixture()], &["test.proto".to_string()], &config)
.expect("PascalCase prefix must be accepted");
assert!(joined(&files).contains(&format!("pub struct {good}User")));
}
}
#[test]
fn test_non_reserved_field_name_accepted() {
let field = make_field("cached_size", 1, Label::LABEL_OPTIONAL, Type::TYPE_INT32);
let msg = DescriptorProto {
name: Some("OkMessage".to_string()),
field: vec![field],
..Default::default()
};
let mut file = proto3_file("test.proto");
file.package = Some("my.pkg".to_string());
file.message_type = vec![msg];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
assert!(
result.is_ok(),
"cached_size should be allowed as a field name"
);
}
#[test]
fn test_module_name_conflict_detected() {
let mut file = proto3_file("test.proto");
file.package = Some("my.pkg".to_string());
file.message_type = vec![
DescriptorProto {
name: Some("HTTPRequest".to_string()),
..Default::default()
},
DescriptorProto {
name: Some("HttpRequest".to_string()),
..Default::default()
},
];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
assert!(result.is_err());
let err = result.unwrap_err().to_string();
assert!(
err.contains("http_request"),
"should mention module name: {err}"
);
assert!(
err.contains("HTTPRequest"),
"should mention first message: {err}"
);
assert!(
err.contains("HttpRequest"),
"should mention second message: {err}"
);
}
#[test]
fn test_nested_module_name_conflict_detected() {
let parent = DescriptorProto {
name: Some("Parent".to_string()),
nested_type: vec![
DescriptorProto {
name: Some("FOO".to_string()),
..Default::default()
},
DescriptorProto {
name: Some("Foo".to_string()),
..Default::default()
},
],
..Default::default()
};
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![parent];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
assert!(result.is_err());
let err = result.unwrap_err().to_string();
assert!(err.contains("foo"), "should mention module name: {err}");
}
#[test]
fn test_different_snake_case_names_no_conflict() {
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![
DescriptorProto {
name: Some("FooBar".to_string()),
..Default::default()
},
DescriptorProto {
name: Some("FooBaz".to_string()),
..Default::default()
},
];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
assert!(
result.is_ok(),
"distinct snake_case names should not conflict"
);
}
#[test]
fn test_nested_type_oneof_coexist_in_separate_trees() {
let msg = DescriptorProto {
name: Some("Parent".to_string()),
nested_type: vec![DescriptorProto {
name: Some("MyField".to_string()),
..Default::default()
}],
oneof_decl: vec![OneofDescriptorProto {
name: Some("my_field".to_string()),
..Default::default()
}],
field: vec![{
let mut f = make_field("val", 1, Label::LABEL_OPTIONAL, Type::TYPE_STRING);
f.oneof_index = Some(0);
f
}],
..Default::default()
};
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![msg];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
let files = result.expect("nested type + oneof same-name should coexist");
let content = &joined(&files);
assert!(
content.contains("pub enum MyField {"),
"oneof enum should drop Oneof suffix: {content}"
);
assert!(
content.contains("pub struct MyField"),
"nested message struct should keep its original name: {content}"
);
}
#[test]
fn test_nested_type_oneof_no_conflict() {
let msg = DescriptorProto {
name: Some("Parent".to_string()),
nested_type: vec![DescriptorProto {
name: Some("Inner".to_string()),
..Default::default()
}],
oneof_decl: vec![OneofDescriptorProto {
name: Some("my_field".to_string()),
..Default::default()
}],
field: vec![{
let mut f = make_field("val", 1, Label::LABEL_OPTIONAL, Type::TYPE_STRING);
f.oneof_index = Some(0);
f
}],
..Default::default()
};
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![msg];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
assert!(result.is_ok(), "Inner and MyField should not conflict");
}
#[test]
fn test_nested_enum_oneof_coexists_with_suffix() {
let msg = DescriptorProto {
name: Some("PerkRestrictions".to_string()),
enum_type: vec![EnumDescriptorProto {
name: Some("RegionCodes".to_string()),
value: vec![enum_value("REGION_CODES_UNKNOWN", 0), enum_value("US", 1)],
..Default::default()
}],
oneof_decl: vec![OneofDescriptorProto {
name: Some("region_codes".to_string()),
..Default::default()
}],
field: vec![{
let mut f = make_field("code", 1, Label::LABEL_OPTIONAL, Type::TYPE_STRING);
f.oneof_index = Some(0);
f
}],
..Default::default()
};
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![msg];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
let files = result.expect("nested enum + oneof same-name should coexist");
let content = &joined(&files);
assert_eq!(
content.matches("pub enum RegionCodes {").count(),
2,
"expected two RegionCodes enums (proto + oneof): {content}"
);
}
#[test]
fn test_sibling_oneof_view_names_do_not_collide() {
let msg = DescriptorProto {
name: Some("Parent".to_string()),
oneof_decl: vec![
OneofDescriptorProto {
name: Some("my_field".to_string()),
..Default::default()
},
OneofDescriptorProto {
name: Some("my_field_view".to_string()),
..Default::default()
},
],
field: vec![
{
let mut f = make_field("a", 1, Label::LABEL_OPTIONAL, Type::TYPE_STRING);
f.oneof_index = Some(0);
f
},
{
let mut f = make_field("b", 2, Label::LABEL_OPTIONAL, Type::TYPE_STRING);
f.oneof_index = Some(1);
f
},
],
..Default::default()
};
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![msg];
let files = generate(
&[file],
&["test.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("sibling oneof names must resolve without collision");
let content = &joined(&files);
assert!(
content.contains("pub enum MyField {"),
"first oneof owned enum: {content}"
);
assert!(
content.contains("pub enum MyFieldView {"),
"second oneof owned enum: {content}"
);
}
#[test]
fn test_foo_and_fooview_siblings_coexist() {
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![
DescriptorProto {
name: Some("Foo".to_string()),
..Default::default()
},
DescriptorProto {
name: Some("FooView".to_string()),
..Default::default()
},
];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
let files = result.expect("Foo + FooView siblings should coexist");
let content = &joined(&files);
assert!(content.contains("pub struct Foo {"));
assert!(content.contains("pub struct FooView {"));
assert!(content.contains("pub struct FooView<'a>"));
}
#[test]
fn test_top_level_message_named_view_compiles() {
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![DescriptorProto {
name: Some("View".to_string()),
nested_type: vec![DescriptorProto {
name: Some("Inner".to_string()),
..Default::default()
}],
..Default::default()
}];
let result = generate(
&[file],
&["test.proto".to_string()],
&CodeGenConfig::default(),
);
let files = result.expect("top-level `message View` must compile");
for f in files
.iter()
.filter(|f| f.kind != GeneratedFileKind::PackageMod)
{
syn::parse_str::<syn::File>(&f.content).expect("generated content must parse");
}
let content = joined(&files);
assert!(content.contains("pub mod __buffa {"));
}
#[test]
fn test_reserved_sentinel_package_segment_rejected() {
let mut file = proto3_file("test.proto");
file.package = Some("foo.__buffa".to_string());
file.message_type = vec![DescriptorProto {
name: Some("X".to_string()),
..Default::default()
}];
let err = generate(
&[file],
&["test.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("__buffa package segment must be rejected");
assert!(
matches!(err, CodeGenError::ReservedModuleName { .. }),
"expected ReservedModuleName, got {err:?}"
);
}
#[test]
fn test_reserved_sentinel_message_name_rejected() {
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![DescriptorProto {
name: Some("__Buffa".to_string()),
..Default::default()
}];
let err = generate(
&[file],
&["test.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("__Buffa message name must be rejected");
let msg = err.to_string();
assert!(msg.contains("__buffa"), "error should name sentinel: {msg}");
assert!(msg.contains("pkg.__Buffa"), "error should locate it: {msg}");
}
#[test]
fn test_reserved_sentinel_file_level_enum_rejected() {
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.enum_type = vec![EnumDescriptorProto {
name: Some("__buffa".to_string()),
value: vec![enum_value("V", 0)],
..Default::default()
}];
let err = generate(
&[file],
&["test.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("file-level enum __buffa must be rejected");
assert!(
matches!(err, CodeGenError::ReservedModuleName { .. }),
"expected ReservedModuleName, got {err:?}"
);
let msg = err.to_string();
assert!(
msg.contains("enum 'pkg.__buffa'"),
"should locate it: {msg}"
);
}
#[test]
fn test_nested_enum_named_buffa_allowed() {
let mut file = proto3_file("test.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![DescriptorProto {
name: Some("Foo".to_string()),
enum_type: vec![EnumDescriptorProto {
name: Some("__buffa".to_string()),
value: vec![enum_value("V", 0)],
..Default::default()
}],
..Default::default()
}];
generate(
&[file],
&["test.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("nested enum __buffa should be allowed");
}
#[test]
fn test_proto3_optional_field_name_matches_nested_enum_no_conflict() {
let msg = DescriptorProto {
name: Some("StringFieldMatcher".to_string()),
enum_type: vec![EnumDescriptorProto {
name: Some("MatchOperator".to_string()),
value: vec![
enum_value("MATCH_OPERATOR_UNKNOWN", 0),
enum_value("MATCH_OPERATOR_EXACT_MATCH", 1),
],
..Default::default()
}],
oneof_decl: vec![OneofDescriptorProto {
name: Some("_match_operator".to_string()),
..Default::default()
}],
field: vec![{
let mut f = make_field("match_operator", 4, Label::LABEL_OPTIONAL, Type::TYPE_ENUM);
f.type_name = Some(".minimal.StringFieldMatcher.MatchOperator".to_string());
f.oneof_index = Some(0);
f.proto3_optional = Some(true);
f
}],
..Default::default()
};
let mut file = proto3_file("test.proto");
file.package = Some("minimal".to_string());
file.message_type = vec![msg];
let config = CodeGenConfig::default();
let result = generate(&[file], &["test.proto".to_string()], &config);
assert!(
result.is_ok(),
"synthetic oneof should not conflict with nested enum: {}",
result.unwrap_err()
);
}
#[test]
fn test_nested_message_named_option_does_not_shadow_prelude() {
let option_msg = DescriptorProto {
name: Some("Option".to_string()),
field: vec![
make_field("title", 1, Label::LABEL_OPTIONAL, Type::TYPE_STRING),
{
let mut f = make_field("int_value", 2, Label::LABEL_OPTIONAL, Type::TYPE_UINT64);
f.oneof_index = Some(0);
f
},
],
oneof_decl: vec![OneofDescriptorProto {
name: Some("value".to_string()),
..Default::default()
}],
..Default::default()
};
let picker_msg = DescriptorProto {
name: Some("Picker".to_string()),
field: vec![{
let mut f = make_field("options", 1, Label::LABEL_REPEATED, Type::TYPE_MESSAGE);
f.type_name = Some(".test.option_shadow.Picker.Option".to_string());
f
}],
nested_type: vec![option_msg],
..Default::default()
};
let mut file = proto3_file("option_shadow.proto");
file.package = Some("test.option_shadow".to_string());
file.message_type = vec![picker_msg];
let config = CodeGenConfig {
generate_views: false,
..Default::default()
};
let result = generate(&[file], &["option_shadow.proto".to_string()], &config);
let files = result.expect("nested Option message should not break codegen");
let content = &joined(&files);
assert!(
content.contains("pub struct Option"),
"nested Option struct must exist: {content}"
);
assert!(
!content.contains("pub value: Option<"),
"bare Option<> in struct field would shadow core::option::Option: {content}"
);
assert!(
content.contains("::core::option::Option<"),
"must use fully-qualified ::core::option::Option: {content}"
);
}
#[test]
fn test_top_level_message_named_option_qualifies_option() {
let mut file = proto3_file("option_top.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![
DescriptorProto {
name: Some("Option".to_string()),
..Default::default()
},
DescriptorProto {
name: Some("Wrapper".to_string()),
field: vec![{
let mut f = make_field("tag", 1, Label::LABEL_OPTIONAL, Type::TYPE_STRING);
f.proto3_optional = Some(true);
f.oneof_index = Some(0);
f
}],
oneof_decl: vec![OneofDescriptorProto {
name: Some("_tag".to_string()),
..Default::default()
}],
..Default::default()
},
];
let config = CodeGenConfig {
generate_views: false,
..Default::default()
};
let result = generate(&[file], &["option_top.proto".to_string()], &config);
let files = result.expect("top-level Option should not break codegen");
let content = &joined(&files);
assert!(
content.contains("::core::option::Option<"),
"must use fully-qualified ::core::option::Option for optional field: {content}"
);
assert!(
!content.contains("pub tag: Option<"),
"bare Option<> on Wrapper field would shadow core::option::Option: {content}"
);
}
#[test]
fn test_nested_option_blocked_propagates_through_sibling_subtree() {
let inner_msg = DescriptorProto {
name: Some("Inner".to_string()),
field: vec![{
let mut f = make_field("x", 1, Label::LABEL_OPTIONAL, Type::TYPE_INT32);
f.proto3_optional = Some(true);
f.oneof_index = Some(0);
f
}],
oneof_decl: vec![OneofDescriptorProto {
name: Some("_x".to_string()),
..Default::default()
}],
..Default::default()
};
let middle_msg = DescriptorProto {
name: Some("Middle".to_string()),
field: vec![{
let mut f = make_field("note", 1, Label::LABEL_OPTIONAL, Type::TYPE_STRING);
f.proto3_optional = Some(true);
f.oneof_index = Some(0);
f
}],
oneof_decl: vec![OneofDescriptorProto {
name: Some("_note".to_string()),
..Default::default()
}],
nested_type: vec![inner_msg],
..Default::default()
};
let outer_msg = DescriptorProto {
name: Some("Outer".to_string()),
nested_type: vec![
DescriptorProto {
name: Some("Option".to_string()),
..Default::default()
},
middle_msg,
],
..Default::default()
};
let mut file = proto3_file("option_deep.proto");
file.package = Some("pkg".to_string());
file.message_type = vec![outer_msg];
let config = CodeGenConfig {
generate_views: false,
..Default::default()
};
let files = generate(&[file], &["option_deep.proto".to_string()], &config)
.expect("nested Option sibling should not break codegen");
let content = &joined(&files);
assert!(
!content.contains("pub note: Option<"),
"Middle.note must qualify Option (sibling collision): {content}"
);
assert!(
!content.contains("pub x: Option<"),
"Inner.x must qualify Option (inherited via use super::*): {content}"
);
}
#[test]
fn test_cross_file_message_named_option_shadows_prelude() {
let mut file_a = proto3_file("message.proto");
file_a.package = Some("pkg".to_string());
file_a.message_type = vec![DescriptorProto {
name: Some("Option".to_string()),
field: vec![make_field(
"text",
1,
Label::LABEL_OPTIONAL,
Type::TYPE_STRING,
)],
..Default::default()
}];
let mut file_b = proto3_file("session.proto");
file_b.package = Some("pkg".to_string());
file_b.message_type = vec![DescriptorProto {
name: Some("Wrapper".to_string()),
field: vec![{
let mut f = make_field("a", 1, Label::LABEL_OPTIONAL, Type::TYPE_STRING);
f.oneof_index = Some(0);
f
}],
oneof_decl: vec![OneofDescriptorProto {
name: Some("kind".to_string()),
..Default::default()
}],
..Default::default()
}];
let config = CodeGenConfig {
generate_views: false,
..Default::default()
};
let files = generate(
&[file_a, file_b],
&["message.proto".to_string(), "session.proto".to_string()],
&config,
)
.expect("cross-file Option should not break codegen");
let session_owned = files
.iter()
.find(|f| f.name.starts_with("session") && f.kind == GeneratedFileKind::Owned)
.expect("session owned file must exist");
assert!(
!session_owned.content.contains("pub kind: Option<"),
"bare Option<> in session.rs would shadow file A's struct: {}",
session_owned.content,
);
assert!(
session_owned.content.contains("::core::option::Option<"),
"session.rs must use fully-qualified ::core::option::Option: {}",
session_owned.content,
);
}
#[test]
fn test_message_named_type_with_nested() {
let mut file = proto3_file("type_test.proto");
file.package = Some("google.api.expr.v1alpha1".to_string());
file.message_type.push(DescriptorProto {
name: Some("Type".to_string()),
field: vec![FieldDescriptorProto {
name: Some("primitive".to_string()),
number: Some(1),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_ENUM),
type_name: Some(".google.api.expr.v1alpha1.Type.PrimitiveType".to_string()),
..Default::default()
}],
nested_type: vec![],
enum_type: vec![EnumDescriptorProto {
name: Some("PrimitiveType".to_string()),
value: vec![
enum_value("PRIMITIVE_TYPE_UNSPECIFIED", 0),
enum_value("BOOL", 1),
],
..Default::default()
}],
..Default::default()
});
let config = CodeGenConfig {
generate_views: false,
..Default::default()
};
let result = generate(&[file], &["type_test.proto".to_string()], &config);
let files = result.expect("message named Type should generate valid code");
let content = &joined(&files);
assert!(
content.contains("pub struct Type"),
"missing struct Type: {content}"
);
assert!(
content.contains("pub mod r#type"),
"missing r#type module: {content}"
);
}
#[test]
fn test_keyword_field_debug_label_drops_raw_prefix() {
let mut file = proto3_file("keyword_field.proto");
file.package = Some("pkg".to_string());
file.message_type.push(DescriptorProto {
name: Some("Item".to_string()),
field: vec![FieldDescriptorProto {
name: Some("type".to_string()),
number: Some(1),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_STRING),
..Default::default()
}],
..Default::default()
});
let files = generate(
&[file],
&["keyword_field.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("keyword-named field should generate");
let content: String = joined(&files)
.chars()
.filter(|c| !c.is_whitespace())
.collect();
assert!(
content.contains(r#".field("type",&self.r#type)"#),
"Debug label must drop the r# prefix: {content}"
);
assert!(
!content.contains(r#".field("r#type""#),
"raw-ident prefix must not appear in Debug labels: {content}"
);
}
#[test]
fn test_message_with_oneof_field_named_type() {
let mut file = proto3_file("checked.proto");
file.package = Some("google.api.expr.v1alpha1".to_string());
file.message_type.push(DescriptorProto {
name: Some("Type".to_string()),
field: vec![
FieldDescriptorProto {
name: Some("message_type".to_string()),
number: Some(9),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_STRING),
oneof_index: Some(0),
..Default::default()
},
FieldDescriptorProto {
name: Some("type".to_string()),
number: Some(11),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_MESSAGE),
type_name: Some(".google.api.expr.v1alpha1.Type".to_string()),
oneof_index: Some(0),
..Default::default()
},
],
oneof_decl: vec![OneofDescriptorProto {
name: Some("type_kind".to_string()),
..Default::default()
}],
..Default::default()
});
let config = CodeGenConfig {
generate_views: false,
..Default::default()
};
let result = generate(&[file], &["checked.proto".to_string()], &config);
let files = result.expect("Type message with oneof 'type' field should generate");
let content = &joined(&files);
assert!(
content.contains("pub struct Type"),
"missing struct Type: {content}"
);
}
#[test]
fn test_oneof_variant_named_self_escapes_to_self_underscore() {
let mut file = proto3_file("self_variant.proto");
file.package = Some("pkg".to_string());
file.message_type.push(DescriptorProto {
name: Some("Identity".to_string()),
field: vec![
FieldDescriptorProto {
name: Some("self".to_string()),
number: Some(1),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_BOOL),
oneof_index: Some(0),
..Default::default()
},
FieldDescriptorProto {
name: Some("manager".to_string()),
number: Some(2),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_STRING),
oneof_index: Some(0),
..Default::default()
},
],
oneof_decl: vec![OneofDescriptorProto {
name: Some("identity".to_string()),
..Default::default()
}],
..Default::default()
});
let files = generate(
&[file],
&["self_variant.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("oneof with `self` variant must compile");
let content = &joined(&files);
assert!(
content.contains("Self_(bool)"),
"expected `Self_(bool)` variant; got:\n{content}"
);
assert!(
content.contains("Manager(::buffa::alloc::string::String)"),
"non-keyword variant must remain unrenamed; got:\n{content}"
);
assert!(
!content.contains(" Self("),
"raw `Self(` survived in generated code:\n{content}"
);
}
#[test]
fn test_oneof_named_self_escapes_its_enum_to_self_underscore() {
let mut file = proto3_file("self_oneof.proto");
file.package = Some("pkg".to_string());
file.message_type.push(DescriptorProto {
name: Some("Identity".to_string()),
field: vec![
FieldDescriptorProto {
name: Some("anonymous".to_string()),
number: Some(1),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_BOOL),
oneof_index: Some(0),
..Default::default()
},
FieldDescriptorProto {
name: Some("manager".to_string()),
number: Some(2),
label: Some(Label::LABEL_OPTIONAL),
r#type: Some(Type::TYPE_STRING),
oneof_index: Some(0),
..Default::default()
},
],
oneof_decl: vec![OneofDescriptorProto {
name: Some("self_".to_string()),
..Default::default()
}],
..Default::default()
});
let files = generate(
&[file],
&["self_oneof.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("oneof named `self_` must generate");
let content = &joined(&files);
assert!(
content.contains("pub enum Self_"),
"expected the oneof enum to be escaped to `Self_`; got:\n{content}"
);
assert!(
!content.contains("pub enum Self {"),
"raw `pub enum Self` survived in generated code:\n{content}"
);
assert!(
content.contains("Manager(::buffa::alloc::string::String)"),
"the oneof's variants must be unaffected; got:\n{content}"
);
}
fn oneof_name_file(names: &[&str], synthetic_index: Option<usize>) -> FileDescriptorProto {
let mut file = proto3_file("oneof_names.proto");
file.package = Some("my.pkg".to_string());
file.message_type.push(DescriptorProto {
name: Some("Msg".to_string()),
field: names
.iter()
.enumerate()
.map(|(index, _)| {
let mut field = make_field(
&format!("choice_{index}"),
index as i32 + 1,
Label::LABEL_OPTIONAL,
Type::TYPE_STRING,
);
field.oneof_index = Some(index as i32);
if synthetic_index == Some(index) {
field.proto3_optional = Some(true);
}
field
})
.collect(),
oneof_decl: names
.iter()
.map(|name| OneofDescriptorProto {
name: Some((*name).to_string()),
..Default::default()
})
.collect(),
..Default::default()
});
file
}
#[track_caller]
fn assert_oneof_name_conflict(first: &str, second: &str, rust_name: &str) {
assert_oneof_name_conflict_in_file(
oneof_name_file(&[first, second], None),
"my.pkg.Msg",
first,
second,
rust_name,
&CodeGenConfig::default(),
);
}
#[track_caller]
fn assert_oneof_name_conflict_in_file(
file: FileDescriptorProto,
message_name: &str,
first: &str,
second: &str,
rust_name: &str,
config: &CodeGenConfig,
) {
let err = generate(&[file], &["oneof_names.proto".to_string()], config)
.expect_err("colliding sibling oneof names must be rejected");
let CodeGenError::OneofEnumNameConflict {
message_name: got_message,
first_oneof,
second_oneof,
rust_name: got_rust_name,
} = &err
else {
panic!("expected OneofEnumNameConflict, got: {err}");
};
assert_eq!(
(
got_message.as_str(),
first_oneof.as_str(),
second_oneof.as_str(),
got_rust_name.as_str()
),
(message_name, first, second, rust_name)
);
}
#[test]
fn test_sibling_oneofs_with_same_pascal_case_are_rejected() {
assert_oneof_name_conflict("foo_bar", "foo__bar", "FooBar");
}
#[test]
fn test_oneof_name_conflict_message_names_both_oneofs_and_the_remedy() {
let err = generate(
&[oneof_name_file(&["foo_bar", "foo__bar"], None)],
&["oneof_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("colliding sibling oneof names must be rejected");
assert_eq!(
err.to_string(),
"oneof enum name conflict in message 'my.pkg.Msg': oneofs 'foo_bar' and 'foo__bar' \
both map to Rust enum 'FooBar'; rename one of them"
);
}
#[test]
fn test_sibling_oneofs_with_same_keyword_escaped_name_are_rejected() {
assert_oneof_name_conflict("self", "self_", "Self_");
}
#[test]
fn test_sibling_oneofs_with_different_names_are_accepted() {
let files = generate(
&[oneof_name_file(&["first", "second"], None)],
&["oneof_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("distinct sibling oneof names must generate");
let content = joined(&files);
assert!(content.contains("pub enum First"), "{content}");
assert!(content.contains("pub enum Second"), "{content}");
}
#[test]
fn test_nested_oneof_conflict_reports_full_name_without_views() {
let mut file = oneof_name_file(&["foo_bar", "foo__bar"], None);
let inner = file.message_type.pop().expect("inner message");
file.message_type.push(DescriptorProto {
name: Some("Outer".to_string()),
nested_type: vec![inner],
..Default::default()
});
let config = CodeGenConfig {
generate_views: false,
..Default::default()
};
assert_oneof_name_conflict_in_file(
file,
"my.pkg.Outer.Msg",
"foo_bar",
"foo__bar",
"FooBar",
&config,
);
}
#[test]
fn test_synthetic_oneof_name_collision_is_ignored() {
let files = generate(
&[oneof_name_file(&["foo_bar", "foo__bar"], Some(1))],
&["oneof_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("synthetic proto3 optional oneofs do not emit enums");
assert_eq!(joined(&files).matches("pub enum FooBar {").count(), 1);
}
fn type_name_file(messages: &[&str], enums: &[&str]) -> FileDescriptorProto {
let mut file = proto3_file("type_names.proto");
file.package = Some("my.pkg".to_string());
let mut holder = DescriptorProto {
name: Some("Holder".to_string()),
..Default::default()
};
for name in messages {
file.message_type.push(DescriptorProto {
name: Some((*name).to_string()),
..Default::default()
});
}
for name in enums {
file.enum_type.push(EnumDescriptorProto {
name: Some((*name).to_string()),
value: vec![enum_value("UNSPECIFIED", 0)],
..Default::default()
});
}
let kinds = messages
.iter()
.map(|name| (name, Type::TYPE_MESSAGE))
.chain(enums.iter().map(|name| (name, Type::TYPE_ENUM)));
for (number, (name, ty)) in (1..).zip(kinds) {
let mut field = make_field(&format!("f{number}"), number, Label::LABEL_OPTIONAL, ty);
field.type_name = Some(format!(".my.pkg.{name}"));
holder.field.push(field);
}
file.message_type.push(holder);
file
}
#[test]
fn test_primitive_type_names_get_a_trailing_underscore() {
let files = generate(
&[type_name_file(&["bool", "str", "usize"], &["u32", "f64"])],
&["type_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("primitive-named types generate");
let content = joined(&files);
for decl in [
"pub struct bool_ {",
"pub struct str_ {",
"pub struct usize_ {",
"pub enum u32_ {",
"pub enum f64_ {",
] {
assert!(content.contains(decl), "missing `{decl}`: {content}");
}
assert!(
content.contains("pub f1: ::buffa::MessageField<bool_"),
"{content}"
);
assert!(
content.contains("pub f4: ::buffa::EnumValue<u32_>"),
"{content}"
);
assert!(!content.contains("pub struct bool {"), "{content}");
}
#[test]
fn test_keyword_type_names_get_a_trailing_underscore() {
let files = generate(
&[type_name_file(
&["Self", "super", "type", "match"],
&["crate", "async"],
)],
&["type_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("keyword-named types generate");
let content = joined(&files);
for decl in [
"pub struct Self_ {",
"pub struct super_ {",
"pub struct type_ {",
"pub struct match_ {",
"pub enum crate_ {",
"pub enum async_ {",
] {
assert!(content.contains(decl), "missing `{decl}`: {content}");
}
assert!(
content.contains("pub f3: ::buffa::MessageField<type_"),
"{content}"
);
assert!(!content.contains("struct r#type"), "{content}");
}
#[test]
fn test_type_name_prefix_is_applied_before_the_escape() {
let config = CodeGenConfig {
type_name_prefix: "Pb".to_string(),
..Default::default()
};
let files = generate(
&[type_name_file(&["bool", "bool_"], &[])],
&["type_names.proto".to_string()],
&config,
)
.expect("prefixed names do not collide");
let content = joined(&files);
assert!(content.contains("pub struct Pbbool {"), "{content}");
assert!(content.contains("pub struct Pbbool_ {"), "{content}");
}
#[track_caller]
fn assert_type_name_conflict(file: FileDescriptorProto, expected: (&str, &str, &str, &str)) {
let err = generate(
&[file],
&["type_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("types that escape to one Rust name must be rejected");
let CodeGenError::TypeNameConflict {
scope,
first_type,
second_type,
rust_name,
} = &err
else {
panic!("expected TypeNameConflict, got: {err}");
};
assert_eq!(
(
scope.as_str(),
first_type.as_str(),
second_type.as_str(),
rust_name.as_str()
),
expected
);
}
#[test]
fn test_types_that_escape_to_one_name_are_rejected() {
assert_type_name_conflict(
type_name_file(&["bool", "bool_"], &[]),
("my.pkg", "bool", "bool_", "bool_"),
);
assert_type_name_conflict(
type_name_file(&["type", "type_"], &[]),
("my.pkg", "type", "type_", "type_"),
);
assert_type_name_conflict(
type_name_file(&["Self"], &["Self_"]),
("my.pkg", "Self", "Self_", "Self_"),
);
}
#[test]
fn test_nested_type_name_conflict_reports_the_enclosing_message() {
let mut file = type_name_file(&[], &[]);
let holder = &mut file.message_type[0];
for name in ["u8_", "u8"] {
holder.nested_type.push(DescriptorProto {
name: Some(name.to_string()),
..Default::default()
});
}
assert_type_name_conflict(file, ("my.pkg.Holder", "u8_", "u8", "u8_"));
}
#[test]
fn test_type_name_conflict_message_names_both_types_and_the_remedy() {
let err = generate(
&[type_name_file(&["bool", "bool_"], &[])],
&["type_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("types that escape to one Rust name must be rejected");
assert_eq!(
err.to_string(),
"type name conflict in 'my.pkg': 'bool' and 'bool_' both map to Rust type 'bool_'; \
rename one of them"
);
}
#[test]
fn test_unused_primitive_names_keep_their_spelling() {
let files = generate(
&[type_name_file(&["char", "u16", "isize"], &["i8"])],
&["type_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("these names generate as written");
let content = joined(&files);
for decl in [
"pub struct char {",
"pub struct u16 {",
"pub struct isize {",
"pub enum i8 {",
] {
assert!(content.contains(decl), "missing `{decl}`: {content}");
}
}
#[test]
fn test_type_name_conflict_spans_the_files_of_a_package() {
let mut first = type_name_file(&["bool"], &[]);
first.name = Some("a.proto".to_string());
first
.message_type
.retain(|m| m.name.as_deref() == Some("bool"));
let mut second = type_name_file(&["bool_"], &[]);
second.name = Some("b.proto".to_string());
second
.message_type
.retain(|m| m.name.as_deref() == Some("bool_"));
let err = generate(
&[first, second],
&["a.proto".to_string(), "b.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("two files of one package share its module");
assert!(
matches!(
&err,
CodeGenError::TypeNameConflict { scope, rust_name, .. }
if scope == "my.pkg" && rust_name == "bool_"
),
"{err}"
);
}
#[test]
fn test_escaped_and_similar_names_get_distinct_any_registry_constants() {
let config = CodeGenConfig {
generate_json: true,
generate_text: true,
..Default::default()
};
let files = generate(
&[type_name_file(&["bool", "Bool_"], &[])],
&["type_names.proto".to_string()],
&config,
)
.expect("`bool` and `Bool_` generate side by side");
let content = joined(&files);
for constant in [
"pub const __BOOL_JSON_ANY:",
"pub const __BOOL__JSON_ANY:",
"pub const __BOOL_TEXT_ANY:",
"pub const __BOOL__TEXT_ANY:",
] {
assert_eq!(
content.matches(constant).count(),
1,
"{constant}: {content}"
);
}
}
#[test]
fn test_missing_type_name_is_reported_before_a_type_name_conflict() {
let mut file = type_name_file(&[], &[]);
for _ in 0..2 {
file.message_type.push(DescriptorProto::default());
}
let err = generate(
&[file],
&["type_names.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("an unnamed message is rejected");
assert!(matches!(err, CodeGenError::MissingField(_)), "{err}");
}
fn oneof_member_file(members: &[&str]) -> FileDescriptorProto {
let mut file = proto3_file("oneof_members.proto");
file.package = Some("my.pkg".to_string());
file.message_type.push(DescriptorProto {
name: Some("Msg".to_string()),
field: members
.iter()
.enumerate()
.map(|(index, name)| {
let mut field = make_field(
name,
index as i32 + 1,
Label::LABEL_OPTIONAL,
Type::TYPE_STRING,
);
field.oneof_index = Some(0);
field
})
.collect(),
oneof_decl: vec![OneofDescriptorProto {
name: Some("kind".to_string()),
..Default::default()
}],
..Default::default()
});
file
}
#[track_caller]
fn assert_oneof_variant_conflict(first: &str, second: &str, rust_name: &str) {
assert_oneof_variant_conflict_in_file(
oneof_member_file(&[first, second]),
"my.pkg.Msg",
first,
second,
rust_name,
&CodeGenConfig::default(),
);
}
#[track_caller]
fn assert_oneof_variant_conflict_in_file(
file: FileDescriptorProto,
message_name: &str,
first: &str,
second: &str,
rust_name: &str,
config: &CodeGenConfig,
) {
let err = generate(&[file], &["oneof_members.proto".to_string()], config)
.expect_err("colliding oneof member names must be rejected");
let CodeGenError::OneofVariantNameConflict {
message_name: got_message,
oneof_name,
first_field,
second_field,
rust_name: got_rust_name,
} = &err
else {
panic!("expected OneofVariantNameConflict, got: {err}");
};
assert_eq!(
(
got_message.as_str(),
oneof_name.as_str(),
first_field.as_str(),
second_field.as_str(),
got_rust_name.as_str()
),
(message_name, "kind", first, second, rust_name)
);
}
#[test]
fn test_oneof_members_with_same_pascal_case_are_rejected() {
assert_oneof_variant_conflict("foo", "foo_", "Foo");
assert_oneof_variant_conflict("foo_bar", "foo__bar", "FooBar");
}
#[test]
fn test_oneof_members_with_same_keyword_escaped_name_are_rejected() {
assert_oneof_variant_conflict("self", "self_", "Self_");
}
#[test]
fn test_oneof_variant_conflict_message_names_the_oneof_both_members_and_the_remedy() {
let err = generate(
&[oneof_member_file(&["foo", "foo_"])],
&["oneof_members.proto".to_string()],
&CodeGenConfig::default(),
)
.expect_err("colliding oneof member names must be rejected");
assert_eq!(
err.to_string(),
"oneof variant name conflict in message 'my.pkg.Msg': members 'foo' and 'foo_' of \
oneof 'kind' both map to Rust variant 'Foo'; rename one of them"
);
}
#[test]
fn test_oneof_variant_conflict_reports_the_first_two_colliding_members() {
assert_oneof_variant_conflict_in_file(
oneof_member_file(&["foo", "bar", "foo_"]),
"my.pkg.Msg",
"foo",
"foo_",
"Foo",
&CodeGenConfig::default(),
);
}
#[test]
fn test_nested_oneof_variant_conflict_reports_full_name_without_views() {
let mut file = oneof_member_file(&["foo", "foo_"]);
let inner = file.message_type.pop().expect("inner message");
file.message_type.push(DescriptorProto {
name: Some("Outer".to_string()),
nested_type: vec![inner],
..Default::default()
});
let config = CodeGenConfig {
generate_views: false,
..Default::default()
};
assert_oneof_variant_conflict_in_file(file, "my.pkg.Outer.Msg", "foo", "foo_", "Foo", &config);
}
#[test]
fn test_oneof_members_with_different_names_are_accepted() {
let files = generate(
&[oneof_member_file(&["foo", "foo_bar", "self"])],
&["oneof_members.proto".to_string()],
&CodeGenConfig::default(),
)
.expect("distinct oneof member names must generate");
let content = joined(&files);
assert!(content.contains("pub enum Kind"), "{content}");
assert!(content.contains("Foo("), "{content}");
assert!(content.contains("FooBar("), "{content}");
assert!(content.contains("Self_("), "{content}");
}