Ich versuche, einen Testfall mit dem neuen UI-Test zu schreiben, der in Xcode 7 Beta 2 verfügbar ist. Die App verfügt über einen Anmeldebildschirm, auf dem sie den Server anruft, um sich anzumelden. Damit ist eine Verzögerung verbunden, da es sich um eine asynchrone Operation handelt.

Gibt es eine Möglichkeit, im XCTestCase einen Verzögerungs- oder Wartemechanismus zu verursachen, bevor Sie mit weiteren Schritten fortfahren?

Es ist keine ordnungsgemäße Dokumentation verfügbar, und ich habe die Header-Dateien der Klassen durchgesehen. Konnte nichts im Zusammenhang damit finden.

Irgendwelche Ideen / Vorschläge?

Asynchrones UI-Testen wurde in Xcode 7 Beta 4 eingeführt. Warten auf ein Etikett mit dem Text "Hallo Welt!" Um zu erscheinen, können Sie Folgendes tun:

let app = XCUIApplication()
app.launch()

let label = app.staticTexts["Hello, world!"]
let exists = NSPredicate(format: "exists == 1")

expectationForPredicate(exists, evaluatedWithObject: label, handler: nil)
waitForExpectationsWithTimeout(5, handler: nil)

Weitere Details zu UI-Tests finden Sie in meinem Blog.

Außerdem können Sie einfach schlafen:

sleep(10)

Da die UITests in einem anderen Prozess ausgeführt werden, funktioniert dies. Ich weiß nicht, wie ratsam es ist, aber es funktioniert.

Xcode 9 hat mit XCTWaiter neue Tricks eingeführt

Testfall wartet explizit

wait(for: [documentExpectation], timeout: 10)

Kellnerinstanz delegiert zum Testen

XCTWaiter(delegate: self).wait(for: [documentExpectation], timeout: 10)

Die Kellnerklasse gibt das Ergebnis zurück

let result = XCTWaiter.wait(for: [documentExpectation], timeout: 10)
switch(result) {
case .completed:
    //all expectations were fulfilled before timeout!
case .timedOut:
    //timed out before all of its expectations were fulfilled
case .incorrectOrder:
    //expectations were not fulfilled in the required order
case .invertedFulfillment:
    //an inverted expectation was fulfilled
case .interrupted:
    //waiter was interrupted before completed or timedOut
}

Beispielnutzung

Vor Xcode 9

Ziel c

- (void)waitForElementToAppear:(XCUIElement *)element withTimeout:(NSTimeInterval)timeout
{
    NSUInteger line = __LINE__;
    NSString *file = [NSString stringWithUTF8String:__FILE__];
    NSPredicate *existsPredicate = [NSPredicate predicateWithFormat:@"exists == true"];

    [self expectationForPredicate:existsPredicate evaluatedWithObject:element handler:nil];

    [self waitForExpectationsWithTimeout:timeout handler:^(NSError * _Nullable error) {
        if (error != nil) {
            NSString *message = [NSString stringWithFormat:@"Failed to find %@ after %f seconds",element,timeout];
            [self recordFailureWithDescription:message inFile:file atLine:line expected:YES];
        }
    }];
}

VERWENDUNG

XCUIElement *element = app.staticTexts["Name of your element"];
[self waitForElementToAppear:element withTimeout:5];

Schnell

func waitForElementToAppear(element: XCUIElement, timeout: NSTimeInterval = 5,  file: String = #file, line: UInt = #line) {
        let existsPredicate = NSPredicate(format: "exists == true")

        expectationForPredicate(existsPredicate,
                evaluatedWithObject: element, handler: nil)

        waitForExpectationsWithTimeout(timeout) { (error) -> Void in
            if (error != nil) {
                let message = "Failed to find \(element) after \(timeout) seconds."
                self.recordFailureWithDescription(message, inFile: file, atLine: line, expected: true)
            }
        }
    }

VERWENDUNG

let element = app.staticTexts["Name of your element"]
self.waitForElementToAppear(element)

oder

let element = app.staticTexts["Name of your element"]
self.waitForElementToAppear(element, timeout: 10)

QUELLE

iOS 11 / Xcode 9

<#yourElement#>.waitForExistence(timeout: 5)

Dies ist ein großartiger Ersatz für alle benutzerdefinierten Implementierungen auf dieser Site!

Schauen Sie sich unbedingt meine Antwort hier an: https://stackoverflow.com/a/48937714/971329 . Dort beschreibe ich eine Alternative zum Warten auf Anfragen, die die Laufzeit Ihrer Tests erheblich verkürzt!

Ab Xcode 8.3 können wir XCTWaiter http://masilotti.com/xctest-waiting/ verwenden.

func waitForElementToAppear(_ element: XCUIElement) -> Bool {
    let predicate = NSPredicate(format: "exists == true")
    let expectation = expectation(for: predicate, evaluatedWith: element, 
                                  handler: nil)

    let result = XCTWaiter().wait(for: [expectation], timeout: 5)
    return result == .completed
}

