Unit testing Decodable: what's your approach for invalid data? - swift

Question

Let's say you have a JSON with several fields:
Students: [
student: {
name: "Harry"
surname: "Smith"
age: 24
},
...
]
and decodables:
struct Students : Decodable {
let student: [Student]
}
struct Student : Decodable {
let name: String
let surname: String
let age: Int
}
If you want to test invalid data, do you write a sequence of tests with te following fake data?
Test1 data:
{
name: null
surname: "Smith"
age: 24
}
Test2 data:
{
name: "Harry"
surname: null
age: 24
}
Test3 data:
{
name: "Harry"
surname: "Smith"
age: null
}
And maybe a test with a wrong type?
{
name: "Harry"
surname: "Smith"
age: "24" //<- string
}
So do you write all these tests, one for each of the above jsons or does this not make sense to you?

Answer 1

It makes sense writing separate test for each key-value pair if we were not able to see the reason of failure and we had to handle it ourself for each pair. For example, old way of JSONSerialization to get Dictionary and then manually checking each key-value if they exist, if yes, does type matches etc. If we were able to get all the values and expected then we would use to initialize the type e.g, Student. In this kind of scenario, instead of putting so many if-else to report proper failure one can think of separate cases for each pair.
Now that we have Codable and error thrown clearly provide all the information for failure so a single test is enough.

Answer 2

The Decodable protocol provides a series of specific Decoding errors.
As already mentioned by Kamran use one test and catch all possible Decoding errors for example
do {
XCTAssertNoThrow(try JSONDecoder().decode(Students.self, from: data))
} catch let DecodingError.dataCorrupted(context) {
XCTFail("Data corrupted: \(context.debugDescription)")
} catch let DecodingError.keyNotFound(key, context) {
let message = "Key '\(key)' not found: \(context.debugDescription), codingPath: \(context.codingPath)"
XCTFail(message)
} catch let DecodingError.valueNotFound(value, context) {
let message = "Value '\(value)' not found: \(context.debugDescription), codingPath: \(context.codingPath)"
XCTFail(message)
} catch let DecodingError.typeMismatch(type, context) {
let message = "Type '\(type)' mismatch: \(context.debugDescription), codingPath: \(context.codingPath)"
XCTFail(message)
} catch {
XCTFail(error.localizedDescription)
}

Answer 3

I'd primarily test the success way with at least one case.
Also I'd test a few cases with "borderline" values like unusual characters in String values or Integer values around the 32/64bit threshold.
Finally I'd test for one case where all the required (non-optional) values are null. If you later change the model for some properties to be optional this test would fail so you can check if you need to make adaptions because of the changed circumstance.