Add tests for serializing/deserializing the different error messages

Author: gabotechs

src/errors/arrow_error.rs

@@ -176,3 +176,69 @@ impl ArrowErrorProto {
         (err, self.ctx.clone())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::{Error as IoError, ErrorKind};
+
+    #[test]
+    fn test_arrow_error_roundtrip() {
+        let test_cases = vec![
+            ArrowError::NotYetImplemented("test not implemented".to_string()),
+            ArrowError::ExternalError(Box::new(std::io::Error::new(
+                ErrorKind::Other,
+                "external error",
+            ))),
+            ArrowError::CastError("cast error".to_string()),
+            ArrowError::MemoryError("memory error".to_string()),
+            ArrowError::ParseError("parse error".to_string()),
+            ArrowError::SchemaError("schema error".to_string()),
+            ArrowError::ComputeError("compute error".to_string()),
+            ArrowError::DivideByZero,
+            ArrowError::ArithmeticOverflow("overflow".to_string()),
+            ArrowError::CsvError("csv error".to_string()),
+            ArrowError::JsonError("json error".to_string()),
+            ArrowError::IoError(
+                "io message".to_string(),
+                IoError::new(ErrorKind::NotFound, "file not found"),
+            ),
+            ArrowError::IpcError("ipc error".to_string()),
+            ArrowError::InvalidArgumentError("invalid arg".to_string()),
+            ArrowError::ParquetError("parquet error".to_string()),
+            ArrowError::CDataInterface("cdata error".to_string()),
+            ArrowError::DictionaryKeyOverflowError,
+            ArrowError::RunEndIndexOverflowError,
+        ];
+
+        for original_error in test_cases {
+            let proto = ArrowErrorProto::from_arrow_error(
+                &original_error,
+                Some(&"test context".to_string()),
+            );
+            let (recovered_error, recovered_ctx) = proto.to_arrow_error();
+
+            assert_eq!(original_error.to_string(), recovered_error.to_string());
+            assert_eq!(recovered_ctx, Some("test context".to_string()));
+
+            let proto_no_ctx = ArrowErrorProto::from_arrow_error(&original_error, None);
+            let (recovered_error_no_ctx, recovered_ctx_no_ctx) = proto_no_ctx.to_arrow_error();
+
+            assert_eq!(
+                original_error.to_string(),
+                recovered_error_no_ctx.to_string()
+            );
+            assert_eq!(recovered_ctx_no_ctx, None);
+        }
+    }
+
+    #[test]
+    fn test_malformed_protobuf_message() {
+        let malformed_proto = ArrowErrorProto {
+            inner: None,
+            ctx: None,
+        };
+        let (recovered_error, _) = malformed_proto.to_arrow_error();
+        assert!(matches!(recovered_error, ArrowError::ExternalError(_)));
+    }
+}

src/errors/datafusion_error.rs

@@ -265,3 +265,134 @@ impl std::fmt::Display for DistributedDataFusionGenericError {
 }
 
 impl Error for DistributedDataFusionGenericError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use datafusion::arrow::error::ArrowError;
