How to assert io errors in Rust? - unit-testing

Question

There are plenty of tutorials showing how to write unit tests in Rust. I've read dozen and all of them focuses on asserting values in case of success. Situation doesn't seem so straight forward in case of an error. Errors do not implement PartialEq trait by default so you can't use assert_eq! macro. Also, some functions may return multiple variants of error depending on what kind of issue occurred (ex. io::Error which may be of different kind.) I could just check if error occurred or not but it doesn't seem enough.
Example below.
fn parse_data(input: i32) -> Result<i32, io::Error> {
match input {
0 => Ok(0),
_ => Err(io::Error::new(io::ErrorKind::InvalidData, "unexpected number"))
}
}
#[test]
fn test_parsing_wrong_data() {
let result = parse_data(1);
assert!(result.is_err());
let got = result.unwrap_err();
let want = io::Error::new(io::ErrorKind::InvalidData, "unexpected number");
// compilation error here: binary operation `==` cannot be applied to type `std::io::Error`
assert_eq!(want, got);
}
I assume this is not idiomatic approach, since it's not compiling. Hence the question - what is a proper and idiomatic approach in similar situation?

Answer 1

TL;DR: Error should implement PartialEq
Result<T, E> only implements PartialEq when T and E also implement PartialEq, but io::Error doesn't. alex confirm that cause io::Error takes an extra error that implements dyn Error, allowing the user to add extra information lead std to not implement PartialEq.
I see a lot of answer and comment that seem a lot of peoples use io::Error to create their own error. This is NOT a good practice, io::Error should be used only if you deal yourself with io. There is the Error Handling Project Group if you want to learn and share your view about error in Rust.
For now there is some common crate in Rust to make your own error (feel free to add crate):
snafu (my favorite)
thiserror
anyhow
quick-error
I don't totally agree but here a good guide about Error in Rust.
Anyway, the solution that you probably want in your case is just to compare the ErrorKind value. As ErrorKind implements PartialEq this will compile with assert_eq()
use std::io;
fn parse_data(input: i32) -> Result<i32, io::Error> {
match input {
0 => Ok(0),
x => Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("unexpected number {}", x),
)),
}
}
#[test]
fn test_parsing_wrong_data() {
let result = parse_data(1).map_err(|e| e.kind());
let expected = Err(io::ErrorKind::InvalidData);
assert_eq!(expected, result);
}

Answer 2

I solved it with this
assert!(matches!(result, Err(crate::Error::InvalidType(t)) if t == "foobar"));
This solution doesn't require PartialEq for the Error, but still allows me to compare with the variant contents.
If you don't care about the contents of the variant, then its just
assert!(matches!(result, Err(crate::Error::InvalidType(_))));

Answer 3

In my case I had several structs with differents fields, they all implement the std::error::Error trait. This worked for me in a cleaner way than making an instance of any struct I needed:
let result = parse_data(1);
let your_error = result.unwrap_err().downcast_ref::<MyCustomError>();
assert!(your_error.is_some());
That downcasts the error to a specific type, in case it's the correct type it's a Some(_) value, otherwise, it's None. However, I'm a newbie in Rust, it's probably that this is not the best way to solve your problem.

Answer 4

If you use the type Result,
there is a built in method is_err().
This means you can test with assert!(my_result.is_err());.

Answer 5

A macro using Genaritos answer.
macro_rules! is_error_type {
($result:ident,$err_type:ident) => {
$result.unwrap_err().downcast_ref::<$err_type>().is_some()
}
}
used like this:
let result = parse_data(1);
assert!(is_error_type(result, MyCustomError));