Come posso ottenere XCTest per attendere chiamate asincrone in setUp prima dell'esecuzione dei test?

Question

Sto scrivendo test di integrazione in Xcode 6 per andare a fianco dei miei test unitari e funzionali. XCTest ha un metodo setUp() che viene chiamato prima di ogni test. Grande!

Ha anche XCTestException che consente di scrivere test asincroni. Ottimo anche!

Tuttavia, desidero popolare il mio database di test con i dati di test prima di ogni test e setUp inizia a eseguire i test prima che venga eseguita la chiamata al database asincrono.

C'è un modo per impostare setUp fino a quando il mio database non è pronto prima di eseguire i test?

Ecco un esempio di ciò che ho fatto ora. Dal momento che i rendimenti programma di installazione prima il database è popolando devo duplicare un sacco di codice di prova ogni prova:

func test_checkSomethingExists() { 

    let expectation = expectationWithDescription("") 
    var expected:DatabaseItem 

    // Fill out a database with data. 
    var data = getData() 
    overwriteDatabase(data, { 
     // Database populated. 
     // Do test... in this pseudocode I just check something... 
     db.retrieveDatabaseItem({ expected in 

     XCTAssertNotNil(expected) 

     expectation.fulfill() 
     }) 
    }) 

    waitForExpectationsWithTimeout(5.0) { (error) in 
     if error != nil { 
      XCTFail(error.localizedDescription) 
     } 
    } 

} 

Ecco quello che vorrei:

class MyTestCase: XCTestCase { 

    override func setUp() { 
     super.setUp() 

     // Fill out a database with data. I can make this call do anything, here 
     // it returns a block. 
     var data = getData() 
     db.overwriteDatabase(data, onDone:() ->() { 

      // When database done, do something that causes setUp to end 
      // and start running tests 

     })   
    } 

    func test_checkSomethingExists() { 

     let expectation = expectationWithDescription("") 
     var expected:DatabaseItem 


      // Do test... in this pseudocode I just check something... 
      db.retrieveDatabaseItem({ expected in 

      XCTAssertNotNil(expected) 

      expectation.fulfill() 
     }) 

     waitForExpectationsWithTimeout(5.0) { (error) in 
      if error != nil { 
       XCTFail(error.localizedDescription) 
      } 
     } 

    } 

} 

Answer 1

Ci sono due tecniche per l'esecuzione di test asincroni. XCTestExpectation e semafori. Nel caso di fare qualcosa di asincrono in setUp, si dovrebbe usare la tecnica del semaforo:

override func setUp() { 
    super.setUp() 

    // Fill out a database with data. I can make this call do anything, here 
    // it returns a block. 

    let data = getData() 

    let semaphore = dispatch_semaphore_create(0) 

    db.overwriteDatabase(data) { 

     // do some stuff 

     dispatch_semaphore_signal(semaphore) 
    } 

    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) 
} 

nota, per questo al lavoro, questo blocco onDone non può essere eseguito sul thread principale (altrimenti ti deadlock).

---

loop Se questo blocco onDone gira sulla coda principale, è possibile utilizzare Esegui:

override func setUp() { 
    super.setUp() 

    var finished = false 

    // Fill out a database with data. I can make this call do anything, here 
    // it returns a block. 

    let data = getData() 

    db.overwriteDatabase(data) { 

     // do some stuff 

     finished = true 
    } 

    while !finished { 
     NSRunLoop.currentRunLoop().runMode(NSDefaultRunLoopMode, beforeDate: NSDate.distantFuture()) 
    } 
} 

Si tratta di un modello molto inefficiente, ma a seconda di come overwriteDatabase è stata attuata, potrebbe essere necessario

Nota, utilizzare questo modello solo se si è a conoscenza del fatto che il blocco onDone viene eseguito sul thread principale (in caso contrario sarà necessario eseguire la sincronizzazione della variabile finished).

Answer 2

Invece di utilizzare semafori o loop di blocco, è possibile utilizzare la stessa funzione waitForExpectationsWithTimeout:handler: che si utilizza nei casi di test asincroni.

// Swift 
override func setUp() { 
    super.setUp() 

    let exp = expectation(description: "\(#function)\(#line)") 

    // Issue an async request 
    let data = getData() 
    db.overwriteDatabase(data) { 
     // do some stuff 
     exp.fulfill() 
    } 

    // Wait for the async request to complete 
    waitForExpectations(timeout: 40, handler: nil) 
} 

// Objective-C 
- (void)setUp { 
    [super setUp]; 

    NSString *description = [NSString stringWithFormat:@"%s%d", __FUNCTION__, __LINE__]; 
    XCTestExpectation *exp = [self expectationWithDescription:description]; 

    // Issue an async request 
    NSData *data = [self getData]; 
    [db overwriteDatabaseData: data block: ^(){ 
     [exp fulfill]; 
    }];   

    // Wait for the async request to complete 
    [self waitForExpectationsWithTimeout:40 handler: nil]; 
}