+    use datafusion::common::{DataFusionError, SchemaError};
+    use datafusion::logical_expr::sqlparser::parser::ParserError;
+    use datafusion::parquet::errors::ParquetError;
+    use object_store::Error as ObjectStoreError;
+    use std::io::{Error as IoError, ErrorKind};
+    use std::sync::Arc;
+
+    #[test]
+    fn test_datafusion_error_roundtrip() {
+        let test_cases = vec![
+            DataFusionError::ArrowError(
+                ArrowError::ComputeError("compute".to_string()),
+                Some("arrow context".to_string()),
+            ),
+            DataFusionError::ParquetError(ParquetError::General("parquet error".to_string())),
+            DataFusionError::ObjectStore(ObjectStoreError::NotFound {
+                path: "test/path".to_string(),
+                source: Box::new(std::io::Error::new(ErrorKind::NotFound, "not found")),
+            }),
+            DataFusionError::IoError(IoError::new(
+                ErrorKind::PermissionDenied,
+                "permission denied",
+            )),
+            DataFusionError::SQL(
+                ParserError::ParserError("sql parse error".to_string()),
+                Some("sql backtrace".to_string()),
+            ),
+            DataFusionError::NotImplemented("not implemented".to_string()),
+            DataFusionError::Internal("internal error".to_string()),
+            DataFusionError::Plan("plan error".to_string()),
+            DataFusionError::Configuration("config error".to_string()),
+            DataFusionError::SchemaError(
+                SchemaError::AmbiguousReference {
+                    field: datafusion::common::Column::new_unqualified("test_field"),
+                },
+                Box::new(None),
+            ),
+            DataFusionError::Execution("execution error".to_string()),
+            DataFusionError::ResourcesExhausted("resources exhausted".to_string()),
+            DataFusionError::External(Box::new(std::io::Error::new(ErrorKind::Other, "external"))),
+            DataFusionError::Context(
+                "context message".to_string(),
+                Box::new(DataFusionError::Internal("nested".to_string())),
+            ),
+            DataFusionError::Substrait("substrait error".to_string()),
+            DataFusionError::Collection(vec![
+                DataFusionError::Internal("error 1".to_string()),
+                DataFusionError::Internal("error 2".to_string()),
+            ]),
+            DataFusionError::Shared(Arc::new(DataFusionError::Internal(
+                "shared error".to_string(),
+            ))),
+        ];
+
+        for original_error in test_cases {
+            let proto = DataFusionErrorProto::from_datafusion_error(&original_error);
+            let recovered_error = proto.to_datafusion_err();
+
+            assert_eq!(original_error.to_string(), recovered_error.to_string());
+        }
+    }
+
+    #[test]
+    fn test_malformed_protobuf_message() {
+        let malformed_proto = DataFusionErrorProto { inner: None };
+        let recovered_error = malformed_proto.to_datafusion_err();
+        assert!(matches!(recovered_error, DataFusionError::Internal(_)));
+    }
+
+    #[test]
+    fn test_nested_datafusion_errors() {
+        let nested_error = DataFusionError::Context(
+            "outer context".to_string(),
+            Box::new(DataFusionError::Context(
+                "inner context".to_string(),
+                Box::new(DataFusionError::Internal("deepest error".to_string())),
+            )),
+        );
+
+        let proto = DataFusionErrorProto::from_datafusion_error(&nested_error);
+        let recovered_error = proto.to_datafusion_err();
+
+        assert_eq!(nested_error.to_string(), recovered_error.to_string());
+    }
+
+    #[test]
+    fn test_collection_errors() {
+        let collection_error = DataFusionError::Collection(vec![
+            DataFusionError::Internal("error 1".to_string()),
+            DataFusionError::Plan("error 2".to_string()),
+            DataFusionError::Execution("error 3".to_string()),
+        ]);
+
+        let proto = DataFusionErrorProto::from_datafusion_error(&collection_error);
+        let recovered_error = proto.to_datafusion_err();
+
+        assert_eq!(collection_error.to_string(), recovered_error.to_string());
+    }
+
+    #[test]
+    fn test_sql_error_with_backtrace() {
+        let sql_error = DataFusionError::SQL(
+            ParserError::ParserError("syntax error".to_string()),
+            Some("test backtrace".to_string()),
+        );
+
+        let proto = DataFusionErrorProto::from_datafusion_error(&sql_error);
+        let recovered_error = proto.to_datafusion_err();
+
+        if let DataFusionError::SQL(_, backtrace) = recovered_error {
+            assert_eq!(backtrace, Some("test backtrace".to_string()));
+        } else {
+            panic!("Expected SQL error");
+        }
+    }
+
+    #[test]
+    fn test_distributed_generic_error() {
+        let generic_error = DistributedDataFusionGenericError {
+            message: "test message".to_string(),
+        };
+
+        assert_eq!(generic_error.to_string(), "test message");
+        assert!(Error::source(&generic_error).is_none());
+    }
+}

src/errors/io_error.rs

@@ -107,3 +107,69 @@ impl IoErrorProto {
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use prost::Message;
+    use std::io::{Error as IoError, ErrorKind};
+
+    #[test]
+    fn test_io_error_roundtrip() {
+        let test_cases = vec![
+            (ErrorKind::NotFound, "file not found"),
+            (ErrorKind::PermissionDenied, "permission denied"),
+            (ErrorKind::ConnectionRefused, "connection refused"),
+            (ErrorKind::ConnectionReset, "connection reset"),
+            (ErrorKind::ConnectionAborted, "connection aborted"),
+            (ErrorKind::NotConnected, "not connected"),
+            (ErrorKind::AddrInUse, "address in use"),
+            (ErrorKind::AddrNotAvailable, "address not available"),
+            (ErrorKind::BrokenPipe, "broken pipe"),
+            (ErrorKind::AlreadyExists, "already exists"),
+            (ErrorKind::WouldBlock, "would block"),
+            (ErrorKind::InvalidInput, "invalid input"),
+            (ErrorKind::InvalidData, "invalid data"),
+            (ErrorKind::TimedOut, "timed out"),
+            (ErrorKind::WriteZero, "write zero"),
+            (ErrorKind::Interrupted, "interrupted"),
+            (ErrorKind::UnexpectedEof, "unexpected eof"),
+            (ErrorKind::Other, "other error"),
+        ];
+
+        for (kind, msg) in test_cases {
+            let original_error = IoError::new(kind, msg);
+            let proto = IoErrorProto::from_io_error("test message", &original_error);
+            let (recovered_error, recovered_message) = proto.to_io_error();
+
+            assert_eq!(original_error.kind(), recovered_error.kind());
+            assert_eq!(original_error.to_string(), recovered_error.to_string());
+            assert_eq!(recovered_message, "test message");
+        }
+    }
+
+    #[test]
+    fn test_protobuf_serialization() {
+        let original_error = IoError::new(ErrorKind::NotFound, "file not found");
+        let proto = IoErrorProto::from_io_error("test message", &original_error);
+        let proto = IoErrorProto::decode(proto.encode_to_vec().as_ref()).unwrap();
+        let (recovered_error, recovered_message) = proto.to_io_error();
+
+        assert_eq!(original_error.kind(), recovered_error.kind());
+        assert_eq!(original_error.to_string(), recovered_error.to_string());
+        assert_eq!(recovered_message, "test message");
+    }
+
+    #[test]
+    fn test_unknown_error_kind() {
+        let proto = IoErrorProto {
+            msg: "test message".to_string(),
+            code: -1,
+            err: "unknown error".to_string(),
+        };
+        let (recovered_error, recovered_message) = proto.to_io_error();
+
+        assert_eq!(recovered_error.kind(), ErrorKind::Other);
+        assert_eq!(recovered_message, "test message");
+    }
+}

