def test__using_with_valid_zip_and_target_folder(self):
test_zip = Files.current_folder()
target_folder = '/tmp/unzip_test'
with Zip_Folder(test_zip) as (zip_file):
with Unzip_File(zip_file, target_folder, True) as temp_folder:
assert Files.exists(temp_folder) is True
assert Files.exists(temp_folder) is False
def test_zip_files(self):
target_file = '/tmp/test_zip.zip'
Files.delete(target_file)
assert Files.exists(target_file) is False
Dev.pprint(Files.zip_files('..', '*.py', '/tmp/test_zip.zip'))
assert Files.exists(target_file) is True
Files.delete(target_file)
assert Files.exists(target_file) is False
def delete(self, name):
virtual_path = "{0}/{1}".format(self.base_folder, self.fix_name(name) + '.md')
full_path = self.md_file_path(virtual_path)
if Files.exists(full_path) is False:
return False
Files.delete(full_path)
return Files.exists(full_path) is False
def test__using_with__no_params(self):
with Temp_File() as temp:
assert Files.file_extension(temp.file_path) == '.tmp'
assert Files.exists (temp.file_path)
assert Files.contents(temp.file_path) == '...'
assert Files.not_exists(temp.file_path)
with Temp_File('abc','txt') as temp:
assert Files.file_extension(temp.file_path) == '.txt'
assert Files.exists (temp.file_path)
assert Files.contents(temp.file_path) == 'abc'
assert Files.not_exists(temp.file_path)
def test_participant_create(self):
name = 'an test user'
result = self.hugo_page.create(name)
assert result.get('status') == 'ok'
data = result.get('data')
path = self.hugo_page.md_file_path(data['path'])
assert data['metadata']['title'] == 'an test user'
assert data['path'] == '/content/participant/an-test-user.md'
assert Files.exists(path) is True
assert self.hugo_page.delete(name) is True
assert Files.exists(path) is False
def load_dependency(target):
if os.getenv('AWS_REGION') is None:
return
from osbot_aws.apis.S3 import S3
import shutil
import sys
s3 = S3()
s3_bucket = 'gw-bot-lambdas'
s3_key = 'lambdas-dependencies/{0}.zip'.format(target)
tmp_dir = Files.path_combine('/tmp/lambdas-dependencies', target)
#return s3.file_exists(s3_bucket,s3_key)
if s3.file_exists(s3_bucket, s3_key) is False:
raise Exception(
"In Lambda load_dependency, could not find dependency for: {0}".
format(target))
if Files.not_exists(
tmp_dir
): # if the tmp folder doesn't exist it means that we are loading this for the first time (on a new Lambda execution environment)
zip_file = s3.file_download(
s3_bucket, s3_key, False) # download zip file with dependencies
shutil.unpack_archive(zip_file, extract_dir=tmp_dir) # unpack them
sys.path.append(
tmp_dir
) # add tmp_dir to the path that python uses to check for dependencies
return Files.exists(tmp_dir)
def test__init__(self):
temp_file = Temp_File()
assert Files.exists (temp_file.tmp_folder)
assert Files.not_exists(temp_file.tmp_file)
assert Files.not_exists(temp_file.file_path)
assert temp_file.tmp_folder in temp_file.file_path
assert '/' == temp_file.file_path.replace(temp_file.tmp_folder,'').replace(temp_file.tmp_file,'')
def test_render__with_clip_params(self):
#params = ['/examples/bootstrap-cdn.html' ,0 ,0 ,500 ,50 ]
params = ['examples/wardley_map/cup-of-tea.html', 250, 50, 600, 200]
png_data = self.browser_commands.render(None, None, params)
Files.delete(self.png_file)
self._save_png_data(png_data)
assert Files.exists(self.png_file)
def test_render(self):
params = ['examples/wardley_map/cup-of-tea.html']
png_data = self.browser_commands.render(None, None, params)
Files.delete(self.png_file)
self._save_png_data(png_data)
assert Files.exists(self.png_file)
def test_screenshot_file(self):
with Temp_File(self.html, 'html') as temp_file:
clip = {'x': 1, 'y': 1, 'width': 180, 'height': 30}
img_file = self.render_page.screenshot_file(temp_file.file_path,
self.tmp_img,
clip=clip)
assert Files.exists(img_file)
def create_temp_file(self, new_code=None):
if new_code: self.lambda_code = new_code
self.tmp_file = Files.path_combine(self.folder,
'{0}.py'.format(self.file_name))
Files.write(self.tmp_file, self.lambda_code)
assert Files.exists(self.tmp_file)
return self
def create(self, name):
template = self.load(self.file_template)
template['metadata']['title'] = name
template['path'] = template['path'].replace('_template', self.fix_name(name))
file_path = self.md_file_path(template['path'])
if Files.exists(file_path):
return { 'status': 'error', 'data':'target file already existed: {0}'.format(file_path)}
return self.save(template)
def test_add_file(self):
lambda_file = Files.path_combine(
__file__, '../../../../osbot_aws/lambdas/dev/hello_world.py')
assert Files.exists(lambda_file)
self.package.add_file(lambda_file)
assert self.package.get_files() == ['/hello_world.py']
self.package.aws_lambda.handler = 'hello_world.run'
self.package.update()
assert self.package.invoke() == 'From lambda code, hello None'
def test_screenshot_url(self):
#url = 'https://github.com/GoogleChrome/puppeteer'
#url = 'https://www.google.co.uk'
#url = 'http://visjs.org/examples/network/other/manipulation.html'
#url = 'http://visjs.org/examples/graph3d/01_basics.html'
url = 'https://getbootstrap.com/docs/4.3/examples/dashboard/'
tmp_img = '/tmp/test_screenshot_html.png'
Files.delete(tmp_img)
self.render_page.screenshot_url(url, tmp_img)
assert Files.exists(tmp_img)
def load(self, path):
if Files.exists(path):
file_data = frontmatter.load(path)
relative_path = path.replace(self.folder_oss, '')
data = {
'path': relative_path,
'content': file_data.content,
'metadata': file_data.metadata
}
return data
def load(self, path):
if Files.exists(path):
try:
file_data = frontmatter.load(path)
relative_path = path.replace(self.folder_oss, '')
data = {
'path': relative_path,
'content': file_data.content,
'metadata': file_data.metadata
}
return data
except Exception as error:
print('[Hugo_Page][load] for {0} error: {1}'.format(
path, error))
def load(self, reload=False):
if self.data is None or reload:
path = self.name
if Files.exists(path) and '.md' in path:
self.path_md_file = path
else:
if '.md' not in path:
path = self.hugo_page.fix_name(path) + '.md'
if self.name.startswith(self.base_folder) is False: # fix path
path = self.base_folder + path
self.path_md_file = self.hugo_page.md_file_path(path)
self.data = self.hugo_page.load(self.path_md_file)
title = self.field('title')
if title:
self.name = title
return self
def save(self, data):
try:
post = frontmatter.Post(data.get('content'))
post.metadata = data.get('metadata')
for key, value in post.metadata.items():
default_value = '' if key not in ['sessions'] else []
post.metadata[key] = value if value else default_value
file_path = self.md_file_path(data['path'] )
Files.write(file_path, frontmatter.dumps(post))
if Files.exists(file_path):
return { 'status': 'ok', 'data': data }
else:
return {'status': 'error', 'data': 'file not saved ok: {0}'.format(file_path) }
except Exception as error:
return { 'status': 'error', 'data': error }
def test_upload(self):
tmp_folder = Temp_Folder_Code(self.lambda_name)
(self.aws_lambda.set_s3_bucket (self.s3_bucket )
.set_s3_key (self.s3_key )
.set_folder_code(tmp_folder.folder ))
#self.aws_lambda.upload()
#assert tmp_folder.s3_file_exists() is True
downloaded_file = self.aws_lambda.s3().file_download(self.s3_bucket, self.s3_key) # download file uploaded
assert Files.exists(downloaded_file)
unzip_location = tmp_folder.folder + '_unzipped'
Files.unzip_file(downloaded_file,unzip_location) # unzip it
assert Files.contents(Files.find(unzip_location+'/*').pop()) == tmp_folder.lambda_code # confirm unzipped file's contents
self.aws_lambda.s3().file_delete(self.s3_bucket, self.s3_key)
def use_lambda_file(self, lambda_file):
file_path = Files.path_combine(self.get_root_folder(), lambda_file)
if Files.exists(file_path) is False:
return {
'status':
'error',
'data':
'could not find lambda file `{0}` in root folder `{1}`'.format(
lambda_file, self.get_root_folder())
}
target_file = Files.path_combine(self.tmp_folder,
'{0}.py'.format(self.lambda_name))
Files.copy(file_path, target_file)
return {
'status': 'ok',
'file_path': file_path,
'target_file': target_file
}
def test_exists(self):
assert Files.exists(Files.current_folder()) is True
assert Files.exists('aaaa_bbb_ccc' ) is False
assert Files.exists(None ) is False
def __exit__(self, type, value, traceback):
if Files.exists(self.zip_file) and self.delete_zip_file:
Files.delete(self.zip_file)
def test__init__(self):
assert Files.folder_exists(self.hugo_page.folder_oss)
assert Files.file_name(self.hugo_page.folder_oss) == 'oss2019'
assert Files.exists(self.hugo_page.file_template)
def test_screenshot_folder(self):
web_root = Files.current_folder()
clip = {'x': 1, 'y': 1, 'width': 280, 'height': 200}
Files.delete(self.tmp_img)
self.render_page.screenshot_folder(web_root, self.tmp_img, clip)
assert Files.exists(self.tmp_img)
def exists(self):
return Files.exists(self.path_repo)
def test_screenshot_html(self):
img_file = self.render_page.screenshot_html(self.html, self.tmp_img)
assert Files.exists(img_file)
def get_last_chrome_session(self):
if Files.exists(self.file_tmp_last_chrome_session):
return Json.load_json(self.file_tmp_last_chrome_session)
return {}
def test_temp_folder(self):
assert Files.exists(Files.temp_folder())
assert '/tmp/aa_' in Files.temp_folder('_bb', 'aa_', '/tmp')
def test__init__(self):
assert Files.exists(self.gsheet_data.data_folder) == True
async def test_screenshot(self):
await self.api.open('https://news.bbc.co.uk')
file = await self.api.screenshot()
assert Files.exists(file)
