async def test_get_all_presence(presence_service, mocked_presence_api_client):
    mocked_presence_api_client.v2_users_presence_get.return_value = \
        deserialize_object(V2PresenceList, "["
                                           "    {"
                                           "        \"category\":\"AVAILABLE\","
                                           "        \"userId\":14568529068038,"
                                           "        \"timestamp\":1533928483800},"
                                           "    {"
                                           "        \"category\":\"OFFLINE\","
                                           "        \"userId\":974217539631,"
                                           "        \"timestamp\":1503286226030"
                                           "    }"
                                           "]")

    presence_list = await presence_service.get_all_presence(1234, 5000)

    mocked_presence_api_client.v2_users_presence_get.assert_called_once_with(session_token="session_token",
                                                                             last_user_id=1234,
                                                                             limit=5000)
    assert len(presence_list) == 2
    assert presence_list[0].user_id == 14568529068038
    assert presence_list[0].category == "AVAILABLE"
    assert presence_list[0].timestamp == 1533928483800
    assert presence_list[1].user_id == 974217539631
    assert presence_list[1].category == "OFFLINE"
async def test_read_presence_feed(presence_service, mocked_presence_api_client):
    mocked_presence_api_client.v1_presence_feed_feed_id_read_get.return_value = \
        deserialize_object(V2PresenceList, "["
                                           "  {"
                                           "      \"category\":\"AVAILABLE\","
                                           "      \"userId\":7078106103901,"
                                           "      \"timestamp\":1489769156271"
                                           "  },"
                                           "  {"
                                           "      \"category\":\"ON_THE_PHONE\","
                                           "      \"userId\":7078106103902,"
                                           "      \"timestamp\":1489769156273"
                                           "  }"
                                           "]")

    feed_id = "c4dca251-8639-48db-a9d4-f387089e17cf"
    presence_list = await presence_service.read_presence_feed(feed_id)

    mocked_presence_api_client.v1_presence_feed_feed_id_read_get.assert_called_once_with(session_token="session_token",
                                                                                         feed_id=feed_id)
    assert len(presence_list) == 2
    assert presence_list[0].category == "AVAILABLE"
    assert presence_list[0].user_id == 7078106103901
    assert presence_list[1].category == "ON_THE_PHONE"
    assert presence_list[1].user_id == 7078106103902
async def test_list_connections(connection_api, connection_service):
    connection_api.v1_connection_list_get = AsyncMock()
    connection_api.v1_connection_list_get.return_value = deserialize_object(UserConnectionList,
                                                                            "["
                                                                            "   {"
                                                                            "       \"userId\": 7078106126503,"
                                                                            "       \"status\": \"PENDING_OUTGOING\","
                                                                            "       \"updatedAt\": 1471018076255"
                                                                            "   },"
                                                                            "   {"
                                                                            "       \"userId\": 7078106103809,"
                                                                            "       \"status\": \"PENDING_INCOMING\","
                                                                            "       \"updatedAt\": 1467562406219"
                                                                            "   }"
                                                                            "]")

    user_connections = await connection_service.list_connections(ConnectionStatus.ALL, [7078106126503, 7078106103809])

    connection_api.v1_connection_list_get.assert_called_with(
        user_ids="7078106126503,7078106103809",
        status=ConnectionStatus.ALL.value,
        session_token="session_token"
    )

    assert len(user_connections) == 2
    assert user_connections[0].user_id == 7078106126503
    assert user_connections[1].status == ConnectionStatus.PENDING_INCOMING.value
async def test_create_presence_feed(presence_service, mocked_presence_api_client):
    mocked_presence_api_client.v1_presence_feed_create_post.return_value = \
        deserialize_object(StringId, "{\"id\":\"c4dca251-8639-48db-a9d4-f387089e17cf\"}")

    feed_id = await presence_service.create_presence_feed()

    assert feed_id == "c4dca251-8639-48db-a9d4-f387089e17cf"
async def test_delete_presence_feed(presence_service, mocked_presence_api_client):
    mocked_presence_api_client.v1_presence_feed_feed_id_delete_post.return_value = \
        deserialize_object(StringId, "{\"id\":\"c4dca251-8639-48db-a9d4-f387089e17cf\"}")

    feed_id = await presence_service.delete_presence_feed("c4dca251-8639-48db-a9d4-f387089e17cf")

    mocked_presence_api_client.v1_presence_feed_feed_id_delete_post.assert_called_once_with(
        session_token="session_token",
        feed_id=feed_id)
    assert feed_id == "c4dca251-8639-48db-a9d4-f387089e17cf"
