really get includes errors down to a concise message when we know that all types are wrong or exactly one type is correct.

Author: mattpolzin

Sources/JSONAPI/Document/Includes.swift

@@ -243,14 +243,33 @@ extension IncludesDecodingError: CustomStringConvertible {
         }
         let ordinalDescription = "\(idx + 1)\(ordinalSuffix)"
 
-        return "Out of \(totalIncludesCount) includes, the \(ordinalDescription) one failed to parse: \(error)"
+        return "Out of the \(totalIncludesCount) includes in the document, the \(ordinalDescription) one failed to parse: \(error)"
     }
 }
 
 public struct IncludeDecodingError: Swift.Error, Equatable, CustomStringConvertible {
     public let failures: [ResourceObjectDecodingError]
 
     public var description: String {
+        // concise error when all failures are mismatched JSON:API types:
+        if case let .jsonTypeMismatch(foundType: foundType)? = failures.first?.cause,
+           failures.allSatisfy({ $0.cause.isTypeMismatch }) {
+            let expectedTypes = failures
+                .compactMap { "'\($0.resourceObjectJsonAPIType)'" }
+                .joined(separator: ", ")
+
+            return "Found JSON:API type '\(foundType)' but expected one of \(expectedTypes)"
+        }
+
+        // concise error when all but failures but one are type mismatches because
+        // we can assume the correct type was found but there was some other error:
+        let nonTypeMismatches = failures.filter({ !$0.cause.isTypeMismatch})
+        if nonTypeMismatches.count == 1, let nonTypeMismatch = nonTypeMismatches.first {
+            return String(describing: nonTypeMismatch)
+        }
+
+        // fall back to just describing all of the reasons it could not have been any of the available
+        // types:
         return failures
             .enumerated()
             .map {

Sources/JSONAPI/Resource/Resource Object/ResourceObjectDecodingError.swift

@@ -19,6 +19,11 @@ public struct ResourceObjectDecodingError: Swift.Error, Equatable {
         case typeMismatch(expectedTypeName: String)
         case jsonTypeMismatch(foundType: String)
         case quantityMismatch(expected: JSONAPICodingError.Quantity)
+
+        internal var isTypeMismatch: Bool {
+            guard case .jsonTypeMismatch = self else { return false}
+            return true
+        }
     }
 
     public enum Location: String, Equatable {

Tests/JSONAPITests/Document/DocumentDecodingErrorTests.swift

@@ -92,7 +92,7 @@ final class DocumentDecodingErrorTests: XCTestCase {
                     return
             }
 
-            XCTAssertEqual(String(describing: error), #"Out of 3 includes, the 3rd one failed to parse: found JSON:API type "not_an_author" but expected "authors""#)
+            XCTAssertEqual(String(describing: error), #"Out of the 3 includes in the document, the 3rd one failed to parse: found JSON:API type "not_an_author" but expected "authors""#)
         }
     }
 
@@ -112,14 +112,7 @@ final class DocumentDecodingErrorTests: XCTestCase {
 
             XCTAssertEqual(
                 String(describing: error),
-                #"""
-                Out of 3 includes, the 3rd one failed to parse: 
-                Could not have been Include Type `articles` because:
-                found JSON:API type "not_an_author" but expected "articles"
-
-                Could not have been Include Type `authors` because:
-                found JSON:API type "not_an_author" but expected "authors"
-                """#
+                "Out of the 3 includes in the document, the 3rd one failed to parse: Found JSON:API type 'not_an_author' but expected one of 'articles', 'authors'"
             )
         }
     }
@@ -140,14 +133,7 @@ final class DocumentDecodingErrorTests: XCTestCase {
 
             XCTAssertEqual(
                 String(describing: error),
-                #"""
-                Out of 3 includes, the 2nd one failed to parse: 
-                Could not have been Include Type `articles` because:
-                found JSON:API type "not_an_author" but expected "articles"
-
-                Could not have been Include Type `authors` because:
-                found JSON:API type "not_an_author" but expected "authors"
-                """#
+                "Out of the 3 includes in the document, the 2nd one failed to parse: Found JSON:API type 'not_an_author' but expected one of 'articles', 'authors'"
             )
         }
     }

Tests/JSONAPITests/Includes/IncludesDecodingErrorTests.swift

@@ -18,69 +18,39 @@ final class IncludesDecodingErrorTests: XCTestCase {
 
             XCTAssertEqual(
                 (error as? IncludesDecodingError).map(String.init(describing:)),
-                """
-                Out of 3 includes, the 3rd one failed to parse: \nCould not have been Include Type `test_entity1` because:
-                found JSON:API type "test_entity4" but expected "test_entity1"
-
-                Could not have been Include Type `test_entity2` because:
-                found JSON:API type "test_entity4" but expected "test_entity2"
-                """
+                "Out of the 3 includes in the document, the 3rd one failed to parse: Found JSON:API type 'test_entity4' but expected one of 'test_entity1', 'test_entity2'"
             )
         }
 
         // now test that we get the same error with a different total include count from a different test stub
         XCTAssertThrowsError(try testDecoder.decode(Includes<Include2<TestEntity, TestEntity2>>.self, from: four_different_type_includes)) { (error2: Error) -> Void in
             XCTAssertEqual(
                 (error2 as? IncludesDecodingError).map(String.init(describing:)),
-                """
-                Out of 4 includes, the 3rd one failed to parse: \nCould not have been Include Type `test_entity1` because:
-                found JSON:API type "test_entity4" but expected "test_entity1"
-
-                Could not have been Include Type `test_entity2` because:
-                found JSON:API type "test_entity4" but expected "test_entity2"
-                """
+                "Out of the 4 includes in the document, the 3rd one failed to parse: Found JSON:API type 'test_entity4' but expected one of 'test_entity1', 'test_entity2'"
             )
         }
 
         // and with six total includes
         XCTAssertThrowsError(try testDecoder.decode(Includes<Include2<TestEntity, TestEntity2>>.self, from: six_includes_one_bad_type)) { (error2: Error) -> Void in
             XCTAssertEqual(
                 (error2 as? IncludesDecodingError).map(String.init(describing:)),
-                """
-                Out of 6 includes, the 5th one failed to parse: \nCould not have been Include Type `test_entity1` because:
-                found JSON:API type "test_entity4" but expected "test_entity1"
-
-                Could not have been Include Type `test_entity2` because:
-                found JSON:API type "test_entity4" but expected "test_entity2"
-                """
+                "Out of the 6 includes in the document, the 5th one failed to parse: Found JSON:API type 'test_entity4' but expected one of 'test_entity1', 'test_entity2'"
             )
         }
 
         // and with a number of total includes between 10 and 19
         XCTAssertThrowsError(try testDecoder.decode(Includes<Include2<TestEntity, TestEntity2>>.self, from: eleven_includes_one_bad_type)) { (error2: Error) -> Void in
             XCTAssertEqual(
                 (error2 as? IncludesDecodingError).map(String.init(describing:)),
-                """
-                Out of 11 includes, the 10th one failed to parse: \nCould not have been Include Type `test_entity1` because:
-                found JSON:API type "test_entity4" but expected "test_entity1"
-
-                Could not have been Include Type `test_entity2` because:
-                found JSON:API type "test_entity4" but expected "test_entity2"
-                """
+                "Out of the 11 includes in the document, the 10th one failed to parse: Found JSON:API type 'test_entity4' but expected one of 'test_entity1', 'test_entity2'"
             )
         }
 
         // and finally with a larger number of total includes
         XCTAssertThrowsError(try testDecoder.decode(Includes<Include2<TestEntity, TestEntity2>>.self, from: twenty_two_includes_one_bad_type)) { (error2: Error) -> Void in
             XCTAssertEqual(
                 (error2 as? IncludesDecodingError).map(String.init(describing:)),
-                """
-                Out of 22 includes, the 21st one failed to parse: \nCould not have been Include Type `test_entity1` because:
-                found JSON:API type "test_entity4" but expected "test_entity1"
-
-                Could not have been Include Type `test_entity2` because:
-                found JSON:API type "test_entity4" but expected "test_entity2"
-                """
+                "Out of the 22 includes in the document, the 21st one failed to parse: Found JSON:API type 'test_entity4' but expected one of 'test_entity1', 'test_entity2'"
             )
         }
     }
@@ -94,16 +64,7 @@ final class IncludesDecodingErrorTests: XCTestCase {
         ) { (error: Error) -> Void in
             XCTAssertEqual(
                 (error as? IncludesDecodingError).map(String.init(describing:)),
-                """
-                Out of 3 includes, the 3rd one failed to parse: \nCould not have been Include Type `test_entity1` because:
-                found JSON:API type "test_entity2" but expected "test_entity1"
-
-                Could not have been Include Type `test_entity2` because:
-                'foo' attribute is required and missing.
-
-                Could not have been Include Type `test_entity4` because:
-                found JSON:API type "test_entity2" but expected "test_entity4"
-                """
+                "Out of the 3 includes in the document, the 3rd one failed to parse: 'foo' attribute is required and missing."
             )
         }
     }