Add watchdog tests and fix double-reconnect bug on cancelled tasks

- Fix: NSURLErrorCancelled in didCompleteWithError now returns early,
  preventing double-reconnect when watchdog or reconnect cancels the task
- Add HoldingURLProtocol mock and 3 watchdog tests
- Make watchdogInterval, baseReconnectDelay, urlSessionConfiguration injectable

Author: laurentftech

Sources/NtfyClient.swift

@@ -93,7 +93,7 @@ final class NtfyClient: NSObject, @unchecked Sendable {
 
     private var reconnectAttempts = 0
     private let maxReconnectAttempts = 10
-    private let baseReconnectDelay: TimeInterval = 2.0
+    private let baseReconnectDelay: TimeInterval
     private let maxReconnectDelay: TimeInterval = 300.0  // 5 minutes max
     private var reconnectTimer: Timer?
     private var isConnecting = false
@@ -103,15 +103,17 @@ final class NtfyClient: NSObject, @unchecked Sendable {
     private let lastMessageTimeKey: String  // UserDefaults key for persistence
 
     // Watchdog: reconnect if no data received for this long (ntfy sends keepalives every ~55s)
-    private let watchdogInterval: TimeInterval = 120.0
+    private let watchdogInterval: TimeInterval
     private var watchdogTimer: Timer?
     private var lastDataReceived: Date = .distantPast
 
-    init(serverURL: String, topics: [String], authToken: String? = nil, fetchMissed: Bool = false) {
+    init(serverURL: String, topics: [String], authToken: String? = nil, fetchMissed: Bool = false, watchdogInterval: TimeInterval = 120.0, baseReconnectDelay: TimeInterval = 2.0, urlSessionConfiguration: URLSessionConfiguration? = nil) {
         self.serverURL = serverURL
         self.topics = topics
         self._authToken = authToken
         self.fetchMissed = fetchMissed
+        self.watchdogInterval = watchdogInterval
+        self.baseReconnectDelay = baseReconnectDelay
 
         // Restore last message time from UserDefaults for fetch_missed
         let topicsKey = topics.sorted().joined(separator: ",")
@@ -125,7 +127,7 @@ final class NtfyClient: NSObject, @unchecked Sendable {
 
         super.init()
 
-        let config = URLSessionConfiguration.default
+        let config = urlSessionConfiguration ?? URLSessionConfiguration.default
         config.timeoutIntervalForRequest = .infinity
         config.timeoutIntervalForResource = .infinity
         config.httpMaximumConnectionsPerHost = 1
@@ -352,11 +354,12 @@ extension NtfyClient: URLSessionDataDelegate {
         stopWatchdog()
 
         if let error = error {
-            // Don't log cancelled errors (normal during reconnect)
             let nsError = error as NSError
-            if nsError.domain != NSURLErrorDomain || nsError.code != NSURLErrorCancelled {
-                Log.error("Connection error: \(error.localizedDescription)")
+            // Cancelled errors are expected when we cancel the task ourselves (reconnect/disconnect) — ignore them
+            if nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorCancelled {
+                return
             }
+            Log.error("Connection error: \(error.localizedDescription)")
             callDelegate { delegate in
                 delegate.ntfyClient(self, didEncounterError: error)
                 delegate.ntfyClientDidDisconnect(self)

Tests/ntfy-macosTests/NtfyClientTests.swift

@@ -1,6 +1,70 @@
 import XCTest
 @testable import ntfy_macos
 
+// MARK: - Mock URLProtocol for watchdog tests
+
+/// Intercepts URLSession requests and returns HTTP 200 without sending any data,
+/// simulating a stale connection where the server stops sending keepalives.
+final class HoldingURLProtocol: URLProtocol {
+    static let requestCountLock = NSLock()
+    nonisolated(unsafe) private static var _requestCount = 0
+    static var requestCount: Int {
+        get { requestCountLock.lock(); defer { requestCountLock.unlock() }; return _requestCount }
+        set { requestCountLock.lock(); defer { requestCountLock.unlock() }; _requestCount = newValue }
+    }
+    nonisolated(unsafe) static var onRequest: ((Int) -> Void)?
+
+    static func reset() {
+        requestCount = 0
+        onRequest = nil
+    }
+
+    override class func canInit(with request: URLRequest) -> Bool { true }
+    override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
+
+    override func startLoading() {
+        let count = HoldingURLProtocol.requestCount + 1
+        HoldingURLProtocol.requestCount = count
+        HoldingURLProtocol.onRequest?(count)
+
+        // Return HTTP 200 but never send data or finish — simulates stale connection
+        let response = HTTPURLResponse(
+            url: request.url!,
+            statusCode: 200,
+            httpVersion: nil,
+            headerFields: nil
+        )!
+        client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+        // Intentionally no didLoad or didFinishLoading — connection stays "open"
+    }
+
+    override func stopLoading() {}
+}
+
+// MARK: - Mock delegate
+
+final class MockNtfyDelegate: NtfyClientDelegate {
+    var onConnect: (() -> Void)?
+    var onDisconnect: (() -> Void)?
+    var onError: ((Error) -> Void)?
+    var onMessage: ((NtfyMessage) -> Void)?
+
+    func ntfyClientDidConnect(_ client: NtfyClient) { onConnect?() }
+    func ntfyClientDidDisconnect(_ client: NtfyClient) { onDisconnect?() }
+    func ntfyClient(_ client: NtfyClient, didEncounterError error: Error) { onError?(error) }
+    func ntfyClient(_ client: NtfyClient, didReceiveMessage message: NtfyMessage) { onMessage?(message) }
+}
+
+// MARK: - Helper
+
+private func makeSessionConfig() -> URLSessionConfiguration {
+    let config = URLSessionConfiguration.ephemeral
+    config.protocolClasses = [HoldingURLProtocol.self]
+    return config
+}
+
+// MARK: - Tests
+
 final class NtfyClientTests: XCTestCase {
     // MARK: - URL Construction
 
@@ -90,4 +154,63 @@ final class NtfyClientTests: XCTestCase {
         client.disconnect()
         client.disconnect()
     }
+
+    // MARK: - Watchdog
+
+    func testWatchdogIntervalIsConfigurable() {
+        let client = NtfyClient(serverURL: "https://ntfy.sh", topics: ["test"], watchdogInterval: 30.0)
+        XCTAssertNotNil(client)
+    }
+
+    /// After disconnect(), the watchdog must not fire and trigger a reconnect.
+    @MainActor func testWatchdogDoesNotFireAfterDisconnect() {
+        HoldingURLProtocol.reset()
+        let connectExp = expectation(description: "No reconnect after disconnect")
+        connectExp.isInverted = true
+
+        let delegate = MockNtfyDelegate()
+        delegate.onConnect = { connectExp.fulfill() }
+
+        let client = NtfyClient(
+            serverURL: "https://ntfy.sh", topics: ["test"],
+            watchdogInterval: 0.05, baseReconnectDelay: 0.0,
+            urlSessionConfiguration: makeSessionConfig()
+        )
+        client.delegate = delegate
+        client.connect()
+        client.disconnect()  // Immediately cancel — watchdog must not trigger
+
+        waitForExpectations(timeout: 0.3)
+    }
+
+/// Cancelled task errors must not trigger reconnect (avoids double-reconnect when watchdog fires).
+    @MainActor func testCancelledTaskDoesNotTriggerReconnect() {
+        HoldingURLProtocol.reset()
+
+        // Connect, then immediately disconnect — only 1 request should ever be made
+        // (no spurious reconnect from the cancelled task's error)
+        let initialExp = expectation(description: "Initial request received")
+        HoldingURLProtocol.onRequest = { count in
+            if count >= 1 { initialExp.fulfill() }
+        }
+
+        let client = NtfyClient(
+            serverURL: "https://ntfy.sh", topics: ["test"],
+            watchdogInterval: 60.0, baseReconnectDelay: 0.0,
+            urlSessionConfiguration: makeSessionConfig()
+        )
+        client.connect()
+        waitForExpectations(timeout: 1.0)
+
+        // Disconnect and wait — request count must stay at 1
+        client.disconnect()
+        let noExtraExp = expectation(description: "No extra reconnect request")
+        noExtraExp.isInverted = true
+        HoldingURLProtocol.onRequest = { count in
+            if count >= 2 { noExtraExp.fulfill() }
+        }
+        waitForExpectations(timeout: 0.3)
+
+        XCTAssertEqual(HoldingURLProtocol.requestCount, 1)
+    }
 }