martin-g commented on code in PR #2505:
URL: https://github.com/apache/avro/pull/2505#discussion_r1332550531
##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
Ok(())
}
+
+ #[test]
+ fn test_avro_3862_get_aliases() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "aliases": ["r1", "ns2.r2"],
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
Review Comment:
```suggestion
Some(aliases) => assert_eq!(aliases, &expected),
```
##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
Ok(())
}
+
+ #[test]
+ fn test_avro_3862_get_aliases() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "aliases": ["r1", "ns2.r2"],
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Enum
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "aliases": ["en1", "ns2.en2"],
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Fixed
+ let schema_str = r#"
+ {
+ "name": "fixed1",
+ "namespace": "ns1",
+ "type": "fixed",
+ "aliases": ["fx1", "ns2.fx2"],
+ "size": 10
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.fx1")?, Alias::new("ns2.fx2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "fixed1",
+ "namespace": "ns1",
+ "type": "fixed",
+ "size": 10
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for non-named type
+ let schema = Schema::Int;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ Ok(())
+ }
+
+ #[test]
+ fn test_avro_3862_get_doc() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "type": "record",
+ "doc": "Record Document",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = "Record Document";
+ match schema.doc() {
+ Some(s) => assert_eq!(s, expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "type": "record",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.doc() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Enum
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "type": "enum",
+ "doc": "Enum Document",
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = "Enum Document";
+ match schema.doc() {
+ Some(s) => assert_eq!(s, expected),
Review Comment:
```suggestion
Some(aliases) => assert_eq!(aliases, expected),
```
##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
Ok(())
}
+
+ #[test]
+ fn test_avro_3862_get_aliases() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "aliases": ["r1", "ns2.r2"],
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Enum
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "aliases": ["en1", "ns2.en2"],
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Fixed
+ let schema_str = r#"
+ {
+ "name": "fixed1",
+ "namespace": "ns1",
+ "type": "fixed",
+ "aliases": ["fx1", "ns2.fx2"],
+ "size": 10
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.fx1")?, Alias::new("ns2.fx2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "fixed1",
+ "namespace": "ns1",
+ "type": "fixed",
+ "size": 10
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for non-named type
+ let schema = Schema::Int;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ Ok(())
+ }
+
+ #[test]
+ fn test_avro_3862_get_doc() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "type": "record",
+ "doc": "Record Document",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = "Record Document";
+ match schema.doc() {
+ Some(s) => assert_eq!(s, expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "type": "record",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.doc() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Enum
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "type": "enum",
+ "doc": "Enum Document",
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = "Enum Document";
+ match schema.doc() {
+ Some(s) => assert_eq!(s, expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "type": "enum",
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.doc() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Fixed
+ let schema_str = r#"
+ {
+ "name": "fixed1",
+ "type": "fixed",
+ "doc": "Fixed Document",
+ "size": 10
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = "Fixed Document";
+ match schema.doc() {
+ Some(s) => assert_eq!(s, expected),
Review Comment:
```suggestion
Some(aliases) => assert_eq!(aliases, expected),
```
##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
Ok(())
}
+
+ #[test]
+ fn test_avro_3862_get_aliases() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "aliases": ["r1", "ns2.r2"],
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Enum
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "aliases": ["en1", "ns2.en2"],
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Fixed
+ let schema_str = r#"
+ {
+ "name": "fixed1",
+ "namespace": "ns1",
+ "type": "fixed",
+ "aliases": ["fx1", "ns2.fx2"],
+ "size": 10
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.fx1")?, Alias::new("ns2.fx2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
Review Comment:
```suggestion
Some(aliases) => assert_eq!(aliases, &expected),
```
##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
Ok(())
}
+
+ #[test]
+ fn test_avro_3862_get_aliases() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "aliases": ["r1", "ns2.r2"],
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Enum
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "aliases": ["en1", "ns2.en2"],
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Fixed
+ let schema_str = r#"
+ {
+ "name": "fixed1",
+ "namespace": "ns1",
+ "type": "fixed",
+ "aliases": ["fx1", "ns2.fx2"],
+ "size": 10
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.fx1")?, Alias::new("ns2.fx2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "fixed1",
+ "namespace": "ns1",
+ "type": "fixed",
+ "size": 10
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for non-named type
+ let schema = Schema::Int;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ Ok(())
+ }
+
+ #[test]
+ fn test_avro_3862_get_doc() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "type": "record",
+ "doc": "Record Document",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = "Record Document";
+ match schema.doc() {
+ Some(s) => assert_eq!(s, expected),
Review Comment:
```suggestion
Some(aliases) => assert_eq!(aliases, expected),
```
##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
Ok(())
}
+
+ #[test]
+ fn test_avro_3862_get_aliases() -> TestResult {
+ // Test for Record
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "aliases": ["r1", "ns2.r2"],
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
+ None => panic!("Expected Some({:?}), got None", expected),
+ }
+
+ let schema_str = r#"
+ {
+ "name": "record1",
+ "namespace": "ns1",
+ "type": "record",
+ "fields": [
+ { "name": "f1", "type": "int" },
+ { "name": "f2", "type": "string" }
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ match schema.aliases() {
+ None => (),
+ some => panic!("Expected None, got {some:?}"),
+ }
+
+ // Test for Enum
+ let schema_str = r#"
+ {
+ "name": "enum1",
+ "namespace": "ns1",
+ "type": "enum",
+ "aliases": ["en1", "ns2.en2"],
+ "symbols": ["a", "b", "c"]
+ }
+ "#;
+ let schema = Schema::parse_str(schema_str)?;
+ let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+ match schema.aliases() {
+ Some(s) => assert_eq!(s, &expected),
Review Comment:
```suggestion
Some(aliases) => assert_eq!(aliases, &expected),
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
