def _load_user_and_chat_id_80661419(self, session):
'''
helper function that loads the db_model.User and
db_model.Chat for user / chat id `80661419` which we need if we want to
test messages
'''
# load user
user_json_path = u.get_fake_tdlib_messages_path("user/user_id_80661419.json")
user_obj = u.load_tdlib_generated_obj_from_file(user_json_path, self.converter)
self.assertIsInstance(user_obj, tdg.user)
user_dbmodel_obj = UserAide.new_user_from_tdlib_user(session, user_obj)
self.assertEqual(user_dbmodel_obj.tg_user_id, 80661419)
session.add(user_dbmodel_obj)
session.commit()
# load chat
chat_json_path = u.get_fake_tdlib_messages_path("chat/chat_private_id_80661419_has_photo.json")
chat_tdlib_obj = u.load_tdlib_generated_obj_from_file(chat_json_path, self.converter)
self.assertIsInstance(chat_tdlib_obj, tdg.chat)
chat_dbmodel_obj = ChatAide.new_chat_from_tdlib_chat(session, chat_tdlib_obj)
self.assertEqual(chat_dbmodel_obj.tg_chat_id, 80661419)
session.add(chat_dbmodel_obj)
session.commit()
def test_get_chat_by_tg_chat_id(self):
'''
`ChatAide.get_chat_by_tg_chat_id`, insert chat into database and assert we can get it out
'''
with u.get_testing_sqla_session_contextmanager() as session:
p3 = u.get_fake_tdlib_messages_path(
"chat/chat_basic_group_id_-423872019_no_photo.json")
tdlib_obj3 = u.load_tdlib_generated_obj_from_file(
p3, self.converter)
self.assertIsInstance(tdlib_obj3, tdg.chat)
chat_three = chat_aide.ChatAide.new_chat_from_tdlib_chat(
session, tdlib_obj3)
session.add(chat_three)
session.commit()
result_chat_three = chat_aide.ChatAide.get_chat_by_tg_chat_id(
session, -423872019)
self.assertEqual(result_chat_three.tg_chat_id, -423872019)
self.assertEqual(len(result_chat_three.versions), 1)
self.assertIsInstance(result_chat_three, db_model.BasicGroupChat)
self.assertEqual(result_chat_three.versions[0].title,
"telegram_dl development")
def test_get_text_entities_single_entity_per_message(self):
'''
`TextEntityAide.get_text_entity_from_tdlib_text_entity` with the various types of TextEntities
'''
for iter_param in self.test_params:
if not iter_param.should_skip:
with self.subTest(textEntityType=iter_param.te_type):
json_path = self.fake_message_prefix / "message_id_18874368_chat_id_-1001446368458_text_entity_bold.json"
message_json = u.get_fake_tdlib_messages_path(
iter_param.json_path)
message_obj = u.load_tdlib_generated_obj_from_file(
message_json, self.converter)
# assert that the loaded type is what we expect
self.assertIsInstance(message_obj, tdg.message)
with u.get_testing_sqla_session_contextmanager(
) as session:
self._add_testing_data_to_session(session)
# Message related assertions, just to be safe
loaded_message = MessageAide.new_message_from_tdlib_message(
session, message_obj)
self.assertEqual(
len(loaded_message.versions), 1,
"make sure we only have 1 loaded version")
message_version = loaded_message.versions[-1]
self.assertIsInstance(
message_version, db_model.MessageVersionText,
"verify db_model.MessageVersion subclass")
self.assertEqual(iter_param.msg_text,
message_version.text,
"verify message text")
# Text Entity related assertions
loaded_text_entities = TextEntityAide.get_text_entities_from_tdlib_text_entity_sequence(
message_version, message_obj.content.text.entities)
self.assertEqual(
len(loaded_text_entities), 1,
"make sure we only have 1 text entity")
te = loaded_text_entities[0]
self.assertIsInstance(
te, db_model.TextEntity,
"verify type is db_model.TextEntity")
self.assertEqual(te.offset, iter_param.te_offset,
"verify TextEntity offset")
self.assertEqual(te.length, iter_param.te_length,
"verify TextEntity length")
self.assertEqual(te.text_entity_type,
iter_param.te_type,
"verify type of TextEntity")
def test_get_chat_by_tg_chat_id(self):
'''
`ChatAide.get_chat_by_tg_chat_id`, insert chat into database and assert we can get it out
'''
with u.get_testing_sqla_session_contextmanager() as session:
# add the db_model.User that this private chat is with, or else it
# will have a integrity error when we add the chat
user_json = u.get_fake_tdlib_messages_path(
"user/user_id_80661419.json")
user_obj = u.load_tdlib_generated_obj_from_file(
user_json, self.converter)
self.assertIsInstance(user_obj, tdg.user)
user_tdlib_obj = UserAide.new_user_from_tdlib_user(
session, user_obj)
session.add(user_tdlib_obj)
# add the db_model.PrivateChat
p4 = u.get_fake_tdlib_messages_path(
"chat/chat_private_id_80661419_has_photo.json")
tdlib_obj4 = u.load_tdlib_generated_obj_from_file(
p4, self.converter)
self.assertIsInstance(tdlib_obj4, tdg.chat)
chat_four = chat_aide.ChatAide.new_chat_from_tdlib_chat(
session, tdlib_obj4)
session.add(chat_four)
# commit it
session.commit()
# do assertions
result_chat_four = chat_aide.ChatAide.get_chat_by_tg_chat_id(
session, 80661419)
self.assertEqual(result_chat_four.tg_chat_id, 80661419)
self.assertEqual(len(result_chat_four.versions), 1)
self.assertIsInstance(result_chat_four, db_model.PrivateChat)
self.assertEqual(result_chat_four.versions[0].title, "John Smith")
def _add_testing_data_to_session(self, session):
'''
Adds testing data that all of the unit tests in this file will use, since all
of the examples are messages that were sent in a channel (so therefore no user)
and were all sent within the same chat (a supergroup channel)
'''
# load the chat
path_chat = u.get_fake_tdlib_messages_path(
"chat/chat_supergroup_id_-1001446368458_channel_no_photo.json")
tdlib_obj_chat = u.load_tdlib_generated_obj_from_file(
path_chat, self.converter)
self.assertIsInstance(tdlib_obj_chat, tdg.chat)
chat = ChatAide.new_chat_from_tdlib_chat(session, tdlib_obj_chat)
session.add(chat)
session.commit()
def _load_and_return_message_id_599515987968(self, session):
'''
helper function that loads the db_model.Message for message id `599515987968`
and returns the resulting db_model.Message object
'''
# load message from JSON
message_json = u.get_fake_tdlib_messages_path("message/messageText/message_id_599515987968_chat_id_80661419_message_text.json")
message_tdlib_obj = u.load_tdlib_generated_obj_from_file(message_json, self.converter)
self.assertIsInstance(message_tdlib_obj, tdg.message)
self.assertIsInstance(message_tdlib_obj.content, tdg.messageText)
message_dbmodel_obj = MessageAide.new_message_from_tdlib_message(session, message_tdlib_obj)
session.add(message_dbmodel_obj)
session.commit()
return message_dbmodel_obj
def test_compare_tdlib_and_dbmodel_chat_equal(self):
'''
`ChatAide.test_compare_tdlib_and_dbmodel_chat`, should be equal
'''
p = u.get_fake_tdlib_messages_path("chat/chat_supergroup_id_-1001446368458_channel_has_photo.json")
tdlib_obj = u.load_tdlib_generated_obj_from_file(p, self.converter)
# create the db_model objects from JSON
asof_time = arrow.utcnow()
chat_dbmodel_obj = self._get_supergroup_channel_chat_photo(asof_time)
# assert that we correctly compare these as true
compare_result = chat_aide.ChatAide.compare_tdlib_and_dbmodel_chat(
dbmodel_chat=chat_dbmodel_obj,
tdlib_chat=tdlib_obj)
self.assertTrue(compare_result)
def test_get_chat_by_tg_chat_id(self):
'''
`ChatAide.get_chat_by_tg_chat_id`, insert chat into database and assert we can get it out
'''
with u.get_testing_sqla_session_contextmanager() as session:
p1 = u.get_fake_tdlib_messages_path("chat/chat_supergroup_id_-1001446368458_channel_has_photo.json")
tdlib_obj1 = u.load_tdlib_generated_obj_from_file(p1, self.converter)
self.assertIsInstance(tdlib_obj1, tdg.chat)
chat_one = chat_aide.ChatAide.new_chat_from_tdlib_chat(session, tdlib_obj1)
session.add(chat_one)
session.commit()
result_chat_one = chat_aide.ChatAide.get_chat_by_tg_chat_id(session, -1001446368458)
self.assertEqual(result_chat_one.tg_chat_id, -1001446368458)
self.assertEqual(len(result_chat_one.versions), 1)
self.assertIsInstance(result_chat_one, db_model.SuperGroupChat)
self.assertEqual(result_chat_one.versions[0].title, "TestingChannel")
def test_get_chat_by_tg_chat_id(self):
'''
`ChatAide.get_chat_by_tg_chat_id`, insert chat into database and assert we can get it out
'''
with u.get_testing_sqla_session_contextmanager() as session:
p2 = u.get_fake_tdlib_messages_path(
"chat/chat_supergroup_id_-1001266163180_no_photo.json")
tdlib_obj2 = u.load_tdlib_generated_obj_from_file(
p2, self.converter)
self.assertIsInstance(tdlib_obj2, tdg.chat)
chat_two = chat_aide.ChatAide.new_chat_from_tdlib_chat(
session, tdlib_obj2)
session.add(chat_two)
session.commit()
result_chat_two = chat_aide.ChatAide.get_chat_by_tg_chat_id(
session, -1001266163180)
self.assertEqual(result_chat_two.tg_chat_id, -1001266163180)
self.assertEqual(len(result_chat_two.versions), 1)
self.assertIsInstance(result_chat_two, db_model.SuperGroupChat)
self.assertEqual(result_chat_two.versions[0].title, "TGS stuff")
def test_compare_tdlib_and_dbmodel_chat_multiple_chat_versions(self):
'''
`ChatAide.test_compare_tdlib_and_dbmodel_chat`, with multiple `db_model.ChatVersion` objects
NOTE: this is not fully testing the `relationship` of the Chat -> ChatVersion
(the `versions` field), since when loading from the database it will sort by the
`ChatVersion.as_of` field
so theoretically we could do `Chat.versions.insert(0, chat_ver_obj)`
(instead of `append()`) and that will insert it at index 0, even if the
`chat_ver_obj` is not the earliest ChatVersion (by the `as_of` field),
but since we aren't loading it from the database, sqlalchemy doesn't
re-sort it for us or anything
'''
asof_time = arrow.utcnow()
chat_dbmodel_obj = self._get_supergroup_channel_chat_photo(asof_time)
p = u.get_fake_tdlib_messages_path("chat/chat_supergroup_id_-1001446368458_channel_has_photo.json")
tdlib_obj = u.load_tdlib_generated_obj_from_file(p, self.converter)
# so we have a Chat (Supergroup) with a photo, it should equal the message that we loaded
# from the JSON
compare_result_one = chat_aide.ChatAide.compare_tdlib_and_dbmodel_chat(
dbmodel_chat=chat_dbmodel_obj,
tdlib_chat=tdlib_obj)
self.assertEqual(len(chat_dbmodel_obj.versions), 1)
# has a photo to start out with
self.assertNotEqual(chat_dbmodel_obj.versions[-1].photo_set, None)
self.assertTrue(compare_result_one)
# now add a chat version where we 'remove' the photo
# and add it as a version
chat_ver_no_photo = self._get_chat_version(arrow.now(), "TestingChannel", None, False)
chat_dbmodel_obj.versions.append(chat_ver_no_photo)
# now the compare method should return as not equal
compare_result_two = chat_aide.ChatAide.compare_tdlib_and_dbmodel_chat(
dbmodel_chat=chat_dbmodel_obj,
tdlib_chat=tdlib_obj)
self.assertEqual(len(chat_dbmodel_obj.versions), 2)
# does not have a photo for this one
self.assertEqual(chat_dbmodel_obj.versions[-1].photo_set, None)
self.assertFalse(compare_result_two)
# if we add another version that should be the same as the "first" version
# (has the same photo), then it should compare as equal again
chat_ver_photo_two = self._get_chat_version(arrow.now(), "TestingChannel", self._get_photo_set(), False)
chat_dbmodel_obj.versions.append(chat_ver_photo_two)
compare_result_three = chat_aide.ChatAide.compare_tdlib_and_dbmodel_chat(
dbmodel_chat=chat_dbmodel_obj,
tdlib_chat=tdlib_obj)
self.assertEqual(len(chat_dbmodel_obj.versions), 3)
# has a photo
self.assertNotEqual(chat_dbmodel_obj.versions[-1].photo_set, None)
self.assertTrue(compare_result_three)
def test_new_message_from_tdlib_message(self):
with u.get_testing_sqla_session_contextmanager() as session:
# add the db_model.User that this private chat is with, or else it
# will have a integrity error when we add the chat
message_json = u.get_fake_tdlib_messages_path("message/messageText/message_id_599515987968_chat_id_80661419_message_text.json")
message_tdlib_obj = u.load_tdlib_generated_obj_from_file(message_json, self.converter)
self.assertIsInstance(message_tdlib_obj, tdg.message)
self.assertIsInstance(message_tdlib_obj.content, tdg.messageText)
# load user
user_json_path = u.get_fake_tdlib_messages_path("user/user_id_80661419.json")
user_obj = u.load_tdlib_generated_obj_from_file(user_json_path, self.converter)
self.assertIsInstance(user_obj, tdg.user)
user_dbmodel_obj = UserAide.new_user_from_tdlib_user(session, user_obj)
session.add(user_dbmodel_obj)
session.commit()
self.assertEqual(user_dbmodel_obj.tg_user_id, 80661419)
# load chat
chat_json_path = u.get_fake_tdlib_messages_path("chat/chat_private_id_80661419_has_photo.json")
chat_tdlib_obj = u.load_tdlib_generated_obj_from_file(chat_json_path, self.converter)
self.assertIsInstance(chat_tdlib_obj, tdg.chat)
chat_dbmodel_obj = ChatAide.new_chat_from_tdlib_chat(session, chat_tdlib_obj)
session.add(chat_dbmodel_obj)
session.commit()
# save and load message
message_dbmodel_obj = MessageAide.new_message_from_tdlib_message(session, message_tdlib_obj)
session.add(message_dbmodel_obj)
session.commit()
retrieved_message_dbmodel_obj = MessageAide.get_message_by_tg_message_and_tg_chat_id(
session, 599515987968, 80661419)
# message assertions
self.assertEqual(retrieved_message_dbmodel_obj.tg_message_id, 599515987968)
self.assertTrue(retrieved_message_dbmodel_obj.is_outgoing)
self.assertFalse(retrieved_message_dbmodel_obj.is_channel_post)
self.assertTrue(retrieved_message_dbmodel_obj.can_edit)
self.assertTrue(retrieved_message_dbmodel_obj.can_forward)
self.assertTrue(retrieved_message_dbmodel_obj.can_be_deleted_only_for_self)
self.assertFalse(retrieved_message_dbmodel_obj.can_be_deleted_for_all_users)
self.assertEqual(retrieved_message_dbmodel_obj.restriction_reason, "")
self.assertIsNone(retrieved_message_dbmodel_obj.via_bot_user)
self.assertIsNone(retrieved_message_dbmodel_obj.reply_to_message)
self.assertEqual(retrieved_message_dbmodel_obj.sender_user.user_id, user_dbmodel_obj.user_id)
self.assertEqual(retrieved_message_dbmodel_obj.chat.chat_id, chat_dbmodel_obj.chat_id)
# message version assertions
self.assertEqual(len(retrieved_message_dbmodel_obj.versions), 1)
latest_ver = retrieved_message_dbmodel_obj.versions[0]
self.assertIsInstance(latest_ver, db_model.MessageVersionText)
self.assertEqual(latest_ver.date, arrow.get(1589260319))
self.assertIsNone(latest_ver.edit_date)
self.assertEqual(latest_ver.author_signature, "")
self.assertEqual(latest_ver.ttl, 0)
# MessageVersionText assertions
self.assertEqual(latest_ver.text, "https://twitter.com/dril/status/107911000199671808")
# TODO: ASSERT WEB PAGE
# MessageVersionText TextEntities assertions
self.assertEqual(len(latest_ver.text_entities), 1)
text_entity = latest_ver.text_entities[0]
self.assertEqual(text_entity.offset, 0)
self.assertEqual(text_entity.length, 50)
self.assertEqual(text_entity.text_entity_type, dbme.TextEntityTypeEnum.TEXT_ENTITY_TYPE_URL)
def test_new_chat_from_tdlib_chat(self):
'''
`ChatAide.new_chat_from_tdlib_chat`, get new `db_model.Chat` from `tdlib_generated.chat`
'''
with u.get_testing_sqla_session_contextmanager() as session:
# add the db_model.User that this private chat is with, or else it
# will have a integrity error when we add the chat
user_json = u.get_fake_tdlib_messages_path(
"user/user_id_80661419.json")
user_obj = u.load_tdlib_generated_obj_from_file(
user_json, self.converter)
self.assertIsInstance(user_obj, tdg.user)
user_tdlib_obj = UserAide.new_user_from_tdlib_user(
session, user_obj)
session.add(user_tdlib_obj)
# add the db_model.PrivateChat
p = u.get_fake_tdlib_messages_path(
"chat/chat_private_id_80661419_has_photo.json")
tdlib_obj = u.load_tdlib_generated_obj_from_file(p, self.converter)
self.assertIsInstance(tdlib_obj, tdg.chat)
db_model_chat_obj = chat_aide.ChatAide.new_chat_from_tdlib_chat(
session, tdlib_obj)
# assertions
self.assertIsInstance(db_model_chat_obj, db_model.PrivateChat)
self.assertEqual(db_model_chat_obj.tg_chat_id, 80661419)
self.assertEqual(len(db_model_chat_obj.versions), 1)
latest_ver = db_model_chat_obj.versions[-1]
self.assertEqual(latest_ver.title, "John Smith")
self.assertFalse(latest_ver.is_sponsored)
##################################
# test the photo set
##################################
latest_ver_photo_set = latest_ver.photo_set
self.assertEqual(len(latest_ver_photo_set.photos), 2)
# big chat photo
big_list = latest_ver_photo_set \
.get_photos_by_thumnail_type(dbe.PhotoSizeThumbnailType.PHOTO_BIG)
self.assertEqual(len(big_list), 1)
big_photo = big_list[0]
self.assertEqual(big_photo.thumbnail_type,
dbe.PhotoSizeThumbnailType.PHOTO_BIG)
self.assertEqual(big_photo.width, -1)
self.assertEqual(big_photo.height, -1)
self.assertFalse(big_photo.has_stickers)
big_file = big_photo.file
# NOTE: so this seems weird, since if you look at the JSON, the `file.id` for this
# is clearly 30 (and 29 for the user), but since a Private Chat is between you
# and another user, the photo is the other user's profile photo.
# so since we have to add the user that this chat is with to the database session
# (or else we get an integrity error), the `file.id` is actually of the file of the
# user's photo , and therefore in the user json rather than the chat json
# however the remote_file_id and remote_unique_id should be the same!
self.assertEqual(big_file.tg_file_id, 15)
self.assertEqual(big_file.size, 0)
self.assertEqual(big_file.expected_size, 0)
self.assertEqual(
big_file.remote_file_id,
"AQADAQADXKkxG6vLzgQACLJsEjAABAMAA6vLzgQABHHpJIC1z601EmwAAhgE")
self.assertEqual(big_file.remote_unique_id, "AQADsmwSMAAEEmwAAg")
# small chat photo
small_list = latest_ver_photo_set \
.get_photos_by_thumnail_type(dbe.PhotoSizeThumbnailType.PHOTO_SMALL)
self.assertEqual(len(small_list), 1)
small_photo = small_list[0]
self.assertEqual(small_photo.thumbnail_type,
dbe.PhotoSizeThumbnailType.PHOTO_SMALL)
self.assertEqual(small_photo.width, -1)
self.assertEqual(small_photo.height, -1)
self.assertFalse(small_photo.has_stickers)
small_file = small_photo.file
# see note above
self.assertEqual(small_file.tg_file_id, 14)
self.assertEqual(small_file.size, 0)
self.assertEqual(small_file.expected_size, 0)
self.assertEqual(
small_file.remote_file_id,
"AQADAQADXKkxG6vLzgQACLJsEjAABAIAA6vLzgQABHHpJIC1z601EGwAAhgE")
self.assertEqual(small_file.remote_unique_id, "AQADsmwSMAAEEGwAAg")
def test_compare_dbmodel_and_tdlib_message(self):
'''
test `MessageAide.compare_dbmodel_and_tdlib_message` for general Message stuff
not for anything in db_model.MessageVersion / tdlib_generated.MessageContent
'''
message_json = u.get_fake_tdlib_messages_path("message/messageText/message_id_599515987968_chat_id_80661419_message_text.json")
message_tdlib_obj = u.load_tdlib_generated_obj_from_file(message_json, self.converter)
with u.get_testing_sqla_session_contextmanager() as session:
# add the db_model.User and db_model.Chat that this private chat is with, or else it
# will have a integrity error when we add the chat
self._load_user_and_chat_id_80661419(session)
# do the initial load of the first message
initial_dbmodel_message_obj = self._load_and_return_message_id_599515987968(session)
# assert that the db_model.Message and tdlib_generated.message are equal
is_equal_unmodified_message = MessageAide.compare_dbmodel_and_tdlib_message(
initial_dbmodel_message_obj, message_tdlib_obj)
self.assertTrue(is_equal_unmodified_message, "unmodified message should be equal")
# get a copy of the message from the sqlalchemy session so we can 'modify it' for testing
# note: i was originally using `_load_and_return_message_id_599515987968` here but then
# it was not proving equal because it was adding another (duplicate) TextEntity to the message
# probably because the message already existed , but i would think it would be a brand new
# message / MessageVersion, rather than using the existing one, so maybe this is a bug? i'm not
# sure, should probably look into this at some point
# TODO
modified_dbmodel_message_obj = session.query(db_model.Message) \
.filter(db_model.Message.message_id == initial_dbmodel_message_obj.message_id) \
.first()
attributes_to_modify = [
AttributeToModify(attr_name="is_outgoing", attr_value=False),
AttributeToModify(attr_name="is_channel_post", attr_value=True),
AttributeToModify(attr_name="can_edit", attr_value=False),
AttributeToModify(attr_name="can_forward", attr_value=False),
AttributeToModify(attr_name="can_be_deleted_only_for_self", attr_value=False),
AttributeToModify(attr_name="can_be_deleted_for_all_users", attr_value=True),
AttributeToModify(attr_name="restriction_reason", attr_value='''{"ios":"contains a sonic meme"'''),
]
for iter_attr_to_mod in attributes_to_modify:
# make sure the db_model and tdlib message should be equal before modification
self.assertTrue(
MessageAide.compare_dbmodel_and_tdlib_message(
modified_dbmodel_message_obj, message_tdlib_obj),
"tdlib and dbmodel message should be equal before modification")
# modify the db_model message and assert it is no longer equal
old_value = getattr(modified_dbmodel_message_obj, iter_attr_to_mod.attr_name)
setattr(modified_dbmodel_message_obj, iter_attr_to_mod.attr_name, iter_attr_to_mod.attr_value)
is_equal_with_modified_message = MessageAide.compare_dbmodel_and_tdlib_message(
modified_dbmodel_message_obj, message_tdlib_obj)
self.assertFalse(is_equal_with_modified_message,
"tdlib and dbmodel message after modification should not be equal")
# modify the value back to its original value and make sure it is equal
setattr(modified_dbmodel_message_obj, iter_attr_to_mod.attr_name, old_value)
self.assertTrue(
MessageAide.compare_dbmodel_and_tdlib_message(
modified_dbmodel_message_obj, message_tdlib_obj),
"tdlib and dbmodel message should be equal after restoring original value")
def test_new_user_from_tdlib_user_equal(self):
'''
`UserAide.new_user_from_tdlib_user`, should be equal
'''
with u.get_testing_sqla_session_contextmanager() as session:
# add the db_model.User that this private chat is with, or else it
# will have a integrity error when we add the chat
user_json = u.get_fake_tdlib_messages_path(
"user/user_id_80661419.json")
user_obj = u.load_tdlib_generated_obj_from_file(
user_json, self.converter)
self.assertIsInstance(user_obj, tdg.user)
user_dbmodel_obj = UserAide.new_user_from_tdlib_user(
session, user_obj)
session.add(user_dbmodel_obj)
# assertions
self.assertEqual(user_dbmodel_obj.tg_user_id, 80661419)
self.assertEqual(len(user_dbmodel_obj.versions), 1)
latest_ver = user_dbmodel_obj.versions[-1]
self.assertEqual(latest_ver.first_name, "John")
self.assertEqual(latest_ver.last_name, "Doe")
self.assertEqual(latest_ver.user_name, "TestingJohnDoe")
# NOTE: it seems that the `sqlalchemy_utils.PhoneNumberType` converts
# a string phone number into a `phonenumbers` object only when its been
# loaded from the database
# so that means we should expect the number to be a STRING here
# but in other tests (like in a `get_user_by_tg_user_id` test) the phone number
# would be a `phonenumber` object
expected_phone_number = phonenumbers.parse(
"+15555555", region=constants.PHONE_NUMBER_DEFAULT_REGION)
phone_number_from_user_parsed_from_str = PhoneNumberAide \
.parse_phone_number_from_string(latest_ver.phone_number)
self.assertIsInstance(latest_ver.phone_number, str)
self.assertEqual(phone_number_from_user_parsed_from_str,
expected_phone_number)
self.assertTrue(latest_ver.is_contact)
self.assertTrue(latest_ver.is_mutual_contact)
self.assertFalse(latest_ver.is_verified)
self.assertFalse(latest_ver.is_support)
self.assertEqual(latest_ver.restriction_reason, "")
self.assertFalse(latest_ver.is_scam)
self.assertTrue(latest_ver.have_access)
self.assertEqual(latest_ver.language_code, "")
self.assertEqual(latest_ver.user_type,
dbe.UserTypeEnum.USER_TYPE_REGULAR)
#########################
# test profile photo set
#########################
latest_ver_profile_photo_set = latest_ver.profile_photo_set
self.assertEqual(len(latest_ver_profile_photo_set.photos), 2)
self.assertEqual(latest_ver_profile_photo_set.tg_id,
346438157110192450)
# test big
# NOTE: we _cannot_ use the `big` and `small` relationship properties here since we
# created this object manually and have not loaded it from the database, and the relationship
# is a `primaryjoin` so even though the relationship should exist, they are None at the moment
# unless we fetch the object fresh from the database again
big_list = latest_ver_profile_photo_set \
.get_photos_by_thumnail_type(dbe.PhotoSizeThumbnailType.PHOTO_BIG)
self.assertEqual(len(big_list), 1)
big_photo = big_list[0]
self.assertEqual(big_photo.thumbnail_type,
dbe.PhotoSizeThumbnailType.PHOTO_BIG)
self.assertEqual(big_photo.width, -1)
self.assertEqual(big_photo.height, -1)
self.assertFalse(big_photo.has_stickers)
big_file = big_photo.file
self.assertEqual(big_file.tg_file_id, 15)
self.assertEqual(big_file.size, 0)
self.assertEqual(big_file.expected_size, 0)
self.assertEqual(
big_file.remote_file_id,
"AQADAQADXKkxG6vLzgQACLJsEjAABAMAA6vLzgQABHHpJIC1z601EmwAAhgE")
self.assertEqual(big_file.remote_unique_id, "AQADsmwSMAAEEmwAAg")
# test small
# see note above
small_list = latest_ver_profile_photo_set \
.get_photos_by_thumnail_type(dbe.PhotoSizeThumbnailType.PHOTO_SMALL)
self.assertEqual(len(small_list), 1)
small_photo = small_list[0]
self.assertEqual(small_photo.thumbnail_type,
dbe.PhotoSizeThumbnailType.PHOTO_SMALL)
self.assertEqual(small_photo.width, -1)
self.assertEqual(small_photo.height, -1)
self.assertFalse(small_photo.has_stickers)
small_file = small_photo.file
# see note above
self.assertEqual(small_file.tg_file_id, 14)
self.assertEqual(small_file.size, 0)
self.assertEqual(small_file.expected_size, 0)
self.assertEqual(
small_file.remote_file_id,
"AQADAQADXKkxG6vLzgQACLJsEjAABAIAA6vLzgQABHHpJIC1z601EGwAAhgE")
self.assertEqual(small_file.remote_unique_id, "AQADsmwSMAAEEGwAAg")