def update_topic(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id)
# [START update_topic]
topic = "updated thread topic"
chat_thread_client.update_topic(topic=topic)
# [END update_topic]
print("update_chat_thread succeeded")
def list_read_receipts(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationUserCredential
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationUserCredential(self.token),
self._thread_id)
# [START list_read_receipts]
read_receipts = chat_thread_client.list_read_receipts()
print("list_read_receipts succeeded, receipts:")
for read_receipt in read_receipts:
print(read_receipt)
def list_members(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationUserCredential
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationUserCredential(self.token),
self._thread_id)
# [START list_members]
chat_thread_members = chat_thread_client.list_members()
print("list_chat_members succeeded, members: ")
for chat_thread_member in chat_thread_members:
print(chat_thread_member)
def remove_participant(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationUserIdentifier, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id)
# [START remove_participant]
chat_thread_client.remove_participant(self.new_user)
# [END remove_participant]
print("remove_chat_participant succeeded")
def update_message(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id)
# [START update_message]
content = "updated content"
chat_thread_client.update_message(self._message_id, content=content)
# [END update_message]
print("update_chat_message succeeded")
def send_typing_notification(self):
from azure.communication.chat import ChatThreadClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationTokenCredential(refresh_options),
self._thread_id)
# [START send_typing_notification]
chat_thread_client.send_typing_notification()
# [END send_typing_notification]
print("send_typing_notification succeeded")
def get_message(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id)
# [START get_message]
chat_message = chat_thread_client.get_message(self._message_id)
# [END get_message]
print("get_chat_message succeeded, message id:", chat_message.id, \
"content: ", chat_message.content)
def send_read_receipt(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationUserCredential
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationUserCredential(self.token),
self._thread_id)
# [START send_read_receipt]
chat_thread_client.send_read_receipt(self._message_id)
# [END send_read_receipt]
print("send_read_receipt succeeded")
def delete_message(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationTokenCredential(refresh_options),
self._thread_id)
# [START delete_message]
chat_thread_client.delete_message(self._message_id)
# [END delete_message]
print("delete_chat_message succeeded")
def list_members(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationTokenCredential(refresh_options),
self._thread_id)
# [START list_members]
chat_thread_members = chat_thread_client.list_members()
print("list_chat_members succeeded, members: ")
for chat_thread_member in chat_thread_members:
print(chat_thread_member)
def remove_member(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationUserCredential, CommunicationUser
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationUserCredential(self.token),
self._thread_id)
# [START remove_member]
chat_thread_client.remove_member(self.new_user)
# [END remove_member]
print("remove_chat_member succeeded")
def update_thread(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationUserCredential
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationUserCredential(self.token),
self._thread_id)
# [START update_thread]
topic = "updated thread topic"
chat_thread_client.update_thread(topic=topic)
# [END update_thread]
print("update_chat_thread succeeded")
def get_message(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationUserCredential
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationUserCredential(self.token),
self._thread_id)
# [START get_message]
chat_message = chat_thread_client.get_message(self._message_id)
# [END get_message]
print("get_chat_message succeeded, message id:", chat_message.id, \
"content: ", chat_message.content)
def send_read_receipt(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationTokenCredential(refresh_options),
self._thread_id)
# [START send_read_receipt]
chat_thread_client.send_read_receipt(self._message_id)
# [END send_read_receipt]
print("send_read_receipt succeeded")
def list_read_receipts(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationTokenCredential(refresh_options),
self._thread_id)
# [START list_read_receipts]
read_receipts = chat_thread_client.list_read_receipts()
print("list_read_receipts succeeded, receipts:")
for read_receipt in read_receipts:
print(read_receipt)
def update_message(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationUserCredential
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationUserCredential(self.token),
self._thread_id)
# [START update_message]
content = "updated content"
chat_thread_client.update_message(self._message_id, content=content)
# [END update_message]
print("update_chat_message succeeded")
def test_send_typing_notification(self):
thread_id = "19:[email protected]"
raised = False
def mock_send(*_, **__):
return mock_response(status_code=200)
chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send))
try:
chat_thread_client.send_typing_notification()
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
def test_list_participants_with_results_per_page(self):
thread_id = "19:[email protected]"
participant_id_1 = "8:acs:9b665d53-8164-4923-ad5d-5e983b07d2e7_00000006-5399-552c-b274-5a3a0d0000dc"
participant_id_2 = "8:acs:9b665d53-8164-4923-ad5d-5e983b07d2e7_00000006-9d32-35c9-557d-5a3a0d0002f1"
raised = False
def mock_send(*_, **__):
return mock_response(status_code=200,
json_payload={
"value": [{
"communicationIdentifier": {
"rawId": participant_id_1,
"communicationUser": {
"id": participant_id_1
}
},
"displayName":
"Bob",
"shareHistoryTime":
"2020-10-30T10:50:50Z"
}, {
"communicationIdentifier": {
"rawId": participant_id_2,
"communicationUser": {
"id": participant_id_2
}
},
"displayName":
"Bob",
"shareHistoryTime":
"2020-10-30T10:50:50Z"
}]
})
chat_thread_client = ChatThreadClient("https://endpoint",
TestChatThreadClient.credential,
thread_id,
transport=Mock(send=mock_send))
chat_thread_participants = None
try:
chat_thread_participants = chat_thread_client.list_participants(
results_per_page=2)
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
for chat_thread_participant_page in chat_thread_participants.by_page():
l = list(chat_thread_participant_page)
assert len(l) == 2
def list_messages(self):
from azure.communication.chat import ChatThreadClient
from azure.communication.chat import CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(self.endpoint, CommunicationTokenCredential(refresh_options), self._thread_id)
# [START list_messages]
from datetime import datetime, timedelta
start_time = datetime.utcnow() - timedelta(days=1)
chat_messages = chat_thread_client.list_messages(results_per_page=1, start_time=start_time)
print("list_messages succeeded with results_per_page is 1, and start time is yesterday UTC")
for chat_message_page in chat_messages.by_page():
l = list(chat_message_page)
print("page size: ", len(l))
def test_add_participants_w_failed_participants_returns_nonempty_list(
self):
thread_id = "19:[email protected]"
new_participant_id = "8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041"
raised = False
error_message = "some error message"
def mock_send(*_, **__):
return mock_response(status_code=201,
json_payload={
"errors": {
"invalidParticipants": [{
"code": "string",
"message": error_message,
"target": new_participant_id,
"details": []
}]
}
})
chat_thread_client = ChatThreadClient("https://endpoint",
TestChatThreadClient.credential,
thread_id,
transport=Mock(send=mock_send))
new_participant = ChatThreadParticipant(
user=CommunicationUserIdentifier(new_participant_id),
display_name='name',
share_history_time=datetime.utcnow())
participants = [new_participant]
try:
result = chat_thread_client.add_participants(participants)
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
self.assertTrue(len(result) == 1)
failed_participant = result[0][0]
communication_error = result[0][1]
self.assertEqual(new_participant.user.identifier,
failed_participant.user.identifier)
self.assertEqual(new_participant.display_name,
failed_participant.display_name)
self.assertEqual(new_participant.share_history_time,
failed_participant.share_history_time)
self.assertEqual(error_message, communication_error.message)
def test_delete_message(self):
thread_id = "19:[email protected]"
message_id='1596823919339'
raised = False
def mock_send(*_, **__):
return mock_response(status_code=204)
chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send))
try:
chat_thread_client.delete_message(message_id)
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
def test_remove_member(self):
thread_id = "19:[email protected]"
member_id="8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041"
raised = False
def mock_send(*_, **__):
return mock_response(status_code=204)
chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send))
try:
chat_thread_client.remove_member(CommunicationUserIdentifier(member_id))
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
def test_send_message_w_type(self):
thread_id = "19:[email protected]"
message_id='1596823919339'
raised = False
message_str = "Hi I am Bob."
chat_message_types = [ChatMessageType.TEXT, ChatMessageType.HTML, "text", "html"]
for chat_message_type in chat_message_types:
def mock_send(*_, **__):
return mock_response(status_code=201, json_payload={
"id": message_id,
"type": chat_message_type,
"sequenceId": "3",
"version": message_id,
"content": {
"message": message_str,
"topic": "Lunch Chat thread",
"participants": [
{
"id": "8:acs:8540c0de-899f-5cce-acb5-3ec493af3800_0e59221d-0c1d-46ae-9544-c963ce56c10b",
"displayName": "Bob",
"shareHistoryTime": "2020-10-30T10:50:50Z"
}
],
"initiator": "8:acs:8540c0de-899f-5cce-acb5-3ec493af3800_0e59221d-0c1d-46ae-9544-c963ce56c10b"
},
"senderDisplayName": "Bob",
"createdOn": "2021-01-27T01:37:33Z",
"senderId": "8:acs:46849534-eb08-4ab7-bde7-c36928cd1547_00000007-e155-1f06-1db7-3a3a0d00004b"
})
chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id,
transport=Mock(send=mock_send))
try:
content='hello world'
sender_display_name='sender name'
create_message_result_id = chat_thread_client.send_message(
content=content,
chat_message_type=chat_message_type,
sender_display_name=sender_display_name)
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
assert create_message_result_id == message_id
def add_participant(self):
from azure.communication.chat import ChatThreadClient, CommunicationTokenCredential, \
CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_thread_client = ChatThreadClient(self.endpoint, CommunicationTokenCredential(refresh_options),
self._thread_id)
# [START add_participant]
from azure.communication.chat import ChatThreadParticipant
from datetime import datetime
new_chat_thread_participant = ChatThreadParticipant(
user=self.new_user,
display_name='name',
share_history_time=datetime.utcnow())
chat_thread_client.add_participant(new_chat_thread_participant)
# [END add_participant]
print("add_chat_participant succeeded")
def add_members(self):
from azure.communication.chat import ChatThreadClient, CommunicationUserCredential
chat_thread_client = ChatThreadClient(
self.endpoint, CommunicationUserCredential(self.token),
self._thread_id)
# [START add_members]
from azure.communication.chat import ChatThreadMember
from datetime import datetime
new_member = ChatThreadMember(user=self.new_user,
display_name='name',
share_history_time=datetime.utcnow())
thread_members = [new_member]
chat_thread_client.add_members(thread_members)
# [END add_members]
print("add_chat_members succeeded")
def test_get_message(self):
thread_id = "19:[email protected]"
message_id='1596823919339'
raised = False
def mock_send(*_, **__):
return mock_response(status_code=200, json_payload={"id": message_id})
chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send))
message = None
try:
message = chat_thread_client.get_message(message_id)
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
assert message.id == message_id
def test_list_read_receipts_with_results_per_page(self):
thread_id = "19:[email protected]"
message_id_1 = "1596823919339"
message_id_2 = "1596823919340"
raised = False
def mock_send(*_, **__):
return mock_response(status_code=200,
json_payload={
"value": [{
"chatMessageId": message_id_1,
"senderCommunicationIdentifier": {
"rawId": "string",
"communicationUser": {
"id": "string"
}
}
}, {
"chatMessageId": message_id_2,
"senderCommunicationIdentifier": {
"rawId": "string",
"communicationUser": {
"id": "string"
}
}
}]
})
chat_thread_client = ChatThreadClient("https://endpoint",
TestChatThreadClient.credential,
thread_id,
transport=Mock(send=mock_send))
read_receipts = None
try:
read_receipts = chat_thread_client.list_read_receipts(
results_per_page=2)
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
for read_receipt_page in read_receipts.by_page():
l = list(read_receipt_page)
assert len(l) == 2
def test_list_read_receipts(self):
thread_id = "19:[email protected]"
message_id="1596823919339"
raised = False
def mock_send(*_, **__):
return mock_response(status_code=200, json_payload={"value": [{"chatMessageId": message_id}]})
chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send))
read_receipts = None
try:
read_receipts = chat_thread_client.list_read_receipts()
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
for read_receipt_page in read_receipts.by_page():
l = list(read_receipt_page)
assert len(l) == 1
def test_add_participant(self):
thread_id = "19:[email protected]"
new_participant_id="8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041"
raised = False
def mock_send(*_, **__):
return mock_response(status_code=201)
chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send))
new_participant = ChatThreadParticipant(
user=CommunicationUserIdentifier(new_participant_id),
display_name='name',
share_history_time=datetime.utcnow())
try:
chat_thread_client.add_participant(new_participant)
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
def test_list_members(self):
thread_id = "19:[email protected]"
member_id="8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041"
raised = False
def mock_send(*_, **__):
return mock_response(status_code=200, json_payload={"value": [{"id": member_id}]})
chat_thread_client = ChatThreadClient("https://endpoint", TestChatThreadClient.credential, thread_id, transport=Mock(send=mock_send))
chat_thread_members = None
try:
chat_thread_members = chat_thread_client.list_members()
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
for chat_thread_member_page in chat_thread_members.by_page():
l = list(chat_thread_member_page)
assert len(l) == 1
l[0].user.id = member_id