async def test_get_presence(presence_service, mocked_presence_api_client):
    mocked_presence_api_client.v2_user_presence_get.return_value = deserialize_object(V2Presence,
                                                                                      "{\"category\":\"AVAILABLE\","
                                                                                      "\"userId\":14568529068038,"
                                                                                      "\"timestamp\":1533928483800}")

    presence = await presence_service.get_presence()

    assert presence.category == "AVAILABLE"
    assert presence.user_id == 14568529068038
Esempio n. 7
0
async def test_get_status(user_api, user_service):
    user_api.v1_admin_user_uid_status_get = AsyncMock()
    user_api.v1_admin_user_uid_status_get.return_value = deserialize_object(
        UserStatus, "{\"status\": \"ENABLED\"}")

    status = await user_service.get_status(1234)

    user_api.v1_admin_user_uid_status_get.assert_called_with(
        uid=1234, session_token="session_token")

    assert status.status == "ENABLED"
Esempio n. 8
0
async def test_get_attachment_types(mocked_api_client, message_service):
    mocked_api_client.call_api.return_value = deserialize_object(StringList, "["
                                                                             "   \".bmp\","
                                                                             "   \".doc\","
                                                                             "   \".png\","
                                                                             "   \".mpeg\""
                                                                             "]")

    attachment_types = await message_service.get_attachment_types()

    assert len(attachment_types) == 4
    assert attachment_types[0] == ".bmp"
Esempio n. 9
0
async def test_get_delegates(user_api, user_service):
    user_api.v1_admin_user_uid_delegates_get = AsyncMock()
    user_api.v1_admin_user_uid_delegates_get.return_value = deserialize_object(
        IntegerList, "[7215545078461]")

    delegate_list = await user_service.get_delegates(1234)

    user_api.v1_admin_user_uid_delegates_get.assert_called_with(
        uid=1234, session_token="session_token")

    assert len(delegate_list) == 1
    assert delegate_list[0] == 7215545078461
async def test_set_presence(presence_service, mocked_presence_api_client):
    mocked_presence_api_client.v2_user_presence_post.return_value = deserialize_object(V2Presence,
                                                                                       "{\"category\":\"AWAY\","
                                                                                       "\"userId\":14568529068038,"
                                                                                       "\"timestamp\":1533928483800}")

    presence = await presence_service.set_presence(PresenceStatus.AWAY, True)

    mocked_presence_api_client.v2_user_presence_post.assert_called_once_with(session_token="session_token",
                                                                             presence=V2PresenceStatus(category="AWAY"),
                                                                             soft=True)
    assert presence.category == "AWAY"
    assert presence.user_id == 14568529068038
async def test_get_user_presence(presence_service, mocked_presence_api_client):
    mocked_presence_api_client.v3_user_uid_presence_get.return_value = \
        deserialize_object(V2Presence,
                           "{\"category\":\"AVAILABLE\","
                           "\"userId\":14568529068038,"
                           "\"timestamp\":1533928483800}")

    presence = await presence_service.get_user_presence(1234, True)

    mocked_presence_api_client.v3_user_uid_presence_get.assert_called_once_with(uid=1234,
                                                                                session_token="session_token",
                                                                                local=True)
    assert presence.user_id == 14568529068038
    assert presence.category == "AVAILABLE"
async def test_get_connection(connection_api, connection_service):
    connection_api.v1_connection_user_user_id_info_get = AsyncMock()
    connection_api.v1_connection_user_user_id_info_get.return_value = \
        deserialize_object(UserConnection, "{"
                                           "   \"userId\": 769658112378,"
                                           "   \"status\": \"ACCEPTED\""
                                           "}")

    user_connection = await connection_service.get_connection(769658112378)

    connection_api.v1_connection_user_user_id_info_get.assert_called_with(
        user_id="769658112378",
        session_token="session_token"
    )
    assert user_connection.user_id == 769658112378
    assert user_connection.status == ConnectionStatus.ACCEPTED.value
