Add tests

Author: ben-kaufman

BitkitTests/AddressTypeIntegrationTests.swift

@@ -171,4 +171,156 @@ final class AddressTypeIntegrationTests: XCTestCase {
             context: "AddressTypeIntegrationTests"
         )
     }
+
+    // MARK: - Mutex / Concurrency
+
+    @MainActor
+    func testUpdateAddressTypeMutexReturnsImmediately() async throws {
+        try await setupWalletAndNode()
+
+        Logger.test("Testing updateAddressType mutex guard", context: "AddressTypeIntegrationTests")
+        // First call should succeed
+        let success = await settings.updateAddressType(.taproot, wallet: nil)
+        XCTAssertTrue(success)
+
+        // Same type returns true (guard: addressType == selectedAddressType)
+        let sameTypeResult = await settings.updateAddressType(.taproot, wallet: nil)
+        XCTAssertTrue(sameTypeResult, "Same type should return true immediately")
+    }
+
+    // MARK: - Channel Fundable Balance Excludes Legacy
+
+    @MainActor
+    func testGetChannelFundableBalanceExcludesLegacy() async throws {
+        try await setupWalletAndNode()
+
+        let blocktank = CoreService.shared.blocktank
+
+        // Enable legacy monitoring and switch to legacy
+        settings.addressTypesToMonitor = [.nativeSegwit, .legacy]
+        UserDefaults.standard.synchronize()
+        let updateSuccess = await settings.updateAddressType(.legacy, wallet: nil)
+        XCTAssertTrue(updateSuccess)
+
+        let legacyAddress = try await lightning.newAddressForType(.legacy)
+        Logger.test("Funding legacy address: \(legacyAddress)", context: "AddressTypeIntegrationTests")
+        let txId = try await blocktank.regtestDepositFunds(address: legacyAddress, amountSat: 50000)
+        XCTAssertFalse(txId.isEmpty)
+
+        try await blocktank.regtestMineBlocks(6)
+        try await Task.sleep(nanoseconds: 15_000_000_000)
+        try await lightning.sync()
+
+        // Verify legacy has balance
+        let legacyBalance = try await lightning.getBalanceForAddressType(.legacy)
+        XCTAssertGreaterThan(legacyBalance.totalSats, 0, "Legacy should have balance")
+
+        // Channel fundable should NOT include legacy
+        let fundable = try await lightning.getChannelFundableBalance(
+            selectedType: .legacy,
+            monitoredTypes: [.nativeSegwit, .legacy]
+        )
+        XCTAssertEqual(fundable, 0, "Channel fundable should exclude legacy even when it has balance")
+        Logger.test("Channel fundable correctly excludes legacy: \(fundable)", context: "AddressTypeIntegrationTests")
+    }
+
+    // MARK: - Disable Monitoring With Balance Fails
+
+    @MainActor
+    func testSetMonitoringDisableWithBalanceFails() async throws {
+        try await setupWalletAndNode()
+
+        let blocktank = CoreService.shared.blocktank
+
+        // Enable taproot monitoring
+        settings.addressTypesToMonitor = [.nativeSegwit]
+        UserDefaults.standard.synchronize()
+        let addSuccess = await settings.setMonitoring(.taproot, enabled: true, wallet: nil)
+        XCTAssertTrue(addSuccess, "Adding taproot should succeed")
+
+        // Fund the taproot address
+        let taprootAddress = try await lightning.newAddressForType(.taproot)
+        Logger.test("Funding taproot address: \(taprootAddress)", context: "AddressTypeIntegrationTests")
+        let txId = try await blocktank.regtestDepositFunds(address: taprootAddress, amountSat: 50000)
+        XCTAssertFalse(txId.isEmpty)
+
+        try await blocktank.regtestMineBlocks(6)
+        try await Task.sleep(nanoseconds: 15_000_000_000)
+        try await lightning.sync()
+
+        // Verify taproot has balance
+        let taprootBalance = try await lightning.getBalanceForAddressType(.taproot)
+        XCTAssertGreaterThan(taprootBalance.totalSats, 0, "Taproot should have balance after funding")
+
+        // Attempt to disable — should fail because of balance
+        Logger.test("Attempting to disable taproot monitoring with balance", context: "AddressTypeIntegrationTests")
+        let disableSuccess = await settings.setMonitoring(.taproot, enabled: false, wallet: nil)
+        XCTAssertFalse(disableSuccess, "Disabling type with balance should fail")
+        XCTAssertTrue(settings.addressTypesToMonitor.contains(.taproot), "Taproot should remain monitored")
+    }
+
+    // MARK: - Prune Preserves Types With Balance
+
+    @MainActor
+    func testPruneEmptyPreservesTypesWithBalance() async throws {
+        try await setupWalletAndNode()
+
+        let blocktank = CoreService.shared.blocktank
+
+        // Enable taproot monitoring
+        settings.addressTypesToMonitor = [.nativeSegwit]
+        UserDefaults.standard.synchronize()
+        let addSuccess = await settings.setMonitoring(.taproot, enabled: true, wallet: nil)
+        XCTAssertTrue(addSuccess)
+
+        // Fund the taproot address
+        let taprootAddress = try await lightning.newAddressForType(.taproot)
+        Logger.test("Funding taproot for prune test: \(taprootAddress)", context: "AddressTypeIntegrationTests")
+        let txId = try await blocktank.regtestDepositFunds(address: taprootAddress, amountSat: 50000)
+        XCTAssertFalse(txId.isEmpty)
+
+        try await blocktank.regtestMineBlocks(6)
+        try await Task.sleep(nanoseconds: 15_000_000_000)
+        try await lightning.sync()
+
+        // Add legacy (will be empty)
+        let addLegacy = await settings.setMonitoring(.legacy, enabled: true, wallet: nil)
+        XCTAssertTrue(addLegacy)
+        XCTAssertEqual(settings.addressTypesToMonitor.count, 3)
+
+        Logger.test("Pruning — should remove empty legacy but keep funded taproot", context: "AddressTypeIntegrationTests")
+        await settings.pruneEmptyAddressTypesAfterRestore()
+
+        XCTAssertTrue(settings.addressTypesToMonitor.contains(.nativeSegwit), "nativeSegwit should remain")
+        XCTAssertTrue(settings.addressTypesToMonitor.contains(.taproot), "Funded taproot should remain")
+        XCTAssertFalse(settings.addressTypesToMonitor.contains(.legacy), "Empty legacy should be pruned")
+    }
+
+    // MARK: - Address Format Verification
+
+    @MainActor
+    func testNewAddressMatchesTypeFormat() async throws {
+        try await setupWalletAndNode()
+
+        // Enable all types so LDK creates wallets for each
+        settings.addressTypesToMonitor = [.nativeSegwit]
+        UserDefaults.standard.synchronize()
+        for type in [LDKNode.AddressType.taproot, .nestedSegwit, .legacy] {
+            let success = await settings.setMonitoring(type, enabled: true, wallet: nil)
+            XCTAssertTrue(success, "Enabling \(type.stringValue) monitoring should succeed")
+        }
+
+        let expectations: [(LDKNode.AddressType, String, String)] = [
+            (.legacy, "m", "Legacy address should start with m or n on regtest"),
+            (.nestedSegwit, "2", "Nested SegWit address should start with 2 on regtest"),
+            (.nativeSegwit, "bcrt1q", "Native SegWit address should start with bcrt1q on regtest"),
+            (.taproot, "bcrt1p", "Taproot address should start with bcrt1p on regtest"),
+        ]
+
+        for (type, prefix, message) in expectations {
+            let address = try await lightning.newAddressForType(type)
+            Logger.test("\(type.stringValue) address: \(address)", context: "AddressTypeIntegrationTests")
+            XCTAssertTrue(address.hasPrefix(prefix), "\(message), got: \(address)")
+        }
+    }
 }