More tests for history view model

AutoCatTests/Extensions/VehicleDto+Presets.swift

@@ -32,6 +32,21 @@ extension VehicleDto {
         vehicle.number = validNumber
         return vehicle
     }
+    
+    static var outdatedVehicle: VehicleDto {
+        var vehicle = VehicleDto()
+        vehicle.number = validNumber
+        vehicle.currentNumber = validNumber2
+        return vehicle
+    }
+    
+    static var needSyncVehicle: VehicleDto {
+        var vehicle = VehicleDto()
+        vehicle.brand = VehicleBrandDto()
+        vehicle.number = validNumber
+        vehicle.synchronized = false
+        return vehicle
+    }
 }
 
 // Fluent

AutoCatTests/HistoryTests.swift

@@ -15,18 +15,14 @@ import Foundation
 @MainActor
 struct HistoryTests {
     
-    var storageServiceMock: MockStorageServiceProtocol
+    let storageServiceMock = MockStorageServiceProtocol()
-    var apiServiceMock: MockApiServiceProtocol
+    let apiServiceMock = MockApiServiceProtocol()
-    var vehicleServiceMock: MockVehicleServiceProtocol
+    let vehicleServiceMock = MockVehicleServiceProtocol()
     
     var viewModel: HistoryViewModel
     
     init() async {
         
-        storageServiceMock = MockStorageServiceProtocol()
-        apiServiceMock = MockApiServiceProtocol()
-        vehicleServiceMock = MockVehicleServiceProtocol()
-        
         viewModel = HistoryViewModel(
             apiService: apiServiceMock,
             storageService: storageServiceMock,
@@ -34,25 +30,148 @@ struct HistoryTests {
         )
     }
 
-    @Test func test() async throws {
+    @Test("History (show filtered vehicles)", arguments: HistoryFilter.allCases)
+    func historyShowFilteredVehicles(_ filter: HistoryFilter) async {
         
         let dbURL = URL(fileURLWithPath: "testDbUrl")
 
+        let vehicles: [VehicleDto] = switch filter {
+        case .all:
+            [.normal, .unrecognizedVehicle, .outdatedVehicle, .needSyncVehicle]
+        case .unrecognized:
+            [.unrecognizedVehicle]
+        case .outdated:
+            [.outdatedVehicle]
+        case .notSynced:
+            [.needSyncVehicle]
+        }
+        
+        given(storageServiceMock)
+            .loadVehicles()
+            .willReturn(vehicles)
+        
+        given(storageServiceMock)
+            .dbFileURL
+            .willReturn(dbURL)
+        
+        await viewModel.onAppear()
+        viewModel.filter = filter
+        viewModel.applyFilters()
+        
+        #expect(viewModel.vehicles == vehicles)
+        #expect(viewModel.vehiclesFiltered == vehicles)
+        #expect(viewModel.vehicleSections.count == 1)
+        #expect(viewModel.dbFileURL == dbURL)
+        #expect(viewModel.hud == nil)
+    }
+    
+    @Test("History (search vehicles)")
+    func historySearchVehicles() async {
+    
+        let vehicles: [VehicleDto] = [
+            .init(number: "А123АА761"),
+            .init(number: "А456ВВ761"),
+            .init(number: "А456ЕЕ761"),
+            .init(number: "А456ОО761"),
+            .init(number: "А123ММ161"),
+            .init(number: "А123НН761")
+        ]
+        
+        given(storageServiceMock)
+            .loadVehicles()
+            .willReturn(vehicles)
+        
+        given(storageServiceMock)
+            .dbFileURL
+            .willReturn(nil)
+        
+        await viewModel.onAppear()
+        viewModel.searchText = "123..761"
+        
+        #expect(viewModel.vehicles.count == 6)
+        #expect(viewModel.vehiclesFiltered.count == 2)
+        #expect(viewModel.vehiclesFiltered[0].number == "А123АА761")
+        #expect(viewModel.vehiclesFiltered[1].number == "А123НН761")
+        #expect(viewModel.dbFileURL == nil)
+    }
+    
+    @Test("History (delete vehicle)")
+    func historyDeleteVehicle() async {
+        
         given(storageServiceMock)
             .loadVehicles()
             .willReturn([.normal])
         
         given(storageServiceMock)
             .dbFileURL
-            .willReturn(dbURL)
+            .willReturn(nil)
+        
+        given(storageServiceMock)
+            .deleteVehicle(number: .any)
+            .willReturn()
+        
+        when(storageServiceMock)
+            .loadVehicles()
+            .perform {
+                given(storageServiceMock)
+                    .loadVehicles()
+                    .willReturn([])
+            }
         
         await viewModel.onAppear()
+        await viewModel.deleteVehicle(.normal)
         
-        #expect(viewModel.vehicles == [.normal])
+        verify(storageServiceMock)
-        #expect(viewModel.vehiclesFiltered == [.normal])
+            .deleteVehicle(number: .any)
-        #expect(viewModel.vehicleSections.count == 1)
+            .called(.once)
-        #expect(viewModel.dbFileURL == dbURL)
+        
+        verify(storageServiceMock)
+            .loadVehicles()
+            .called(.exactly(2))
+        
+        #expect(viewModel.vehicles.isEmpty)
+        #expect(viewModel.vehiclesFiltered.isEmpty)
+        #expect(viewModel.vehicleSections.isEmpty)
     }
     
+    @Test("History (update vehicle)")
+    func historyUpdateVehicle() async {
         
+        let updatedVehicle: VehicleDto = .normal.addNote(text: "123")
+    
+        given(storageServiceMock)
+            .loadVehicles()
+            .willReturn([.normal])
+        
+        given(storageServiceMock)
+            .dbFileURL
+            .willReturn(nil)
+        
+        given(vehicleServiceMock)
+            .updateHistory(number: .any)
+            .willReturn((vehicle: updatedVehicle, errors: []))
+        
+        when(storageServiceMock)
+            .loadVehicles()
+            .perform {
+                given(storageServiceMock)
+                    .loadVehicles()
+                    .willReturn([updatedVehicle])
+            }
+        
+        await viewModel.onAppear()
+        await viewModel.updateVehicle(.normal)
+        
+        verify(vehicleServiceMock)
+            .updateHistory(number: .any)
+            .called(.once)
+        
+        verify(storageServiceMock)
+            .loadVehicles()
+            .called(.exactly(3))
+        
+        #expect(viewModel.vehicles.count == 1)
+        #expect(viewModel.vehiclesFiltered.count == 1)
+        #expect(viewModel.vehicles.first?.notes.first?.text == "123")
+    }
 }