async def test_set_chrome_log_file(self):
log_file = '/tmp/chrome_logfile.log'
file_delete(log_file)
chrome = Chrome().headless(True)
chrome.chrome_args.enable_logging(log_file)
await chrome.browser()
assert 'Could not get the download directory.' in file_contents(
log_file).split('\n').pop(0)
def get_log_file(self, log_file, size=0):
path = f'/var/log/{log_file}.log'
if size > 0:
return self.esxi_ssh.tail(path, size)
log_file = self.esxi_ssh.exec_scp_command(path)
if log_file:
log_data = file_contents(log_file)
file_delete(log_file)
return log_data
def test_save(self):
target_file = temp_file() # temp file to save data
assert file_not_exists(target_file) # confirm it doesn't exist
with patch.object(Hash_Json, 'get_file_path', return_value=target_file): # patch get_file_path to return temp file path
assert self.hash_json.get_file_path() == target_file # confirm patch is in place
self.hash_json.save() # call write_to_file
assert file_exists(target_file) # confirm temp file now exists
assert self.hash_json.load() == self.hash_json.data() # confirm reloaded data is correct
assert json_load_file(target_file) == self.hash_json.data() # also confirm using direct json load of temp file
assert self.hash_json.get_file_path() != target_file # confirm pathc is not there (after 'with' ends)
file_delete(target_file) # delete temp file
def test_prepare_hd2_hash_folder_zip(self):
zip_name = self.zip_name
test_path_list = [self.test_folder]
response = self.file_distributor.prepare_hd2_hash_folder_zip(
test_path_list, zip_name)
assert response == os.path.join(self.file_distributor.zip_folder,
zip_name)
assert file_exists(
os.path.join(self.file_distributor.zip_folder, zip_name))
file_delete(os.path.join(self.file_distributor.zip_folder, zip_name))
def add_test_files(self, count=5, text_size=10, execute_stage_1=False):
added_files = []
#random_blog = random_text(length=count*text_size)
for i in range(1, count + 1):
text = random_text(
) + '_' * text_size # much better performance than using random_text for the full string
test_file = Test_Data().create_test_pdf(text=text,
file_key=f"temp_file_{i}")
added_files.append(self.storage.hd1_add_file(test_file))
file_delete(test_file)
if execute_stage_1:
self.execute_stage_1()
return added_files
def test_upload__download(self):
local_file = temp_file(file_contents="This is a local file - " +
random_string()) # create local temp file
self.datastore_file.upload(local_file) # upload file to server
tmp_file = self.datastore_file.download() # download file from server
assert file_exists(tmp_file) # confirm it exists
assert file_contents(local_file) == file_contents(
tmp_file
) # confirm content matches the randomly generated temp content
assert self.datastore_file.delete(
) is True # delete temp file from data_store
file_delete(local_file) # delete local temp file
def test_is_hash(self):
test_file = temp_file(contents='aaaa')
file_hash = Metadata_Utils().file_hash(test_file) # create hash from file
text_hash = str_sha256('asd') # create hash from string
assert self.hash_json.is_hash(file_hash ) is True # confirm both are valid hashes
assert self.hash_json.is_hash(text_hash ) is True
assert self.hash_json.is_hash(None ) is False # testing all sorts of conner cases
assert self.hash_json.is_hash('' ) is False # empty strings
assert self.hash_json.is_hash('aaaa' ) is False # non hash string
assert self.hash_json.is_hash(file_hash + 'aaaa') is False # confirm only exact matches work
assert self.hash_json.is_hash(text_hash + 'aaaa') is False
assert self.hash_json.is_hash('aaa' + file_hash ) is False
assert self.hash_json.is_hash(text_hash + '\nb`') is False # confirm content in new lines is also not a match
assert self.hash_json.is_hash('a\n' + file_hash ) is False
file_delete(test_file)
def test_key_pair_create_to_file(self):
key_name = 'osbot-unit-tests-temp_key_pair'
result = self.ec2.key_pair_create_to_file(key_name=key_name)
key_pair_id = result.get('key_pair').get('KeyPairId')
path_key_pair = result.get('path_key_pair')
assert file_exists(path_key_pair) is True
assert file_contents(path_key_pair).find('BEGIN RSA PRIVATE KEY') > -1
assert self.ec2.key_pair_delete(key_pair_id=key_pair_id) is True
assert file_delete(path_key_pair) is True
def test_prepare_zip(self):
zip_name = self.zip_name
response = self.file_distributor.prepare_zip(self.test_file,
zip_name) # zip a file
assert response == os.path.join(self.file_distributor.zip_folder,
zip_name)
assert file_exists(
os.path.join(self.file_distributor.zip_folder, zip_name))
file_delete(os.path.join(self.file_distributor.zip_folder, zip_name))
response = self.file_distributor.prepare_zip(self.test_folder,
zip_name) # zip a folder
assert response == os.path.join(self.file_distributor.zip_folder,
zip_name)
assert file_exists(
os.path.join(self.file_distributor.zip_folder, zip_name))
file_delete(os.path.join(self.file_distributor.zip_folder, zip_name))
def setup_test_environment__Deploy_Lambda(
cls): # todo: refactor into separate class
STS().check_current_session_credentials()
cls.lambda_name = "osbot_test_deploy_lambda"
cls.lambda_code = Temp_Folder_With_Lambda_File(cls.lambda_name)
cls.code_folder = cls.lambda_code.folder
lambda_file = cls.lambda_code.tmp_file
module_folder = path_combine(cls.code_folder,
"osbot_test_deploy_lambda")
lambda_in_module = path_combine(module_folder, file_name(lambda_file))
folder_create(module_folder)
file_copy(lambda_file,
lambda_in_module) # todo add a file_move to OSBot_Utils
file_delete(lambda_file)
file_create(path_combine(module_folder, '__init__.py'), "")
sys.path.append(cls.code_folder)
cls.lambda_module = importlib.import_module(
"osbot_test_deploy_lambda.osbot_test_deploy_lambda")
cls.lambda_function = cls.lambda_module.run
def test_get_access_key_for_user(
self): # test CI_Setup().get_access_key_for_user method
path_temp_credentials = self.ci_setup.path_temp_credentials # store path in local var to make it easier to read
assert file_delete(
path_temp_credentials
) is True # make sure temp file with access keys doesn't exist
credential_1 = self.ci_setup.get_access_key_for_user(
) # create first test credential
assert file_exists(
path_temp_credentials) # confirm temp file now exists
assert len(self.ci_setup.iam.user_access_keys()
) == 1 # confirm there is only one access key for this user
file_delete(path_temp_credentials) # delete temp file
credential_2 = self.ci_setup.get_access_key_for_user(
delete_keys=False
) # create another credential with delete_keys set to false
assert len(self.ci_setup.iam.user_access_keys()
) == 2 # confirm that there are 2 keys now in this user
assert credential_1 != credential_2 # confirm that first and second credentials don't match
assert file_exists(
path_temp_credentials) # confirm that temp file exists
credential_3 = self.ci_setup.get_access_key_for_user(
delete_keys=True
) # create 3rd credential (with delete_keys set to True)
assert len(self.ci_setup.iam.user_access_keys()
) == 1 # confirm that there is only 1 key for this user
assert credential_1 != credential_3 # and the that the credentials don't match
credential_4 = self.ci_setup.get_access_key_for_user(
new_key=False
) # with new_key=False we should get the value from temp file
assert credential_1 != credential_4 # which means that they shouldn't match with first credential
assert credential_3 == credential_4 # but should match with the 3rd
assert len(self.ci_setup.iam.user_access_keys(
)) == 1 # finally confirm there is only one valid key for this user
async def test_keep_open(self):
file_delete(Chrome_Setup(None, None).file_tmp_last_chrome_session)
url_1 = 'https://www.google.com/404'
url_2 = 'https://www.google.com/ABC'
chrome_1 = Chrome().keep_open(
) # 1st chrome object (with keep_open setting)
browser_1 = await chrome_1.browser(
) # open process and get browser object
page_1 = (await browser_1.pages()).pop() # get first page
await page_1.goto(url_1) # open 404 in google
assert page_1.url == url_1 # confirm url
chrome_2 = Chrome().keep_open() # create 2nd chrome object
browser_2 = await chrome_2.browser(
) # connect to chrome and get browser object
page_2 = (await browser_2.pages()).pop() # get page object
assert page_2.url == url_1 # confirm url
await page_2.goto(url_2) # open another page in browser_2
assert page_1.url == url_2 # confirm it was opened in browser 1
assert page_2.url == url_2 # and in browser_2
chrome_3 = Chrome().keep_open() # create 3rd chrome object
browser_3 = await chrome_3.browser(
) # connect to chrome and get browser object
page_3 = (await browser_3.pages()).pop() # get page object
assert page_3.url == url_2 # confirm url
assert self.chrome.chrome_setup.connect_method(
) == 'No browser open or connected'
assert chrome_1.chrome_setup.connect_method(
) == 'Started chrome process'
assert chrome_2.chrome_setup.connect_method(
) == 'Connected to running chrome process'
assert chrome_3.chrome_setup.connect_method(
) == 'Connected to running chrome process'
#await browser_1.close()
await browser_3.close() # close browser
def test_file_create(self):
target = temp_file()
text = random_string()
assert file_delete(target) is True
assert file_exists(target) is False
assert file_create(target, text) == target
assert file_exists(target) is True
assert file_contents(target) == text
empty_file = file_create()
assert file_exists(empty_file) is True
assert file_contents(empty_file) == ''
def prepare_hd2_hash_folder_zip(self,path_list, zip_name):
try:
self.temp_folder = temp_folder()
for hash_folder_path in path_list:
name = ntpath.basename(hash_folder_path)
dst_path = os.path.join(self.temp_folder, name)
if os.path.isdir(hash_folder_path):
folder_copy(hash_folder_path, dst_path)
hd2_source_file = os.path.join(dst_path, "source")
if os.path.isfile(hd2_source_file):
file_delete(hd2_source_file)
target_file_path = os.path.join(self.zip_folder, zip_name)
zip_files(self.temp_folder, file_pattern='*.*', target_file = target_file_path)
folder_delete_all(self.temp_folder)
return target_file_path
except Exception as error:
logger.error(f"File_Distributor: prepare_zip : {error}")
raise error
def test_file_copy(self):
text_a = random_string()
text_b = random_string()
file_a = temp_file(contents=text_a)
file_b = temp_file(contents=text_b)
assert file_exists(file_a) is True
assert file_exists(file_b) is True
assert file_contents(file_a) == text_a
assert file_contents(file_b) == text_b
assert file_delete(file_b) is True
assert file_exists(file_b) is False
file_copy(file_a, file_b)
assert file_exists(file_b) is True
assert file_contents(file_b) == text_a
def tearDownClass(cls) -> None:
file_delete(cls.test_file)
def tearDownClass(cls) -> None:
super().tearDownClass()
file_delete(cls.test_file)
def tearDown(self) -> None:
file_delete(self.file_path)
def tearDownClass(cls) -> None:
file_delete(cls.file_path)
file_delete(cls.file_copy_path)
def tearDown(self):
file_delete(self.path_temp_png) # delete file is created
def tearDownClass(cls) -> None:
file_delete(cls.test_file)
folder_delete_all(cls.temp_dir)
Metadata(file_hash=cls.file_hash).delete()