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 get_chat_thread_client(self):
# [START get_chat_thread_client]
from azure.communication.chat import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options))
chat_thread_client = chat_client.get_chat_thread_client(self._thread_id)
# [END get_chat_thread_client]
print("chat_thread_client created with thread id: ", chat_thread_client.thread_id)
def get_chat_thread_client(self):
# [START get_chat_thread_client]
from azure.communication.chat import ChatClient, CommunicationUserCredential
chat_client = ChatClient(self.endpoint,
CommunicationUserCredential(self.token))
chat_thread_client = chat_client.get_chat_thread_client(
self._thread_id)
# [END get_chat_thread_client]
print("chat_thread_client created with thread id: ",
chat_thread_client.thread_id)
def get_chat_thread_client(self):
token = self.token
endpoint = self.endpoint
thread_id = self._thread_id
# [START get_chat_thread_client]
from azure.communication.chat import ChatClient, CommunicationTokenCredential
chat_client = ChatClient(endpoint, CommunicationTokenCredential(token))
chat_thread_client = chat_client.get_chat_thread_client(thread_id)
# [END get_chat_thread_client]
print("get_chat_thread_client succeeded with thread id: ",
chat_thread_client.thread_id)
def get_chat_thread_properties(self):
thread_id = self._thread_id
token = self.token
endpoint = self.endpoint
# [START get_thread]
from azure.communication.chat import ChatClient, CommunicationTokenCredential
# set `endpoint` to an existing ACS endpoint
chat_client = ChatClient(endpoint, CommunicationTokenCredential(token))
chat_thread_client = chat_client.get_chat_thread_client(thread_id)
chat_thread_properties = chat_thread_client.get_properties()
print('Expected Thread Id: ', thread_id, ' Actual Value: ', chat_thread_properties.id)
# [END get_thread]
print("get_chat_thread_properties succeeded, thread id: " + chat_thread.id + ", thread topic: " + chat_thread.topic)
def get_chat_thread_properties(self):
thread_id = self._thread_id
# [START get_thread]
from azure.communication.chat import ChatClient
from azure.communication.identity._shared.user_credential import CommunicationTokenCredential
from azure.communication.chat._shared.user_token_refresh_options import CommunicationTokenRefreshOptions
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_client = ChatClient(self.endpoint,
CommunicationTokenCredential(refresh_options))
chat_thread_client = chat_client.get_chat_thread_client(thread_id)
chat_thread_properties = chat_thread_client.get_properties()
print('Expected Thread Id: ', thread_id, ' Actual Value: ',
chat_thread_properties.id)
# [END get_thread]
print("get_chat_thread_properties succeeded, thread id: " +
chat_thread.id + ", thread topic: " + chat_thread.topic)
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)
def test_get_thread_client(self):
thread_id = "19:[email protected]"
chat_client = ChatClient("https://endpoint", TestChatClient.credential)
chat_thread_client = chat_client.get_chat_thread_client(thread_id)
assert chat_thread_client.thread_id == 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
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)
print('Chat Thread Id: ', chat_thread_item.id)
