func testUpdateRegistrationToAnotherAttendee()

in AmplifyPlugins/DataStore/AWSDataStoreCategoryPluginIntegrationTests/TransformerV2/DataStoreConnectionScenario8V2Tests.swift [121:218]
93 lines of code
15 McCabe index (conditional complexity)

    func testUpdateRegistrationToAnotherAttendee() throws {
        try startAmplifyAndWaitForSync()
        guard let attendee = saveAttendee(),
              let attendee2 = saveAttendee(),
              let meeting = saveMeeting(),
              var registration = saveRegistration(meeting: meeting, attendee: attendee) else {
                  XCTFail("Could not create attendee, meeting, registration")
                  return
              }
        let createReceived = expectation(description: "Create notification received")
        createReceived.expectedFulfillmentCount = 4 // 4 models (2 attendees and 1 meeting and 1 registration)
        let updateReceived = expectation(description: "Update notification received")

        let hubListener = Amplify.Hub.listen(
            to: .dataStore,
            eventName: HubPayload.EventName.DataStore.syncReceived) { payload in
                guard let mutationEvent = payload.data as? MutationEvent
                else {
                    XCTFail("Can't cast payload as mutation event")
                    return
                }
                if let attendeeEvent = try? mutationEvent.decodeModel() as? Attendee8V2,
                   attendeeEvent.id == attendee.id || attendeeEvent.id == attendee2.id {
                    if mutationEvent.mutationType == GraphQLMutationType.create.rawValue {
                        XCTAssertEqual(mutationEvent.version, 1)
                        createReceived.fulfill()
                        return
                    }

                }

                if let meetingEvent = try? mutationEvent.decodeModel() as? Meeting8V2, meetingEvent.id == meeting.id {
                    if mutationEvent.mutationType == GraphQLMutationType.create.rawValue {
                        XCTAssertEqual(meetingEvent.title, meeting.title)
                        XCTAssertEqual(mutationEvent.version, 1)
                        createReceived.fulfill()
                        return
                    }
                }
                if let registrationEvent = try? mutationEvent.decodeModel() as? Registration8V2,
                   registrationEvent.id == registration.id {
                    if mutationEvent.mutationType == GraphQLMutationType.create.rawValue {
                        XCTAssertEqual(mutationEvent.version, 1)
                        createReceived.fulfill()
                        return
                    } else if mutationEvent.mutationType == GraphQLMutationType.update.rawValue {
                        XCTAssertEqual(mutationEvent.version, 2)
                        updateReceived.fulfill()
                        return
                    }
                }
            }
        guard try HubListenerTestUtilities.waitForListener(with: hubListener, timeout: 5.0) else {
            XCTFail("Listener not registered for hub")
            return
        }
        wait(for: [createReceived], timeout: TestCommonConstants.networkTimeout)

        let updateRegistrationCompleted = expectation(description: "update registration completed")
        registration.attendee = attendee2
        Amplify.DataStore.save(registration) { result in
            switch result {
            case .success(let updatedRegistration):
                XCTAssertEqual(updatedRegistration.attendee.id, attendee2.id)
                updateRegistrationCompleted.fulfill()
            case .failure(let response): XCTFail("Failed with: \(response)")
            }
        }
        wait(for: [updateRegistrationCompleted, updateReceived], timeout: TestCommonConstants.networkTimeout)

        let getAttendeesCompleted = expectation(description: "get attendees completed")
        getAttendeesCompleted.expectedFulfillmentCount = 2
        Amplify.DataStore.query(Attendee8V2.self, byId: attendee.id) { result in
            switch result {
            case .success(let queriedAttendeeOptional):
                guard let queriedAttendee = queriedAttendeeOptional else {
                    XCTFail("Could not get attendee")
                    return
                }
                XCTAssertEqual(queriedAttendee.meetings?.count, 0)
                getAttendeesCompleted.fulfill()
            case .failure(let response): XCTFail("Failed with: \(response)")
            }
        }
        Amplify.DataStore.query(Attendee8V2.self, byId: attendee2.id) { result in
            switch result {
            case .success(let queriedAttendeeOptional):
                guard let queriedAttendee = queriedAttendeeOptional else {
                    XCTFail("Could not get attendee")
                    return
                }
                XCTAssertEqual(queriedAttendee.meetings?.count, 1)
                getAttendeesCompleted.fulfill()
            case .failure(let response): XCTFail("Failed with: \(response)")
            }
        }
        wait(for: [getAttendeesCompleted], timeout: TestCommonConstants.networkTimeout)
    }