func testOptimisticWriteWithQueryParameter()

in AWSAppSyncIntegrationTests/AWSAppSyncAPIKeyAuthTests.swift [173:247]
65 lines of code
2 McCabe index (conditional complexity)

    func testOptimisticWriteWithQueryParameter() {
        let postCreated = expectation(description: "Post created successfully.")
        let successfulMutationEvent2Expectation = expectation(description: "Mutation done successfully.")
        let successfulOptimisticWriteExpectation = expectation(description: "Optimisitc write done successfully.")
        let successfulQueryFetchExpectation = expectation(description: "Query fetch should success.")
        let successfulLocalQueryFetchExpectation = expectation(description: "Local query fetch should success.")

        let addPost = DefaultTestPostData.defaultCreatePostWithoutFileUsingParametersMutation

        appSyncClient?.perform(mutation: addPost, queue: AWSAppSyncAPIKeyAuthTests.mutationQueue, resultHandler:  { result, error in
            print("CreatePost result handler invoked")
            XCTAssertNil(error)
            XCTAssertNotNil(result?.data?.createPostWithoutFileUsingParameters?.id)
            XCTAssertEqual(result!.data!.createPostWithoutFileUsingParameters?.author, DefaultTestPostData.author)
            postCreated.fulfill()
        })
        wait(for: [postCreated], timeout: AWSAppSyncAPIKeyAuthTests.networkOperationTimeout)

        let fetchQuery = ListPostsQuery()

        var cacheCount = 0

        appSyncClient?.fetch(query: fetchQuery,
                             cachePolicy: .fetchIgnoringCacheData,
                             queue: AWSAppSyncAPIKeyAuthTests.subscriptionAndFetchQueue) { result, error in
                                XCTAssertNil(error)
                                XCTAssertNotNil(result?.data?.listPosts)
                                XCTAssertGreaterThan(result?.data?.listPosts?.count ?? 0, 0, "Expected service to return at least 1 event.")
                                cacheCount = result?.data?.listPosts?.count ?? 0
                                successfulQueryFetchExpectation.fulfill()
        }

        wait(for: [successfulQueryFetchExpectation], timeout: AWSAppSyncAPIKeyAuthTests.networkOperationTimeout)

        appSyncClient?.perform(mutation: addPost,
                               queue: AWSAppSyncAPIKeyAuthTests.mutationQueue,
                               optimisticUpdate: { transaction in
                                do {
                                    try transaction?.update(query: fetchQuery) { data in
                                        let item = ListPostsQuery.Data.ListPost(
                                            id: "TestItemId",
                                            author: DefaultTestPostData.author,
                                            title: DefaultTestPostData.title,
                                            content: DefaultTestPostData.content,
                                            ups: 0,
                                            downs: 0
                                        )
                                        data.listPosts?.append(item)
                                    }
                                    successfulOptimisticWriteExpectation.fulfill()
                                } catch {
                                    XCTFail("Failed to perform optimistic update: \(error)")
                                }
        },
                               resultHandler: { result, error in
                                XCTAssertNil(error)
                                XCTAssertNotNil(result?.data?.createPostWithoutFileUsingParameters?.id)
                                XCTAssertEqual(result?.data?.createPostWithoutFileUsingParameters?.author, DefaultTestPostData.author)
                                successfulMutationEvent2Expectation.fulfill()
        })

        wait(for: [successfulOptimisticWriteExpectation, successfulMutationEvent2Expectation], timeout: AWSAppSyncAPIKeyAuthTests.networkOperationTimeout)

        appSyncClient?.fetch(query: fetchQuery,
                             cachePolicy: .returnCacheDataDontFetch,
                             queue: AWSAppSyncAPIKeyAuthTests.subscriptionAndFetchQueue) { (result, error) in
            XCTAssertNil(error)
            XCTAssertNotNil(result?.data?.listPosts)
            XCTAssertGreaterThan(result?.data?.listPosts?.count ?? 0, 0, "Expected cache to return at least 1 event.")
            XCTAssertEqual(result?.data?.listPosts?.count ?? 0, cacheCount + 1)
            successfulLocalQueryFetchExpectation.fulfill()
        }

        wait(for: [successfulLocalQueryFetchExpectation], timeout: 5.0)
    }