async def test_communicationtokencredential_throws_if_proactive_refresh_enabled_without_token_refresher( self): with pytest.raises(ValueError) as err: CommunicationTokenCredential(self.sample_token, proactive_refresh=True) assert str( err.value ) == "When 'proactive_refresh' is True, 'token_refresher' must not be None." with pytest.raises(ValueError) as err: CommunicationTokenCredential(self.sample_token, proactive_refresh=True, token_refresher=None) assert str( err.value ) == "When 'proactive_refresh' is True, 'token_refresher' must not be None."
async def test_proactive_refresher_should_be_called_after_specified_time( self): refresh_minutes = 10 token_validity_minutes = 60 start_timestamp = get_current_utc_as_int() skip_to_timestamp = start_timestamp + \ (token_validity_minutes - refresh_minutes + 5) * 60 initial_token = generate_token_with_custom_expiry( token_validity_minutes * 60) refreshed_token = generate_token_with_custom_expiry( 2 * token_validity_minutes * 60) refresher = MagicMock(return_value=self.get_completed_future( create_access_token(refreshed_token))) with patch(user_credential_async.__name__ + '.' + get_current_utc_as_int.__name__, return_value=skip_to_timestamp): credential = CommunicationTokenCredential( initial_token, token_refresher=refresher, proactive_refresh=True) async with credential: access_token = await credential.get_token() assert refresher.call_count == 1 assert access_token.token == refreshed_token # check that next refresh is always scheduled assert credential._timer is not None
def setUp(self): super(ChatClientTestAsync, self).setUp() self.recording_processors.extend([ BodyReplacerProcessor(keys=[ "id", "token", "createdBy", "participants", "multipleStatus", "value" ]), URIIdentityReplacer(), ResponseReplacerProcessor(keys=[self._resource_name]), ChatURIReplacer() ]) endpoint, _ = parse_connection_str(self.connection_str) self.endpoint = endpoint self.identity_client = CommunicationIdentityClient.from_connection_string( self.connection_str) # create user self.user = self.identity_client.create_user() token_response = self.identity_client.get_token(self.user, scopes=["chat"]) self.token = token_response.token # create ChatClient refresh_options = CommunicationTokenRefreshOptions(self.token) self.chat_client = ChatClient( self.endpoint, CommunicationTokenCredential(refresh_options))
async def test_fractional_backoff_applied_when_token_expiring(self): token_validity_seconds = 5 * 60 expiring_token = generate_token_with_custom_expiry( token_validity_seconds) refresher = MagicMock(side_effect=[ create_access_token(expiring_token), create_access_token(expiring_token) ]) credential = CommunicationTokenCredential(expiring_token, token_refresher=refresher, proactive_refresh=True) next_milestone = token_validity_seconds / 2 assert credential._timer.interval == next_milestone async with credential: with patch(user_credential_async.__name__ + '.' + get_current_utc_as_int.__name__, return_value=(get_current_utc_as_int() + next_milestone)): await credential.get_token() assert refresher.call_count == 1 next_milestone = next_milestone / 2 assert credential._timer.interval == next_milestone
async def create_thread_async(self): from datetime import datetime from azure.communication.chat.aio import ChatClient from azure.communication.identity._shared.user_credential_async import CommunicationTokenCredential from azure.communication.chat._shared.user_token_refresh_options import CommunicationTokenRefreshOptions from azure.communication.chat import ChatThreadParticipant refresh_options = CommunicationTokenRefreshOptions(self.token) chat_client = ChatClient(self.endpoint, CommunicationTokenCredential(refresh_options)) async with chat_client: # [START create_thread] topic = "test topic" participants = [ ChatThreadParticipant(user=self.user, display_name='name', share_history_time=datetime.utcnow()) ] # creates a new chat_thread everytime create_chat_thread_result = await chat_client.create_chat_thread( topic, thread_participants=participants) # creates a new chat_thread if not exists repeatability_request_id = 'b66d6031-fdcc-41df-8306-e524c9f226b8' # unique identifier create_chat_thread_result_w_repeatability_id = await chat_client.create_chat_thread( topic, thread_participants=participants, repeatability_request_id=repeatability_request_id) # [END create_thread] self._thread_id = create_chat_thread_result.chat_thread.id print("thread created, id: " + self._thread_id)
async def test_proactive_refresher_keeps_scheduling_again(self): refresh_minutes = 10 token_validity_minutes = 60 expired_token = generate_token_with_custom_expiry(-5 * 60) skip_to_timestamp = get_current_utc_as_int() + ( token_validity_minutes - refresh_minutes) * 60 + 1 first_refreshed_token = create_access_token( generate_token_with_custom_expiry(token_validity_minutes * 60)) last_refreshed_token = create_access_token( generate_token_with_custom_expiry(2 * token_validity_minutes * 60)) refresher = MagicMock(side_effect=[ self.get_completed_future(first_refreshed_token), self.get_completed_future(last_refreshed_token) ]) credential = CommunicationTokenCredential(expired_token, token_refresher=refresher, proactive_refresh=True) async with credential: access_token = await credential.get_token() with patch(user_credential_async.__name__ + '.' + get_current_utc_as_int.__name__, return_value=skip_to_timestamp): access_token = await credential.get_token() assert refresher.call_count == 2 assert access_token.token == last_refreshed_token.token # check that next refresh is always scheduled assert credential._timer is not None
async def create_chat_thread_client_async(self): # [START create_chat_thread_client] from datetime import datetime from azure.communication.chat.aio import ChatClient from azure.communication.chat import ChatThreadParticipant from azure.communication.identity import CommunicationUserIdentifier from azure.communication.identity._shared.user_credential_async 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)) async with chat_client: topic = "test topic" participants = [ChatThreadParticipant( user=self.user, display_name='name', share_history_time=datetime.utcnow() )] create_chat_thread_result = await 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("thread created, id: " + self._thread_id) print("create_chat_thread_client_async succeeded")
async def test_raises_if_refresher_returns_expired_token(self): expired_token = generate_token_with_custom_expiry(-(10 * 60)) refresher = MagicMock(return_value=self.get_completed_future( create_access_token(expired_token))) credential = CommunicationTokenCredential(expired_token, token_refresher=refresher) with self.assertRaises(ValueError): await credential.get_token() assert refresher.call_count == 1
def create_chat_client(self): # [START create_chat_client] from azure.communication.chat.aio import ChatClient from azure.communication.identity._shared.user_credential_async 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)) # [END create_chat_client] print("chat_client created")
async def test_exit_cancels_timer(self): refreshed_token = create_access_token( generate_token_with_custom_expiry(30 * 60)) refresher = MagicMock(return_value=refreshed_token) expired_token = generate_token_with_custom_expiry(-10 * 60) credential = CommunicationTokenCredential(expired_token, token_refresher=refresher, proactive_refresh=True) async with credential: assert credential._timer is not None assert refresher.call_count == 0 assert credential._timer is not None
async def test_refresher_should_not_be_called_when_token_still_valid(self): generated_token = generate_token_with_custom_expiry(15 * 60) new_token = generate_token_with_custom_expiry(10 * 60) refresher = MagicMock(return_value=create_access_token(new_token)) credential = CommunicationTokenCredential(generated_token, token_refresher=refresher, proactive_refresh=False) for _ in range(10): access_token = await credential.get_token() refresher.assert_not_called() assert generated_token == access_token.token
async def test_refresher_should_not_be_called_before_expiring_time(self): initial_token = generate_token_with_custom_expiry(15 * 60) refreshed_token = generate_token_with_custom_expiry(10 * 60) refresher = MagicMock( return_value=create_access_token(refreshed_token)) credential = CommunicationTokenCredential(initial_token, token_refresher=refresher, proactive_refresh=True) access_token = await credential.get_token() refresher.assert_not_called() assert initial_token == access_token.token
async def test_refresher_should_be_called_immediately_with_expired_token( self): refreshed_token = generate_token_with_custom_expiry(10 * 60) refresher = MagicMock(return_value=self.get_completed_future( create_access_token(refreshed_token))) expired_token = generate_token_with_custom_expiry(-(5 * 60)) credential = CommunicationTokenCredential(expired_token, token_refresher=refresher) access_token = await credential.get_token() refresher.assert_called_once() assert refreshed_token == access_token.token
async def delete_thread_async(self): from azure.communication.chat.aio import ChatClient from azure.communication.identity._shared.user_credential_async 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)) async with chat_client: # [START delete_thread] await chat_client.delete_chat_thread(self._thread_id) # [END delete_thread] print("delete_thread succeeded")
async def get_thread_async(self): from azure.communication.chat.aio import ChatClient from azure.communication.identity._shared.user_credential_async 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)) async with chat_client: # [START get_thread] chat_thread = await chat_client.get_chat_thread(self._thread_id) # [END get_thread] print("get_thread succeeded, thread id: " + chat_thread.id + ", thread topic: " + chat_thread.topic)
def get_chat_thread_client(self): # [START get_chat_thread_client] from azure.communication.chat.aio import ChatClient from azure.communication.identity._shared.user_credential_async 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( self._thread_id) # [END get_chat_thread_client] print("chat_thread_client created with thread id: ", chat_thread_client.thread_id)
async def test_exit_enter_scenario_throws_exception(self): refreshed_token = create_access_token( generate_token_with_custom_expiry(30 * 60)) refresher = MagicMock(return_value=refreshed_token) expired_token = generate_token_with_custom_expiry(-10 * 60) credential = CommunicationTokenCredential(expired_token, token_refresher=refresher, proactive_refresh=True) credential.get_token() credential.close() assert credential._timer is not None with pytest.raises(RuntimeError) as err: credential.get_token() assert str( err.value ) == "An instance of CommunicationTokenCredential cannot be reused once it has been closed."
async def get_chat_thread_properties_async(self): thread_id = self._thread_id # [START get_thread] from azure.communication.chat.aio import ChatClient from azure.communication.identity._shared.user_credential_async 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)) async with chat_client: chat_thread_client = chat_client.get_chat_thread_client(thread_id) async with chat_thread_client: 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_async succeeded, thread id: " + chat_thread.id + ", thread topic: " + chat_thread.topic)
async def list_threads_async(self): from azure.communication.chat.aio import ChatClient from azure.communication.identity._shared.user_credential_async 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)) async with chat_client: # [START list_threads] from datetime import datetime, timedelta import pytz 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." ) async for chat_thread_info_page in chat_thread_infos.by_page(): async for chat_thread_info in chat_thread_info_page: print("thread id: ", chat_thread_info.id)
class ChatThreadClientSamplesAsync(object): from azure.communication.chat.aio import ChatClient from azure.communication.identity import CommunicationIdentityClient from azure.communication.identity._shared.user_credential_async import CommunicationTokenCredential from azure.communication.chat._shared.user_token_refresh_options import CommunicationTokenRefreshOptions connection_string = os.environ.get("AZURE_COMMUNICATION_SERVICE_CONNECTION_STRING", None) if not connection_string: raise ValueError("Set AZURE_COMMUNICATION_SERVICE_CONNECTION_STRING env before run this sample.") identity_client = CommunicationIdentityClient.from_connection_string(connection_string) user = identity_client.create_user() tokenresponse = identity_client.get_token(user, scopes=["chat"]) token = tokenresponse.token endpoint = os.environ.get("AZURE_COMMUNICATION_SERVICE_ENDPOINT", None) if not endpoint: raise ValueError("Set AZURE_COMMUNICATION_SERVICE_ENDPOINT env before run this sample.") _thread_id = None _message_id = None new_user = identity_client.create_user() refresh_options = CommunicationTokenRefreshOptions(token) _chat_client = ChatClient(endpoint, CommunicationTokenCredential(refresh_options)) async def create_chat_thread_client_async(self): # [START create_chat_thread_client] from datetime import datetime from azure.communication.chat.aio import ChatClient from azure.communication.chat import ChatThreadParticipant from azure.communication.identity import CommunicationUserIdentifier from azure.communication.identity._shared.user_credential_async 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)) async with chat_client: topic = "test topic" participants = [ChatThreadParticipant( user=self.user, display_name='name', share_history_time=datetime.utcnow() )] create_chat_thread_result = await 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("thread created, id: " + self._thread_id) print("create_chat_thread_client_async succeeded") async def update_topic_async(self): thread_id = self._thread_id chat_client = self._chat_client # [START update_topic] # set `thread_id` to an existing thread id async with chat_client: chat_thread = await chat_client.get_chat_thread(thread_id=thread_id) previous_topic = chat_thread.topic chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: topic = "updated thread topic" await chat_thread_client.update_topic(topic=topic) chat_thread = await chat_client.get_chat_thread(thread_id=thread_id) updated_topic = chat_thread.topic print("Chat Thread Topic Update: Previous value: ", previous_topic, ", Current value: ", updated_topic) # [END update_topic] print("update_topic_async succeeded") async def send_message_async(self): thread_id = self._thread_id chat_client = self._chat_client # [START send_message] from azure.communication.chat import ChatMessageType async with chat_client: chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: # Scenario 1: Send message without specifying chat_message_type send_message_result_id = await chat_thread_client.send_message( "Hello! My name is Fred Flinstone", sender_display_name="Fred Flinstone") # Scenario 2: Send message specifying chat_message_type send_message_result_w_type_id = await chat_thread_client.send_message( "Hello! My name is Wilma Flinstone", sender_display_name="Wilma Flinstone", chat_message_type=ChatMessageType.TEXT) # equivalent to setting chat_message_type='text' # Verify message content print("First Message:", (await chat_thread_client.get_message(send_message_result_id)).content.message) print("Second Message:", (await chat_thread_client.get_message(send_message_result_w_type_id)).content.message) # [END send_message] self._message_id = send_message_result_id print("send_message succeeded, message id:", self._message_id) print("send_message succeeded with type specified, message id:", send_message_result_w_type_id) print("send_message_async succeeded") async def get_message_async(self): thread_id = self._thread_id chat_client = self._chat_client message_id = self._message_id # [START get_message] async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: # set `message_id` to an existing message id chat_message = await chat_thread_client.get_message(message_id) print("Message received: ChatMessage: content=", chat_message.content.message, ", id=", chat_message.id) # [END get_message] print("get_message_async succeeded") async def list_messages_async(self): thread_id = self._thread_id chat_client = self._chat_client # [START list_messages] from datetime import datetime, timedelta async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: 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") async for chat_message_page in chat_messages.by_page(): async for chat_message in chat_message_page: print("ChatMessage: message=", chat_message.content.message) # [END list_messages] print("list_messages_async succeeded") async def update_message_async(self): thread_id = self._thread_id chat_client = self._chat_client message_id = self._message_id # [START update_message] async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: # set `message_id` to an existing message id previous_content = (await chat_thread_client.get_message(message_id)).content.message content = "updated message content" await chat_thread_client.update_message(self._message_id, content=content) current_content = (await chat_thread_client.get_message(message_id)).content.message print("Chat Message Updated: Previous value: ", previous_content, ", Current value: ", current_content) # [END update_message] print("update_message_async succeeded") async def send_read_receipt_async(self): thread_id = self._thread_id chat_client = self._chat_client message_id = self._message_id # [START send_read_receipt] async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: # set `message_id` to an existing message id await chat_thread_client.send_read_receipt(message_id) # [END send_read_receipt] print("send_read_receipt_async succeeded") async def list_read_receipts_async(self): thread_id = self._thread_id chat_client = self._chat_client # [START list_read_receipts] async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: read_receipts = chat_thread_client.list_read_receipts() print("list_read_receipts succeeded, receipts:") async for read_receipt_page in read_receipts.by_page(): async for read_receipt in read_receipt_page: print(read_receipt) # [END list_read_receipts] print("list_read_receipts_async succeeded") async def delete_message_async(self): thread_id = self._thread_id chat_client = self._chat_client message_id = self._message_id # [START delete_message] async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: # set `message_id` to an existing message id await chat_thread_client.delete_message(message_id) # [END delete_message] print("delete_message_async succeeded") async def list_participants_async(self): thread_id = self._thread_id chat_client = self._chat_client # [START list_participants] async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: chat_thread_participants = chat_thread_client.list_participants() print("list_participants succeeded, participants:") async for chat_thread_participant_page in chat_thread_participants.by_page(): async for chat_thread_participant in chat_thread_participant_page: print("ChatThreadParticipant: ", chat_thread_participant) # [END list_participants] print("list_participants_async succeeded") async def add_participant_w_check_async(self): thread_id = self._thread_id chat_client = self._chat_client user = self.new_user # [START add_participant] def decide_to_retry(error): """ Custom logic to decide whether to retry to add or not """ return True async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: from azure.communication.chat import ChatThreadParticipant from datetime import datetime new_chat_thread_participant = ChatThreadParticipant( user=user, display_name='name', share_history_time=datetime.utcnow()) try: await chat_thread_client.add_participant(new_chat_thread_participant) except RuntimeError as e: if e is not None and decide_to_retry(error=e): await chat_thread_client.add_participant(new_chat_thread_participant) # [END add_participant] print("add_participant_w_check_async succeeded") async def add_participants_w_check_async(self): thread_id = self._thread_id chat_client = self._chat_client user = self.new_user # [START add_participants] def decide_to_retry(error): """ Custom logic to decide whether to retry to add or not """ return True async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: from azure.communication.chat import ChatThreadParticipant from datetime import datetime new_participant = ChatThreadParticipant( user=self.new_user, display_name='name', share_history_time=datetime.utcnow()) thread_participants = [new_participant] result = await chat_thread_client.add_participants(thread_participants) # list of participants which were unsuccessful to be added to chat thread retry = [p for p, e in result if decide_to_retry(e)] if len(retry) > 0: chat_thread_client.add_participants(retry) # [END add_participants] print("add_participants_w_check_async succeeded") async def remove_participant_async(self): thread_id = self._thread_id chat_client = self._chat_client identity_client = self.identity_client # [START remove_participant] from azure.communication.chat import ChatThreadParticipant from azure.communication.identity import CommunicationUserIdentifier from datetime import datetime async with chat_client: # create 2 new users using CommunicationIdentityClient.create_user method user1 = identity_client.create_user() user2 = identity_client.create_user() # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: # add user1 and user2 to chat thread participant1 = ChatThreadParticipant( user=user1, display_name='Fred Flinstone', share_history_time=datetime.utcnow()) participant2 = ChatThreadParticipant( user=user2, display_name='Wilma Flinstone', share_history_time=datetime.utcnow()) thread_participants = [participant1, participant2] await chat_thread_client.add_participants(thread_participants) # Option 1 : Iterate through all participants, find and delete Fred Flinstone chat_thread_participants = chat_thread_client.list_participants() async for chat_thread_participant_page in chat_thread_participants.by_page(): async for chat_thread_participant in chat_thread_participant_page: print("ChatThreadParticipant: ", chat_thread_participant) if chat_thread_participant.user.identifier == user1.identifier: print("Found Fred!") await chat_thread_client.remove_participant(chat_thread_participant.user) print("Fred has been removed from the thread...") break # Option 2: Directly remove Wilma Flinstone unique_identifier = user2.identifier # in real scenario the identifier would need to be retrieved from elsewhere await chat_thread_client.remove_participant(CommunicationUserIdentifier(unique_identifier)) print("Wilma has been removed from the thread...") # [END remove_participant] # clean up temporary users self.identity_client.delete_user(user1) self.identity_client.delete_user(user2) print("remove_participant_async succeeded") async def send_typing_notification_async(self): thread_id = self._thread_id chat_client = self._chat_client # [START send_typing_notification] async with chat_client: # set `thread_id` to an existing thread id chat_thread_client = chat_client.get_chat_thread_client(thread_id=thread_id) async with chat_thread_client: await chat_thread_client.send_typing_notification() # [END send_typing_notification] print("send_typing_notification_async succeeded") def clean_up(self): print("cleaning up: deleting created users.") self.identity_client.delete_user(self.user) self.identity_client.delete_user(self.new_user)
async def test_init_with_valid_token(self): initial_token = generate_token_with_custom_expiry(5 * 60) credential = CommunicationTokenCredential(initial_token) access_token = await credential.get_token() assert initial_token == access_token.token
async def test_raises_error_for_init_with_invalid_token(self): with pytest.raises(ValueError) as err: CommunicationTokenCredential("not a token") assert str(err.value) == "Token is not formatted correctly"
async def test_raises_error_for_init_with_nonstring_token(self): with pytest.raises(TypeError) as err: CommunicationTokenCredential(1234) assert str(err.value) == "Token must be a string."