def send_draft_message(user_id, draft_message_id):
new_model = BodyMessageModel().create_random_model()
log_info("Create random model = {model}".format(model=new_model))
message_raw = string_to_base64(
create_mime_from_dict(
new_model.get_dict_model_with_initialize_value()))
log_info(
"Generate raw string from model. Raw = {raw}".format(raw=message_raw))
response, model = UserDrafts().send_draft_message(
user_id=user_id,
draft_message_id=draft_message_id,
message_raw=message_raw)
log_info(
"Send draft message = {message} from user = {user} and draft_message_id = {message_id}"
.format(user=user_id, message_id=draft_message_id, message=model))
assert HttpLib.get_response_status_code(response) == status_code_200, \
"Update draft message error: status code = {actual}, expected status code = {expected}. Response text: {text}".\
format(actual=HttpLib.get_response_status_code(response),
expected=status_code_200,
text=HttpLib.get_response_text(response))
return 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 delete_calendar(calendar_id):
"""
Deletes a secondary calendar. Use calendars.clear for clearing all events on primary calendars.
TC: 1. Call delete_calendar.
2. Assert status code.
3. Call calendar_list_list.
4. Assert status code.
5. Assert if calendar_list contains deleted calendar.
:param calendar_id:
"""
res = CalendarsApi().delete_calendar(calendar_id)
status_code = HttpLib.get_response_status_code(res)
assert (status_code == status_code_204), \
"Delete calendar error: status code is {status_code}, response text is: {text}".format(
status_code=status_code,
text=HttpLib.get_response_text(res))
res = CalendarListApi().calendar_list_list()
assert (HttpLib.get_response_status_code(res[0]) == status_code_200), \
"Delete calendar error: status code is {status_code}, response text is: {text}".format(
status_code=status_code,
text=HttpLib.get_response_text(res[0]))
for model in res[1]:
if model.cal_id == calendar_id:
assert False, 'Calendar with {calendar} id={calendar_id} has found after delete.'.format(
calendar=model,
calendar_id=calendar_id)
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 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 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 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 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 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 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 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 move_event(initial_calendar_id, event_id, target_calendar_id):
move_event_response, move_event_model = EventsApi().move_event(initial_calendar_id,
event_id,
target_calendar_id)
log_info("Move event status code is: {status_code}, response text is: {response}".format(
status_code=HttpLib.get_response_status_code(move_event_response),
response=HttpLib.get_response_text(move_event_response)))
assert HttpLib.get_response_status_code(move_event_response) == status_code_200, \
"Error: {response}".format(response=move_event_response)
return move_event_response, move_event_model
def list_draft_messages(user_id):
response, model_array = UserDrafts().list_draft(user_id=user_id)
log_info("List draft messages = {model} for user_id = {user}.".format(
user=user_id,
model='\n'.join(model.__str__() for model in model_array)))
assert HttpLib.get_response_status_code(response) == status_code_200, \
"List draft messages error: status code = {actual}, expected status code = {expected}. Response text: {text}".\
format(actual=HttpLib.get_response_status_code(response),
expected=status_code_200,
text=HttpLib.get_response_text(response))
return model_array
def get_draft_message(user_id, draft_message_id):
response, model = UserDrafts().get_draft(user_id=user_id,
draft_message_id=draft_message_id)
log_info(
"Get draft message = {message} from user = {user} and draft_message_id = {message_id}"
.format(user=user_id, message_id=draft_message_id, message=model))
assert HttpLib.get_response_status_code(response) == status_code_200,\
"Get draft message error: status code = {actual}, expected status code = {expected}. Response text: {text}".\
format(actual=HttpLib.get_response_status_code(response),
expected=status_code_200,
text=HttpLib.get_response_text(response))
return model
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 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 query_freebusy(self, time_min, time_max, time_zone):
"""
Метод тестирует сервис freebusy метод query
:param time_min: минимальное время
:type time_min: str
:param time_max: максимальное время
:type time_max: str
:param time_zone: временная зона
:type time_zone: str
"""
json_data = {
"timeMin": time_min,
"timeMax": time_max,
"timeZone": time_zone
}
expected_model = FreeBusyModel()
expected_model.init_freebusy_from_json(json_data=json_data)
actual_response, actual_model = FreeBusyApi().query(
json_query=json_data)
assert (expected_model == actual_model), "Query freebusy failed: model are not equal. Exp = {0}, Act = {1}". \
format(expected_model, actual_model)
status_code = HttpLib.get_response_status_code(actual_response)
assert (status_code == status_code_200), \
"Query freebusy error: status code is {status_code}, response text is: {text}".format(
status_code=status_code,
text=HttpLib.get_response_text(actual_response))
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 update_event(self,
calendar_id,
event_id,
new_event,
client_id=client,
send_notifications="False"):
url = "{host}/{api}/calendars/{calendar_id}/events/{event_id}".\
format(host=self.host, api=self.api, calendar_id=calendar_id, event_id=event_id)
params = {"sendNotifications": send_notifications}
request_body = create_string_from_json({
"end": new_event.end,
"start": new_event.start,
"attendees": new_event.attendees,
"iCalUID": new_event.iCalUID
})
req = HttpLib(url=url,
header=self.header,
json=create_json_from_string(request_body),
params=params)
req.auth_to_google(client=client_id, scope=scope_calendar)
req.send_put()
if req.get_response_status_code(req.response) is status_code_200:
return req.response, EventModel().get_event_model_from_json(
**req.get_response_json(req.response))
return req.response, None
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 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 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 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
def get_quick_event(self, calendar_id, event_id):
url = "{host}/{api}/calendars/{calendar_id}/events/{event_id}".\
format(host=self.host, api=self.api, calendar_id=calendar_id, event_id=event_id)
req = HttpLib(url)
req.auth_to_google(client=client, scope=scope_calendar)
req.send_get()
if req.get_response_status_code(req.response) is status_code_200:
return req.response, EventModel().get_summary(
**req.get_response_json(req.response))
return req.response, None
def modify_messages(user_id, message_id, add_labels_list):
log_info("Modify messages labels")
actual_response, actual_model = UserMessages().modify_messages(
user_id, message_id, add_labels_list)
status_code = HttpLib.get_response_status_code(actual_response)
assert (status_code == status_code_200), \
"Modify message error: status code is {status_code}, response text is: {text}".format(
status_code=status_code,
text=HttpLib.get_response_text(actual_response))
return actual_model
def list_label(user_id):
"""
Lists all labels in the user's mailbox.
:param user_id: The user's email address.
:return: (list<LabelModel>) list of models.
"""
response, model_list = LabelsApi().list(user_id=user_id)
status_code = HttpLib.get_response_status_code(response)
log_info("Assert status code for 'list_label'")
assert status_code == status_code_200, "List label FAILED. The response status code not equal 200"
return model_list
def delete_label(user_id, label_id):
"""
Immediately and permanently deletes the specified label
and removes it from any messages and threads that it is applied to.
:param label_id:
:param user_id: The user's email address.
"""
response = LabelsApi().delete(user_id=user_id, label_id=label_id)
status_code = HttpLib.get_response_status_code(response)
log_info("Assert status code for 'delete_label'")
assert status_code == status_code_204, "Delete label FAILED. The response status code not equal 204"
def delete_calendar_list(calendar_id):
"""
Delete calendar list
:param calendar_id: ID created calendar
"""
response = CalendarListApi().calendar_list_delete(calendar_id)
response_status_code = HttpLib.get_response_status_code(response)
assert (response_status_code == status_code_204), \
"Delete calendar list failed: Status code isn't '204'." \
"\nResponse:\n{text}Status code = {status_code}".format(text=HttpLib.get_response_json(response),
status_code=response_status_code)
def list_calendar_list():
"""
List calendar list
:return: response, model_list_calendar_list<list(CalendarListModel)>
"""
response, model_list_calendar_list = CalendarListApi().calendar_list_list()
response_status_code = HttpLib.get_response_status_code(response)
assert response_status_code == status_code_200, \
"List calendar list failed: Status code isn't '200'" \
"\nStatus code = {status_code}".format(status_code=response_status_code)
return response, model_list_calendar_list
