Refactor: Testable Keychain and Identity Manager (#584)

* Make static functions instance functions to be testable

* Injectable KeychainManager + Mock + updated tests

* Remove `pendingActions` from identity manager (dead code)

* Remove `getHandshakeState` from identity manager (dead code)

* Remove `getAllSocialIdentities` from identity manager (dead code)

* Remove `getCryptographicIdentity` from identity manager (dead code)

* Remove `resolveIdentity` from identity manager (dead code)

* Identity Manager: minor clean up

* Put Identity Manager behind a protocol

* Remove Keychain and Identity Manager singletons

* Tests: include MockKeychain/MockIdentityManager in project; init identityManager in CommandProcessorTests

---------

Co-authored-by: jack <jackjackbits@users.noreply.github.com>

bitchatTests/CommandProcessorTests.swift

@@ -2,10 +2,23 @@ import XCTest
 @testable import bitchat
 
 final class CommandProcessorTests: XCTestCase {
+    
+    var identityManager: MockIdentityManager!
+    
+    override func setUp() {
+        super.setUp()
+        // Provide a minimal identity manager for commands that query identity/block lists
+        identityManager = MockIdentityManager(MockKeychain())
+    }
+    
+    override func tearDown() {
+        identityManager = nil
+        super.tearDown()
+    }
 
     @MainActor
     func test_slap_notFoundGrammar() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil)
+        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/slap @system")
         switch result {
         case .error(let message):
@@ -17,7 +30,7 @@ final class CommandProcessorTests: XCTestCase {
 
     @MainActor
     func test_hug_notFoundGrammar() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil)
+        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/hug @system")
         switch result {
         case .error(let message):
@@ -29,7 +42,7 @@ final class CommandProcessorTests: XCTestCase {
 
     @MainActor
     func test_slap_usageMessage() {
-        let processor = CommandProcessor(chatViewModel: nil, meshService: nil)
+        let processor = CommandProcessor(chatViewModel: nil, meshService: nil, identityManager: identityManager)
         let result = processor.process("/slap")
         switch result {
         case .error(let message):
@@ -39,4 +52,3 @@ final class CommandProcessorTests: XCTestCase {
         }
     }
 }
-

bitchatTests/EndToEnd/PrivateChatE2ETests.swift

@@ -16,6 +16,8 @@ final class PrivateChatE2ETests: XCTestCase {
     var bob: MockBluetoothMeshService!
     var charlie: MockBluetoothMeshService!
     
+    private var mockKeychain: MockKeychain!
+    
     override func setUp() {
         super.setUp()
         MockBLEService.resetTestBus()
@@ -24,6 +26,7 @@ final class PrivateChatE2ETests: XCTestCase {
         alice = createMockService(peerID: TestConstants.testPeerID1, nickname: TestConstants.testNickname1)
         bob = createMockService(peerID: TestConstants.testPeerID2, nickname: TestConstants.testNickname2)
         charlie = createMockService(peerID: TestConstants.testPeerID3, nickname: TestConstants.testNickname3)
+        mockKeychain = MockKeychain()
         
         // Delivery tracking is now handled internally by BLEService
     }
@@ -32,6 +35,7 @@ final class PrivateChatE2ETests: XCTestCase {
         alice = nil
         bob = nil
         charlie = nil
+        mockKeychain = nil
         super.tearDown()
     }
     
@@ -116,8 +120,8 @@ final class PrivateChatE2ETests: XCTestCase {
         let aliceKey = Curve25519.KeyAgreement.PrivateKey()
         let bobKey = Curve25519.KeyAgreement.PrivateKey()
         
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish encrypted session
         do {

bitchatTests/Fragmentation/FragmentationTests.swift

@@ -10,6 +10,21 @@ import XCTest
 @testable import bitchat
 
 final class FragmentationTests: XCTestCase {
+    
+    private var mockKeychain: MockKeychain!
+    private var mockIdentityManager: MockIdentityManager!
+    
+    override func setUp() {
+        super.setUp()
+        mockKeychain = MockKeychain()
+        mockIdentityManager = MockIdentityManager(mockKeychain)
+    }
+    
+    override func tearDown() {
+        mockKeychain = nil
+        mockIdentityManager = nil
+        super.tearDown()
+    }
 
     private final class CaptureDelegate: BitchatDelegate {
         var publicMessages: [(peerID: String, nickname: String, content: String)] = []
@@ -75,7 +90,7 @@ final class FragmentationTests: XCTestCase {
     }
 
     func test_reassembly_from_fragments_delivers_public_message() {
-        let ble = BLEService()
+        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
         let capture = CaptureDelegate()
         ble.delegate = capture
 
@@ -106,7 +121,7 @@ final class FragmentationTests: XCTestCase {
     }
 
     func test_duplicate_fragment_does_not_break_reassembly() {
-        let ble = BLEService()
+        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
         let capture = CaptureDelegate()
         ble.delegate = capture
 
@@ -132,7 +147,7 @@ final class FragmentationTests: XCTestCase {
     }
 
     func test_invalid_fragment_header_is_ignored() {
-        let ble = BLEService()
+        let ble = BLEService(keychain: mockKeychain, identityManager: mockIdentityManager)
         let capture = CaptureDelegate()
         ble.delegate = capture
 

bitchatTests/Integration/IntegrationTests.swift

@@ -14,6 +14,7 @@ final class IntegrationTests: XCTestCase {
     
     var nodes: [String: MockBluetoothMeshService] = [:]
     var noiseManagers: [String: NoiseSessionManager] = [:]
+    private var mockKeychain: MockKeychain!
     
     override func setUp() {
         super.setUp()
@@ -21,6 +22,7 @@ final class IntegrationTests: XCTestCase {
         // broadcast propagation across a larger mesh. Integration-only.
         MockBLEService.resetTestBus()
         MockBLEService.autoFloodEnabled = true
+        mockKeychain = MockKeychain()
         
         // Create a network of nodes
         createNode("Alice", peerID: TestConstants.testPeerID1)
@@ -34,6 +36,7 @@ final class IntegrationTests: XCTestCase {
         MockBLEService.autoFloodEnabled = false
         nodes.removeAll()
         noiseManagers.removeAll()
+        mockKeychain = nil
         super.tearDown()
     }
     
@@ -307,7 +310,7 @@ final class IntegrationTests: XCTestCase {
         
         // Simulate Bob restart by recreating his Noise manager
         let bobKey = Curve25519.KeyAgreement.PrivateKey()
-        noiseManagers["Bob"] = NoiseSessionManager(localStaticKey: bobKey)
+        noiseManagers["Bob"] = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Re-establish Noise handshake explicitly via managers
         do {
@@ -593,7 +596,7 @@ final class IntegrationTests: XCTestCase {
         
         // Create Noise manager
         let key = Curve25519.KeyAgreement.PrivateKey()
-        noiseManagers[name] = NoiseSessionManager(localStaticKey: key)
+        noiseManagers[name] = NoiseSessionManager(localStaticKey: key, keychain: mockKeychain)
     }
     
     private func connect(_ node1: String, _ node2: String) {

bitchatTests/Mocks/MockBLEService.swift

@@ -36,6 +36,8 @@ final class MockBLEService: NSObject {
     var myPeerID: String = "MOCK1234"
     var myNickname: String = "MockUser"
     
+    private let mockKeychain = MockKeychain()
+    
     // Test-specific properties
     var sentMessages: [(message: BitchatMessage, packet: BitchatPacket)] = []
     var sentPackets: [BitchatPacket] = []
@@ -272,7 +274,7 @@ final class MockBLEService: NSObject {
     }
     
     func getNoiseService() -> NoiseEncryptionService {
-        return NoiseEncryptionService()
+        return NoiseEncryptionService(keychain: mockKeychain)
     }
     
     func getFingerprint(for peerID: String) -> String? {

bitchatTests/Mocks/MockIdentityManager.swift

@@ -0,0 +1,80 @@
+//
+// MockIdentityManager.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+@testable import bitchat
+
+final class MockIdentityManager: SecureIdentityStateManagerProtocol {
+    private let keychain: KeychainManagerProtocol
+    
+    init(_ keychain: KeychainManagerProtocol) {
+        self.keychain = keychain
+    }
+    
+    func loadIdentityCache() {}
+    
+    func saveIdentityCache() {}
+    
+    func forceSave() {}
+    
+    func getSocialIdentity(for fingerprint: String) -> SocialIdentity? {
+        nil
+    }
+    
+    func upsertCryptographicIdentity(fingerprint: String, noisePublicKey: Data, signingPublicKey: Data?, claimedNickname: String?) {}
+    
+    func getCryptoIdentitiesByPeerIDPrefix(_ peerID: String) -> [CryptographicIdentity] {
+        []
+    }
+    
+    func updateSocialIdentity(_ identity: SocialIdentity) {}
+    
+    func getFavorites() -> Set<String> {
+        Set()
+    }
+    
+    func setFavorite(_ fingerprint: String, isFavorite: Bool) {}
+    
+    func isFavorite(fingerprint: String) -> Bool {
+        false
+    }
+    
+    func isBlocked(fingerprint: String) -> Bool {
+        false
+    }
+    
+    func setBlocked(_ fingerprint: String, isBlocked: Bool) {}
+    
+    func isNostrBlocked(pubkeyHexLowercased: String) -> Bool {
+        true
+    }
+    
+    func setNostrBlocked(_ pubkeyHexLowercased: String, isBlocked: Bool) {}
+    
+    func getBlockedNostrPubkeys() -> Set<String> {
+        Set()
+    }
+    
+    func registerEphemeralSession(peerID: String, handshakeState: HandshakeState) {}
+    
+    func updateHandshakeState(peerID: String, state: HandshakeState) {}
+    
+    func clearAllIdentityData() {}
+    
+    func removeEphemeralSession(peerID: String) {}
+    
+    func setVerified(fingerprint: String, verified: Bool) {}
+    
+    func isVerified(fingerprint: String) -> Bool {
+        true
+    }
+    
+    func getVerifiedFingerprints() -> Set<String> {
+        Set()
+    }
+}

bitchatTests/Mocks/MockKeychain.swift

@@ -0,0 +1,46 @@
+//
+// MockKeychain.swift
+// bitchat
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import Foundation
+@testable import bitchat
+
+final class MockKeychain: KeychainManagerProtocol {
+    private var storage: [String: Data] = [:]
+    
+    func saveIdentityKey(_ keyData: Data, forKey key: String) -> Bool {
+        storage[key] = keyData
+        return true
+    }
+    
+    func getIdentityKey(forKey key: String) -> Data? {
+        storage[key]
+    }
+    
+    func deleteIdentityKey(forKey key: String) -> Bool {
+        storage.removeValue(forKey: key)
+        return true
+    }
+    
+    func deleteAllKeychainData() -> Bool {
+        storage.removeAll()
+        return true
+    }
+    
+    func secureClear(_ data: inout Data) {
+        //
+        data = Data()
+    }
+    
+    func secureClear(_ string: inout String) {
+        string = ""
+    }
+    
+    func verifyIdentityKeyExists() -> Bool {
+        storage["identity_noiseStaticKey"] != nil
+    }
+}

bitchatTests/Noise/NoiseProtocolTests.swift

@@ -16,16 +16,19 @@ final class NoiseProtocolTests: XCTestCase {
     var bobKey: Curve25519.KeyAgreement.PrivateKey!
     var aliceSession: NoiseSession!
     var bobSession: NoiseSession!
+    private var mockKeychain: MockKeychain!
     
     override func setUp() {
         super.setUp()
         aliceKey = Curve25519.KeyAgreement.PrivateKey()
         bobKey = Curve25519.KeyAgreement.PrivateKey()
+        mockKeychain = MockKeychain()
     }
     
     override func tearDown() {
         aliceSession = nil
         bobSession = nil
+        mockKeychain = nil
         super.tearDown()
     }
     
@@ -36,12 +39,14 @@ final class NoiseProtocolTests: XCTestCase {
         aliceSession = NoiseSession(
             peerID: TestConstants.testPeerID2,
             role: .initiator,
+            keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
         bobSession = NoiseSession(
             peerID: TestConstants.testPeerID1,
             role: .responder,
+            keychain: mockKeychain,
             localStaticKey: bobKey
         )
         
@@ -80,6 +85,7 @@ final class NoiseProtocolTests: XCTestCase {
         aliceSession = NoiseSession(
             peerID: TestConstants.testPeerID2,
             role: .initiator,
+            keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
@@ -144,6 +150,7 @@ final class NoiseProtocolTests: XCTestCase {
         aliceSession = NoiseSession(
             peerID: TestConstants.testPeerID2,
             role: .initiator,
+            keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
@@ -157,7 +164,7 @@ final class NoiseProtocolTests: XCTestCase {
     // MARK: - Session Manager Tests
     
     func testSessionManagerBasicOperations() throws {
-        let manager = NoiseSessionManager(localStaticKey: aliceKey)
+        let manager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         
         // Create session
         let session = manager.createSession(for: TestConstants.testPeerID2, role: .initiator)
@@ -174,7 +181,7 @@ final class NoiseProtocolTests: XCTestCase {
     }
     
     func testSessionManagerHandshakeInitiation() throws {
-        let manager = NoiseSessionManager(localStaticKey: aliceKey)
+        let manager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
         
         // Initiate handshake
         let handshakeData = try manager.initiateHandshake(with: TestConstants.testPeerID2)
@@ -187,8 +194,8 @@ final class NoiseProtocolTests: XCTestCase {
     }
     
     func testSessionManagerIncomingHandshake() throws {
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Alice initiates
         let message1 = try aliceManager.initiateHandshake(with: TestConstants.testPeerID2)
@@ -211,8 +218,8 @@ final class NoiseProtocolTests: XCTestCase {
     }
     
     func testSessionManagerEncryptionDecryption() throws {
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -256,11 +263,11 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testSessionIsolation() throws {
         // Create two separate session pairs
-        let aliceSession1 = NoiseSession(peerID: "peer1", role: .initiator, localStaticKey: aliceKey)
-        let bobSession1 = NoiseSession(peerID: "alice1", role: .responder, localStaticKey: bobKey)
+        let aliceSession1 = NoiseSession(peerID: "peer1", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        let bobSession1 = NoiseSession(peerID: "alice1", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
-        let aliceSession2 = NoiseSession(peerID: "peer2", role: .initiator, localStaticKey: aliceKey)
-        let bobSession2 = NoiseSession(peerID: "alice2", role: .responder, localStaticKey: bobKey)
+        let aliceSession2 = NoiseSession(peerID: "peer2", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        let bobSession2 = NoiseSession(peerID: "alice2", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
         // Establish both pairs
         try performHandshake(initiator: aliceSession1, responder: bobSession1)
@@ -282,8 +289,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testPeerRestartDetection() throws {
         // Establish initial sessions
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
@@ -295,7 +302,7 @@ final class NoiseProtocolTests: XCTestCase {
         _ = try aliceManager.decrypt(message2, from: TestConstants.testPeerID2)
         
         // Simulate Bob restart by creating new manager with same key
-        let bobManagerRestarted = NoiseSessionManager(localStaticKey: bobKey)
+        let bobManagerRestarted = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Bob initiates new handshake after restart
         let newHandshake1 = try bobManagerRestarted.initiateHandshake(with: TestConstants.testPeerID1)
@@ -318,8 +325,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testNonceDesynchronizationRecovery() throws {
         // Create two sessions
-        aliceSession = NoiseSession(peerID: TestConstants.testPeerID2, role: .initiator, localStaticKey: aliceKey)
-        bobSession = NoiseSession(peerID: TestConstants.testPeerID1, role: .responder, localStaticKey: bobKey)
+        aliceSession = NoiseSession(peerID: TestConstants.testPeerID2, role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+        bobSession = NoiseSession(peerID: TestConstants.testPeerID1, role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
         
         // Establish sessions
         try performHandshake(initiator: aliceSession, responder: bobSession)
@@ -342,8 +349,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testConcurrentEncryption() throws {
         // Test thread safety of encryption operations
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
@@ -380,8 +387,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testSessionStaleDetection() throws {
         // Test that sessions are properly marked as stale
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
         
@@ -394,8 +401,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testHandshakeAfterDecryptionFailure() throws {
         // Test that handshake is properly initiated after decryption failure
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -413,8 +420,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testHandshakeAlwaysAcceptedWithExistingSession() throws {
         // Test that handshake is always accepted even with existing valid session
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -453,8 +460,8 @@ final class NoiseProtocolTests: XCTestCase {
     
     func testNonceDesynchronizationCausesRehandshake() throws {
         // Test that nonce desynchronization leads to proper re-handshake
-        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey)
-        let bobManager = NoiseSessionManager(localStaticKey: bobKey)
+        let aliceManager = NoiseSessionManager(localStaticKey: aliceKey, keychain: mockKeychain)
+        let bobManager = NoiseSessionManager(localStaticKey: bobKey, keychain: mockKeychain)
         
         // Establish sessions
         try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
@@ -499,8 +506,8 @@ final class NoiseProtocolTests: XCTestCase {
     func testHandshakePerformance() throws {
         measure {
             do {
-                let alice = NoiseSession(peerID: "bob", role: .initiator, localStaticKey: aliceKey)
-                let bob = NoiseSession(peerID: "alice", role: .responder, localStaticKey: bobKey)
+                let alice = NoiseSession(peerID: "bob", role: .initiator, keychain: mockKeychain, localStaticKey: aliceKey)
+                let bob = NoiseSession(peerID: "alice", role: .responder, keychain: mockKeychain, localStaticKey: bobKey)
                 try performHandshake(initiator: alice, responder: bob)
             } catch {
                 XCTFail("Handshake failed: \(error)")
@@ -530,12 +537,14 @@ final class NoiseProtocolTests: XCTestCase {
         aliceSession = NoiseSession(
             peerID: TestConstants.testPeerID2,
             role: .initiator,
+            keychain: mockKeychain,
             localStaticKey: aliceKey
         )
         
         bobSession = NoiseSession(
             peerID: TestConstants.testPeerID1,
             role: .responder,
+            keychain: mockKeychain,
             localStaticKey: bobKey
         )