304 lines
12 KiB
Swift
304 lines
12 KiB
Swift
import XCTest
|
|
import Foundation
|
|
import CoreGraphics
|
|
|
|
final class MultiWindowNotificationsUITests: XCTestCase {
|
|
private var dataPath = ""
|
|
private var socketPath = ""
|
|
|
|
override func setUp() {
|
|
super.setUp()
|
|
continueAfterFailure = false
|
|
dataPath = "/tmp/cmux-ui-test-multi-window-notifs-\(UUID().uuidString).json"
|
|
socketPath = "/tmp/cmux-ui-test-socket-\(UUID().uuidString).sock"
|
|
try? FileManager.default.removeItem(atPath: dataPath)
|
|
try? FileManager.default.removeItem(atPath: socketPath)
|
|
}
|
|
|
|
override func tearDown() {
|
|
try? FileManager.default.removeItem(atPath: dataPath)
|
|
try? FileManager.default.removeItem(atPath: socketPath)
|
|
super.tearDown()
|
|
}
|
|
|
|
func testNotificationsRouteToCorrectWindow() {
|
|
let app = XCUIApplication()
|
|
app.launchEnvironment["CMUX_UI_TEST_MULTI_WINDOW_NOTIF_SETUP"] = "1"
|
|
app.launchEnvironment["CMUX_UI_TEST_MULTI_WINDOW_NOTIF_PATH"] = dataPath
|
|
app.launch()
|
|
app.activate()
|
|
|
|
XCTAssertTrue(
|
|
waitForData(keys: [
|
|
"window1Id",
|
|
"window2Id",
|
|
"window2InitialSidebarSelection",
|
|
"tabId1",
|
|
"tabId2",
|
|
"notifId1",
|
|
"notifId2",
|
|
"expectedLatestWindowId",
|
|
"expectedLatestTabId",
|
|
], timeout: 15.0),
|
|
"Expected multi-window notification setup data"
|
|
)
|
|
|
|
guard let setup = loadData() else {
|
|
XCTFail("Missing setup data")
|
|
return
|
|
}
|
|
|
|
let expectedLatestWindowId = setup["expectedLatestWindowId"] ?? ""
|
|
let expectedLatestTabId = setup["expectedLatestTabId"] ?? ""
|
|
let window2Id = setup["window2Id"] ?? ""
|
|
let window2InitialSidebarSelection = setup["window2InitialSidebarSelection"] ?? ""
|
|
let tabId2 = setup["tabId2"] ?? ""
|
|
let notifId2 = setup["notifId2"] ?? ""
|
|
|
|
XCTAssertFalse(expectedLatestWindowId.isEmpty)
|
|
XCTAssertFalse(expectedLatestTabId.isEmpty)
|
|
XCTAssertFalse(window2Id.isEmpty)
|
|
XCTAssertEqual(window2InitialSidebarSelection, "notifications")
|
|
XCTAssertFalse(tabId2.isEmpty)
|
|
XCTAssertFalse(notifId2.isEmpty)
|
|
|
|
// Sanity: ensure the second window was actually created.
|
|
XCTAssertTrue(waitForWindowCount(atLeast: 2, app: app, timeout: 6.0))
|
|
|
|
// Jump to latest unread (Cmd+Shift+U). This should bring the owning window forward.
|
|
let beforeToken = loadData()?["focusToken"]
|
|
app.typeKey("u", modifierFlags: [.command, .shift])
|
|
|
|
XCTAssertTrue(
|
|
waitForFocusChange(from: beforeToken, timeout: 6.0),
|
|
"Expected focus record after jump-to-unread"
|
|
)
|
|
guard let afterJump = loadData() else {
|
|
XCTFail("Missing focus data after jump")
|
|
return
|
|
}
|
|
XCTAssertEqual(afterJump["focusedWindowId"], expectedLatestWindowId)
|
|
XCTAssertEqual(afterJump["focusedTabId"], expectedLatestTabId)
|
|
|
|
// Open the notifications popover (Cmd+I) and click the notification belonging to window 2.
|
|
let beforeClickToken = afterJump["focusToken"]
|
|
app.typeKey("i", modifierFlags: [.command])
|
|
|
|
let targetButton = app.buttons["NotificationPopoverRow.\(notifId2)"]
|
|
XCTAssertTrue(targetButton.waitForExistence(timeout: 6.0), "Expected notification row button to exist")
|
|
XCTAssertTrue(
|
|
clickNotificationPopoverRowAndWaitForFocusChange(
|
|
button: targetButton,
|
|
app: app,
|
|
from: beforeClickToken,
|
|
timeout: 6.0
|
|
),
|
|
"Expected focus record after clicking notification"
|
|
)
|
|
guard let afterClick = loadData() else {
|
|
XCTFail("Missing focus data after click")
|
|
return
|
|
}
|
|
XCTAssertEqual(afterClick["focusedWindowId"], window2Id)
|
|
XCTAssertEqual(afterClick["focusedTabId"], tabId2)
|
|
XCTAssertEqual(afterClick["focusedSidebarSelection"], "tabs")
|
|
}
|
|
|
|
func testNotificationsPopoverCanCloseViaShortcutAndEscape() {
|
|
let app = XCUIApplication()
|
|
app.launchEnvironment["CMUX_UI_TEST_MULTI_WINDOW_NOTIF_SETUP"] = "1"
|
|
app.launchEnvironment["CMUX_UI_TEST_MULTI_WINDOW_NOTIF_PATH"] = dataPath
|
|
app.launch()
|
|
app.activate()
|
|
|
|
XCTAssertTrue(
|
|
waitForData(keys: ["notifId1"], timeout: 15.0),
|
|
"Expected multi-window notification setup data"
|
|
)
|
|
|
|
guard let notifId1 = loadData()?["notifId1"], !notifId1.isEmpty else {
|
|
XCTFail("Missing setup notification id")
|
|
return
|
|
}
|
|
|
|
XCTAssertTrue(waitForWindowCount(atLeast: 1, app: app, timeout: 6.0))
|
|
|
|
app.typeKey("i", modifierFlags: [.command])
|
|
let targetButton = app.buttons["NotificationPopoverRow.\(notifId1)"]
|
|
XCTAssertTrue(targetButton.waitForExistence(timeout: 6.0), "Expected popover to open on Show Notifications shortcut")
|
|
|
|
app.typeKey("i", modifierFlags: [.command])
|
|
XCTAssertTrue(waitForElementToDisappear(targetButton, timeout: 3.0), "Expected popover to close on repeated Show Notifications shortcut")
|
|
|
|
app.typeKey("i", modifierFlags: [.command])
|
|
XCTAssertTrue(targetButton.waitForExistence(timeout: 6.0), "Expected popover to reopen on Show Notifications shortcut")
|
|
|
|
app.typeKey(XCUIKeyboardKey.escape.rawValue, modifierFlags: [])
|
|
XCTAssertTrue(waitForElementToDisappear(targetButton, timeout: 3.0), "Expected popover to close on Escape")
|
|
}
|
|
|
|
func testEmptyNotificationsPopoverBlocksTerminalTyping() {
|
|
let app = XCUIApplication()
|
|
app.launchEnvironment["CMUX_SOCKET_PATH"] = socketPath
|
|
app.launch()
|
|
app.activate()
|
|
|
|
XCTAssertTrue(waitForWindowCount(atLeast: 1, app: app, timeout: 8.0))
|
|
XCTAssertTrue(waitForSocketPong(timeout: 8.0), "Expected control socket to respond")
|
|
|
|
_ = socketCommand("clear_notifications")
|
|
|
|
app.typeKey("i", modifierFlags: [.command])
|
|
XCTAssertTrue(app.staticTexts["No notifications yet"].waitForExistence(timeout: 6.0), "Expected empty notifications popover state")
|
|
|
|
let marker = "cmux_notif_block_\(UUID().uuidString.replacingOccurrences(of: "-", with: "").prefix(8))"
|
|
let before = readCurrentTerminalText() ?? ""
|
|
XCTAssertFalse(before.contains(marker), "Unexpected marker precondition collision")
|
|
|
|
app.typeText(marker)
|
|
RunLoop.current.run(until: Date().addingTimeInterval(0.25))
|
|
|
|
guard let after = readCurrentTerminalText() else {
|
|
XCTFail("Expected terminal text from control socket")
|
|
return
|
|
}
|
|
XCTAssertFalse(after.contains(marker), "Expected typing to be blocked while empty notifications popover is open")
|
|
}
|
|
|
|
private func clickNotificationPopoverRowAndWaitForFocusChange(
|
|
button: XCUIElement,
|
|
app: XCUIApplication,
|
|
from token: String?,
|
|
timeout: TimeInterval
|
|
) -> Bool {
|
|
// `.click()` on a button inside an NSPopover can be flaky on the VM; prefer a coordinate click
|
|
// within the left side of the row (away from the clear button).
|
|
if button.exists {
|
|
let coord = button.coordinate(withNormalizedOffset: CGVector(dx: 0.15, dy: 0.5))
|
|
coord.click()
|
|
} else {
|
|
button.click()
|
|
}
|
|
|
|
// If the coordinate click was swallowed (popover auto-dismiss, etc), retry with a normal click.
|
|
let firstDeadline = min(1.0, timeout)
|
|
if waitForFocusChange(from: token, timeout: firstDeadline) {
|
|
return true
|
|
}
|
|
button.click()
|
|
return waitForFocusChange(from: token, timeout: max(0.0, timeout - firstDeadline))
|
|
}
|
|
|
|
private func waitForWindowCount(atLeast count: Int, app: XCUIApplication, timeout: TimeInterval) -> Bool {
|
|
let deadline = Date().addingTimeInterval(timeout)
|
|
while Date() < deadline {
|
|
if app.windows.count >= count { return true }
|
|
RunLoop.current.run(until: Date().addingTimeInterval(0.05))
|
|
}
|
|
return app.windows.count >= count
|
|
}
|
|
|
|
private func waitForElementToDisappear(_ element: XCUIElement, timeout: TimeInterval) -> Bool {
|
|
let predicate = NSPredicate(format: "exists == false")
|
|
let expectation = XCTNSPredicateExpectation(predicate: predicate, object: element)
|
|
return XCTWaiter().wait(for: [expectation], timeout: timeout) == .completed
|
|
}
|
|
|
|
private func waitForFocusChange(from token: String?, timeout: TimeInterval) -> Bool {
|
|
let deadline = Date().addingTimeInterval(timeout)
|
|
while Date() < deadline {
|
|
if let data = loadData(),
|
|
let current = data["focusToken"],
|
|
!current.isEmpty,
|
|
current != token {
|
|
return true
|
|
}
|
|
RunLoop.current.run(until: Date().addingTimeInterval(0.05))
|
|
}
|
|
if let data = loadData(),
|
|
let current = data["focusToken"],
|
|
!current.isEmpty,
|
|
current != token {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
private func waitForData(keys: [String], timeout: TimeInterval) -> Bool {
|
|
let deadline = Date().addingTimeInterval(timeout)
|
|
while Date() < deadline {
|
|
if let data = loadData(), keys.allSatisfy({ (data[$0] ?? "").isEmpty == false }) {
|
|
return true
|
|
}
|
|
RunLoop.current.run(until: Date().addingTimeInterval(0.05))
|
|
}
|
|
if let data = loadData(), keys.allSatisfy({ (data[$0] ?? "").isEmpty == false }) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
private func waitForSocketPong(timeout: TimeInterval) -> Bool {
|
|
let deadline = Date().addingTimeInterval(timeout)
|
|
while Date() < deadline {
|
|
if socketCommand("ping") == "PONG" {
|
|
return true
|
|
}
|
|
RunLoop.current.run(until: Date().addingTimeInterval(0.05))
|
|
}
|
|
return socketCommand("ping") == "PONG"
|
|
}
|
|
|
|
private func socketCommand(_ cmd: String) -> String? {
|
|
let nc = "/usr/bin/nc"
|
|
guard FileManager.default.isExecutableFile(atPath: nc) else { return nil }
|
|
|
|
let proc = Process()
|
|
proc.executableURL = URL(fileURLWithPath: nc)
|
|
proc.arguments = ["-U", socketPath, "-w", "2"]
|
|
|
|
let inPipe = Pipe()
|
|
let outPipe = Pipe()
|
|
let errPipe = Pipe()
|
|
proc.standardInput = inPipe
|
|
proc.standardOutput = outPipe
|
|
proc.standardError = errPipe
|
|
|
|
do {
|
|
try proc.run()
|
|
} catch {
|
|
return nil
|
|
}
|
|
|
|
if let data = (cmd + "\n").data(using: .utf8) {
|
|
inPipe.fileHandleForWriting.write(data)
|
|
}
|
|
inPipe.fileHandleForWriting.closeFile()
|
|
|
|
proc.waitUntilExit()
|
|
|
|
let outData = outPipe.fileHandleForReading.readDataToEndOfFile()
|
|
guard let outStr = String(data: outData, encoding: .utf8) else { return nil }
|
|
if let first = outStr.split(separator: "\n", maxSplits: 1).first {
|
|
return String(first).trimmingCharacters(in: .whitespacesAndNewlines)
|
|
}
|
|
let trimmed = outStr.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
return trimmed.isEmpty ? nil : trimmed
|
|
}
|
|
|
|
private func readCurrentTerminalText() -> String? {
|
|
guard let response = socketCommand("read_terminal_text"), response.hasPrefix("OK ") else {
|
|
return nil
|
|
}
|
|
let encoded = String(response.dropFirst(3)).trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard let data = Data(base64Encoded: encoded) else { return nil }
|
|
return String(data: data, encoding: .utf8)
|
|
}
|
|
|
|
private func loadData() -> [String: String]? {
|
|
guard let data = try? Data(contentsOf: URL(fileURLWithPath: dataPath)) else {
|
|
return nil
|
|
}
|
|
return (try? JSONSerialization.jsonObject(with: data)) as? [String: String]
|
|
}
|
|
}
|