Ein weiterer Trick besteht darin, eine waitFunktion zu schreiben. John Sundell ist es zu verdanken, dass er sie mir gezeigt hat

extension XCTestCase {

  func wait(for duration: TimeInterval) {
    let waitExpectation = expectation(description: "Waiting")

    let when = DispatchTime.now() + duration
    DispatchQueue.main.asyncAfter(deadline: when) {
      waitExpectation.fulfill()
    }

    // We use a buffer here to avoid flakiness with Timer on CI
    waitForExpectations(timeout: duration + 0.5)
  }
}

und benutze es gerne

func testOpenLink() {
  let delegate = UIApplication.shared.delegate as! AppDelegate
  let route = RouteMock()
  UIApplication.shared.open(linkUrl, options: [:], completionHandler: nil)

  wait(for: 1)

  XCTAssertNotNil(route.location)
}

Basierend auf der Antwort von @ Ted habe ich diese Erweiterung verwendet:

extension XCTestCase {

    // Based on https://stackoverflow.com/a/33855219
    func waitFor<T>(object: T, timeout: TimeInterval = 5, file: String = #file, line: UInt = #line, expectationPredicate: @escaping (T) -> Bool) {
        let predicate = NSPredicate { obj, _ in
            expectationPredicate(obj as! T)
        }
        expectation(for: predicate, evaluatedWith: object, handler: nil)

        waitForExpectations(timeout: timeout) { error in
            if (error != nil) {
                let message = "Failed to fulful expectation block for \(object) after \(timeout) seconds."
                self.recordFailure(withDescription: message, inFile: file, atLine: line, expected: true)
            }
        }
    }

}

Sie können es so verwenden

let element = app.staticTexts["Name of your element"]
waitFor(object: element) { $0.exists }

Sie können auch darauf warten, dass ein Element verschwindet oder eine andere Eigenschaft geändert wird (mithilfe des entsprechenden Blocks).

waitFor(object: element) { !$0.exists } // Wait for it to disappear

Bearbeiten:

Mir ist gerade eingefallen, dass in Xcode 7b4 jetzt UI-Tests durchgeführt wurden expectationForPredicate:evaluatedWithObject:handler:

Original:

Eine andere Möglichkeit besteht darin, die Laufschleife für eine festgelegte Zeitspanne zu drehen. Wirklich nur nützlich, wenn Sie wissen, auf wie viel (geschätzte) Zeit Sie warten müssen

Obj-C: [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow: <<time to wait in seconds>>]]

Schnell: NSRunLoop.currentRunLoop().runMode(NSDefaultRunLoopMode, beforeDate: NSDate(timeIntervalSinceNow: <<time to wait in seconds>>))

Dies ist nicht besonders nützlich, wenn Sie einige Bedingungen testen müssen, um Ihren Test fortzusetzen. Verwenden Sie eine whileSchleife, um bedingte Prüfungen durchzuführen.

Der folgende Code funktioniert nur mit Ziel C.

- (void)wait:(NSUInteger)interval {

    XCTestExpectation *expectation = [self expectationWithDescription:@"wait"];
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(interval * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        [expectation fulfill];
    });
    [self waitForExpectationsWithTimeout:interval handler:nil];
}

Rufen Sie einfach diese Funktion wie unten angegeben auf.

[self wait: 10];

In meinem Fall sleepentstand ein Nebeneffekt, den ich benutztewait

let _ = XCTWaiter.wait(for: [XCTestExpectation(description: "Hello World!")], timeout: 2.0)

Gemäß der API für XCUIElement .existskann überprüft werden, ob eine Abfrage vorhanden ist oder nicht, sodass die folgende Syntax in einigen Fällen hilfreich sein kann!

let app = XCUIApplication()
app.launch()

let label = app.staticTexts["Hello, world!"]
while !label.exists {
    sleep(1)
}

Wenn Sie sicher sind, dass Ihre Erwartungen irgendwann erfüllt werden, können Sie versuchen, dies auszuführen. Es sollte beachtet werden, dass ein Absturz vorzuziehen ist, wenn die Wartezeit zu lang ist. In diesem Fall waitForExpectationsWithTimeout(_,handler:_)sollte der Beitrag von @Joe Masilotti verwendet werden.

Schlaf blockiert den Thread

"Während der Thread blockiert ist, findet keine Run-Loop-Verarbeitung statt."

Sie können waitForExistence verwenden

let app = XCUIApplication()
app.launch()

if let label = app.staticTexts["Hello, world!"] {
label.waitForExistence(timeout: 5)
}

Dies führt zu einer Verzögerung, ohne den Thread in den Ruhezustand zu versetzen oder beim Timeout einen Fehler auszulösen:

let delayExpectation = XCTestExpectation()
delayExpectation.isInverted = true
wait(for: [delayExpectation], timeout: 5)

Da die Erwartung umgekehrt ist, tritt eine leise Zeitüberschreitung auf.