Abeeujah commented on code in PR #241:
URL: https://github.com/apache/sedona-db/pull/241#discussion_r2470572923
##########
c/sedona-geos/src/st_buffer.rs:
##########
@@ -163,4 +302,203 @@ mod tests {
let envelope_result =
envelope_tester.invoke_array(buffer_result).unwrap();
assert_array_equal(&envelope_result, &expected_envelope);
}
+
+ #[rstest]
+ fn udf_with_buffer_params(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)]
sedona_type: SedonaType) {
+ let udf = SedonaScalarUDF::from_kernel("st_buffer",
st_buffer_style_impl());
+ let tester = ScalarUdfTester::new(
+ udf.into(),
+ vec![
+ sedona_type.clone(),
+ SedonaType::Arrow(DataType::Float64),
+ SedonaType::Arrow(DataType::Utf8),
+ ],
+ );
+ tester.assert_return_type(WKB_GEOMETRY);
+
+ let envelope_udf = sedona_functions::st_envelope::st_envelope_udf();
+ let envelope_tester = ScalarUdfTester::new(envelope_udf.into(),
vec![WKB_GEOMETRY]);
+
+ let buffer_result_flat = tester
+ .invoke_scalar_scalar_scalar("LINESTRING (0 0, 10 0)", 2.0,
"endcap=flat".to_string())
+ .unwrap();
+ let envelope_result =
envelope_tester.invoke_scalar(buffer_result_flat).unwrap();
+ let expected_envelope = "POLYGON((0 -2, 0 2, 10 2, 10 -2, 0 -2))";
+ tester.assert_scalar_result_equals(envelope_result, expected_envelope);
+
+ let buffer_result_square = tester
+ .invoke_scalar_scalar_scalar("LINESTRING (0 0, 10 0)", 1.0,
"endcap=square".to_string())
+ .unwrap();
+ let envelope_result =
envelope_tester.invoke_scalar(buffer_result_square).unwrap();
+ let expected_envelope = "POLYGON((-1 -1, -1 1, 11 1, 11 -1, -1 -1))";
+ tester.assert_scalar_result_equals(envelope_result, expected_envelope);
+ }
+
+ #[rstest]
+ fn udf_with_quad_segs(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)]
sedona_type: SedonaType) {
+ let udf = SedonaScalarUDF::from_kernel("st_buffer",
st_buffer_style_impl());
+ let tester = ScalarUdfTester::new(
+ udf.into(),
+ vec![
+ sedona_type.clone(),
+ SedonaType::Arrow(DataType::Float64),
+ SedonaType::Arrow(DataType::Utf8),
+ ],
+ );
+ tester.assert_return_type(WKB_GEOMETRY);
+
+ let envelope_udf = sedona_functions::st_envelope::st_envelope_udf();
+ let envelope_tester = ScalarUdfTester::new(envelope_udf.into(),
vec![WKB_GEOMETRY]);
+ let input_wkt = "POINT (5 5)";
+ let buffer_dist = 3.0;
+
+ let buffer_result_default = tester
+ .invoke_scalar_scalar_scalar(input_wkt, buffer_dist,
"endcap=round".to_string())
+ .unwrap();
+ let envelope_result_default = envelope_tester
+ .invoke_scalar(buffer_result_default)
+ .unwrap();
+
+ let expected_envelope = "POLYGON((2 2, 2 8, 8 8, 8 2, 2 2))";
+ tester.assert_scalar_result_equals(envelope_result_default,
expected_envelope);
+
+ let buffer_result_low_segs = tester
+ .invoke_scalar_scalar_scalar(
+ input_wkt,
+ buffer_dist,
+ "quad_segs=1 endcap=round".to_string(),
+ )
+ .unwrap();
+ let envelope_result_low_segs = envelope_tester
+ .invoke_scalar(buffer_result_low_segs)
+ .unwrap();
+ tester.assert_scalar_result_equals(envelope_result_low_segs,
expected_envelope);
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_endcap() {
+ let err = parse_buffer_params(Some("endcap=invalid")).err().unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid endcap style: 'invalid'. Valid options: round, flat,
butt, square"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_join() {
+ let err = parse_buffer_params(Some("join=invalid")).err().unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid join style: 'invalid'. Valid options: round, mitre,
miter, bevel"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_side() {
+ let err = parse_buffer_params(Some("side=invalid")).err().unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid side: 'invalid'. Valid options: both, left, right"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_mitre_limit() {
+ let err = parse_buffer_params(Some("mitre_limit=not_a_number"))
+ .err()
+ .unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid mitre_limit value: 'not_a_number'. Expected a valid
number"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_miter_limit() {
+ let err = parse_buffer_params(Some("miter_limit=abc")).err().unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid mitre_limit value: 'abc'. Expected a valid number"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_quad_segs() {
+ let err = parse_buffer_params(Some("quad_segs=not_an_int"))
+ .err()
+ .unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid quadrant_segments value: 'not_an_int'. Expected a valid
number"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_quadrant_segments() {
+ let err = parse_buffer_params(Some("quadrant_segments=xyz"))
+ .err()
+ .unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid quadrant_segments value: 'xyz'. Expected a valid number"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_multiple_invalid_params() {
+ // Test that the first invalid parameter is caught
+ let err = parse_buffer_params(Some("endcap=wrong join=mitre"))
+ .err()
+ .unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid endcap style: 'wrong'. Valid options: round, flat, butt,
square"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_mixed_with_valid() {
+ // Test invalid parameter after valid ones
+ let err = parse_buffer_params(Some("endcap=round join=invalid"))
+ .err()
+ .unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid join style: 'invalid'. Valid options: round, mitre,
miter, bevel"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_invalid_param_name() {
+ let err = parse_buffer_params(Some("unknown_param=value"))
+ .err()
+ .unwrap();
+ assert_eq!(
+ err.message(),
+ "Invalid buffer parameter: unknown_param (accept: 'endcap',
'join', 'mitre_limit', 'miter_limit', 'quad_segs', 'quadrant_segments' and
'side')"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_missing_value() {
+ let err = parse_buffer_params(Some("endcap=round bare_param
join=mitre"))
+ .err()
+ .unwrap();
+ assert_eq!(
+ err.message(),
+ "Missing value for buffer parameter: bare_param"
+ );
+ }
+
+ #[test]
+ fn test_parse_buffer_params_duplicate_params_no_error() {
+ let result = parse_buffer_params(Some("endcap=round endcap=flat"));
+ assert!(result.is_ok());
+ }
+
+ #[test]
+ fn test_parse_buffer_params_quad_segs_out_of_range() {
+ let result = parse_buffer_params(Some("quad_segs=-5"));
+ assert!(result.is_ok());
+ }
Review Comment:
BufferParams don't expose getter methods, nor implement traits that makes
them easily testable, so I went ahead with testing behaviors instead of the
values
--
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]
