func testGetUserThenFetchPostEditorsToRetrievePosts()

in AmplifyPlugins/API/AWSAPICategoryPluginFunctionalTests/GraphQLModelBased/GraphQLConnectionScenario5Tests.swift [218:305]
86 lines of code
10 McCabe index (conditional complexity)

    func testGetUserThenFetchPostEditorsToRetrievePosts() {
        guard let post1 = createPost(title: "title") else {
            XCTFail("Could not create post")
            return
        }
        guard let post2 = createPost(title: "title") else {
            XCTFail("Could not create post")
            return
        }
        guard let user = createUser(username: "username") else {
            XCTFail("Could not create user")
            return
        }
        guard createPostEditor(post: post1, editor: user) != nil else {
            XCTFail("Could not create postEditor with `post1`")
            return
        }
        guard createPostEditor(post: post2, editor: user) != nil else {
            XCTFail("Could not create postEditor with `post2`")
            return
        }
        let getUserCompleted = expectation(description: "get user complete")
        let fetchPostEditorCompleted = expectation(description: "fetch postEditors complete")
        var results: List<PostEditor5>?
        Amplify.API.query(request: .get(User5.self, byId: user.id)) { result in
            switch result {
            case .success(let result):
                switch result {
                case .success(let queriedUserOptional):
                    guard let queriedUser = queriedUserOptional else {
                        XCTFail("Could not get post")
                        return
                    }
                    XCTAssertEqual(queriedUser.id, user.id)
                    getUserCompleted.fulfill()
                    guard let posts = queriedUser.posts else {
                        XCTFail("Could not get postEditors")
                        return
                    }
                    posts.fetch { fetchResults in
                        switch fetchResults {
                        case .success:
                            results = posts
                            fetchPostEditorCompleted.fulfill()
                        case .failure(let error):
                            XCTFail("Could not fetch postEditors \(error)")
                        }
                    }
                case .failure(let response):
                    XCTFail("Failed with: \(response)")
                }
            case .failure(let error):
                XCTFail("\(error)")
            }
        }
        wait(for: [getUserCompleted, fetchPostEditorCompleted], timeout: TestCommonConstants.networkTimeout)

        guard var subsequentResults = results else {
            XCTFail("Could not get first results")
            return
        }
        var resultsArray: [PostEditor5] = []
        resultsArray.append(contentsOf: subsequentResults)
        while subsequentResults.hasNextPage() {
            let semaphore = DispatchSemaphore(value: 0)
            subsequentResults.getNextPage { result in
                defer {
                    semaphore.signal()
                }
                switch result {
                case .success(let listResult):
                    subsequentResults = listResult
                    resultsArray.append(contentsOf: subsequentResults)
                case .failure(let coreError):
                    XCTFail("Unexpected error: \(coreError)")
                }

            }
            semaphore.wait()
        }
        XCTAssertEqual(resultsArray.count, 2)
        XCTAssertTrue(resultsArray.contains(where: { (postEditor) -> Bool in
            postEditor.post.id == post1.id
        }))
        XCTAssertTrue(resultsArray.contains(where: { (postEditor) -> Bool in
            postEditor.post.id == post2.id
        }))
    }