func testAllSubscriptionsCancelledShouldDisconnectTheWebsocket2()

in AppSyncRealTimeClientIntegrationTests/AppSyncRealTimeClientIntegrationTests.swift [72:153]
75 lines of code
17 McCabe index (conditional complexity)

    func testAllSubscriptionsCancelledShouldDisconnectTheWebsocket2() {
        let connectedInvoked = expectation(description: "Connection established")
        connectedInvoked.expectedFulfillmentCount = 3

        let authInterceptor = APIKeyAuthInterceptor(apiKey)
        let connectionProvider = ConnectionProviderFactory.createConnectionProvider(
            for: url,
            authInterceptor: authInterceptor,
            connectionType: .appSyncRealtime
        )
        let subscriptionConnection1 = AppSyncSubscriptionConnection(provider: connectionProvider)
        let item1 = subscriptionConnection1.subscribe(
            requestString: requestString,
            variables: nil
        ) { event, _ in
            if case let .connection(state) = event {
                if case .connected = state {
                    connectedInvoked.fulfill()
                }
            }
        }
        let subscriptionConnection2 = AppSyncSubscriptionConnection(provider: connectionProvider)
        let item2 = subscriptionConnection2.subscribe(
            requestString: requestString,
            variables: nil
        ) { event, _ in
            if case let .connection(state) = event {
                if case .connected = state {
                    connectedInvoked.fulfill()
                }
            }
        }
        let subscriptionConnection3 = AppSyncSubscriptionConnection(provider: connectionProvider)
        let item3 = subscriptionConnection3.subscribe(
            requestString: requestString,
            variables: nil
        ) { event, _ in
            if case let .connection(state) = event {
                if case .connected = state {
                    connectedInvoked.fulfill()
                }
            }
        }

        XCTAssertNotNil(item1)
        XCTAssertNotNil(item2)
        XCTAssertNotNil(item3)
        wait(for: [connectedInvoked], timeout: TestCommonConstants.networkTimeout)

        guard let realTimeConnectionProvider = connectionProvider as? RealtimeConnectionProvider else {
            XCTFail("Could not retrieve concrete connection provider")
            return
        }

        assertStatus(of: realTimeConnectionProvider, equals: .connected)

        subscriptionConnection1.unsubscribe(item: item1)
        assertStatus(of: realTimeConnectionProvider, equals: .connected)
        subscriptionConnection2.unsubscribe(item: item2)
        assertStatus(of: realTimeConnectionProvider, equals: .connected)
        subscriptionConnection3.unsubscribe(item: item3)

        assertStatus(of: realTimeConnectionProvider, equals: .notConnected)

        let newConnectedInvoked = expectation(description: "Connection established")
        let subscriptionConnection4 = AppSyncSubscriptionConnection(provider: connectionProvider)
        let newItem = subscriptionConnection4.subscribe(
            requestString: requestString,
            variables: nil
        ) { event, _ in
            if case let .connection(state) = event {
                if case .connected = state {
                    newConnectedInvoked.fulfill()
                }
            }
        }
        wait(for: [newConnectedInvoked], timeout: TestCommonConstants.networkTimeout)
        assertStatus(of: realTimeConnectionProvider, equals: .connected)
        subscriptionConnection4.unsubscribe(item: newItem)
        sleep(5)
        assertStatus(of: realTimeConnectionProvider, equals: .notConnected)
    }