Converting to Swift Testing

drekka · Nov 19, 2024 · 384e3c9 · 384e3c9
1 parent 891829e
commit 384e3c9
Showing 1 changed file with 44 additions and 42 deletions.
diff --git a/Tests/Property wrappers/DateStringTests.swift b/Tests/Property wrappers/DateStringTests.swift
@@ -10,97 +10,99 @@ private struct OptionalDayContainer<Configurator>: Codable where Configurator: D
     @DateString<Day?, Configurator> var d1: Day?
 }
 
+@Suite("Date string decoding")
+struct DateStringDecodingTests {
 
-struct DateStringTests {
-
-    @Test("Decoding am ISO8601 string")
-    func decodingISO8601DateString() throws {
+    @Test("Decoding an ISO8601 date")
+    func decodingAnISO8601Date() throws {
         let json = #"{"d1": "2012-02-01"}"#
         let result = try JSONDecoder().decode(DayContainer<DateStringConfig.ISO>.self, from: json.data(using: .utf8)!)
         #expect(result.d1 == Day(2012, 02, 01))
     }
 
-    func testDecodingAustralianDateStrings() throws {
+    @Test("Decoding an DMY date")
+    func decodingADMYDate() throws {
         let json = #"{"d1": "01/02/2012"}"#
         let result = try JSONDecoder().decode(DayContainer<DateStringConfig.DMY>.self, from: json.data(using: .utf8)!)
-        expect(result.d1) == Day(2012, 02, 01)
+        #expect(result.d1 == Day(2012, 02, 01))
     }
 
-    func testDecodingAmericanDateStrings() throws {
+    @Test("Decoding an MDY date")
+    func decodingAMDYDate() throws {
         let json = #"{"d1": "02/01/2012"}"#
         let result = try JSONDecoder().decode(DayContainer<DateStringConfig.MDY>.self, from: json.data(using: .utf8)!)
-        expect(result.d1) == Day(2012, 02, 01)
+        #expect(result.d1 == Day(2012, 02, 01))
     }
-}
-
-class CodableAsDateStroingOptionalTests: XCTestCase {
 
-    func testDecodingISO8601DateString() throws {
+    @Test("Decoding an optional ISO8601 date")
+    func decodingAnIOptionalISO8601Date() throws {
         let json = #"{"d1": "2012-02-01"}"#
         let result = try JSONDecoder().decode(OptionalDayContainer<DateStringConfig.ISO>.self, from: json.data(using: .utf8)!)
-        expect(result.d1) == Day(2012, 02, 01)
+        #expect(result.d1 == Day(2012, 02, 01))
     }
 
-    func testDecodingAustralianDateStrings() throws {
+    @Test("Decoding an DMY date")
+    func decodingAnOptionalDMYDate() throws {
         let json = #"{"d1": "01/02/2012"}"#
         let result = try JSONDecoder().decode(OptionalDayContainer<DateStringConfig.DMY>.self, from: json.data(using: .utf8)!)
-        expect(result.d1) == Day(2012, 02, 01)
+        #expect(result.d1 == Day(2012, 02, 01))
     }
 
-    func testDecodingAmericanDateStrings() throws {
+    @Test("Decoding an MDY date")
+    func decodingAnOptionalMDYDate() throws {
         let json = #"{"d1": "02/01/2012"}"#
         let result = try JSONDecoder().decode(OptionalDayContainer<DateStringConfig.MDY>.self, from: json.data(using: .utf8)!)
-        expect(result.d1) == Day(2012, 02, 01)
+        #expect(result.d1 == Day(2012, 02, 01))
     }
 
-    func testDecodingNilAustralianDateStrings() throws {
+    @Test("Decoding a nil date")
+    func decodingANilDate() throws {
         let json = #"{"d1": null}"#
         let result = try JSONDecoder().decode(OptionalDayContainer<DateStringConfig.DMY>.self, from: json.data(using: .utf8)!)
-        expect(result.d1) == nil
+        #expect(result.d1 == nil)
     }
 
-    func testDecodingInvalidAustralianDateStringsThrows() throws {
-
-        let json = #"{"d1": "xxx"}"#
-        let decoder = JSONDecoder()
-        expect(try decoder.decode(OptionalDayContainer<DateStringConfig.DMY>.self, from: json.data(using: .utf8)!))
-            .to(throwError { error in
-                guard case let DecodingError.dataCorrupted(context) = error else {
-                    fail("Incorrect error \(error)")
-                    return
-                }
-                expect(context.codingPath.map { $0.stringValue }) == ["d1"]
-                expect(context.debugDescription) == "Unable to read the date string."
-            })
+    @Test("Decoding an invalid date throws an error")
+    func decodingInvalidDateThrows() throws {
+        do {
+            let json = #"{"d1": "xxx"}"#
+            _ = try JSONDecoder().decode(OptionalDayContainer<DateStringConfig.DMY>.self, from: json.data(using: .utf8)!)
+        } catch DecodingError.dataCorrupted(let context) {
+            #expect(context.codingPath.map(\.stringValue) == ["d1"])
+            #expect(context.debugDescription == "Unable to read the date string.")
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
     }
 }
 
-class CodableAsDateStringEncodingTests: XCTestCase {
+@Suite("Date string encoding")
+class DateStringEncodingTests {
 
-    func testEncoding() throws {
+    @Test("Encoding a DMY date")
+    func dateEncoding() throws {
         let instance = DayContainer<DateStringConfig.DMY>(d1: Day(2012, 02, 01))
         let encoder = JSONEncoder()
         encoder.outputFormatting = .withoutEscapingSlashes
         let result = try encoder.encode(instance)
-        expect(String(data: result, encoding: .utf8)!) == #"{"d1":"01/02/2012"}"#
+        #expect(String(data: result, encoding: .utf8)! == #"{"d1":"01/02/2012"}"#)
     }
-}
-
-class CodableAsDateStringOptionalTests: XCTestCase {
 
-    func testEncoding() throws {
+    @Test("Encoding an optional DMY date")
+    func optionalDateEncoding() throws {
         let instance = OptionalDayContainer<DateStringConfig.DMY>(d1: Day(2012, 02, 01))
         let encoder = JSONEncoder()
         encoder.outputFormatting = .withoutEscapingSlashes
         let result = try encoder.encode(instance)
-        expect(String(data: result, encoding: .utf8)!) == #"{"d1":"01/02/2012"}"#
+        #expect(String(data: result, encoding: .utf8)! == #"{"d1":"01/02/2012"}"#)
     }
 
-    func testEncodingNil() throws {
+    @Test("Encoding an optional DMY date from a nil")
+    func optionalDateEncodingWithNil() throws {
         let instance = OptionalDayContainer<DateStringConfig.DMY>(d1: nil)
         let encoder = JSONEncoder()
         encoder.outputFormatting = .withoutEscapingSlashes
         let result = try encoder.encode(instance)
-        expect(String(data: result, encoding: .utf8)!) == #"{"d1":null}"#
+        #expect(String(data: result, encoding: .utf8)! == #"{"d1":null}"#)
     }
 }