async def test_reject_connection(connection_api, connection_service):
    connection_api.v1_connection_reject_post = AsyncMock()
    connection_api.v1_connection_reject_post.return_value = deserialize_object(UserConnection,
                                                                               "{"
                                                                               "   \"userId\": 7215545059385,"
                                                                               "   \"status\": \"REJECTED\","
                                                                               "   \"firstRequestedAt\": 1471044955409,"
                                                                               "   \"updatedAt\": 1471045390420,"
                                                                               "   \"requestCounter\": 1"
                                                                               "}")

    user_connection = await connection_service.reject_connection(7215545059385)

    connection_api.v1_connection_reject_post.assert_called_with(
        connection_request=UserConnectionRequest(user_id=7215545059385),
        session_token="session_token"
    )

    assert user_connection.user_id == 7215545059385
    assert user_connection.status == ConnectionStatus.REJECTED.value
async def test_accept_connection(connection_api, connection_service):
    connection_api.v1_connection_accept_post = AsyncMock()
    connection_api.v1_connection_accept_post.return_value = deserialize_object(UserConnection,
                                                                               "{"
                                                                               "   \"userId\": 7078106169577,"
                                                                               "   \"status\": \"ACCEPTED\","
                                                                               "   \"firstRequestedAt\": 1471046357339,"
                                                                               "   \"updatedAt\": 1471046517684,"
                                                                               "   \"requestCounter\": 1"
                                                                               "}")

    user_connection = await connection_service.accept_connection(7078106169577)

    connection_api.v1_connection_accept_post.assert_called_with(
        connection_request=UserConnectionRequest(user_id=7078106169577),
        session_token="session_token"
    )

    assert user_connection.user_id == 7078106169577
    assert user_connection.first_requested_at == 1471046357339
    assert user_connection.status == ConnectionStatus.ACCEPTED.value
Esempio n. 15
0
async def test_get_feature_entitlements(user_api, user_service):
    user_api.v1_admin_user_uid_features_get = AsyncMock()
    user_api.v1_admin_user_uid_features_get.return_value = \
        deserialize_object(FeatureList, payload="["
                                                "   {"
                                                "       \"entitlment\": \"canCreatePublicRoom\","
                                                "       \"enabled\": true},"
                                                "   {   "
                                                "       \"entitlment\": \"isExternalRoomEnabled\","
                                                "       \"enabled\": false"
                                                "   }"
                                                "]")

    feature_list = await user_service.get_feature_entitlements(1234)

    user_api.v1_admin_user_uid_features_get.assert_called_with(
        uid=1234, session_token="session_token")

    assert len(feature_list) == 2
    assert feature_list[0].entitlment == "canCreatePublicRoom"
    assert not feature_list[1].enabled
async def test_create_connection(connection_api, connection_service):
    connection_api.v1_connection_create_post = AsyncMock()
    connection_api.v1_connection_create_post.return_value = deserialize_object(UserConnection,
                                                                               "{"
                                                                               "  \"userId\": 7078106126503,"
                                                                               "  \"status\": \"PENDING_OUTGOING\","
                                                                               "  \"firstRequestedAt\": 1471018076255,"
                                                                               "  \"updatedAt\": 1471018076255,"
                                                                               "  \"requestCounter\": 1"
                                                                               "}")

    user_connection = await connection_service.create_connection(7078106126503)

    connection_api.v1_connection_create_post.assert_called_with(
        connection_request=UserConnectionRequest(user_id=7078106126503),
        session_token="session_token"
    )

    assert user_connection.user_id == 7078106126503
    assert user_connection.request_counter == 1
    assert user_connection.status == ConnectionStatus.PENDING_OUTGOING.value
Esempio n. 17
0
async def test_import_message(mocked_api_client, message_service):
    mocked_api_client.call_api.return_value = deserialize_object(V4ImportResponseList,
                                                                 "["
                                                                 "   {"
                                                                 "       \"messageId\": \"FjSY1y3L\",  "
                                                                 "       \"originatingSystemId\": \"AGENT_SDK\","
                                                                 "       \"originalMessageId\": \"M2\""
                                                                 "   }"
                                                                 "]")

    import_response = await message_service.import_messages([V4ImportedMessage(
        message="test_message",
        intended_message_timestamp=1433045622000,
        intended_message_from_user_id=7215545057281,
        originating_system_id="fooChat",
        stream_id="Z3oQRAZGTCNl5KjiUH2G1n___qr9lLT8dA"
    )])

    assert len(import_response) == 1
    assert import_response[0].message_id == "FjSY1y3L"
    assert import_response[0].originating_system_id == "AGENT_SDK"