Saya mencoba untuk menulis kasus uji menggunakan Pengujian UI baru yang tersedia di Xcode 7 beta 2. Aplikasi ini memiliki layar login di mana ia membuat panggilan ke server untuk login. Ada penundaan yang terkait dengan ini karena ini merupakan operasi yang tidak sinkron.

Apakah ada cara untuk menyebabkan penundaan atau menunggu mekanisme di XCTestCase sebelum melanjutkan ke langkah selanjutnya?

Tidak ada dokumentasi yang tepat tersedia dan saya membaca file Header kelas. Tidak dapat menemukan apa pun yang terkait dengan ini.

Ada ide / saran?

Asynchronous UI Testing diperkenalkan di Xcode 7 Beta 4. Untuk menunggu label dengan teks "Halo, dunia!" untuk muncul Anda dapat melakukan hal berikut:

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)

Rincian lebih lanjut tentang Pengujian UI dapat ditemukan di blog saya.

Selain itu, Anda bisa tidur:

sleep(10)

Karena UITests berjalan dalam proses lain, ini berfungsi. Saya tidak tahu bagaimana itu disarankan, tetapi berhasil.

iOS 11 / Xcode 9

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

Ini adalah pengganti yang bagus untuk semua implementasi kustom di situs ini!

Pastikan untuk melihat jawaban saya di sini: https://stackoverflow.com/a/48937714/971329 . Di sana saya menjelaskan alternatif untuk menunggu permintaan yang akan sangat mengurangi waktu tes Anda berjalan!

Xcode 9 memperkenalkan trik baru dengan XCTWaiter

Test case menunggu secara eksplisit

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

Delegasi instance pelayan untuk menguji

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

Kelas pelayan mengembalikan hasil

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
}

penggunaan sampel

Sebelum Xcode 9

Tujuan 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];
        }
    }];
}

PEMAKAIAN

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

Cepat

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)
            }
        }
    }

PEMAKAIAN

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

atau

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

SUMBER

Pada Xcode 8.3, kita dapat menggunakan XCTWaiter http://masilotti.com/xctest-waiting/

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
}

Trik lain adalah menulis waitfungsi, kredit diberikan kepada John Sundell karena menunjukkannya kepada saya

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)
  }
}

dan menggunakannya seperti

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)
}

Berdasarkan jawaban @ Ted , saya telah menggunakan ekstensi ini:

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)
            }
        }
    }

}

Anda bisa menggunakannya seperti ini

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

Ini juga memungkinkan untuk menunggu elemen menghilang, atau properti lainnya berubah (dengan menggunakan blok yang sesuai)

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

Edit:

Sebenarnya baru saja terpikir oleh saya bahwa di Xcode 7b4, pengujian UI sekarang telah expectationForPredicate:evaluatedWithObject:handler:

Asli:

Cara lain adalah dengan memutar putaran proses untuk waktu yang ditentukan. Benar-benar hanya berguna jika Anda tahu berapa banyak (perkiraan) waktu yang harus Anda tunggu

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

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

Ini tidak sangat berguna jika Anda perlu menguji beberapa kondisi untuk melanjutkan tes Anda. Untuk menjalankan pemeriksaan bersyarat, gunakan satu whilelingkaran.

Kode berikut hanya berfungsi dengan Objective 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];
}

Cukup panggil fungsi ini seperti yang diberikan di bawah ini.

[self wait: 10];

Dalam kasus saya sleepbuat efek samping jadi saya gunakanwait

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

Menurut API untuk XCUIElement .existsdapat digunakan untuk memeriksa apakah ada pertanyaan atau tidak sehingga sintaks berikut dapat berguna dalam beberapa kasus!

let app = XCUIApplication()
app.launch()

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

Jika Anda yakin harapan Anda akan terpenuhi pada akhirnya Anda bisa mencoba menjalankannya. Perlu dicatat bahwa mogok mungkin lebih baik jika penantiannya terlalu lama dalam hal mana waitForExpectationsWithTimeout(_,handler:_)dari pos @ Jo Masilotti harus digunakan.

tidur akan memblokir utas

"Tidak ada proses run loop terjadi saat utas diblokir."

Anda dapat menggunakan waitForExistence

let app = XCUIApplication()
app.launch()

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

Ini akan membuat penundaan tanpa membuat utas tertidur atau membuat kesalahan pada batas waktu:

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

Karena harapannya terbalik, ia akan diam-diam habis.