Comparing between two errors - ios

Question

In my app, I am throwing around errors by using the Error protocol. And there are many of these error types in my app such as AuthError, ApiError, etc. Not to mention the third-party frameworks's errors such as RxCocoaURLError, Twilio's NSError, etc. And then there is an enum to show/hide the error messages on the view:
enum ErrorMessageEvent {
case hide
case show(error: Error)
}
Now, in the unit test, I have a need to compare between two errors like so:
func testGetDataButtonTappedFailed_ShouldShowError() {
let error = ApiError(type: .serviceUnavailable, message: "ABC")
let viewModel = createViewModel(dataProvider: { _ in .error(error) })
var actualErrorMessageEvent: ErrorMessageEvent?
viewModel.errorMessageEvent
.emit(onNext: { actualErrorMessageEvent = $0 })
.disposed(by: disposeBag)
viewModel.getDataButtonTapped(id: 1)
XCTAssertEqual(.show(error: error), actualErrorMessageEvent)
}
Now when I added the Equatable to the ErrorMessageEvent and added this for the comparison func, but it always failed:
static func == (lhs: ErrorMessageEvent, rhs: ErrorMessageEvent) -> Bool {
switch (lhs, rhs) {
case (.hide, .hide): return true
case (.show(let lError), .show(let rError)):
return lError as AnyObject === rError as AnyObject
default: return false
}
}
What is the right way to compare those two errors and fix this? Thanks.

Answer 1

First, make sure that each kind of error that you are dealing with properly conforms to Equatable. Why are we using Equatable rather than ===? Because the error types value types. RxCocoaURLError is an enum for example. And === never works on structs, even if you cast to AnyObject, because two different objects will be created when you do. Example:
enum Foo {
case a(Int)
case b(String)
}
(Foo.a(1) as AnyObject) === (Foo.a(1) as AnyObject) // false
The next step is to make ErrorMessageEvent generic (kind of like Optional, or half of Result):
enum ErrorMessageEvent<Failure: Error> {
case hide
case show(error: Failure)
// this (tries to) changes the type of the error
func mapError<T: Error>(toType type: T.Type) -> ErrorMessageEvent<T>? {
switch self {
case .hide:
return .hide
case .show(error: let e):
return (e as? T).map(ErrorMessageEvent<T>.show)
}
}
}
// messages with an equatable error are also equatable
// the compiler will synthesise the implementation for us
extension ErrorMessageEvent : Equatable where Failure : Equatable {}
You can use ErrorMessageEvent<Error> for the type of observable for viewModel.errorMessageEvent. Then, when you want to compare errors in a test, you'd know which type of error you are comparing at that point, so you can do:
let error = ApiError(type: .serviceUnavailable, message: "ABC")
// ...
// I *think* it can infer the types. If not, write out the full "ErrorMessageEvent<ApiError>.show"
XCTAssertEqual(
.show(error: error),
actualErrorMessageEvent?.mapError(toType: ApiError.self))
At this point, you might have realised. This is just reinventing the wheel of Optional<T>. So rather than ErrorMessageEvent, you can also consider an using an optional. Your ErrorMessageEvent might be overengineering.
let error = ApiError(type: .serviceUnavailable, message: "ABC")
let viewModel = createViewModel(dataProvider: { _ in .error(error) })
var actualErrorMessage: ApiError?
// viewModel.errorMessageEvent would be an Observable<Error?>
viewModel.errorMessageEvent
.emit(onNext: { actualErrorMessage = $0 as? ApiError })
.disposed(by: disposeBag)
viewModel.getDataButtonTapped(id: 1)
XCTAssertEqual(error, actualErrorMessageEvent)
It doesn't have as descriptive names as show and hide (It uses none and some instead), so if that's what you care about, I can understand.

Answer 2

So, based on #Sweeper's answer, I came up with this custom assertion function instead:
func XCTAssertEqualGenericError<ErrorType: Equatable>(_ expected: ErrorType,
_ actual: Error?,
file: StaticString = #file,
line: UInt = #line) throws {
let actualError = try XCTUnwrap(actual as? ErrorType, file: file, line: line)
XCTAssertEqual(expected, actualError, file: file, line: line)
}
And use it in this two assertions:
func XCTAssertErrorMessageEventHide(_ actual: ErrorMessageEvent?,
file: StaticString = #file, line: UInt = #line) {
guard let actual = actual else {
XCTFail("Actual ErrorMessageEvent is nil!")
return
}
switch actual {
case .show: XCTFail("Actual ErrorMessageEvent is not of the type .hide!")
case .hide: return
}
}
func XCTAssertErrorMessageEventShow<ErrorType: Equatable>(_ expected: ErrorMessageEvent,
_ actual: ErrorMessageEvent?,
errorType: ErrorType.Type,
file: StaticString = #file,
line: UInt = #line) throws {
guard let actual = actual else {
XCTFail("Actual ErrorMessageEvent is nil!")
return
}
switch (expected, actual) {
case (.hide, _):
XCTFail("Expected ErrorMessageEvent is not of the type .show(_, _)!")
case (_, .hide):
XCTFail("Actual ErrorMessageEvent is not of the type .show(_, _)!")
case (.show(let lError, let lDuration), .show(let rError, let rDuration)):
XCTAssertEqual(lDuration, rDuration, file: file, line: line)
let expectedError = try XCTUnwrap(lError as? ErrorType, file: file, line: line)
try XCTAssertEqualGenericError(expectedError, rError, file: file, line: line)
default: return
}
}
Thanks again.