src/errors/objectstore_error.rs

@@ -250,3 +250,88 @@ fn parse_store(store: &str) -> &'static str {
         _ => "Unknown",
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use object_store::Error as ObjectStoreError;
+    use std::io::ErrorKind;
+
+    #[test]
+    fn test_object_store_error_roundtrip() {
+        let test_cases = vec![
+            // Use known store names that will be preserved
+            ObjectStoreError::Generic {
+                store: "S3",
+                source: Box::new(std::io::Error::new(ErrorKind::Other, "generic error")),
+            },
+            ObjectStoreError::NotFound {
+                path: "test/path".to_string(),
+                source: Box::new(std::io::Error::new(ErrorKind::NotFound, "not found")),
+            },
+            ObjectStoreError::AlreadyExists {
+                path: "existing/path".to_string(),
+                source: Box::new(std::io::Error::new(ErrorKind::AlreadyExists, "exists")),
+            },
+            ObjectStoreError::Precondition {
+                path: "precondition/path".to_string(),
+                source: Box::new(std::io::Error::new(ErrorKind::Other, "precondition failed")),
+            },
+            ObjectStoreError::NotSupported {
+                source: Box::new(std::io::Error::new(ErrorKind::Unsupported, "not supported")),
+            },
+            ObjectStoreError::NotModified {
+                path: "not/modified".to_string(),
+                source: Box::new(std::io::Error::new(ErrorKind::Other, "not modified")),
+            },
+            ObjectStoreError::NotImplemented,
+            ObjectStoreError::PermissionDenied {
+                path: "denied/path".to_string(),
+                source: Box::new(std::io::Error::new(
+                    ErrorKind::PermissionDenied,
+                    "permission denied",
+                )),
+            },
+            ObjectStoreError::Unauthenticated {
+                path: "auth/path".to_string(),
+                source: Box::new(std::io::Error::new(ErrorKind::Other, "unauthenticated")),
+            },
+            ObjectStoreError::UnknownConfigurationKey {
+                key: "unknown_key".to_string(),
+                store: "S3",
+            },
+        ];
+
+        for original_error in test_cases {
+            let proto = ObjectStoreErrorProto::from_object_store_error(&original_error);
+            let recovered_error = proto.to_object_store_error();
+
+            assert_eq!(original_error.to_string(), recovered_error.to_string());
+        }
+    }
+
+    #[test]
+    fn test_unknown_store_handling() {
+        // Test that unknown store names get mapped to "Unknown"
+        let original_error = ObjectStoreError::Generic {
+            store: "unknown_store",
+            source: Box::new(std::io::Error::new(ErrorKind::Other, "generic error")),
+        };
+        let proto = ObjectStoreErrorProto::from_object_store_error(&original_error);
+        let recovered_error = proto.to_object_store_error();
+
+        // The store name will be changed from "unknown_store" to "Unknown"
+        assert_eq!(
+            recovered_error.to_string(),
+            "Generic Unknown error: generic error"
+        );
+        assert_ne!(original_error.to_string(), recovered_error.to_string());
+    }
+
+    #[test]
+    fn test_malformed_protobuf_message() {
+        let malformed_proto = ObjectStoreErrorProto { inner: None };
+        let recovered_error = malformed_proto.to_object_store_error();
+        assert!(matches!(recovered_error, ObjectStoreError::Generic { .. }));
+    }
+}