daily-notification-plugin/ios/Tests/DailyNotificationRecoveryTests.swift

//
//  DailyNotificationRecoveryTests.swift
//  DailyNotificationPluginTests
//
//  Created by Matthew Raymer on 2025-12-16
//  Copyright © 2025 TimeSafari. All rights reserved.
//

import XCTest
import UserNotifications
@testable import DailyNotificationPlugin

/**
 * Recovery tests for invalid data handling and rollover idempotency
 * 
 * Tests recovery scenarios equivalent to Android TEST 4:
 * - Invalid/corrupt records don't crash recovery
 * - Duplicate delivery events are deduped
 * - Rollover is idempotent (can be called multiple times safely)
 * - Cold-start recovery reconciles state correctly
 * - Migration safety (unknown fields don't crash)
 */
class DailyNotificationRecoveryTests: XCTestCase {
    
    var database: DailyNotificationDatabase!
    var storage: DailyNotificationStorage!
    var scheduler: DailyNotificationScheduler!
    var reactivationManager: DailyNotificationReactivationManager!
    var notificationCenter: UNUserNotificationCenter!
    var testDbPath: String!
    
    override func setUp() {
        super.setUp()
        
        // Create clean test database
        let (db, path) = TestDBFactory.createCleanDatabase()
        database = db
        testDbPath = path
        storage = DailyNotificationStorage(databasePath: path)
        scheduler = DailyNotificationScheduler()
        notificationCenter = UNUserNotificationCenter.current()
        
        reactivationManager = DailyNotificationReactivationManager(
            database: database,
            storage: storage,
            scheduler: scheduler
        )
        
        // Clear UserDefaults
        UserDefaults.standard.removeObject(forKey: "DNP_LAST_LAUNCH_TIME")
        
        // Clear pending notifications
        let expectation = XCTestExpectation(description: "Clear notifications")
        notificationCenter.removeAllPendingNotificationRequests { _ in
            expectation.fulfill()
        }
        wait(for: [expectation], timeout: 2.0)
    }
    
    override func tearDown() {
        reactivationManager = nil
        scheduler = nil
        storage = nil
        database = nil
        notificationCenter = nil
        
        // Clean up test database
        if let path = testDbPath {
            TestDBFactory.cleanupDatabase(path: path)
        }
        
        UserDefaults.standard.removeObject(forKey: "DNP_LAST_LAUNCH_TIME")
        
        super.tearDown()
    }
    
    // MARK: - Invalid Records Tests
    
    /**
     * Test that recovery ignores invalid records and continues
     * 
     * Equivalent to Android TEST 4: Invalid Data Handling
     */
    func test_recovery_ignores_invalid_records_and_continues() async throws {
        // Given: Database with invalid records
        TestDBFactory.injectInvalidNotificationRecord(
            database: database,
            id: "", // Empty ID
            scheduledTime: -1, // Invalid time
            payloadJSON: "invalid json {" // Invalid JSON
        )
        
        TestDBFactory.injectInvalidNotificationRecord(
            database: database,
            id: "test_null_time",
            scheduledTime: 0, // Zero time
            payloadJSON: "{\"title\":\"Test\"}" // Valid JSON but missing fields
        )
        
        // Also inject a valid record to ensure recovery continues
        let validNotification = NotificationContent(
            id: UUID().uuidString,
            title: "Valid Notification",
            body: "Valid Body",
            scheduledTime: Int64(Date().addingTimeInterval(3600).timeIntervalSince1970 * 1000),
            fetchedAt: Int64(Date().timeIntervalSince1970 * 1000),
            url: nil,
            payload: nil,
            etag: nil
        )
        storage.saveNotificationContent(validNotification)
        
        // When: Perform recovery
        let expectation = XCTestExpectation(description: "Recovery with invalid records")
        reactivationManager.performRecovery()
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
            expectation.fulfill()
        }
        await fulfillment(of: [expectation], timeout: 5.0)
        
        // Then: App should not crash, recovery should complete
        XCTAssertTrue(true, "Recovery should complete without crashing on invalid records")
        
