def test_render_svg(self):
result = self.graph_dot.render_svg()
svg = result.get('svg')
if svg:
file_create(self.svg_file, svg)
else:
self.result = result
def save(self):
if not file_exists(self.status_file_path()):
folder_create(self.storage.hd2_status())
file_create(self.status_file_path())
json_save_file_pretty(self.data(), self.status_file_path())
return self
def run(event, context=None):
target_host = event.get('target_host')
ssh_key = event.get('ssh_key')
ssh_key_name = event.get('ssh_key_name')
ssh_user = event.get('ssh_user')
ssh_command = event.get('ssh_command')
# port_forward = event.get('port_forwards' ) # not implemented:
include_stderr = event.get('include_stderr')
ssh_key_file = f'/tmp/{ssh_key_name}'
if file_not_exists(ssh_key_file): # create local key if it doesn't exist
file_create(ssh_key_file, ssh_key)
start_process('chmod', ['600', ssh_key_file])
ssh_params = ['-o', 'StrictHostKeyChecking=no'
] # todo: add support for updating the local hosts file
if ssh_key_file:
ssh_params.append('-i') # set key to use
ssh_params.append(ssh_key_file)
# if port_forward: # todo see if we do actually need this (main use case would be to allow direct HTTP access to an internal server)
# local_port = port_forward.get('local_port' ) # need to see if Lambda will allow binding ports like this
# remote_ip = port_forward.get('remote_ip' )
# remote_port = port_forward.get('remote_port')
ssh_params.append(f'{ssh_user}@{target_host}') # set user and target ip
ssh_params.append(ssh_command) # add command to execute
result = start_process("ssh", ssh_params) # execute command
if include_stderr: # see if we need to include stderr in return value
return result.get('stdout') + result.get('stderr')
return result.get('stdout')
def render_svg_to_file(self, target_file):
result = self.render_svg()
svg = result.get('svg')
print(result.get('error'))
if svg:
file_create(target_file, svg)
return {'status:': 'ok', 'svg_file': target_file}
return {'status:': 'error', 'error': result.get('error')}
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 key_pair_create_to_file(self, key_name, target_folder=None, tags=None):
key_pair = self.key_pair_create(key_name=key_name, tags=tags)
key_pair_id = key_pair.get('KeyPairId')
key_pair_material = key_pair.get('KeyMaterial')
if target_folder is None:
target_folder = temp_folder()
path_key_pair = path_combine(target_folder, key_name + ".pem")
file_create(path_key_pair, key_pair_material)
chmod(path_key_pair, 0o400)
return {
'path_key_pair': path_key_pair,
'key_pair_id': key_pair_id,
'key_pair': key_pair
}
def import_dashboard_from_github(self, dashboard_file_name):
url_dashboards = 'https://raw.githubusercontent.com/filetrust/cdr-plugin-folder-to-folder-test-data/main/kibana-dashboards/'
url_dashboard = url_dashboards + dashboard_file_name
dashboard_data = GET(url_dashboard)
import_file = file_create(extension=dashboard_file_name,
contents=dashboard_data)
return self.import_dashboard(import_file=import_file)
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_file_lines(self):
contents = """1st line
2nd line
3rd line
"""
file_path = file_create(contents=contents)
lines = list(file_lines(file_path))
assert len(lines) == 4
assert lines[0].strip() == '1st line'
assert lines[1].strip() == '2nd line'
assert lines[2].strip() == '3rd line'
assert lines[3].strip() == ''
file_path_gz = file_create_gz(contents=contents)
lines_gz = list(file_lines_gz(file_path_gz))
assert lines == lines_gz
def create_temp_file(self, new_code=None):
self.lambda_code = new_code or self.lambda_code
self.folder = folder_create_temp('tmp_lambda_')
self.tmp_file = path_combine(self.folder, f'{self.file_name}.py')
file_create(self.tmp_file, self.lambda_code)
return self
def test_file_content_sha256(self):
contents = random_string()
file_path = file_create(contents=contents)
assert file_contents_sha256(file_path) == bytes_sha256(
str_to_bytes(contents))
def test_file_not_exists(self):
target = temp_file()
assert file_not_exists(target) is True
file_create(target, 'asd')
assert file_not_exists(target) is False
def setUp(self) -> None:
self.file_path = file_create(contents=csv_string)
def test_export_dashboard(self):
dashboard_id = 'd73d7220-ab6f-11eb-b1b2-a1d32a234c46'
dashboard = Dashboard(kibana=self.kibana, dashboard_id=dashboard_id)
export_data = dashboard.export_dashboard()
pprint(file_create(contents=export_data))
def save_file(python_object, path=None, pretty=False):
json_data = json_dumps(python_object=python_object,
indent=2,
pretty=pretty)
return file_create(path=path, contents=json_data)
