def test_list_chat_threads(self):
thread_id = "19:[email protected]"
raised = False
def mock_send(*_, **__):
return mock_response(status_code=200,
json_payload={"value": [{
"id": thread_id
}]})
chat_client = ChatClient("https://endpoint",
TestChatClient.credential,
transport=Mock(send=mock_send))
chat_threads = None
try:
chat_threads = chat_client.list_chat_threads()
except:
raised = True
self.assertFalse(raised, 'Expected is no excpetion raised')
for chat_thread_item_page in chat_threads.by_page():
l = list(chat_thread_item_page)
assert len(l) == 1
assert l[0].id == thread_id
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 list_threads(self):
# [START list_threads]
from azure.communication.chat import ChatClient, CommunicationTokenCredential, CommunicationTokenRefreshOptions
from datetime import datetime, timedelta
import pytz
refresh_options = CommunicationTokenRefreshOptions(self.token)
chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options))
start_time = datetime.utcnow() - timedelta(days=2)
start_time = start_time.replace(tzinfo=pytz.utc)
chat_thread_infos = chat_client.list_chat_threads(results_per_page=5, start_time=start_time)
print("list_threads succeeded with results_per_page is 5, and were created since 2 days ago.")
for info in chat_thread_infos:
print("thread id:", info.id)
def list_threads(self):
token = self.token
endpoint = self.endpoint
# [START list_threads]
from azure.communication.chat import ChatClient, CommunicationTokenCredential
from datetime import datetime, timedelta
chat_client = ChatClient(endpoint, CommunicationTokenCredential(token))
start_time = datetime.utcnow() - timedelta(days=2)
chat_threads = chat_client.list_chat_threads(results_per_page=5,
start_time=start_time)
print(
"list_threads succeeded with results_per_page is 5, and were created since 2 days ago."
)
for chat_thread_item_page in chat_threads.by_page():
for chat_thread_item in chat_thread_item_page:
print("thread id:", chat_thread_item.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
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)
# 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)
# Send a message to a chat thread
content = 'hello world'
sender_display_name = 'sender name'
# specify chat message type with pre-built enumerations
send_message_result_w_enum = chat_thread_client.send_message(
content=content,
sender_display_name=sender_display_name,
chat_message_type=ChatMessageType.TEXT)
print("Message sent: id: ", send_message_result_w_enum.id)
