Add tests for migrations

Author: fpseverino

Package.swift

@@ -38,21 +38,24 @@ let package = Package(
         .testTarget(
             name: "FluentWalletTests",
             dependencies: [
-                .target(name: "FluentWallet")
+                .target(name: "FluentWallet"),
+                .product(name: "XCTFluent", package: "fluent-kit"),
             ],
             swiftSettings: swiftSettings
         ),
         .testTarget(
             name: "FluentPassesTests",
             dependencies: [
-                .target(name: "FluentPasses")
+                .target(name: "FluentPasses"),
+                .product(name: "XCTFluent", package: "fluent-kit"),
             ],
             swiftSettings: swiftSettings
         ),
         .testTarget(
             name: "FluentOrdersTests",
             dependencies: [
-                .target(name: "FluentOrders")
+                .target(name: "FluentOrders"),
+                .product(name: "XCTFluent", package: "fluent-kit"),
             ],
             swiftSettings: swiftSettings
         ),

Tests/FluentOrdersTests/FluentOrdersTests.swift

@@ -1,24 +1,38 @@
 import FluentOrders
 import FluentWallet
 import Testing
+import XCTFluent
 
 import struct Foundation.UUID
 
 @Suite("FluentOrders Tests")
 struct FluentOrdersTests {
+    let test = ArrayTestDatabase()
+
     @Test("Order Concrete Model")
     func order() async throws {
+        let migration = CreateOrder()
+        try await migration.prepare(on: test.db)
+
         let typeIdentifier = "Test Type Identifier"
         let authenticationToken = "Test Authentication Token"
 
-        let order = Order(typeIdentifier: typeIdentifier, authenticationToken: authenticationToken)
+        test.append([
+            TestOutput(Order(typeIdentifier: typeIdentifier, authenticationToken: authenticationToken))
+        ])
+
+        let fetchedOrder = try #require(await Order.query(on: test.db).first())
+        #expect(fetchedOrder._$typeIdentifier.value == typeIdentifier)
+        #expect(fetchedOrder._$authenticationToken.value == authenticationToken)
 
-        #expect(order._$typeIdentifier.value == typeIdentifier)
-        #expect(order._$authenticationToken.value == authenticationToken)
+        try await migration.revert(on: test.db)
     }
 
     @Test("OrdersRegistration Concrete Model")
     func ordersRegistration() async throws {
+        let migration = CreateOrdersRegistration()
+        try await migration.prepare(on: test.db)
+
         let device = Device()
         device._$id.value = 1
         let order = Order()
@@ -27,8 +41,14 @@ struct FluentOrdersTests {
         let ordersRegistration = OrdersRegistration()
         ordersRegistration.$device.id = device.id!
         ordersRegistration.$order.id = order.id!
+        test.append([
+            TestOutput(ordersRegistration)
+        ])
+
+        let fetchedOrdersRegistration = try #require(await OrdersRegistration.query(on: test.db).first())
+        #expect(fetchedOrdersRegistration._$device.id == device.id)
+        #expect(fetchedOrdersRegistration._$order.id == order.id)
 
-        #expect(ordersRegistration._$device.id == device.id)
-        #expect(ordersRegistration._$order.id == order.id)
+        try await migration.revert(on: test.db)
     }
 }

Tests/FluentPassesTests/FluentPassesTests.swift

@@ -1,28 +1,43 @@
 import FluentPasses
 import FluentWallet
 import Testing
+import XCTFluent
 
 import struct Foundation.UUID
 
 @Suite("FluentPasses Tests")
 struct FluentPassesTests {
+    let test = ArrayTestDatabase()
+
     @Test("Pass Concrete Model")
     func pass() async throws {
+        let migration = CreatePass()
+        try await migration.prepare(on: test.db)
+
         let typeIdentifier = "Test Type Identifier"
         let authenticationToken = "Test Authentication Token"
         let personalization = Personalization()
         personalization._$id.value = 1
 
         let pass = Pass(typeIdentifier: typeIdentifier, authenticationToken: authenticationToken)
         pass.$personalization.id = personalization.id!
+        test.append([
+            TestOutput(pass)
+        ])
 
-        #expect(pass._$typeIdentifier.value == typeIdentifier)
-        #expect(pass._$authenticationToken.value == authenticationToken)
-        #expect(pass._$personalization.id == personalization.id)
+        let fetchedPass = try #require(await Pass.query(on: test.db).first())
+        #expect(fetchedPass._$typeIdentifier.value == typeIdentifier)
+        #expect(fetchedPass._$authenticationToken.value == authenticationToken)
+        #expect(fetchedPass._$personalization.id == personalization.id)
+
+        try await migration.revert(on: test.db)
     }
 
     @Test("PassesRegistration Concrete Model")
     func passesRegistration() async throws {
+        let migration = CreatePassesRegistration()
+        try await migration.prepare(on: test.db)
+
         let device = Device()
         device._$id.value = 1
         let pass = Pass()
@@ -31,13 +46,22 @@ struct FluentPassesTests {
         let passesRegistration = PassesRegistration()
         passesRegistration.$device.id = device.id!
         passesRegistration.$pass.id = pass.id!
+        test.append([
+            TestOutput(passesRegistration)
+        ])
 
-        #expect(passesRegistration._$device.id == device.id)
-        #expect(passesRegistration._$pass.id == pass.id)
+        let fetchedPassesRegistration = try #require(await PassesRegistration.query(on: test.db).first())
+        #expect(fetchedPassesRegistration._$device.id == device.id)
+        #expect(fetchedPassesRegistration._$pass.id == pass.id)
+
+        try await migration.revert(on: test.db)
     }
 
     @Test("Personalization Concrete Model")
     func personalization() async throws {
+        let migration = CreatePersonalization()
+        try await migration.prepare(on: test.db)
+
         let fullName = "Test Name"
         let givenName = String(fullName.prefix(4))
         let familyName = String(fullName.suffix(4))
@@ -54,14 +78,20 @@ struct FluentPassesTests {
         personalization.postalCode = postalCode
         personalization.isoCountryCode = isoCountryCode
         personalization.phoneNumber = phoneNumber
+        test.append([
+            TestOutput(personalization)
+        ])
+
+        let fetchedPersonalization = try #require(await Personalization.query(on: test.db).first())
+        #expect(fetchedPersonalization._$fullName.value == fullName)
+        #expect(fetchedPersonalization._$givenName.value == givenName)
+        #expect(fetchedPersonalization._$familyName.value == familyName)
+        #expect(fetchedPersonalization._$emailAddress.value == emailAddress)
+        #expect(fetchedPersonalization._$postalCode.value == postalCode)
+        #expect(fetchedPersonalization._$isoCountryCode.value == isoCountryCode)
+        #expect(fetchedPersonalization._$phoneNumber.value == phoneNumber)
 
-        #expect(personalization._$fullName.value == fullName)
-        #expect(personalization._$givenName.value == givenName)
-        #expect(personalization._$familyName.value == familyName)
-        #expect(personalization._$emailAddress.value == emailAddress)
-        #expect(personalization._$postalCode.value == postalCode)
-        #expect(personalization._$isoCountryCode.value == isoCountryCode)
-        #expect(personalization._$phoneNumber.value == phoneNumber)
+        try await migration.revert(on: test.db)
     }
 
     @Test("PersonalizationJSON initialization")

Tests/FluentWalletTests/FluentWalletTests.swift

@@ -1,25 +1,44 @@
 import FluentWallet
 import Testing
+import XCTFluent
 
 @Suite("FluentWallet Tests")
 struct FluentWalletTests {
+    let test = ArrayTestDatabase()
+
     @Test("Device Concrete Model")
     func devices() async throws {
+        let migration = CreateDevice()
+        try await migration.prepare(on: test.db)
+
         let libraryIdentifier = "Test Library Identifier"
         let pushToken = "Test Push Token"
 
-        let device = Device(libraryIdentifier: libraryIdentifier, pushToken: pushToken)
+        test.append([
+            TestOutput(Device(libraryIdentifier: libraryIdentifier, pushToken: pushToken))
+        ])
+
+        let fetchedDevice = try #require(await Device.query(on: test.db).first())
+        #expect(fetchedDevice._$libraryIdentifier.value == libraryIdentifier)
+        #expect(fetchedDevice._$pushToken.value == pushToken)
 
-        #expect(device._$libraryIdentifier.value == libraryIdentifier)
-        #expect(device._$pushToken.value == pushToken)
+        try await migration.revert(on: test.db)
     }
 
     @Test("LogEntry Concrete Model")
     func logEntries() async throws {
+        let migration = CreateLogEntry()
+        try await migration.prepare(on: test.db)
+
         let message = "Test message"
 
-        let logEntry = LogEntry(message: message)
+        test.append([
+            TestOutput(LogEntry(message: message))
+        ])
+
+        let fetchedLogEntry = try #require(await LogEntry.query(on: test.db).first())
+        #expect(fetchedLogEntry._$message.value == message)
 
-        #expect(logEntry._$message.value == message)
+        try await migration.revert(on: test.db)
     }
 }