def create_thread(self):
token = self.token
endpoint = self.endpoint
user = self.user
# [START create_thread]
from datetime import datetime
from azure.communication.chat import (ChatClient, ChatParticipant,
CommunicationUserIdentifier,
CommunicationTokenCredential)
# set `endpoint` to an existing ACS endpoint
chat_client = ChatClient(endpoint, CommunicationTokenCredential(token))
topic = "test topic"
participants = [
ChatParticipant(identifier=user,
display_name='name',
share_history_time=datetime.utcnow())
]
# creates a new chat_thread everytime
create_chat_thread_result = chat_client.create_chat_thread(
topic, thread_participants=participants)
# creates a new chat_thread if not exists
idempotency_token = 'b66d6031-fdcc-41df-8306-e524c9f226b8' # unique identifier
create_chat_thread_result_w_repeatability_id = chat_client.create_chat_thread(
topic,
thread_participants=participants,
idempotency_token=idempotency_token)
# [END create_thread]
self._thread_id = create_chat_thread_result.chat_thread.id
print("thread created, id: " + self._thread_id)
def create_thread(self):
# [START create_thread]
from datetime import datetime
from azure.communication.chat import(
ChatClient,
CommunicationUserIdentifier,
CommunicationTokenCredential,
CommunicationTokenRefreshOptions
ChatThreadParticipant
)
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options))
topic = "test topic"
participants = [ChatThreadParticipant(
user=self.user,
display_name='name',
share_history_time=datetime.utcnow()
)]
# creates a new chat_thread everytime
chat_thread_client = chat_client.create_chat_thread(topic, participants)
# creates a new chat_thread if not exists
repeatability_request_id = 'b66d6031-fdcc-41df-8306-e524c9f226b8' # unique identifier
chat_thread_client_w_repeatability_id = chat_client.create_chat_thread(topic,
participants,
repeatability_request_id)
# [END create_thread]
self._thread_id = chat_thread_client.thread_id
print("thread created, id: " + self._thread_id)
def create_chat_thread_client(self):
token = self.token
endpoint = self.endpoint
user = self.user
# [START create_chat_thread_client]
from datetime import datetime
from azure.communication.identity import CommunicationUserIdentifier
from azure.communication.chat import (
ChatClient,
ChatThreadParticipant,
CommunicationTokenCredential
)
# retrieve `token` using CommunicationIdentityClient.get_token method
# set `endpoint` to ACS service endpoint
# create `user` using CommunicationIdentityClient.create_user method for new users;
# else for existing users set `user` = CommunicationUserIdentifier(some_user_id)
chat_client = ChatClient(endpoint, CommunicationTokenCredential(token))
topic = "test topic"
participants = [ChatThreadParticipant(
user=user,
display_name='name',
share_history_time=datetime.utcnow()
)]
create_chat_thread_result = chat_client.create_chat_thread(topic, thread_participants=participants)
chat_thread_client = chat_client.get_chat_thread_client(create_chat_thread_result.chat_thread.id)
# [END create_chat_thread_client]
self._thread_id = create_chat_thread_result.chat_thread.id
print("chat_thread_client created")
def test_access_token_validation(self):
"""
This is to make sure that consecutive calls made using the same chat_client or chat_thread_client
does not throw an exception due to mismatch in the generation of azure.core.credentials.AccessToken
"""
# create ChatClient
chat_client = ChatClient(self.endpoint,
CommunicationTokenCredential(self.token))
raised = False
try:
# create chat thread
topic1 = "test topic1"
create_chat_thread1_result = chat_client.create_chat_thread(topic1)
self.thread_id = create_chat_thread1_result.chat_thread.id
# get chat thread client
chat_thread1_client = chat_client.get_chat_thread_client(
self.thread_id)
# list all chat threads
chat_thead_infos = chat_client.list_chat_threads()
for chat_threads_info_page in chat_thead_infos.by_page():
for chat_thread_info in chat_threads_info_page:
print("ChatThreadInfo: ", chat_thread_info)
except:
raised = True
assert raised is False
def test_create_chat_thread(self):
thread_id = "19:[email protected]"
chat_thread_client = None
raised = False
def mock_send(*_, **__):
return mock_response(status_code=207,
json_payload={
"multipleStatus": [{
"id": thread_id,
"statusCode": 201,
"type": "Thread"
}]
})
chat_client = ChatClient("https://endpoint",
TestChatClient.credential,
transport=Mock(send=mock_send))
topic = "test topic"
user = CommunicationUser(
"8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041")
members = [
ChatThreadMember(user=user,
display_name='name',
share_history_time=datetime.utcnow())
]
try:
chat_thread_client = chat_client.create_chat_thread(topic, members)
except:
raised = True
raise
self.assertFalse(raised, 'Expected is no excpetion raised')
assert chat_thread_client.thread_id == thread_id
def test_create_chat_thread_w_repeatability_request_id(self):
thread_id = "19:[email protected]"
chat_thread_client = None
raised = False
idempotency_token = "b66d6031-fdcc-41df-8306-e524c9f226b8"
def mock_send(*_, **__):
return mock_response(
status_code=201,
json_payload={
"chatThread": {
"id":
thread_id,
"topic":
"test topic",
"createdOn":
"2020-12-03T21:09:17Z",
"createdBy":
"8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041"
}
})
chat_client = ChatClient("https://endpoint",
TestChatClient.credential,
transport=Mock(send=mock_send))
topic = "test topic"
user = CommunicationUserIdentifier(
"8:acs:57b9bac9-df6c-4d39-a73b-26e944adf6ea_9b0110-08007f1041")
participants = [
ChatParticipant(identifier=user,
display_name='name',
share_history_time=datetime.utcnow())
]
try:
create_chat_thread_result = chat_client.create_chat_thread(
topic=topic,
thread_participants=participants,
idempotency_token=idempotency_token)
except:
raised = True
raise
self.assertFalse(raised, 'Expected is no excpetion raised')
assert create_chat_thread_result.chat_thread.id == thread_id
def create_chat_thread_client(self):
# [START create_chat_thread_client]
from datetime import datetime
from azure.communication.chat import (ChatClient, ChatThreadMember,
CommunicationUser,
CommunicationUserCredential)
chat_client = ChatClient(self.endpoint,
CommunicationUserCredential(self.token))
topic = "test topic"
members = [
ChatThreadMember(user=self.user,
display_name='name',
share_history_time=datetime.utcnow())
]
chat_thread_client = chat_client.create_chat_thread(topic, members)
# [END create_chat_thread_client]
self._thread_id = chat_thread_client.thread_id
print("chat_thread_client created")
def create_chat_thread_client(self):
# [START create_chat_thread_client]
from datetime import datetime
from azure.communication.chat import (
ChatClient,
CommunicationUserIdentifier,
CommunicationTokenCredential,
CommunicationTokenRefreshOptions,
ChatThreadParticipant
)
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options))
topic = "test topic"
participants = [ChatThreadParticipant(
user=self.user,
display_name='name',
share_history_time=datetime.utcnow()
)]
chat_thread_client = chat_client.create_chat_thread(topic, participants)
# [END create_chat_thread_client]
self._thread_id = chat_thread_client.thread_id
print("chat_thread_client created")
class ChatClientTest(CommunicationTestCase):
def setUp(self):
super(ChatClientTest, self).setUp()
self.recording_processors.extend([
BodyReplacerProcessor(keys=["id", "token", "createdBy", "participants", "multipleStatus", "value"]),
URIIdentityReplacer(),
ChatURIReplacer()])
self.identity_client = CommunicationIdentityClient.from_connection_string(
self.connection_str)
endpoint, _ = parse_connection_str(self.connection_str)
self.endpoint = endpoint
# create user and issue token
self.user = self.identity_client.create_user()
tokenresponse = self.identity_client.get_token(self.user, scopes=["chat"])
self.token = tokenresponse.token
# create ChatClient
refresh_options = CommunicationTokenRefreshOptions(self.token)
self.chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options))
def tearDown(self):
super(ChatClientTest, self).tearDown()
# delete created users and chat threads
if not self.is_playback():
self.identity_client.delete_user(self.user)
self.chat_client.delete_chat_thread(self.thread_id)
def _create_thread(self, repeatability_request_id=None):
# create chat thread
topic = "test topic"
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
participants = [ChatThreadParticipant(
user=self.user,
display_name='name',
share_history_time=share_history_time
)]
chat_thread_client = self.chat_client.create_chat_thread(topic, participants, repeatability_request_id)
self.thread_id = chat_thread_client.thread_id
@pytest.mark.live_test_only
def test_create_chat_thread(self):
self._create_thread()
assert self.thread_id is not None
@pytest.mark.live_test_only
def test_create_chat_thread_w_repeatability_request_id(self):
repeatability_request_id = str(uuid4())
# create thread
self._create_thread(repeatability_request_id=repeatability_request_id)
thread_id = self.thread_id
# re-create thread with same repeatability_request_id
self._create_thread(repeatability_request_id=repeatability_request_id)
# test idempotency
assert thread_id == self.thread_id
@pytest.mark.live_test_only
def test_get_chat_thread(self):
self._create_thread()
get_thread_result = self.chat_client.get_chat_thread(self.thread_id)
assert get_thread_result.id == self.thread_id
@pytest.mark.live_test_only
def test_list_chat_threads(self):
self._create_thread()
if self.is_live:
time.sleep(2)
chat_thread_infos = self.chat_client.list_chat_threads(results_per_page=1)
for chat_thread_page in chat_thread_infos.by_page():
li = list(chat_thread_page)
assert len(li) <= 1
@pytest.mark.live_test_only
def test_get_thread_client(self):
self._create_thread()
chat_thread_client = self.chat_client.get_chat_thread_client(self.thread_id)
assert chat_thread_client.thread_id == self.thread_id
@pytest.mark.live_test_only
def test_delete_chat_thread(self):
self._create_thread()
self.chat_client.delete_chat_thread(self.thread_id)
class ChatClientTest(CommunicationTestCase):
def setUp(self):
super(ChatClientTest, self).setUp()
self.recording_processors.extend([
BodyReplacerProcessor(keys=[
"id", "token", "createdBy", "participants", "multipleStatus",
"value"
]),
URIIdentityReplacer(),
ChatURIReplacer()
])
self.identity_client = CommunicationIdentityClient.from_connection_string(
self.connection_str)
endpoint, _ = parse_connection_str(self.connection_str)
self.endpoint = endpoint
# create user and issue token
self.user = self.identity_client.create_user()
tokenresponse = self.identity_client.get_token(self.user,
scopes=["chat"])
self.token = tokenresponse.token
# create ChatClient
self.chat_client = ChatClient(self.endpoint,
CommunicationTokenCredential(self.token))
def tearDown(self):
super(ChatClientTest, self).tearDown()
# delete created users and chat threads
if not self.is_playback():
self.chat_client.delete_chat_thread(self.thread_id)
self.identity_client.delete_user(self.user)
def _create_thread(self, idempotency_token=None):
# create chat thread
topic = "test topic"
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
participants = [
ChatParticipant(identifier=self.user,
display_name='name',
share_history_time=share_history_time)
]
create_chat_thread_result = self.chat_client.create_chat_thread(
topic,
thread_participants=participants,
idempotency_token=idempotency_token)
self.thread_id = create_chat_thread_result.chat_thread.id
@pytest.mark.live_test_only
def test_access_token_validation(self):
"""
This is to make sure that consecutive calls made using the same chat_client or chat_thread_client
does not throw an exception due to mismatch in the generation of azure.core.credentials.AccessToken
"""
# create ChatClient
chat_client = ChatClient(self.endpoint,
CommunicationTokenCredential(self.token))
raised = False
try:
# create chat thread
topic1 = "test topic1"
create_chat_thread1_result = chat_client.create_chat_thread(topic1)
self.thread_id = create_chat_thread1_result.chat_thread.id
# get chat thread client
chat_thread1_client = chat_client.get_chat_thread_client(
self.thread_id)
# list all chat threads
chat_thead_infos = chat_client.list_chat_threads()
for chat_threads_info_page in chat_thead_infos.by_page():
for chat_thread_info in chat_threads_info_page:
print("ChatThreadInfo: ", chat_thread_info)
except:
raised = True
assert raised is False
@pytest.mark.live_test_only
def test_create_chat_thread(self):
self._create_thread()
assert self.thread_id is not None
@pytest.mark.live_test_only
def test_create_chat_thread_w_no_participants(self):
# create chat thread
topic = "test topic"
create_chat_thread_result = self.chat_client.create_chat_thread(topic)
self.thread_id = create_chat_thread_result.chat_thread.id
assert create_chat_thread_result.chat_thread is not None
assert create_chat_thread_result.errors is None
@pytest.mark.live_test_only
def test_create_chat_thread_w_repeatability_request_id(self):
idempotency_token = str(uuid4())
# create thread
self._create_thread(idempotency_token=idempotency_token)
thread_id = self.thread_id
# re-create thread with same idempotency_token
self._create_thread(idempotency_token=idempotency_token)
# test idempotency
assert thread_id == self.thread_id
@pytest.mark.live_test_only
def test_list_chat_threads(self):
self._create_thread()
if self.is_live:
time.sleep(2)
chat_threads = self.chat_client.list_chat_threads(results_per_page=1)
for chat_thread_item_page in chat_threads.by_page():
li = list(chat_thread_item_page)
assert len(li) <= 1
@pytest.mark.live_test_only
def test_get_thread_client(self):
self._create_thread()
chat_thread_client = self.chat_client.get_chat_thread_client(
self.thread_id)
assert chat_thread_client.thread_id == self.thread_id
@pytest.mark.live_test_only
def test_delete_chat_thread(self):
self._create_thread()
self.chat_client.delete_chat_thread(self.thread_id)
class ChatThreadClientTest(CommunicationTestCase):
def setUp(self):
super(ChatThreadClientTest, self).setUp()
self.recording_processors.extend([
BodyReplacerProcessor(keys=[
"id", "token", "senderId", "chatMessageId", "nextLink",
"participants", "multipleStatus", "value"
]),
URIIdentityReplacer(),
ChatURIReplacer()
])
self.identity_client = CommunicationIdentityClient.from_connection_string(
self.connection_str)
endpoint, _ = parse_connection_str(self.connection_str)
self.endpoint = endpoint
# create user and issue token
self.user = self.identity_client.create_user()
tokenresponse = self.identity_client.get_token(self.user,
scopes=["chat"])
self.token = tokenresponse.token
# create another user
self.new_user = self.identity_client.create_user()
tokenresponse = self.identity_client.get_token(self.new_user,
scopes=["chat"])
self.token_new_user = tokenresponse.token
# create ChatClient
refresh_options = CommunicationTokenRefreshOptions(self.token)
refresh_options_new_user = CommunicationTokenRefreshOptions(
self.token_new_user)
self.chat_client = ChatClient(
self.endpoint, CommunicationTokenCredential(refresh_options))
self.chat_client_new_user = ChatClient(
self.endpoint,
CommunicationTokenCredential(refresh_options_new_user))
def tearDown(self):
super(ChatThreadClientTest, self).tearDown()
# delete created users and chat threads
if not self.is_playback():
self.identity_client.delete_user(self.user)
self.identity_client.delete_user(self.new_user)
self.chat_client.delete_chat_thread(self.thread_id)
def _create_thread(self, **kwargs):
# create chat thread, and ChatThreadClient
topic = "test topic"
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
participants = [
ChatThreadParticipant(user=self.user,
display_name='name',
share_history_time=share_history_time)
]
create_chat_thread_result = self.chat_client.create_chat_thread(
topic, thread_participants=participants)
self.chat_thread_client = self.chat_client.get_chat_thread_client(
create_chat_thread_result.chat_thread.id)
self.thread_id = self.chat_thread_client.thread_id
def _create_thread_w_two_users(self, **kwargs):
# create chat thread, and ChatThreadClient
topic = "test topic"
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
participants = [
ChatThreadParticipant(user=self.user,
display_name='name',
share_history_time=share_history_time),
ChatThreadParticipant(user=self.new_user,
display_name='name',
share_history_time=share_history_time)
]
create_chat_thread_result = self.chat_client.create_chat_thread(
topic, thread_participants=participants)
self.chat_thread_client = self.chat_client.get_chat_thread_client(
create_chat_thread_result.chat_thread.id)
self.thread_id = self.chat_thread_client.thread_id
def _send_message(self):
# send a message
content = 'hello world'
sender_display_name = 'sender name'
create_message_result_id = self.chat_thread_client.send_message(
content, sender_display_name=sender_display_name)
message_id = create_message_result_id
return message_id
@pytest.mark.live_test_only
def test_update_topic(self):
self._create_thread()
topic = "update topic"
self.chat_thread_client.update_topic(topic=topic)
@pytest.mark.live_test_only
def test_send_message(self):
self._create_thread()
content = 'hello world'
sender_display_name = 'sender name'
create_message_result_id = self.chat_thread_client.send_message(
content, sender_display_name=sender_display_name)
assert create_message_result_id is not None
@pytest.mark.live_test_only
def test_get_message(self):
self._create_thread()
message_id = self._send_message()
message = self.chat_thread_client.get_message(message_id)
assert message.id == message_id
assert message.type == ChatMessageType.TEXT
assert message.content.message == 'hello world'
@pytest.mark.live_test_only
def test_list_messages(self):
self._create_thread()
self._send_message()
chat_messages = self.chat_thread_client.list_messages(
results_per_page=1)
for chat_message in chat_messages.by_page():
li = list(chat_message)
assert len(li) <= 1
@pytest.mark.live_test_only
def test_update_message(self):
self._create_thread()
message_id = self._send_message()
content = "updated message content"
self.chat_thread_client.update_message(message_id, content=content)
@pytest.mark.live_test_only
def test_delete_message(self):
self._create_thread()
message_id = self._send_message()
self.chat_thread_client.delete_message(message_id)
@pytest.mark.live_test_only
def test_list_participants(self):
self._create_thread()
# add another participant
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
new_participant = ChatThreadParticipant(
user=self.new_user,
display_name='name',
share_history_time=share_history_time)
self.chat_thread_client.add_participant(new_participant)
# fetch list of participants
chat_thread_participants = self.chat_thread_client.list_participants(
results_per_page=1, skip=1)
participant_count = 0
for chat_thread_participant_page in chat_thread_participants.by_page():
li = list(chat_thread_participant_page)
assert len(li) <= 1
participant_count += len(li)
li[0].user.id = self.user.identifier
assert participant_count == 1
@pytest.mark.live_test_only
def test_add_participant(self):
self._create_thread()
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
new_participant = ChatThreadParticipant(
user=self.new_user,
display_name='name',
share_history_time=share_history_time)
raised = False
try:
self.chat_thread_client.add_participant(new_participant)
except RuntimeError as e:
raised = True
assert raised is False
@pytest.mark.live_test_only
def test_add_participants(self):
self._create_thread()
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
new_participant = ChatThreadParticipant(
user=self.new_user,
display_name='name',
share_history_time=share_history_time)
participants = [new_participant]
failed_participants = self.chat_thread_client.add_participants(
participants)
# no error occured while adding participants
assert len(failed_participants) == 0
@pytest.mark.live_test_only
def test_remove_participant(self):
self._create_thread()
# add participant first
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
new_participant = ChatThreadParticipant(
user=self.new_user,
display_name='name',
share_history_time=share_history_time)
participants = [new_participant]
self.chat_thread_client.add_participants(participants)
# test remove participant
self.chat_thread_client.remove_participant(self.new_user)
@pytest.mark.live_test_only
def test_send_typing_notification(self):
self._create_thread()
self.chat_thread_client.send_typing_notification()
@pytest.mark.live_test_only
def test_send_read_receipt(self):
self._create_thread()
message_id = self._send_message()
self.chat_thread_client.send_read_receipt(message_id)
def _wait_on_thread(self, chat_client, thread_id, message_id):
# print("Read Receipts Sent: ", read_receipts_sent)
chat_thread_client = chat_client.get_chat_thread_client(thread_id)
for _ in range(10):
read_receipts_paged = chat_thread_client.list_read_receipts()
chat_message_ids = []
for page in read_receipts_paged.by_page():
for item in page:
chat_message_ids.append(item.chat_message_id)
if message_id in chat_message_ids:
return
else:
print("Sleeping for additional 2 secs")
time.sleep(2)
raise Exception("Read receipts not updated in 20 seconds. Failing.")
@pytest.mark.live_test_only
def test_list_read_receipts(self):
self._create_thread_w_two_users()
# first user send 2 messages
# send messages and read receipts
for i in range(2):
message_id = self._send_message()
self.chat_thread_client.send_read_receipt(message_id)
if self.is_live:
self._wait_on_thread(chat_client=self.chat_client,
thread_id=self.thread_id,
message_id=message_id)
# get chat thread client for second user
chat_thread_client_new_user = self.chat_client_new_user.get_chat_thread_client(
self.thread_id)
# second user sends 1 message
message_id_new_user = chat_thread_client_new_user.send_message(
"content", sender_display_name="sender_display_name")
# send read receipt
chat_thread_client_new_user.send_read_receipt(message_id_new_user)
if self.is_live:
self._wait_on_thread(chat_client=self.chat_client_new_user,
thread_id=self.thread_id,
message_id=message_id_new_user)
# list read receipts
read_receipts = self.chat_thread_client.list_read_receipts(
results_per_page=2, skip=0)
items = []
for page in read_receipts.by_page():
for item in page:
items.append(item)
assert len(items) == 2
@pytest.mark.live_test_only
def test_get_properties(self):
self._create_thread()
get_thread_result = self.chat_thread_client.get_properties(
self.thread_id)
assert get_thread_result.id == self.thread_id
class ChatThreadClientTest(CommunicationTestCase):
def setUp(self):
super(ChatThreadClientTest, self).setUp()
self.recording_processors.extend([
BodyReplacerProcessor(keys=[
"id", "token", "senderId", "chatMessageId", "nextLink",
"members", "multipleStatus", "value"
]),
URIIdentityReplacer(),
ChatURIReplacer()
])
self.identity_client = CommunicationIdentityClient.from_connection_string(
self.connection_str)
endpoint, _ = parse_connection_str(self.connection_str)
self.endpoint = endpoint
# create user and issue token
self.user = self.identity_client.create_user()
tokenresponse = self.identity_client.issue_token(self.user,
scopes=["chat"])
self.token = tokenresponse.token
# create another user
self.new_user = self.identity_client.create_user()
# create ChatClient
self.chat_client = ChatClient(self.endpoint,
CommunicationTokenCredential(self.token))
def tearDown(self):
super(ChatThreadClientTest, self).tearDown()
# delete created users and chat threads
if not self.is_playback():
self.identity_client.delete_user(self.user)
self.identity_client.delete_user(self.new_user)
self.chat_client.delete_chat_thread(self.thread_id)
def _create_thread(self):
# create chat thread, and ChatThreadClient
topic = "test topic"
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
members = [
ChatThreadMember(user=self.user,
display_name='name',
share_history_time=share_history_time)
]
self.chat_thread_client = self.chat_client.create_chat_thread(
topic, members)
self.thread_id = self.chat_thread_client.thread_id
@pytest.mark.live_test_only
def _send_message(self):
# send a message
priority = ChatMessagePriority.NORMAL
content = 'hello world'
sender_display_name = 'sender name'
create_message_result = self.chat_thread_client.send_message(
content,
priority=priority,
sender_display_name=sender_display_name)
self.message_id = create_message_result.id
@pytest.mark.live_test_only
def test_update_thread(self):
self._create_thread()
topic = "update topic"
self.chat_thread_client.update_thread(topic=topic)
@pytest.mark.live_test_only
def test_send_message(self):
self._create_thread()
priority = ChatMessagePriority.NORMAL
content = 'hello world'
sender_display_name = 'sender name'
create_message_result = self.chat_thread_client.send_message(
content,
priority=priority,
sender_display_name=sender_display_name)
assert create_message_result.id is not None
@pytest.mark.live_test_only
def test_get_message(self):
self._create_thread()
self._send_message()
message = self.chat_thread_client.get_message(self.message_id)
assert message.id == self.message_id
@pytest.mark.live_test_only
def test_list_messages(self):
self._create_thread()
self._send_message()
if self.is_live:
time.sleep(2)
chat_messages = self.chat_thread_client.list_messages(
results_per_page=1)
for chat_message in chat_messages.by_page():
li = list(chat_message)
assert len(li) <= 1
@pytest.mark.live_test_only
def test_update_message(self):
self._create_thread()
self._send_message()
content = "updated message content"
self.chat_thread_client.update_message(self.message_id,
content=content)
@pytest.mark.live_test_only
def test_delete_message(self):
self._create_thread()
self._send_message()
self.chat_thread_client.delete_message(self.message_id)
@pytest.mark.live_test_only
def test_list_members(self):
self._create_thread()
if self.is_live:
time.sleep(2)
chat_thread_members = self.chat_thread_client.list_members()
for chat_thread_member_page in chat_thread_members.by_page():
li = list(chat_thread_member_page)
assert len(li) == 1
li[0].user.id = self.user.identifier
@pytest.mark.live_test_only
def test_add_members(self):
self._create_thread()
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
new_member = ChatThreadMember(user=self.new_user,
display_name='name',
share_history_time=share_history_time)
members = [new_member]
self.chat_thread_client.add_members(members)
@pytest.mark.live_test_only
def test_remove_member(self):
self._create_thread()
# add member first
share_history_time = datetime.utcnow()
share_history_time = share_history_time.replace(tzinfo=TZ_UTC)
new_member = ChatThreadMember(user=self.new_user,
display_name='name',
share_history_time=share_history_time)
members = [new_member]
self.chat_thread_client.add_members(members)
# test remove member
self.chat_thread_client.remove_member(self.new_user)
@pytest.mark.live_test_only
def test_send_typing_notification(self):
self._create_thread()
self.chat_thread_client.send_typing_notification()
from datetime import datetime, timedelta
from azure.communication.chat import ChatMessageType
from azure.communication.identity import CommunicationIdentityClient
from azure.communication.chat import ChatParticipant
try:
print('Azure Communication Services - Chat Quickstart')
# Create a chat client
endpoint = "https://<RESOURCE_NAME>.communication.azure.com"
chat_client = ChatClient(endpoint,
CommunicationTokenCredential("<Access Token>"))
# Start a chat thread
topic = "test topic"
create_chat_thread_result = chat_client.create_chat_thread(topic)
chat_thread_client = chat_client.get_chat_thread_client(
create_chat_thread_result.chat_thread.id)
# Get a chat thread client
thread_id = create_chat_thread_result.chat_thread.id
chat_thread_client = chat_client.get_chat_thread_client(thread_id)
# List all chat threads
start_time = datetime.utcnow() - timedelta(days=2)
chat_threads = chat_client.list_chat_threads(results_per_page=5,
start_time=start_time)
for chat_thread_item_page in chat_threads.by_page():
for chat_thread_item in chat_thread_item_page:
print(chat_thread_item)