        // Verify valid notification can still be retrieved
        let retrieved = storage.getNotificationContent(id: validNotification.id)
        XCTAssertNotNil(retrieved, "Valid notification should still be retrievable")
        XCTAssertEqual(retrieved?.id, validNotification.id, "Valid notification ID should match")
    }
    
    /**
     * Test recovery with null/empty required fields
     */
    func test_recovery_handles_null_fields() async throws {
        // Given: Database with null fields
        TestDBFactory.injectNotificationWithNullFields(database: database)
        
        // When: Perform recovery
        let expectation = XCTestExpectation(description: "Recovery with null fields")
        reactivationManager.performRecovery()
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
            expectation.fulfill()
        }
        await fulfillment(of: [expectation], timeout: 3.0)
        
        // Then: App should not crash
        XCTAssertTrue(true, "Recovery should handle null fields gracefully")
    }
    
    // MARK: - Duplicate Delivery Tests
    
    /**
     * Test that duplicate delivery events are deduped
     * 
     * Simulates two delivery events arriving close together
     * Tests the rollover idempotency mechanism
     */
    func test_recovery_dedupes_duplicate_delivery_events() async throws {
        // Given: A notification that was just delivered
        let notificationId = UUID().uuidString
        let pastTime = Int64(Date().addingTimeInterval(-3600).timeIntervalSince1970 * 1000) // 1 hour ago
        let notification = NotificationContent(
            id: notificationId,
            title: "Test Notification",
            body: "Test Body",
            scheduledTime: pastTime,
            fetchedAt: Int64(Date().timeIntervalSince1970 * 1000),
            url: nil,
            payload: nil,
            etag: nil
        )
        storage.saveNotificationContent(notification)
        
        // When: Simulate duplicate delivery events by calling rollover directly twice
        // (Testing the rollover logic directly, which is what handles duplicate deliveries)
        let firstRollover = await scheduler.scheduleNextNotification(
            notification,
            storage: storage,
            fetcher: nil
        )
        
        // Wait a very short time (simulating rapid duplicate delivery)
        try await Task.sleep(nanoseconds: 50_000_000) // 0.05 seconds
        
        // Call rollover again immediately (simulating duplicate delivery)
        let secondRollover = await scheduler.scheduleNextNotification(
            notification,
            storage: storage,
            fetcher: nil
        )
        
        // Then: Check that rollover is idempotent (second call should be skipped)
        // The rollover state tracking should prevent duplicate scheduling
        XCTAssertTrue(true, "Rollover should handle duplicate calls idempotently")
        
        // Verify only one next notification was scheduled
        let pendingNotifications = try await notificationCenter.pendingNotificationRequests()
        let nextDayTime = pastTime + (24 * 60 * 60 * 1000) // 24 hours later
        let rolloverCount = pendingNotifications.filter { request in
            if let trigger = request.trigger as? UNCalendarNotificationTrigger,
               let nextDate = trigger.nextTriggerDate() {
                let pendingTime = Int64(nextDate.timeIntervalSince1970 * 1000)
                // Allow 1 minute tolerance for DST
                return abs(pendingTime - nextDayTime) < (60 * 1000)
            }
            return false
        }.count
        
        // Should have at most 1 rollover notification (idempotency check)
        XCTAssertLessThanOrEqual(rolloverCount, 1, 
                                "Duplicate rollover calls should result in at most one next notification")
    }
    
    // MARK: - Rollover Idempotency Tests
    
    /**
     * Test that rollover is idempotent when called multiple times
     * 
     * Equivalent to Android TEST 0: Daily Rollover Verification
     */
    func test_recovery_rollover_idempotent_when_called_twice() async throws {
        // Given: A notification that was just delivered
        let notificationId = UUID().uuidString
        let pastTime = Int64(Date().addingTimeInterval(-3600).timeIntervalSince1970 * 1000) // 1 hour ago
        let notification = NotificationContent(
            id: notificationId,
            title: "Delivered Notification",
            body: "This was delivered",
            scheduledTime: pastTime,
            fetchedAt: Int64(Date().timeIntervalSince1970 * 1000),
            url: nil,
            payload: nil,
            etag: nil
        )
        storage.saveNotificationContent(notification)
        
        // When: Call scheduleNextNotification twice (simulating duplicate rollover attempts)
        let firstCall = await scheduler.scheduleNextNotification(
            notification,
            storage: storage,
            fetcher: nil
        )
        
        // Wait a bit
        try await Task.sleep(nanoseconds: 100_000_000) // 0.1 seconds
        
        // Call again immediately (should be idempotent)
        let secondCall = await scheduler.scheduleNextNotification(
            notification,
            storage: storage,
            fetcher: nil
        )
        
        // Then: Second call should be skipped (idempotency)
        // First call may succeed, second should be skipped due to rollover state tracking
        XCTAssertTrue(true, "Rollover should be idempotent - second call should be skipped")
        
        // Verify only one next notification was scheduled
        let pendingNotifications = try await notificationCenter.pendingNotificationRequests()
        let nextDayTime = pastTime + (24 * 60 * 60 * 1000) // 24 hours later
        let rolloverCount = pendingNotifications.filter { request in
            if let trigger = request.trigger as? UNCalendarNotificationTrigger,
               let nextDate = trigger.nextTriggerDate() {
                let pendingTime = Int64(nextDate.timeIntervalSince1970 * 1000)
                return abs(pendingTime - nextDayTime) < (60 * 1000) // 1 minute tolerance
            }
            return false
        }.count
        
        XCTAssertLessThanOrEqual(rolloverCount, 1, 
                                "Rollover should be idempotent - only one next notification should be scheduled")
    }
    
    // MARK: - Cold Start Recovery Tests
    
    /**
     * Test recovery after cold start reconciles state correctly
     */
    func test_recovery_after_cold_start_reconciles_state() async throws {
        // Given: Notifications in storage but not in system (simulating cold start)
        let notification1 = NotificationContent(
            id: UUID().uuidString,
            title: "Notification 1",
            body: "Body 1",
            scheduledTime: Int64(Date().addingTimeInterval(3600).timeIntervalSince1970 * 1000),
            fetchedAt: Int64(Date().timeIntervalSince1970 * 1000),
            url: nil,
            payload: nil,
            etag: nil
        )
        
        let notification2 = NotificationContent(
            id: UUID().uuidString,
            title: "Notification 2",
            body: "Body 2",
            scheduledTime: Int64(Date().addingTimeInterval(7200).timeIntervalSince1970 * 1000),
            fetchedAt: Int64(Date().timeIntervalSince1970 * 1000),
            url: nil,
            payload: nil,
            etag: nil
        )
        
        storage.saveNotificationContent(notification1)
        storage.saveNotificationContent(notification2)
        
        // Verify notifications are NOT in system (cold start scenario)
        let pendingBefore = try await notificationCenter.pendingNotificationRequests()
        let foundBefore = pendingBefore.contains { $0.identifier == notification1.id || $0.identifier == notification2.id }
        XCTAssertFalse(foundBefore, "Notifications should not be in system before recovery")
        
        // When: Perform recovery (simulating app launch after cold start)
        let expectation = XCTestExpectation(description: "Cold start recovery")
        reactivationManager.performRecovery()
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
            expectation.fulfill()
        }
        await fulfillment(of: [expectation], timeout: 5.0)
        
        // Then: Notifications should be rescheduled (recovery should reconcile)
        let pendingAfter = try await notificationCenter.pendingNotificationRequests()
        
        // Recovery may or may not succeed depending on permissions, but app shouldn't crash
        XCTAssertNoThrow(pendingAfter, "Recovery should complete without crashing")
        
        // If recovery succeeded, notifications should be rescheduled
        let foundAfter = pendingAfter.contains { $0.identifier == notification1.id || $0.identifier == notification2.id }
        // Note: Recovery may fail due to permissions, but we verify it doesn't crash
        XCTAssertTrue(true, "Recovery should attempt to reschedule notifications")
    }
    
    // MARK: - Migration Safety Tests
    
    /**
     * Test that unknown/missing fields don't crash decode/load paths
     * 
     * Minimum viable migration safety test
     */
    func test_recovery_migration_safety_unknown_fields() async throws {
        // Given: Database with records that have unknown/missing fields
        // We simulate this by injecting records with minimal data
        TestDBFactory.injectInvalidNotificationRecord(
            database: database,
            id: "migration_test_1",
            scheduledTime: Int64(Date().timeIntervalSince1970 * 1000),
            payloadJSON: "{\"title\":\"Test\"}" // Missing 'body' field
        )
        
        TestDBFactory.injectInvalidNotificationRecord(
            database: database,
            id: "migration_test_2",
            scheduledTime: Int64(Date().timeIntervalSince1970 * 1000),
            payloadJSON: "{}" // Empty payload
        )
        
        // When: Try to retrieve notifications (simulating migration/load)
        // Storage should handle missing fields gracefully
        let allNotifications = storage.getAllNotifications()
        
        // Then: App should not crash, should handle missing fields
        XCTAssertNoThrow(allNotifications, "Storage should handle missing fields without crashing")
        
        // Recovery should also handle these gracefully
        let expectation = XCTestExpectation(description: "Migration safety recovery")
        reactivationManager.performRecovery()
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
            expectation.fulfill()
        }
        await fulfillment(of: [expectation], timeout: 3.0)
        
        XCTAssertTrue(true, "Recovery should handle unknown/missing fields gracefully")
    }
}