Xcode 7 beta 2'de mevcut yeni UI Testi kullanarak bir test senaryosu yazmaya çalışıyorum. Uygulama, giriş yapmak için sunucuya bir çağrı yapan bir giriş ekranına sahiptir. Zaman uyumsuz bir işlem olduğu için bununla ilgili bir gecikme vardır.

Sonraki adımlara geçmeden önce XCTestCase'de gecikme veya bekleme mekanizmasına neden olmanın bir yolu var mı?

Uygun bir belge yok ve sınıfların Başlık dosyalarından geçtim. Bununla ilgili hiçbir şey bulamadı.

Herhangi bir fikir / öneriniz var mı?

Xcode 7 Beta 4'te Asenkron UI Testi tanıtıldı. "Merhaba dünya!" Metnini içeren bir etiket beklemek için. görünmek için aşağıdakileri yapabilirsiniz:

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)

Kullanıcı Arayüzü Testi hakkında daha fazla bilgiyi blogumda bulabilirsiniz.

Ayrıca, sadece uyuyabilirsiniz:

sleep(10)

UITest'ler başka bir işlemde çalıştığından, bu işe yarar. Ne kadar tavsiye edilebilir bilmiyorum, ama işe yarıyor.

iOS 11 / Xcode 9

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

Bu, bu sitedeki tüm özel uygulamalar için harika bir alternatif!

Cevabımı burada gördüğünüzden emin olun: https://stackoverflow.com/a/48937714/971329 . Orada, testlerinizin çalışma süresini büyük ölçüde azaltacak talepleri beklemeye bir alternatif açıklıyorum!

Xcode 9 , XCTWaiter ile yeni numaralar getirdi

Test davası açık bir şekilde bekliyor

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

Garson örneği test etmek için temsilci seçiyor

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

Garson sınıfı sonucu döndürüyor

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
}

örnek kullanım

Xcode 9'dan önce

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

KULLANIM

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

hızlı

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

KULLANIM

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

veya

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

KAYNAK

Xcode 8.3 itibariyle http://masilotti.com/xctest-waiting/ adresini kullanabilirizXCTWaiter

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
}

Başka bir hile, bir waitişlev yazmak , kredi bana göstermek için John Sundell'e gidiyor

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

ve onu gibi kullan

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

@ Ted'in cevabına dayanarak şu uzantıyı kullandım:

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

}

Bu şekilde kullanabilirsiniz

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

Ayrıca bir öğenin kaybolmasını veya başka bir özelliğin değişmesini bekler (uygun bloğu kullanarak).

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

Düzenle:

Aslında Xcode 7b4'te UI testinin şimdi expectationForPredicate:evaluatedWithObject:handler:

Orijinal:

Başka bir yol, çalışma döngüsünü belirli bir süre döndürmektir. Gerçekten sadece ne kadar (tahmini) zaman beklemeniz gerektiğini biliyorsanız faydalıdır

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

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

Testinize devam etmek için bazı koşulları test etmeniz gerekiyorsa bu çok kullanışlı değildir. Koşullu denetimleri çalıştırmak için bir whiledöngü kullanın .

Aşağıdaki kod yalnızca Objective C ile çalışır.

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

Sadece bu işlevi aşağıda belirtildiği gibi arayın.

[self wait: 10];

Benim durumumda sleepyan etki yarattım, bu yüzden kullandımwait

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

XCUIElement için API'ye göre .existsbir sorgu olup olmadığını kontrol etmek için kullanılabilir, bu nedenle aşağıdaki sözdizimi bazı durumlarda yararlı olabilir!

let app = XCUIApplication()
app.launch()

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

Beklentinizin eninde sonunda karşılanacağından eminseniz, bunu çalıştırmayı deneyebilirsiniz. Beklemenin çok uzun olması durumunda waitForExpectationsWithTimeout(_,handler:_)çökmenin tercih edilebileceği unutulmamalıdır; bu durumda @Joe Masilotti'nin gönderisinden kullanılmalıdır.

uyku ipliği engeller

"İş parçacığı engellendiğinde çalışma döngüsü işleme gerçekleşmez."

waitForExistence'ı kullanabilirsiniz

let app = XCUIApplication()
app.launch()

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

Bu, iş parçacığını uyku moduna geçirmeden veya zaman aşımı sırasında bir hata atmadan bir gecikme oluşturur:

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

Beklenti tersine döndüğü için sessizce zaman aşımına uğrar.