func testDeleteRegistration()

in AmplifyPlugins/DataStore/AWSDataStoreCategoryPluginIntegrationTests/TransformerV2/DataStoreConnectionScenario8V2Tests.swift [220:309]
90 lines of code
14 McCabe index (conditional complexity)

    func testDeleteRegistration() throws {
        try startAmplifyAndWaitForSync()
        guard let attendee = saveAttendee(),
              let meeting = saveMeeting(),
              let registration = saveRegistration(meeting: meeting, attendee: attendee) else {
                  XCTFail("Could not create attendee, meeting, registration")
            return
        }
        let createReceived = expectation(description: "Create notification received")
        createReceived.expectedFulfillmentCount = 3 // 3 models (1 attendee and 1 meeting and 1 registration)
        let deleteRegistrationRecieved = expectation(description: "Delete registration 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 {
                    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.delete.rawValue {
                        XCTAssertEqual(mutationEvent.version, 2)
                        deleteRegistrationRecieved.fulfill()
                    }
                }
        }
        guard try HubListenerTestUtilities.waitForListener(with: hubListener, timeout: 5.0) else {
            XCTFail("Listener not registered for hub")
            return
        }
        wait(for: [createReceived], timeout: TestCommonConstants.networkTimeout)
        let deleteCompleted = expectation(description: "delete completed")
        Amplify.DataStore.delete(Registration8V2.self, withId: registration.id) { result in
            switch result {
            case .success:
                deleteCompleted.fulfill()
            case .failure(let response): XCTFail("Failed with: \(response)")
            }
        }
        wait(for: [deleteCompleted, deleteRegistrationRecieved], timeout: TestCommonConstants.networkTimeout)
        let getAttendeeCompleted = expectation(description: "get attendee completed")
        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)
                getAttendeeCompleted.fulfill()
            case .failure(let response): XCTFail("Failed with: \(response)")
            }
        }
        wait(for: [getAttendeeCompleted], timeout: TestCommonConstants.networkTimeout)
        let getMeetingCompleted = expectation(description: "get meeting completed")
        Amplify.DataStore.query(Meeting8V2.self, byId: meeting.id) { result in
            switch result {
            case .success(let queriedMeetingOptional):
                guard let queriedMeeting = queriedMeetingOptional else {
                    XCTFail("Could not get meeting")
                    return
                }
                XCTAssertEqual(queriedMeeting.attendees?.count, 0)
                getMeetingCompleted.fulfill()
            case .failure(let response): XCTFail("Failed with: \(response)")
            }
        }
        wait(for: [getMeetingCompleted], timeout: TestCommonConstants.networkTimeout)
    }