Wie kann ich XCTest dazu bringen, auf asynchrone Aufrufe in setUp zu warten, bevor Tests ausgeführt werden?

Ich Schreibe, integration tests in Xcode 6 zu gehen zusammen mit meinem unit-und funktionale tests. XCTest hat eine setUp () - Methode aufgerufen wird, vor jedem test. Super!!!

Es hat auch XCTestException, die lassen mich schreiben asynchronen tests. Ebenfalls Super!

Allerdings möchte ich zum Auffüllen meiner test-Datenbank mit test-Daten vor jedem test und setUp, nur mit der Ausführung der tests, bevor die asynchrone Datenbank-Aufruf erfolgt ist.

Ist es ein Weg, um setUp zu warten, bis meine Datenbank fertig ist, bevor es führt tests?

Hier ist ein Beispiel, was ich jetzt tun soll. Seit dem setUp zurück, bevor die Datenbank erfolgt das Auffüllen habe ich so duplizieren Sie eine Menge von test-code bei jedem test:

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

}

Hier ist, was ich möchte:

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

    }

}

InformationsquelleAutor der Frage Brett Elliot | 2015-04-08

Gibt es zwei Techniken für die Ausführung von asynchronen tests. XCTestExpectation und Semaphoren. In dem Fall etwas zu tun asynchrone setUpdie Sie verwenden sollten, die semaphore-Technik:

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

Hinweis, für die, die arbeiten, dies onDone block nicht in der Haupt-thread (oder du wirst deadlock).

Wenn diese onDone block läuft auf der Haupt-Warteschlange, die Sie verwenden können, ausführen Schleifen:

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

Dies ist eine sehr ineffiziente Muster, aber je nachdem, wie overwriteDatabase umgesetzt wurde, kann es notwendig sein

Hinweis, nur verwenden Sie dieses Muster, wenn Sie wissen, dass onDone block läuft auf dem main thread (sonst werden Sie zu tun haben, einige Synchronisation von finished variable).

InformationsquelleAutor der Antwort Rob

Anstatt Semaphoren oder blockieren Schleifen, können Sie den gleichen waitForExpectationsWithTimeout:handler: Funktion, die Sie in Ihrem async-test-Fällen.

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

InformationsquelleAutor der Antwort RndmTsk

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.