def patch(self, user_id, label_id, label_model):
"""
Updates the specified label. This method supports patch semantics.
:param label_id: the ID of the label to update.
:param user_id: the user's email address.
:param label_model: (LabelModel) model
:return: response, (LabelModel) model
"""
log_info("[Users.labels]: Patch the label with id: {label_id}".format(
label_id=label_id))
url = '{host}/{api}/{user_id}/labels/{label_id}'.format(
host=self.host, api=self.api, user_id=user_id, label_id=label_id)
body = {
"name": label_model.name,
"labelListVisibility": label_model.label_list_visibility,
"messageListVisibility": label_model.message_list_visibility
}
http = HttpLib(url=url, json=body)
http.auth_to_google(client=client, scope=scope_labels)
http.send_patch()
response_json = http.get_response_json(http.response)
label_model = LabelModel().parse_response_to_model(response_json)
log_info(
'[Users.labels]: PATCH response: {status_code}, \n{model}'.format(
status_code=http.get_response_status_code(http.response),
model=label_model))
return http.response, label_model
def list(self, user_id, client_id=client):
"""
Args:
user_id (str): id пользователя
client_id(dict): клиент под которым выполняется авторизация
Returns:
response (requests.Response)
model_array (list)
"""
api = HttpLib(url="{host}/{api}/{user_id}/messages".format(
host=self.host, api=self.api, user_id=user_id))
api.auth_to_google(client=client_id, scope=scope_mail)
api.send_get()
response = api.response
model_array = []
log_info(api.response.text)
if api.get_response_json(response)["resultSizeEstimate"] == 0:
model_array.append(MessageModel().get_empty_list_from_json(
api.get_response_json(response)))
return response, model_array
else:
json_array = api.get_response_json(response)["messages"]
for item in json_array:
model = MessageModel().get_basic_message_from_json(item)
model_array.append(model)
return response, model_array
def calendar_list_insert(self, model_calendar_list):
"""
Adds an entry to the user's calendar list.
:param model_calendar_list<CalendarListModel>
:return: response, model<CalendarListModel>
"""
log_info("Send post request\nCalendarID = [{calendar_id}]".format(
calendar_id=model_calendar_list.cal_id))
body = {
"id": model_calendar_list.cal_id,
"defaultReminders": model_calendar_list.default_reminders,
"notificationSettings": model_calendar_list.notification_settings,
"summaryOverride": model_calendar_list.summary_override,
"colorId": model_calendar_list.color_id
}
http = HttpLib(url=self.url, json=body)
http.auth_to_google(client=client, scope=scope_calendar)
request = http.send_post()
response_json = request.get_response_json(request.response)
model = CalendarListModel().pars_response_to_model(response_json)
log_info(
"Returned:\nResponse:\n{response}\nModel calendarList:\n{model}".
format(response=create_string_from_json(response_json),
model=model))
return request.response, model
def get_file_size_by_name(file_name):
file_size = get_file_size(
get_config_path("test_files{sep}{file_name}".format(
sep=os.sep, file_name=file_name)))
log_info("Size {file_name} = {size}".format(file_name=file_name,
size=file_size))
return file_size
def check_that_message_added(json_obj, message_id):
history_dict = get_value_from_json(json_obj, "history")
check = check_history_message(history_dict, message_id, "messagesAdded")
log_info("Checking that message {message_id} was added in history".format(
message_id=message_id))
assert check, "Message {message_id} was not added from history".format(
message_id=message_id)
def patch_send_as(user_id, send_as_email):
"""
Patch the specified send-as alias
Args:
user_id (str)
send_as_email (str)
Returns:
model (SendAsModel)
"""
request_body = {
"sendAsEmail": send_as_email,
"displayName": get_unique_string(),
"signature": get_unique_string(),
}
expected_model = SendAsModel()
expected_model.get_send_as_model_from_json(request_body)
response = SettingsSendAsApi().patch_send_as(user_id, send_as_email,
request_body)
response_code = HttpLib.get_response_status_code(response)
response_text = HttpLib.get_response_text(response)
log_info(
"Patch the send_as. status code is: {code}, response text is: {text}".
format(code=response_code, text=response_text))
assert response_code == status_code_200, "Error in patching {sendas_email} send_as:{error},status code is: {code}".\
format(sendas_email=send_as_email, error=response_text, code=response_code)
return expected_model
def compare_colors(exp_color_model, act_color_model):
log_info(
"Compare colors models. Exp : \n{exp_color_model} \nAct: \n{act_color_model}"
.format(exp_color_model=exp_color_model,
act_color_model=act_color_model))
assert exp_color_model.__eq__(act_color_model), "The ColorsModel are not equal. Exp = {expected}, Act = {actual}".\
format(expected=exp_color_model, actual=act_color_model)
def get_quick_event(calendar_id, event_id):
response, response_model = EventsApi().get_quick_event(calendar_id, event_id)
log_info("Get quick event status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(response),
response=HttpLib.get_response_text(response)))
assert HttpLib.get_response_status_code(response) == status_code_200, "Error: {response}".format(response=response)
return response, response_model
def insert_acl_rule(role, scope_type, scope_value):
"""
Метод создает правило в календаре
template
Create Acl role | ${role} | ${scope_value} | ${scope_type}
Args:
role (str): тип роли
scope_value (str): email к кому применить правило
scope_type (str): тип пользователя
Return:
expected_model(ACLModel): модель правила
"""
json_insert = create_json_role(role, scope_type, scope_value)
log_info("Create model from json (expected model)")
expected_model = ACLModel()
expected_model.init_acl_from_json(json_data=json_insert)
actual_response = AclApi().insert(json_insert)
actual_status_code = HttpLib.get_response_status_code(actual_response)
actual_json = HttpLib.get_response_json(actual_response)
log_pretty_json(actual_json, "This is response json from server")
assert (actual_status_code == status_code_200),\
"Insert ACL rule Failed. The response status code not equal 200, current status code: {actual_code}".\
format(actual_code=actual_status_code)
return expected_model
def update_acl_rule(role, scope_type, scope_value):
"""
Метод обновляет правило в календаре
Args:
role (str): тип роли
scope_type (str): тип пользователя
scope_value (str): email к кому применияется правило
Return:
expected_model(ACLModel): модель правила
"""
json_update = create_json_role(role, scope_type, scope_value)
log_info("Create model from json (expected model)")
expected_model = ACLModel()
expected_model.init_acl_from_json(json_data=json_update)
actual_response = AclApi().update(json_data=json_update, rule_id="user:{scope_value}".
format(scope_value=scope_value))
actual_status_code = HttpLib.get_response_status_code(actual_response)
actual_json = HttpLib.get_response_json(actual_response)
log_pretty_json(actual_json, "This is response json from server")
assert (actual_status_code == status_code_200), \
"Updating ACL rule Failed. The response status code not equal 200, current status code: {actual_code}". \
format(actual_code=actual_status_code)
return expected_model
def filters_create(self, user_id, model_filters):
"""
Creates a filter
:param user_id: User's email address. The special value "me" can be used to indicate the authenticated user.
:param model_filters
:type: SettingsFiltersModel
:return: response, model<SettingsFiltersModel>
"""
log_info("Send post request\nUserID = [{user_id}]"
"\nModel:\n{model}".format(user_id=user_id, model=model_filters))
url = "{host}/{api}/{user_id}/settings/filters".format(host=self.host, api=self.api, user_id=user_id)
body = {
"action": {
"addLabelIds": model_filters.add_label_id
},
"criteria": {
"from": model_filters.criteria_from,
"to": model_filters.criteria_to,
"negatedQuery": model_filters.criteria_negated_query,
"subject": model_filters.criteria_subject
}
}
api = HttpLib(url=url, json=body)
api.auth_to_google(client=client, scope=scope_gmail_settings_filters)
api.send_post()
response = api.response
response_json = api.get_response_json(response)
model = SettingsFiltersModel().pars_json_to_model(response_json)
log_info("Returned:\nResponse:\n{response}\nModel:\n{model}".
format(response=dumps(response_json, indent=4), model=model))
return response, model
def create_label_model(self,
name=None,
label_list_visibility=None,
message_list_visibility=None):
"""
Create label model with params or with random values
:param name: (string) the display name of the label.
:param label_list_visibility: (string) the visibility of the label
in the label list in the Gmail web interface.
Acceptable values are:
"labelHide": Do not show the label in the label list.
"labelShow": Show the label in the label list. (Default)
"labelShowIfUnread": Show the label if there are any unread messages with that label.
:param message_list_visibility: (string) the visibility of messages with this label
in the message list in the Gmail web interface.
Acceptable values are:
"hide": Do not show the label in the message list.
"show": Show the label in the message list. (Default)
:return: (LabelModel) model
"""
log_info('[Users.labels]: Creating label model...')
self.name = name or Common_functions.get_unique_string()
self.label_list_visibility = label_list_visibility or choice(
['labelHide', 'labelShow', 'labelShowIfUnread'])
self.message_list_visibility = message_list_visibility or choice(
['hide', 'show'])
log_info(message="Model has created \n{model}".format(model=self))
return self
def list(self, user_id):
"""
Lists all labels in the user's mailbox.
:param user_id: The user's email address.
:return: response, (list<LabelModel>) list of models.
"""
log_info(
"[Users.labels]: List of labels for user with id={user_id}".format(
user_id=user_id))
url = '{host}/{api}/{user_id}/labels/'.format(host=self.host,
api=self.api,
user_id=user_id)
http = HttpLib(url=url)
http.auth_to_google(client=client, scope=scope_labels)
http.send_get()
label_models_list = []
labels = get_value_from_json(http.get_response_json(http.response),
'labels')
for label in labels:
label_models_list.append(
LabelModel().parse_response_to_model_for_list(label))
log_info(
'[Users.labels]: LIST response: {status_code}, \n{models}'.format(
status_code=http.get_response_status_code(http.response),
models='\n'.join(model.__str__()
for model in label_models_list)))
return http.response, label_models_list
def check_models_equals(expected_model, actual_model):
log_info(
"Check that expected_model = {expected_model} is equal actual_model = {actual_model}"
.format(expected_model=expected_model, actual_model=actual_model))
assert (expected_model == actual_model), "Compare calendar models FAILED. \
Model {expected_model} is not equal {actual_model}".format(
expected_model=expected_model, actual_model=actual_model)
def create(self, user_id, label_model):
"""
Creates a new label.
:param user_id: The user's email address.
:param label_model: (LabelModel) model
:return: response, (LabelModel) model
"""
log_info(
"[Users.labels]: Creates a new label with body: \n{model}".format(
model=label_model))
url = '{host}/{api}/{user_id}/labels'.format(host=self.host,
api=self.api,
user_id=user_id)
body = {
"name": label_model.name,
"labelListVisibility": label_model.label_list_visibility,
"messageListVisibility": label_model.message_list_visibility
}
http = HttpLib(url=url, json=body)
http.auth_to_google(client=client, scope=scope_labels)
http.send_post()
response_json = http.get_response_json(http.response)
label_model = LabelModel().parse_response_to_model(response_json)
log_info(
'[Users.labels]: CREATE response: {status_code}, \n{model}'.format(
status_code=http.get_response_status_code(http.response),
model=label_model))
return http.response, label_model
def quick_add_event(calendar_id, summary):
quick_add_response, quick_add_model = EventsApi().quick_add_event(calendar_id, summary)
log_info("Quick add event status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(quick_add_response),
response=HttpLib.get_response_text(quick_add_response)))
assert HttpLib.get_response_status_code(quick_add_response) == status_code_200, \
"Error: {response}".format(response=quick_add_response)
return quick_add_response, quick_add_model
def list_events(calendar_id, client_id=client):
response_list_event, list_events = EventsApi().list_events(calendar_id, client_id)
log_info("List events status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(response_list_event),
response=HttpLib.get_response_text(response_list_event)))
assert HttpLib.get_response_status_code(response_list_event) == status_code_200, "Error: {0}" \
.format(response_list_event)
return response_list_event, list_events
def delete_event(calendar_id, event_id, client_id=client, send_notifications="False"):
delete_response = EventsApi().delete_event(calendar_id, event_id, client_id, send_notifications)
log_info("Delete event status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(delete_response),
response=HttpLib.get_response_text(delete_response)))
assert HttpLib.get_response_status_code(delete_response) == status_code_204, "Error: {response}" \
.format(response=delete_response)
return delete_response
def insert_event(calendar_id, event, client_id=client, send_notifications="False"):
insert_response, insert_model = EventsApi().add_event(calendar_id, event, client_id, send_notifications)
log_info("Insert event status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(insert_response),
response=HttpLib.get_response_text(insert_response)))
assert HttpLib.get_response_status_code(insert_response) == status_code_200, "Error: {response}". \
format(response=insert_response)
return insert_response, insert_model
def insert_calendar(calendar):
insert_calendar_response, insert_calendar_model = CalendarsApi().insert_calendar(calendar)
log_info("Insert calendar status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(insert_calendar_response),
response=HttpLib.get_response_text(insert_calendar_response)))
assert HttpLib.get_response_status_code(insert_calendar_response) == status_code_200, "Error: {response}". \
format(response=insert_calendar_response)
return insert_calendar_response, insert_calendar_model
def import_recurrent_event(calendar_id, recurrent_event):
import_response, import_model = EventsApi().import_event(calendar_id, recurrent_event)
log_info("Import recurrent event status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(import_response),
response=HttpLib.get_response_text(import_response)))
assert HttpLib.get_response_status_code(import_response) == status_code_200, "Error: {0}". \
format(import_response)
return import_response, import_model
def patch_event(initial_event_id, new_event, send_notifications=False):
patch_event_response, patch_event_model = EventsApi().patch_event(initial_event_id, new_event, send_notifications)
log_info("Patch event status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(patch_event_response),
response=HttpLib.get_response_text(patch_event_response)))
assert HttpLib.get_response_status_code(patch_event_response) == status_code_200, "Error: {response}". \
format(response=patch_event_response)
return patch_event_response, patch_event_model
def create_random_calendar_list_model(calendar_id):
"""
Create random model without id
:param calendar_id: ID created calendar
:return: model_calendar_list<CalendarListModel>
"""
model = CalendarListModel().create_model_calendar_list(calendar_id)
log_info("Create random model calendarList:\nModel:\n{model}".format(model=model))
return model
def create_filters_model(criteria_label):
"""
Create random model filter
:param criteria_label: Created label with method label.create
:return: model<SettingsFiltersModel>
"""
model = SettingsFiltersModel().get_randomly_model(criteria_label)
log_info("Create random model settingsFilters:\nModel:\n{model}".format(model=model))
return model
def update_event(calendar_id, initial_event_id, new_event, client_id=client, send_notifications=False):
update_event_response, update_event_model = EventsApi().\
update_event(calendar_id, initial_event_id, new_event, client_id, send_notifications)
log_info("Update event status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(update_event_response),
response=HttpLib.get_response_text(update_event_response)))
assert HttpLib.get_response_status_code(update_event_response) == status_code_200, "Error: {response}". \
format(response=update_event_response.text)
return update_event_response, update_event_model
def initialize_attachment_model(size, data):
"""
:param size: Number of bytes for the message part data
:param data: The body data of a MIME message part as a base64url encoded string
:rtype: AttachmentModel
"""
model = AttachmentModel(size=size, data=data)
log_info("Initialize attachment model. {model}".format(model=model))
return model
def check_that_models_labels_are_equal(exp_label_model, act_label_model):
log_info(
"Check labels model that equals. \nExp label: \n{exp_label_model} \nAct label: \n{act_label_model}"
.format(exp_label_model=exp_label_model,
act_label_model=act_label_model))
assert exp_label_model == act_label_model, "Assert labels error! \nExp label: \n{exp_label_model} \nAct label:" \
"\n{act_label_model}".format(exp_label_model=exp_label_model,
act_label_model=act_label_model)
def check_address_in_list(forwarding_list, address):
for forwarding_model in forwarding_list:
log_info(
"Model email is: {model_email}, checking address is: {checking_address}"
.format(model_email=forwarding_model.forwarding_email,
checking_address=address))
if forwarding_model.forwarding_email == address:
return
assert False, "No address {address} in models list".format(address=address)
def get_thread(user_id, thread_id):
response, response_model = ThreadsApi().get_thread(user_id, thread_id)
response_code = HttpLib.get_response_status_code(response)
response_text = HttpLib.get_response_text(response)
log_info(
"Get thread status code is: {code}, response text is: {text}".format(
code=response_code, text=response_text))
assert response_code == status_code_200, "Error while getting the {id} thread: {error}".\
format(id=thread_id, error=response_text)
return response_model
def list_threads(user_id):
response, response_model = ThreadsApi().list_threads(user_id)
response_code = HttpLib.get_response_status_code(response)
response_text = HttpLib.get_response_text(response)
log_info(
"List threads status code is: {code}, response text is: {text}".format(
code=response_code, text=response_text))
assert response_code == status_code_200, "Error while getting the threads list: {error}". \
format(error=response_text)
return response_model
