def test_get_external_file_info(self):
file_name_in_box_folder = 'LiveView_Clean.dwg'
external_file_info_response = self.files_management_client.get_external_file_info(
auth=self.auth, host_id=self.host_id, path=file_name_in_box_folder)
status_code = ClientUtils.get_response_status_code(
external_file_info_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_external_file_info response',
ClientUtils.get_response_body(external_file_info_response))
file_primary_version = ClientUtils.get_value_from_body(
external_file_info_response,
FilesManagementClient.KEY_PRIMARY_VERSION_ID)
file_type = ClientUtils.get_value_from_body(
external_file_info_response, FilesManagementClient.KEY_TYPE)
file_size = ClientUtils.get_value_from_body(
external_file_info_response, FilesManagementClient.KEY_SIZE)
self.assertTrue(
file_primary_version > 0,
'Expected valid primary version id but got: ' +
str(file_primary_version) + self.extra_data.get_all())
self.assertEquals(
'EXTERNAL_DRAWING', file_type,
'Expected file type: EXTERNAL_DRAWING but got: ' + str(file_type) +
self.extra_data.get_all())
self.assertEquals(
62, file_size, 'Expected file size: 62 but got: ' +
str(file_size) + self.extra_data.get_all())
def test_post_drawing_preferences(self):
file_name = 'test_file_post_drawing_prefs' + str(int(time())) + '.dwg'
expected_orth_on = True
expected_line_weight_on = False
self.extra_data.add_test_data('file name', file_name)
created_file_id, msg = TestUtils.create_file(
auth=self.auth, file_name=file_name, extra_data=self.extra_data)
self.assertIsNotNone(created_file_id, msg + self.extra_data.get_all())
user_specific_drawing_prefs = {}
user_specific_drawing_prefs.__setitem__('orthoOn', expected_orth_on)
user_specific_drawing_prefs.__setitem__('lineWeightOn',
expected_line_weight_on)
post_drawing_prefs_response = self.files_management_client.post_drawing_preferences(
auth=self.auth,
file_id=created_file_id,
user_specific_drawing_preferences=user_specific_drawing_prefs)
self.assertIsNotNone(post_drawing_prefs_response,
'Response is None' + self.extra_data.get_all())
status_code = ClientUtils.get_response_status_code(
post_drawing_prefs_response)
self.assertEqual(
httplib.NO_CONTENT, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.assertTrue(
ClientUtils.is_response_body_empty(post_drawing_prefs_response),
'Expected empty response body but got: ' +
str(ClientUtils.get_response_body(post_drawing_prefs_response)) +
self.extra_data.get_all())
get_drawing_prefs_response = self.files_management_client.get_drawing_preferences(
auth=self.auth, file_id=created_file_id)
status_code = ClientUtils.get_response_status_code(
get_drawing_prefs_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_drawing_preferences response',
ClientUtils.get_response_body(get_drawing_prefs_response))
orth_on = ClientUtils.get_value_from_body(
response=get_drawing_prefs_response,
json_path='userSpecificDrawingPreferences.orthoOn')
self.assertEqual(
expected_orth_on, orth_on,
'Expected orth_on: ' + str(expected_orth_on) + 'but got: ' +
str(orth_on) + self.extra_data.get_all())
line_weight_on = ClientUtils.get_value_from_body(
response=get_drawing_prefs_response,
json_path='userSpecificDrawingPreferences.lineWeightOn')
self.assertEqual(
expected_line_weight_on, line_weight_on,
'Expected line_weight_on: ' + str(expected_line_weight_on) +
'but got: ' + str(line_weight_on) + self.extra_data.get_all())
def test_recent_files(self):
response = self.files_management_client.recent_files(self.auth)
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data('response',
ClientUtils.get_response_body(response))
self.assertTrue(
ClientUtils.is_key_in_body(response, 'limit'),
'Expected key limit in response body' + self.extra_data.get_all())
self.assertTrue(
ClientUtils.is_key_in_body(response, 'lastFileDate'),
'Expected key lastFileDate in response body' +
self.extra_data.get_all())
self.assertTrue(
ClientUtils.is_key_in_body(response, 'page'),
'Expected key page in response body' + self.extra_data.get_all())
drawings = ClientUtils.get_value_from_body(
response, FilesManagementClient.KEY_DRAWINGS)
self.assertTrue(
len(drawings) > 0,
'Expected at least one drawing in response body' +
self.extra_data.get_all())
def test_plot_and_download(self): # workflow for mobile-client plotting
polling_timeout_in_seconds = 30
delay_between_polls = 1
file_system_entries, msg = TestUtils.get_internal_partition(
auth=self.auth, extra_data=self.extra_data)
self.assertIsNotNone(file_system_entries,
msg + self.extra_data.get_all())
entry = TestUtils.get_first_drawing_from_internal_file_system(
file_system_entries)
self.extra_data.add_test_data('entry', entry)
version_id_to_plot = TestUtils.get_entry_data_by_keys(
entry, 'versionId')
self.assertTrue(
version_id_to_plot > 0, 'Expected integer version id but got: ' +
str(version_id_to_plot) + self.extra_data.get_all())
self.extra_data.add_test_data('version id to plot', version_id_to_plot)
prepare_file_to_plot_response = self.files_management_client.prepare_file_to_download(
auth=self.auth, version_id=version_id_to_plot, format='plot')
status_code = ClientUtils.get_response_status_code(
prepare_file_to_plot_response)
self.assertEqual(
httplib.ACCEPTED, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'prepare_file_to_download response',
ClientUtils.get_response_body(prepare_file_to_plot_response))
download_id = ClientUtils.get_value_from_body(
prepare_file_to_plot_response,
FilesManagementClient.KEY_DOWNLOAD_ID)
self.assertIsInstance(
download_id, unicode, 'Expected unicode download id but got: ' +
str(download_id) + self.extra_data.get_all())
self.extra_data.add_test_data('download id', download_id)
default_name, msg = TestUtils.poll_for_download(
auth=self.auth,
download_id=download_id,
sleep_period=delay_between_polls,
timeout_in_seconds=polling_timeout_in_seconds,
extra_data=self.extra_data)
self.assertIsNotNone(default_name, msg + self.extra_data.get_all())
download_response = self.files_management_client.download_file(
auth=self.auth,
download_id=download_id,
download_file_name=default_name)
status_code = ClientUtils.get_response_status_code(download_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
downloaded_content = ClientUtils.get_response_raw_content(
download_response)
self.assertIsNotNone(
downloaded_content,
'Expected non empty content download' + self.extra_data.get_all())
def test_post_user_preferences(self):
expected_country = 'UK'
response = self.user_preferences_client.post_user_preferences(
auth=self.auth, country=expected_country)
self.assertIsNotNone(
response, 'Response is None. user_name: ' + str(self.user_name))
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.assertTrue(
ClientUtils.is_response_body_empty(response),
'Expected empty body in response but got ' +
str(ClientUtils.get_response_body(response)) +
self.extra_data.get_all())
get_user_preferences_response = self.user_preferences_client.get_user_preferences(
auth=self.auth)
status_code = ClientUtils.get_response_status_code(
get_user_preferences_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_user_preferences_response',
ClientUtils.get_response_body(get_user_preferences_response))
country = ClientUtils.get_value_from_body(
get_user_preferences_response, UserClient.KEY_COUNTRY)
self.assertEqual(
expected_country, country,
'Expected changed country: ' + str(expected_country) +
' but got: ' + str(country) + self.extra_data.get_all())
def test_get_partition_external(self):
expected_entries_names = [
'xref with block - Standard.zip', 'LiveView_Clean.dwg',
'Permanent_Folder'
]
response = self.partition_client.get_external_partition(
auth=self.auth, host_id=self.host_id)
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data('external_partition response',
ClientUtils.get_response_body(response))
file_system_entries = ClientUtils.get_value_from_body(
response, PartitionClient.KEY_FILE_SYSTEM_ENTRIES)
self.assertIsNotNone(
file_system_entries,
'Expected non empty partition' + self.extra_data.get_all())
file_system_entries_names = TestUtils.get_entries_names_from_file_system_entries(
file_system_entries)
self.assertItemsEqual(
expected_entries_names, file_system_entries_names,
'Expected entries names: ' + str(expected_entries_names) +
' but got: ' + str(file_system_entries_names) +
self.extra_data.get_all())
def test_register_v1_valid(self):
response = self.register_client.register_v1(user_name=self.user_name, password=self.valid_password,
first_name=self.first_name,
last_name=self.last_name)
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(httplib.OK, status_code, 'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data('register response', ClientUtils.get_response_body(response))
eidm_user_id = ClientUtils.get_value_from_body(response, RegisterClient.KEY_EIDM_USER_ID)
self.assertIsNotNone(eidm_user_id, 'Expected eidm user id in response but got None' + self.extra_data.get_all())
self.assertTrue(len(eidm_user_id) > 0, 'Expected a non-empty string as eidm user id but got: ' + str(
eidm_user_id) + self.extra_data.get_all())
eidm_user_name = ClientUtils.get_value_from_body(response, RegisterClient.KEY_EIDM_USER_NAME)
self.assertIsNotNone(eidm_user_name, 'Expected eidm user name in response but got None' + self.extra_data.get_all())
self.assertTrue(len(eidm_user_name) > 0, 'Expected a non-empty string as eidm user name but got: ' + str(
eidm_user_name) + self.extra_data.get_all())
email = ClientUtils.get_value_from_body(response, RegisterClient.KEY_MAIL)
self.assertEquals(self.user_name, email, 'Expected user_name: ' + str(self.user_name) + ' but got: ' + str(
email) + self.extra_data.get_all())
def test_register_v1_valid_account_already_exists(self):
self.make_sure_user_already_registered(self.user_name, self.valid_password)
response = self.register_client.register_v1(user_name=self.user_name, password=self.valid_password,
first_name=self.first_name,
last_name=self.last_name)
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(httplib.OK, status_code, 'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data('register response', ClientUtils.get_response_body(response))
email = ClientUtils.get_value_from_body(response, RegisterClient.KEY_MAIL)
self.assertEquals(self.user_name, email, 'Expected user_name: ' + str(self.user_name) + ' but got: ' + str(
email) + self.extra_data.get_all())
def test_user_status(self):
response = self.user_client.get_user_status(auth=self.auth)
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data('get_user_status response',
ClientUtils.get_response_body(response))
status = ClientUtils.get_value_from_body(response, 'status')
self.assertEqual(
1, status, 'Expected status: 1 but got: ' + str(status) +
self.extra_data.get_all())
def get_internal_partition(auth, extra_data, partition_folder_id=0):
partition_client = PartitionClient()
response = partition_client.get_partition_v2(auth=auth, parent_folder_id=partition_folder_id)
status_code = ClientUtils.get_response_status_code(response)
if not httplib.OK == status_code:
return None, 'Expected status: ' + str(httplib.OK) + ' but got: ' + str(status_code)
extra_data.add_test_data('get_partition response', ClientUtils.get_response_body(response))
file_system_entries = ClientUtils.get_value_from_body(response, PartitionClient.KEY_FILE_SYSTEM_ENTRIES)
if file_system_entries is None:
return None, 'Expected a non-empty partition'
return file_system_entries, ''
def test_login_v2_valid_credentials(self):
response = self.login_client.login_v2(user_name=self.user_name,
password=self.valid_password)
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
response_user_name = ClientUtils.get_value_from_body(
response,
LoginClient.KEY_USER_INFO + '.' + LoginClient.KEY_USERNAME)
self.assertEqual(
self.user_name, response_user_name, 'Expected user_name: ' +
str(self.user_name) + ' but got: ' + str(response_user_name))
response_eidm_user_id = ClientUtils.get_value_from_body(
response,
LoginClient.KEY_USER_INFO + '.' + LoginClient.KEY_EIDM_USER_ID)
self.assertEqual(
LoginTests.eidm_user_id, response_eidm_user_id,
'Expected eidm user id: ' + str(self.eidm_user_id) + ' but got: ' +
str(response_eidm_user_id) + self.extra_data.get_all())
def create_file(auth, file_name, extra_data):
files_management_client = FilesManagementClient()
response = files_management_client.create_file_v2(auth=auth, new_drawing_name=file_name)
status_code = ClientUtils.get_response_status_code(response)
if not httplib.OK == status_code:
return None, 'Expected status: ' + str(httplib.OK) + ' but got: ' + str(status_code)
extra_data.add_test_data('create_file response', ClientUtils.get_response_body(response))
created_file_id = ClientUtils.get_value_from_body(response, FilesManagementClient.KEY_VERSION_ID)
if not created_file_id > 0:
return None, 'Expected a valid file id but got: ' + str(created_file_id)
extra_data.add_test_data('created file id', created_file_id)
return created_file_id, ''
def test_create_folder_v2(self):
folder_name = 'test_folder_create_folder_v2_' + str(int(time()))
expected_code_and_description = (0, 'SUCCESS')
self.extra_data.add_test_data('folder name', folder_name)
create_folder_response = self.folders_management_client.create_folder_v2(
auth=self.auth, new_folder_name=folder_name)
status_code = ClientUtils.get_response_status_code(
create_folder_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'create_folder response',
ClientUtils.get_response_body(create_folder_response))
code_desc = ClientUtils.get_code_and_description_from_response(
create_folder_response)
self.assertEqual(
expected_code_and_description, code_desc,
'Expected ' + str(expected_code_and_description) + ' but got: ' +
str(code_desc) + self.extra_data.get_all())
response_folder_id = ClientUtils.get_value_from_body(
create_folder_response, FoldersManagementClient.KEY_FOLDER_ID)
self.assertTrue(
response_folder_id > 0, 'Expected valid folder id but got: ' +
str(response_folder_id) + self.extra_data.get_all())
self.extra_data.add_test_data('response folder id', response_folder_id)
file_system_entries, msg = TestUtils.get_internal_partition(
auth=self.auth, extra_data=self.extra_data)
self.assertIsNotNone(file_system_entries,
msg + self.extra_data.get_all())
entry = TestUtils.get_entry_from_internal_file_system_entries(
response_folder_id, file_system_entries)
self.assertIsNotNone(
entry, 'Created folder should exist in partition' +
self.extra_data.get_all())
partition_folder_name = TestUtils.get_entry_data_by_keys(
entry=entry, keys=PartitionClient.KEY_ENTRY_NAME)
self.assertEqual(
folder_name, partition_folder_name,
'Expected folder name: ' + str(folder_name) + ' but got: ' +
str(partition_folder_name) + self.extra_data.get_all())
def test_get_user_preferences(self):
response = self.user_preferences_client.get_user_preferences(
auth=self.auth)
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data('get_user_preferences response',
ClientUtils.get_response_body(response))
version = ClientUtils.get_value_from_body(response,
UserClient.KEY_VERSION)
self.assertIsInstance(
version, int, 'Expected an integer version but got: ' +
str(version) + self.extra_data.get_all())
def test_get_partition_path_internal(self):
expected_entries_names = ['Clean Canvas.dwg', 'Dog House Plan Sample.dwg', 'Drive Roller Assembly Sample.dwg',
'Geospatial Sample.dwg', 'Villa Project Sample.dwg']
response = self.partition_client.get_partition_path(auth=self.auth, path='')
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(httplib.OK, status_code, 'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data('response', response)
file_system_entries = ClientUtils.get_value_from_body(response, PartitionClient.KEY_FILE_SYSTEM_ENTRIES)
self.assertIsNotNone(file_system_entries, 'Expected non empty partition' + self.extra_data.get_all())
file_system_entries_names = TestUtils.get_entries_names_from_file_system_entries(file_system_entries)
self.assertItemsEqual(expected_entries_names, file_system_entries_names,
'Expected entries names: ' + str(expected_entries_names) + ' but got: ' + str(
file_system_entries_names) + self.extra_data.get_all())
def poll_master(auth, extra_data, event, search_key, search_value, return_key, sleep_period, timeout_in_seconds,
failure_msg='polling received error code'):
"""
returns a 2-tuple s.t.:
first item is the requested data of caller
second item is the error message if failed
"""
last_notification_id = 0
polling_start_time = int(time())
polling_end_time = polling_start_time
poll_client = PollClient()
while polling_end_time - polling_start_time < timeout_in_seconds:
poll_response = poll_client.poll(auth=auth, last_notification_id=last_notification_id, event=event)
status_code = ClientUtils.get_response_status_code(poll_response)
if httplib.OK != status_code:
return None, 'Expected status: ' + str(httplib.OK) + ' but got: ' + str(status_code)
extra_data.add_test_data('poll response', ClientUtils.get_response_body(poll_response))
notifications = ClientUtils.get_value_from_body(poll_response, PollClient.KEY_NOTIFICATIONS)
if notifications is not None:
for notif in notifications:
notif_id = notif[PollClient.KEY_NOTIFICATION_ID]
if notif_id > last_notification_id:
last_notification_id = notif_id
if notif[PollClient.KEY_NOTIFICATION_TYPE].lower() == event.lower() and \
notif[search_key] == search_value:
notif_status = notif[PollClient.KEY_NOTIFICATION_STATUS]
if notif_status == 0: # Successful
if return_key is not None:
return_value = notif[return_key]
extra_data.add_test_data(return_key, return_value)
return return_value, ''
else:
return True, ''
elif notif_status == 2: # Failed
return None, failure_msg
polling_end_time = int(time())
sleep(sleep_period)
return None, 'Timeout while polling for event: ' + str(event)
def test_get_external_file_provider(self):
file_name_in_box_folder = 'LiveView_Clean.dwg'
external_file_info_response = self.files_management_client.get_external_file_provider_v2(
auth=self.auth, host_id=self.host_id, path=file_name_in_box_folder)
status_code = ClientUtils.get_response_status_code(
external_file_info_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_external_file_provider response',
ClientUtils.get_response_body(external_file_info_response))
provider = ClientUtils.get_value_from_body(
external_file_info_response, FilesManagementClient.KEY_PROVIDER)
self.assertEquals(
'BOX', provider, 'Expected provider: BOX but got: ' +
str(provider) + self.extra_data.get_all())
def create_folder(auth, folder_name, extra_data):
expected_code_and_description = (0, 'SUCCESS')
folders_management_client = FoldersManagementClient()
response = folders_management_client.create_folder_v2(auth=auth, new_folder_name=folder_name)
status_code = ClientUtils.get_response_status_code(response)
if not httplib.OK == status_code:
return None, 'Expected status: ' + str(httplib.OK) + ' but got: ' + str(status_code)
extra_data.add_test_data('create_folder response', ClientUtils.get_response_body(response))
code_and_description = ClientUtils.get_code_and_description_from_response(response)
if not expected_code_and_description == code_and_description:
return None, 'Expected code and description: ' + str(expected_code_and_description) + ' but got: ' + str(
code_and_description)
created_folder_id = ClientUtils.get_value_from_body(response, FoldersManagementClient.KEY_FOLDER_ID)
if not created_folder_id > 0:
return None, 'Expected a valid folder id but got: ' + str(created_folder_id)
extra_data.add_test_data('created folder id', created_folder_id)
return created_folder_id, ''
def setUp(self):
self.extra_data = ExtraDataManager()
self.extra_data.add_test_data('user name', self.user_name)
main_register_and_login_mixin = MainRegisterAndLoginMixin()
if BoxExternalFileSystemTests.auth is None:
response = main_register_and_login_mixin.login_or_register(
user_name=self.user_name,
password=self.password,
first_name=self.first_name,
last_name=self.last_name)
BoxExternalFileSystemTests.auth = main_register_and_login_mixin.get_auth_from_login_data(
response)
self.assertIsInstance(
BoxExternalFileSystemTests.auth, str, 'Invalid auth: ' +
str(BoxExternalFileSystemTests.auth) + self.extra_data.get_all())
if BoxExternalFileSystemTests.host_id is None:
connect_to_box_response = self.external_storage_client.webdav_connect_to_external_storage(
auth=self.auth,
folder_name=self.folder_name,
service_url=self.service_url,
user_name=self.box_user_name,
password=self.box_password)
status_code = ClientUtils.get_response_status_code(
connect_to_box_response)
self.assertEqual(
httplib.OK, status_code, 'Got status code: ' +
str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'webdav_connect_to_external_storage_response',
ClientUtils.get_response_body(connect_to_box_response))
host_id = ClientUtils.get_value_from_body(
connect_to_box_response, ExternalStorageClient.KEY_HOST_ID)
self.assertEquals(
61043, host_id, 'expected host_id: 61043 but got: ' +
str(host_id) + self.extra_data.get_all())
BoxExternalFileSystemTests.host_id = host_id
def setUp(self):
self.extra_data = ExtraDataManager()
self.extra_data.add_test_data('user name', self.user_name)
register_client = RegisterClient()
if LoginTests.eidm_user_id is None:
response = register_client.register_v1(
user_name=self.user_name,
password=self.valid_password,
first_name=self.first_name,
last_name=self.last_name)
status_code = ClientUtils.get_response_status_code(response)
self.assertEqual(
httplib.OK, status_code, 'Got status code: ' +
str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'register response', ClientUtils.get_response_body(response))
LoginTests.eidm_user_id = ClientUtils.get_value_from_body(
response, RegisterClient.KEY_EIDM_USER_ID)
self.assertIsNotNone(
LoginTests.eidm_user_id,
'Expected Eidm user id not None, Register failed in setup' +
self.extra_data.get_all())
def upload_file_to_s3_and_compress(self, compression_type,
delay_between_polls, file_full_path,
file_name, file_size,
polling_timeout_in_seconds):
url_to_upload_response = self.files_management_client.get_url_to_upload_v1(
auth=self.auth,
folder_id=0,
file_name=file_name,
file_size=file_size)
status_code = ClientUtils.get_response_status_code(
url_to_upload_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_url_to_upload response',
ClientUtils.get_response_body(url_to_upload_response))
version_id = ClientUtils.get_value_from_body(
url_to_upload_response, FilesManagementClient.KEY_VERSION_ID)
request_type = ClientUtils.get_value_from_body(
url_to_upload_response, FilesManagementClient.KEY_REQUEST_TYPE)
upload_url = ClientUtils.get_value_from_body(
url_to_upload_response, FilesManagementClient.KEY_URL_TO_UPLOAD)
header_x_amz_acl = ClientUtils.get_value_from_body(
url_to_upload_response, json_path='headers.x-amz-acl')
header_authorization = ClientUtils.get_value_from_body(
url_to_upload_response, json_path='headers.Authorization')
header_content_type = ClientUtils.get_value_from_body(
url_to_upload_response, json_path='headers.Content-Type')
header_x_amz_date = ClientUtils.get_value_from_body(
url_to_upload_response, json_path='headers.x-amz-date')
self.extra_data.add_test_data('version id', version_id)
self.extra_data.add_test_data('request type', request_type)
self.extra_data.add_test_data('upload url', upload_url)
self.extra_data.add_test_data('header x_amz_acl', header_x_amz_acl)
self.extra_data.add_test_data('header authorization',
header_authorization)
self.extra_data.add_test_data('header content_type',
header_content_type)
self.extra_data.add_test_data('header x_amz_date', header_x_amz_date)
upload_to_s3_response = self.s3_client.upload_to_s3(
file_full_path=file_full_path,
url_to_upload=upload_url,
method=request_type,
acl=header_x_amz_acl,
auth=header_authorization,
date=header_x_amz_date,
content_type=header_content_type)
status_code = ClientUtils.get_response_status_code(
upload_to_s3_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
upload_to_compressor_response = self.files_management_client.upload_to_compressor(
auth=self.auth,
version_id=version_id,
compression_type=compression_type)
status_code = ClientUtils.get_response_status_code(
upload_to_compressor_response)
self.assertEqual(
httplib.NO_CONTENT, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
successful_upload, msg = TestUtils.poll_for_upload(
auth=self.auth,
version_id=version_id,
sleep_period=delay_between_polls,
timeout_in_seconds=polling_timeout_in_seconds,
extra_data=self.extra_data)
self.assertIsNotNone(successful_upload,
msg + self.extra_data.get_all())
return version_id
def test_plot_and_send_to_mail(self): # workflow for web-client plotting
polling_timeout_in_seconds = 30
delay_between_polls = 1
send_to = settings.GMAIL_USER_NAME
password = settings.GMAIL_PASSWORD
file_system_entries, msg = TestUtils.get_internal_partition(
auth=self.auth, extra_data=self.extra_data)
self.assertIsNotNone(file_system_entries,
msg + self.extra_data.get_all())
entry = TestUtils.get_first_drawing_from_internal_file_system(
file_system_entries)
self.extra_data.add_test_data('entry', entry)
version_id_to_plot = TestUtils.get_entry_data_by_keys(
entry, 'versionId')
self.assertTrue(
version_id_to_plot > 0, 'Expected valid version id but got: ' +
str(version_id_to_plot) + self.extra_data.get_all())
self.extra_data.add_test_data('version id to plot', version_id_to_plot)
plot_and_send_to_mail_response = self.files_management_client.plot_and_send_to_mail(
auth=self.auth, version_id=version_id_to_plot, send_to=send_to)
status_code = ClientUtils.get_response_status_code(
plot_and_send_to_mail_response)
self.assertEqual(
httplib.ACCEPTED, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'plot_and_send_to_mail response',
ClientUtils.get_response_body(plot_and_send_to_mail_response))
download_id = ClientUtils.get_value_from_body(
plot_and_send_to_mail_response,
FilesManagementClient.KEY_DOWNLOAD_ID)
self.assertIsInstance(
download_id, unicode, 'Expected unicode download id but got: ' +
str(download_id) + self.extra_data.get_all())
self.extra_data.add_test_data('download id', download_id)
default_name, msg = TestUtils.poll_for_plot(
auth=self.auth,
version_id=download_id,
sleep_period=delay_between_polls,
timeout_in_seconds=polling_timeout_in_seconds,
extra_data=self.extra_data)
self.assertIsNotNone(default_name, msg + self.extra_data.get_all())
sleep(20) # wait for email to be sent
gmail_client = GmailClient()
try:
gmail_client.connect_to_account(send_to, password)
except Exception as e:
self.fail('Could not connect to mail account ' + str(send_to) +
' to verify mail was sent after plot. Exception msg: ' +
str(e.message) + '. Exception args: ' + str(e.args) +
self.extra_data.get_all())
self.assertTrue(
gmail_client.open_label('INBOX'),
'Failed to open INBOX label in ' + str(send_to) +
self.extra_data.get_all())
expected_mail_subject = default_name + ' was sent to you by ' + self.first_name + ' ' + self.last_name
self.extra_data.add_test_data('expected mail subject',
expected_mail_subject)
self.assertIsNotNone(
gmail_client.search_mails_in_label(
subject_to_search=expected_mail_subject),
'Could not find sent mail in ' + str(send_to) + ' INBOX' +
self.extra_data.get_all())
def test_timeline_manual(self):
file_name = 'test_file_timeline_manual_' + str(int(time())) + '.dwg'
title = 'test_title_' + str(int(time()))
self.extra_data.add_test_data('file name', file_name)
self.extra_data.add_test_data('title', title)
created_file_id, msg = TestUtils.create_file(
auth=self.auth, file_name=file_name, extra_data=self.extra_data)
self.assertIsNotNone(created_file_id, msg + self.extra_data.get_all())
manual_timeline_response = self.files_management_client.put_timeline_manual(
auth=self.auth, file_id=created_file_id, title=title)
status_code = ClientUtils.get_response_status_code(
manual_timeline_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'put_timeline_manual response',
ClientUtils.get_response_body(manual_timeline_response))
response_title = ClientUtils.get_value_from_body(
manual_timeline_response, FilesManagementClient.KEY_TITLE)
self.assertEqual(
title, response_title, 'Expected title: ' + str(title) +
' but got: ' + str(response_title) + self.extra_data.get_all())
get_timeline_response = self.files_management_client.get_timeline(
auth=self.auth, file_id=created_file_id)
status_code = ClientUtils.get_response_status_code(
get_timeline_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_timeline response',
ClientUtils.get_response_body(get_timeline_response))
response_entries = ClientUtils.get_value_from_body(
get_timeline_response, FilesManagementClient.KEY_ENTRIES)
self.assertIsNotNone(
response_entries,
'Expected non empty entries' + self.extra_data.get_all())
self.assertTrue(
len(response_entries) == 2,
'Expected exactly 2 entries in response body but got: ' +
str(response_entries) + self.extra_data.get_all())
self.extra_data.add_test_data('response entries', response_entries)
entry = response_entries[0]
if entry['title'] != title:
entry = response_entries[1]
entry_primary_id = entry['primaryVersionId']
self.assertEqual(
created_file_id, entry_primary_id,
'Expected file id: ' + str(created_file_id) + ' but got: ' +
str(entry_primary_id) + self.extra_data.get_all())
entry_title = entry['title']
self.assertEqual(
title, entry_title, 'Expected title: ' + str(title) +
' but got: ' + str(entry_title) + self.extra_data.get_all())
users_drawing_prefs_in_response_body = ClientUtils.is_key_in_body(
get_timeline_response, 'usersDrawingPreferences')
self.assertTrue(
users_drawing_prefs_in_response_body,
'Expected usersDrawingPreferences in response body' +
self.extra_data.get_all())
def test_get_url_to_upload_v1(self):
file_name = 'LiveView_Clean.dwg'
file_size = 64128
url_to_upload_response = self.files_management_client.get_url_to_upload_v1(
auth=self.auth,
folder_id=0,
file_name=file_name,
file_size=file_size)
status_code = ClientUtils.get_response_status_code(
url_to_upload_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_url_to_upload response',
ClientUtils.get_response_body(url_to_upload_response))
version_id = ClientUtils.get_value_from_body(
url_to_upload_response, FilesManagementClient.KEY_VERSION_ID)
request_type = ClientUtils.get_value_from_body(
url_to_upload_response, FilesManagementClient.KEY_REQUEST_TYPE)
upload_url = ClientUtils.get_value_from_body(
url_to_upload_response, FilesManagementClient.KEY_URL_TO_UPLOAD)
header_x_amz_date = ClientUtils.get_value_from_body(
url_to_upload_response, json_path='headers.x-amz-date')
header_x_amz_acl = ClientUtils.get_value_from_body(
url_to_upload_response, json_path='headers.x-amz-acl')
header_authorization = ClientUtils.get_value_from_body(
url_to_upload_response, json_path='headers.Authorization')
headers_content_type = ClientUtils.get_value_from_body(
url_to_upload_response, json_path='headers.Content-Type')
self.assertTrue(
version_id > 0, 'Expected valid version id but got: ' +
str(version_id) + self.extra_data.get_all())
self.extra_data.add_test_data('version id', version_id)
self.assertEqual(
'PUT', request_type, 'Expected request type PUT but got: ' +
str(request_type) + self.extra_data.get_all())
self.assertTrue(
len(upload_url) > 0, 'Expected non empty upload url but got: ' +
str(upload_url) + self.extra_data.get_all())
self.assertTrue(
header_x_amz_date > 0, 'Expected valid date but got: ' +
str(header_x_amz_date) + self.extra_data.get_all())
self.assertEqual(
'authenticated-read', header_x_amz_acl,
'Expected x-amz-acl header: authenticated-read but got: ' +
str(header_x_amz_acl) + self.extra_data.get_all())
self.assertTrue(
len(header_authorization) > 0,
'Expected at least one authorization header but got: ' +
str(header_authorization) + self.extra_data.get_all())
self.assertEqual(
'application/octet-stream', headers_content_type,
'Expected content-type header: ' + str(headers_content_type) +
' but got: ' + str(headers_content_type) +
self.extra_data.get_all())
def test_copy_file_v2_internal(self):
file_name = 'test_file_copy_file_v2_internal_' + str(int(
time())) + '.dwg'
file_new_name = 'test_file_copy_file_v2_internal_copy' + str(
int(time())) + '.dwg'
expected_code_and_description = (0, 'SUCCESS')
self.extra_data.add_test_data('file name', file_name)
self.extra_data.add_test_data('file new name', file_new_name)
created_file_id, msg = TestUtils.create_file(
auth=self.auth, file_name=file_name, extra_data=self.extra_data)
self.assertIsNotNone(created_file_id, msg + self.extra_data.get_all())
copy_file_response = self.files_management_client.copy_file_v2_internal(
auth=self.auth,
file_id=created_file_id,
to_folder_id=0,
rename_to=file_new_name)
status_code = ClientUtils.get_response_status_code(copy_file_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'copy_file_internal response',
ClientUtils.get_response_body(copy_file_response))
code_desc = ClientUtils.get_code_and_description_from_response(
copy_file_response)
self.assertEqual(
expected_code_and_description, code_desc,
'Expected ' + str(expected_code_and_description) + ' but got: ' +
str(code_desc) + self.extra_data.get_all())
copied_file_id = ClientUtils.get_value_from_body(
copy_file_response, FilesManagementClient.KEY_PRIMARY_WS_ID)
self.assertTrue(
copied_file_id > 0, 'Expected valid copied file id but got: ' +
str(copied_file_id) + self.extra_data.get_all())
self.extra_data.add_test_data('copied file id', copied_file_id)
file_system_entries, msg = TestUtils.get_internal_partition(
auth=self.auth, extra_data=self.extra_data)
self.assertIsNotNone(file_system_entries,
msg + self.extra_data.get_all())
entry_src = TestUtils.get_entry_from_internal_file_system_entries(
entry_id=created_file_id,
internal_file_system_entries=file_system_entries)
entry_copy = TestUtils.get_entry_from_internal_file_system_entries(
entry_id=copied_file_id,
internal_file_system_entries=file_system_entries)
self.assertIsNotNone(
entry_src, 'Source file should still exist in partition' +
self.extra_data.get_all())
self.assertIsNotNone(
entry_copy, 'Copied file should exist in partition' +
self.extra_data.get_all())
entry_src_name = TestUtils.get_entry_data_by_keys(
entry=entry_src, keys=PartitionClient.KEY_ENTRY_NAME)
entry_copy_name = TestUtils.get_entry_data_by_keys(
entry=entry_copy, keys=PartitionClient.KEY_ENTRY_NAME)
self.assertEqual(
file_name, entry_src_name,
'Expected source file name: ' + str(file_name) + ' but got: ' +
str(entry_src_name) + self.extra_data.get_all())
self.assertEqual(
file_new_name, entry_copy_name,
'Expected copy file name: ' + str(file_new_name) + ' but got: ' +
str(entry_copy_name) + self.extra_data.get_all())
def test_move_file_to_external_folder_rename_and_delete_it_v2(self):
folder_name = 'test_folder_external_file_flow_' + str(int(time()))
file_name = 'test_file_external_file_flow_' + str(int(time())) + '.dwg'
file_new_name = 'test_file_external_file_flow_renamed_' + str(
int(time())) + '.dwg'
permanent_folder = 'Permanent_Folder/'
self.extra_data.add_test_data('folder name', folder_name)
self.extra_data.add_test_data('file name', file_name)
self.extra_data.add_test_data('file new name', file_new_name)
success_code_and_description = (0, 'SUCCESS')
cont_async_code_and_description = (
23, 'FILESYSTEM OPERATION CONTINUES ASYNCRONOUSLY')
polling_timeout_in_seconds = 30
delay_between_polls = 1
success, msg = TestUtils.create_external_folder(
auth=self.auth,
host_id=self.host_id,
folder_path=permanent_folder,
new_folder_name=folder_name,
extra_data=self.extra_data)
self.assertIsNotNone(success, msg + self.extra_data.get_all())
folder_name = permanent_folder + folder_name
self.extra_data.add_test_data('folder name', folder_name)
created_file_id, msg = TestUtils.create_file(
auth=self.auth, file_name=file_name, extra_data=self.extra_data)
self.assertIsNotNone(created_file_id, msg + self.extra_data.get_all())
move_to_external_folder_response = self.files_management_client.move_internal_file_to_external(
auth=self.auth,
file_id=created_file_id,
to_host_id=self.host_id,
to_path=folder_name + '/')
status_code = ClientUtils.get_response_status_code(
move_to_external_folder_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'move_internal_file_to_external response',
ClientUtils.get_response_body(move_to_external_folder_response))
code_desc = ClientUtils.get_code_and_description_from_response(
move_to_external_folder_response)
self.assertEqual(
cont_async_code_and_description, code_desc,
'Expected ' + str(cont_async_code_and_description) + ' but got: ' +
str(code_desc) + self.extra_data.get_all())
polling_id = ClientUtils.get_value_from_body(
move_to_external_folder_response,
FilesManagementClient.KEY_POLLING_ID)
self.assertTrue(
polling_id > 0, 'Expected valid polling id, but got: ' +
str(polling_id) + self.extra_data.get_all())
self.extra_data.add_test_data('polling id', polling_id)
successful_move, msg = TestUtils.poll_for_move_to_external(
auth=self.auth,
polling_id=polling_id,
sleep_period=delay_between_polls,
timeout_in_seconds=polling_timeout_in_seconds,
extra_data=self.extra_data)
self.assertIsNotNone(successful_move, msg + self.extra_data.get_all())
sleep(5)
file_system_entries, msg = TestUtils.get_external_partition(
auth=self.auth,
host_id=self.host_id,
path=folder_name,
extra_data=self.extra_data)
self.assertIsNotNone(file_system_entries,
msg + self.extra_data.get_all())
file_system_entries_names = [
str(entry[self.partition_client.KEY_ENTRY_NAME])
for entry in file_system_entries
if entry['type'] == 'EXTERNAL_DRAWING'
]
if file_name not in file_system_entries_names:
self.fail('New file should have been moved to external host' +
self.extra_data.get_all())
internal_file_system_entries, msg = TestUtils.get_internal_partition(
auth=self.auth, extra_data=self.extra_data)
self.assertIsNotNone(internal_file_system_entries,
msg + self.extra_data.get_all())
file_system_entries_names = [
str(entry[self.partition_client.KEY_ENTRY_NAME])
for entry in internal_file_system_entries
if entry['type'] == 'DRAWING'
]
if file_new_name in file_system_entries_names:
self.fail(
'File should have moved to external folder, and not found in internal partition result'
+ self.extra_data.get_all())
file_relative_path = folder_name + '/' + file_name
self.extra_data.add_test_data('file relative path', file_relative_path)
rename_file_response = self.files_management_client.rename_external_file_v2(
auth=self.auth,
host_id=self.host_id,
name=file_new_name,
path=file_relative_path)
status_code = ClientUtils.get_response_status_code(
rename_file_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'rename_external_file response',
ClientUtils.get_response_body(rename_file_response))
code_desc = ClientUtils.get_code_and_description_from_response(
rename_file_response)
self.assertEqual(
success_code_and_description, code_desc,
'Expected ' + str(success_code_and_description) + ' but got: ' +
str(code_desc) + self.extra_data.get_all())
file_system_entries, msg = TestUtils.get_external_partition(
auth=self.auth,
host_id=self.host_id,
path=folder_name,
extra_data=self.extra_data)
self.assertIsNotNone(file_system_entries,
msg + self.extra_data.get_all())
file_system_entries_names = [
str(entry[self.partition_client.KEY_ENTRY_NAME])
for entry in file_system_entries
if entry['type'] == 'EXTERNAL_DRAWING'
]
if file_new_name not in file_system_entries_names:
self.fail('File should have been renamed in external host' +
self.extra_data.get_all())
file_relative_path = folder_name + '/' + file_new_name
self.extra_data.add_test_data('file relative path', file_relative_path)
delete_file_response = self.files_management_client.delete_external_file_v2(
auth=self.auth, host_id=self.host_id, path=file_relative_path)
status_code = ClientUtils.get_response_status_code(
delete_file_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'delete_external_file response',
ClientUtils.get_response_body(delete_file_response))
code_desc = ClientUtils.get_code_and_description_from_response(
delete_file_response)
self.assertEqual(
success_code_and_description, code_desc,
'Expected ' + str(success_code_and_description) + ' but got: ' +
str(code_desc) + self.extra_data.get_all())
file_system_entries, msg = TestUtils.get_external_partition(
auth=self.auth,
host_id=self.host_id,
path=folder_name,
extra_data=self.extra_data)
self.assertIsNotNone(file_system_entries,
msg + self.extra_data.get_all())
file_system_entries_names = [
str(entry[self.partition_client.KEY_ENTRY_NAME])
for entry in file_system_entries
if entry['type'] == 'EXTERNAL_DRAWING'
]
if file_new_name in file_system_entries_names:
self.fail(
'Folder should have been deleted, and not found in partition result'
+ self.extra_data.get_all())
# Teardown - remove created folder - does not affect test results
self.folders_management_client.delete_external_folder_v2(
auth=self.auth, host_id=self.host_id, path=folder_name)
def test_update_post_old_api(self):
file_name = 'test_file_update_post_' + str(int(time())) + '.dwg'
comment_body = 'test_comment_body'
updated_post_status = 'closed'
self.extra_data.add_test_data('file name', file_name)
created_file_id, msg = TestUtils.create_file(
auth=self.auth, file_name=file_name, extra_data=self.extra_data)
self.assertIsNotNone(created_file_id, msg + self.extra_data.get_all())
new_post_response = self.drawing_feed_client.new_post_old_api(
auth=self.auth, file_id=created_file_id, post_body=comment_body)
status_code = ClientUtils.get_response_status_code(new_post_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'new_post response',
ClientUtils.get_response_body(new_post_response))
post_id = ClientUtils.get_value_from_body(new_post_response,
DrawingFeedClient.KEY_ID)
self.assertIsInstance(
post_id, unicode, 'Expected unicode post id but got: ' +
str(post_id) + self.extra_data.get_all())
self.extra_data.add_test_data('post id', post_id)
update_post_response = self.drawing_feed_client.update_post_old_api(
auth=self.auth,
file_id=created_file_id,
post_id=post_id,
post_status=updated_post_status)
status_code = ClientUtils.get_response_status_code(
update_post_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'update_post response',
ClientUtils.get_response_body(update_post_response))
response_post_id = ClientUtils.get_value_from_body(
update_post_response, DrawingFeedClient.KEY_ID)
self.assertEqual(
post_id, response_post_id, 'Expected post_id: ' + str(post_id) +
' but got: ' + str(response_post_id) + self.extra_data.get_all())
self.assertTrue(
ClientUtils.is_key_in_body(update_post_response, 'updated'),
'Expected key "updated" to exist in response body' +
self.extra_data.get_all())
get_feed_response = self.drawing_feed_client.get_drawing_feed_old_api(
auth=self.auth, file_id=created_file_id)
status_code = ClientUtils.get_response_status_code(get_feed_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_drawing_feed response',
ClientUtils.get_response_body(get_feed_response))
post = TestUtils.get_post_from_drawing_feed_response(
get_feed_response, post_id)
self.assertIsNotNone(
post, 'Expected non empty post' + self.extra_data.get_all())
self.extra_data.add_test_data('post', post)
post_status = post['status']
self.assertEqual(
updated_post_status, post_status,
'Expected updated post status: ' + str(updated_post_status) +
' but got: ' + str(post_status) + self.extra_data.get_all())
def test_new_post(self):
file_name = 'test_file_new_post_' + str(int(time())) + '.dwg'
comment_body = 'test_comment_body'
self.extra_data.add_test_data('file name', file_name)
created_file_id, msg = TestUtils.create_file(
auth=self.auth, file_name=file_name, extra_data=self.extra_data)
self.assertIsNotNone(created_file_id, msg + self.extra_data.get_all())
new_post_response = self.drawing_feed_client.new_post(
auth=self.auth, file_id=created_file_id, post_body=comment_body)
status_code = ClientUtils.get_response_status_code(new_post_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'new_post response',
ClientUtils.get_response_body(new_post_response))
post_status = ClientUtils.get_value_from_body(
new_post_response, DrawingFeedClient.KEY_STATUS)
self.assertEqual(
'open', post_status, 'Expected post status: open but got: ' +
str(post_status) + self.extra_data.get_all())
post_body = ClientUtils.get_value_from_body(new_post_response,
DrawingFeedClient.KEY_BODY)
self.assertEqual(
comment_body, post_body,
'Expected post body: ' + str(comment_body) + ' but got: ' +
str(post_body) + self.extra_data.get_all())
post_id = ClientUtils.get_value_from_body(new_post_response,
DrawingFeedClient.KEY_ID)
self.assertIsInstance(
post_id, unicode, 'Expected unicode post id but got: ' +
str(post_id) + self.extra_data.get_all())
self.extra_data.add_test_data('post id', post_id)
get_feed_response = self.drawing_feed_client.get_drawing_feed(
auth=self.auth, file_id=created_file_id)
status_code = ClientUtils.get_response_status_code(get_feed_response)
self.assertEqual(
httplib.OK, status_code,
'Got status code: ' + str(status_code) + self.extra_data.get_all())
self.extra_data.add_test_data(
'get_drawing_feed response',
ClientUtils.get_response_body(get_feed_response))
post = TestUtils.get_post_from_drawing_feed_response(
get_feed_response, post_id)
self.assertIsNotNone(
post, 'Expected non-empty post' + self.extra_data.get_all())
self.extra_data.add_test_data('post', post)
post_status = post['status']
self.assertEqual(
'open', post_status, 'Expected post status: open but got: ' +
str(post_status) + self.extra_data.get_all())
post_body = post['body']
self.assertEqual(
comment_body, post_body,
'Expected post body: ' + str(comment_body) + 'but got: ' +
str(post_body) + self.extra_data.get_all())
post_actor_name = post['actor']['name']
user_full_name = self.first_name + ' ' + self.last_name
self.assertEqual(
user_full_name, post_actor_name,
'Expected post actor: ' + str(user_full_name) + 'but got: ' +
str(post_actor_name) + self.extra_data.get_all())