多设备多方向UI布局测试优化咨询及旋转异常排查

Hey Joseph, great question! Let's break this down into two parts: fixing the rotation-related layout glitches in your test, and exploring better ways to run multi-device, multi-orientation UI tests.

Your current code uses sleep(3) which is a hard wait—this is unreliable because it doesn't account for varying device performance or actual layout completion times. Here's how to fix it:

Key Improvements: #

1. Replace hard waits with XCTest expectations to wait for actual UI stability
2. Explicitly specify landscape directions (left/right) to avoid system defaults causing inconsistencies
3. Isolate test states to prevent cross-contamination between orientation tests

Optimized Test Code: #

func testMainViewInBothOrientations() {
    let app = XCUIApplication()
    app.launchArguments += ["-UITestingDisableAnimations"] // Disable animations for faster, more stable tests
    app.launch()

    // Test Portrait orientation
    XCTContext.runActivity(named: "Main Button Tap (Portrait)") { activity in
        XCUIDevice.shared.orientation = .portrait
        
        // Wait for main button to be stable in portrait layout
        let mainButton = app.buttons["Main"]
        waitForElementToBeReady(mainButton, timeout: 5)
        
        mainButton.tap()
        
        // Wait for target screen to fully load
        let mainScreenTitle = app.staticTexts["MainScreenTitle"]
        waitForElementToBeReady(mainScreenTitle, timeout: 5)
        
        // Capture and attach screenshot
        let screenshot = XCUIScreen.main.screenshot()
        let attachment = XCTAttachment(screenshot: screenshot)
        attachment.lifetime = .keepAlways
        activity.add(attachment)
        
        // Navigate back and wait for menu state
        app.buttons["Menu"].tap()
        waitForElementToBeReady(mainButton, timeout: 5)
    }

    // Test Landscape orientation (explicit left to avoid system ambiguity)
    XCTContext.runActivity(named: "Main Button Tap (Landscape Left)") { activity in
        XCUIDevice.shared.orientation = .landscapeLeft
        
        // Wait for main button to adjust to landscape layout
        let mainButton = app.buttons["Main"]
        waitForElementToBeReady(mainButton, timeout: 5)
        
        mainButton.tap()
        
        // Wait for target screen to load in landscape
        let mainScreenTitle = app.staticTexts["MainScreenTitle"]
        waitForElementToBeReady(mainScreenTitle, timeout: 5)
        
        // Capture and attach screenshot
        let screenshot = XCUIScreen.main.screenshot()
        let attachment = XCTAttachment(screenshot: screenshot)
        attachment.lifetime = .keepAlways
        activity.add(attachment)
    }
}

// Reusable helper to wait for UI element stability
private func waitForElementToBeReady(_ element: XCUIElement, timeout: TimeInterval) {
    let existsPredicate = NSPredicate(format: "exists == true && isHittable == true")
    let expectation = self.expectation(for: existsPredicate, evaluatedWith: element, handler: nil)
    wait(for: [expectation], timeout: timeout)
}

Why This Works: #

• No more fixed sleeps: We wait for elements to be both existing and hittable, ensuring the layout has fully settled.
• Animation disable: Adding the launch argument eliminates layout jank caused by app animations during rotation.
• Explicit orientation: Using .landscapeLeft instead of generic .landscape avoids inconsistencies across devices.

Beyond xcodebuild with multiple destinations, here are more robust approaches:

1. XCTest Plans (Xcode Built-In) #

Xcode's Test Plans let you visually configure and run tests across multiple devices, OS versions, and configurations:

• Create a new Test Plan via File > New > Test Plan
• Add multiple destinations (e.g., iPhone 15, iPad Air) in the "Destinations" tab
• Configure per-destination settings (like forced orientations) or let your test code handle rotation
• Run the plan to execute tests across all targets and generate a unified result bundle

2. Fastlane Snapshot #

Fastlane's Snapshot tool is designed for automated UI screenshot testing at scale:

• Supports batch runs across multiple devices, OS versions, and orientations
• Automatically handles waiting for UI stability and rotation
• Generates visual reports with screenshots, and can integrate with tools like Percy for automated screenshot diffing
• Example Fastfile snippet:

  lane :run_screenshot_tests do
    snapshot(
      scheme: "YourAppScheme",
      devices: ["iPhone 15", "iPad Air (5th generation)"],
      orientations: ["portrait", "landscape_left"],
      output_directory: "./test-screenshots",
      build_for_testing: true
    )
  end
  

3. Parameterized Test Cases #

Use XCTestSuite to dynamically generate tests for all orientations, avoiding repetitive code:

class MainViewOrientationTests: XCTestCase {
    private let orientations: [UIDeviceOrientation] = [.portrait, .landscapeLeft, .landscapeRight]
    private let app = XCUIApplication()

    override func setUp() {
        super.setUp()
        app.launchArguments += ["-UITestingDisableAnimations"]
        app.launch()
    }

    func testAllOrientations() {
        for orientation in orientations {
            XCTContext.runActivity(named: "Main Screen in \(orientation.rawValue)") { activity in
                XCUIDevice.shared.orientation = orientation
                let mainButton = app.buttons["Main"]
                waitForElementToBeReady(mainButton, timeout: 5)
                
                mainButton.tap()
                let mainScreenTitle = app.staticTexts["MainScreenTitle"]
                waitForElementToBeReady(mainScreenTitle, timeout: 5)
                
                let screenshot = XCUIScreen.main.screenshot()
                let attachment = XCTAttachment(screenshot: screenshot)
                attachment.name = "MainScreen_\(orientation.rawValue)"
                attachment.lifetime = .keepAlways
                activity.add(attachment)
                
                app.buttons["Menu"].tap()
                waitForElementToBeReady(mainButton, timeout: 5)
            }
        }
    }

    private func waitForElementToBeReady(_ element: XCUIElement, timeout: TimeInterval) {
        let predicate = NSPredicate(format: "exists == true && isHittable == true")
        let expectation = self.expectation(for: predicate, evaluatedWith: element, handler: nil)
        wait(for: [expectation], timeout: timeout)
    }
}

4. CI/CD Matrix Runs #

In CI systems like GitHub Actions or GitLab CI, use matrix builds to run tests across combinations of devices, OS versions, and orientations:

• Define a matrix with device models, OS versions, and orientation parameters
• Pass orientation settings to your tests via launch arguments or environment variables
• Aggregate results across all matrix jobs for a complete view of UI stability

内容的提问来源于stack exchange，提问作者Joseph