def __init__(self,
rule_name=None,
event_source=None,
tags=None,
event_bus_name=None):
self.event_bus_name = event_bus_name
self.event_source = event_source or random_string(
prefix='temp_event_source-')
self.rule_name = rule_name or random_string(prefix='temp_event_rule-')
self.rule_tags = tags or {'Name': self.event_source}
self.events = Events()
def __init__(self , queue_name=None, attributes=None, fifo=True):
self.attributes = attributes
self.fifo = fifo
self.queue = None
self.queue_name = queue_name or random_string(prefix='unit_tests_temp_queue_')
if fifo and self.queue_name.endswith('.fifo') is False:
self.queue_name += '.fifo'
def test_cluster(self):
result = self.ecs.cluster(cluster_arn=self.cluster_arn)
assert result.get('clusterName') == self.cluster_name
assert result.get('clusterArn') == self.cluster_arn
assert self.ecs.cluster(cluster_arn=self.cluster_arn +
random_string()) is None
def create_kwargs(self):
kwargs = {
'FunctionName': self.name or random_string(prefix='temp_lambda_'),
'MemorySize': self.memory,
'Role': self.role,
'Timeout': self.timeout,
'TracingConfig': {
'Mode': self.trace_mode
},
'Tags': self.tags
}
if self.env_variables:
kwargs['Environment'] = {'Variables': self.env_variables}
if self.image_uri:
kwargs['Code'] = {'ImageUri': self.image_uri}
kwargs['PackageType'] = "Image"
else:
kwargs['Code'] = {"S3Bucket": self.s3_bucket, "S3Key": self.s3_key}
kwargs['PackageType'] = "Zip"
kwargs['Runtime'] = self.runtime
kwargs['Handler'] = self.handler
if self.layers:
kwargs['Layers'] = self.layers
return kwargs
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 test_port_group_create__port_group_delete(self):
name = 'temp_port_group_' + random_string() # temp port_group to created
vswitch_name = 'vSwitch0' # default vswitch name
network = self.network.port_group_create(name, vswitch_name) # create port_group
assert network.name == name # confirm we received an object with the newly created network
assert name in self.network.networks_names() # confirm it exists
self.network.port_group_delete(name) # delete port_group
assert name not in self.network.networks_names() # confirm it has been deleted
def __init__(self,
queue_name=None,
queue_url=None,
fifo_message_group_id=False):
self.queue_name = queue_name
self.queue_url = queue_url
self.fifo_message_group_id = fifo_message_group_id or random_string(
prefix="message_group_id-")
def test_create(self):
temp_queue_name = random_string(
prefix='k8_unit_tests_another-temp_queue-')
queue_url = self.sqs.queue_create(queue_name=temp_queue_name)
assert queue_url == self.sqs.queue_url(queue_name=temp_queue_name)
assert self.sqs.queue_exists(queue_url=queue_url) is True
assert self.sqs.queue_delete(queue_url=queue_url) is True
def test_log_streams(self):
bad_log_group_name = random_string()
assert self.logs.log_streams(bad_log_group_name) == []
result = self.logs.log_streams(self.log_group_name)
assert len(result) == 1
assert result[0].get('arn') == self.logs.log_stream_arn(
self.log_group_name, self.log_stream_name)
assert result[0].get('logStreamName') == self.log_stream_name
def test_simple_execution(self, region, account_id):
event_data = {'answer': 42}
queue_name = random_string(prefix="osbot_unit_test")
with Temp_SQS_Queue(queue_name=queue_name) as queue:
assert queue_name == queue.queue_name
assert queue.exists() is True
assert queue.queue_url == f'https://{region}.queue.amazonaws.com/{account_id}/{queue.queue_name}'
assert queue.push(event_data).pop() == event_data
pprint(queue.info())
def test_contents_gz(self):
size = 1024
temp_text = random_string(size)
file = file_write(contents=temp_text)
gz_file = file_write_gz(contents=temp_text)
assert file_contents_gz(gz_file) == temp_text
assert file_size(file) == size
assert file_size(gz_file) < size
def test_log_stream_create(self):
# log stream created in test setUpClass
assert self.logs.log_stream(
self.log_group_name,
self.log_stream_name).get('logStreamName') == self.log_stream_name
# create a log stream with random names
random_log_group_name = random_string()
random_log_stream_name = random_string()
assert self.logs.log_stream_create(
random_log_group_name, random_log_stream_name
).get('message') == f'log stream created ok: {random_log_stream_name}'
assert self.logs.log_group_exists(random_log_group_name) is True
assert self.logs.log_stream_exists(random_log_group_name,
random_log_stream_name) is True
self.logs.log_group_delete(random_log_group_name)
assert self.logs.log_group_exists(random_log_group_name) is False
assert self.logs.log_stream_exists(random_log_group_name,
random_log_stream_name) is False
def test_s3_write_access(self):
temp_contents = random_string(length=1024)
temp_file_name = f"{random_string()}_temp_file.txt"
bucket = self.expected_s3_bucket
temp_s3_key = f'{self.expected_s3_prefix}/{temp_file_name}'
assert self.s3.file_exists(bucket=bucket, key=temp_s3_key) is False
self.s3.file_create_from_string(file_contents=temp_contents,
bucket=bucket,
key=temp_s3_key)
assert self.s3.file_delete(bucket=bucket, key=temp_s3_key) is True
assert self.s3.file_exists(bucket=bucket, key=temp_s3_key) is False
def __init__(self,
add_internet_gateway=False,
add_route_table=False,
add_security_group=False,
add_subnet=False):
self.add_internet_gateway = add_internet_gateway
self.add_route_table = add_route_table
self.add_security_group = add_security_group
self.add_subnet = add_subnet
self.vpc_name = random_string(prefix='osbot_aws-temp_vpc-')
self.tags = {'Name': self.vpc_name}
self.vpc = VPC(vpc_name=self.vpc_name, tags=self.tags)
def test_create_and_delete_ec2_instance(self):
image_id = AMI().amazon_linux_2()
name = random_string(prefix='test_ec2_with_ssh_support-')
tags = {'Name': f'osbot_aws - {name}'}
kwargs = { "image_id" : image_id ,
"name" : name ,
"tags" : tags }
instance_id = self.ec2.instance_create(**kwargs)
assert self.ec2.instance_details(instance_id=instance_id).get('state') == {'Code': 0, 'Name': 'pending'}
self.ec2.instance_delete(instance_id)
assert self.ec2.instance_details(instance_id=instance_id).get('state') == {'Code': 32, 'Name': 'shutting-down'}
def setUpClass(cls) -> None:
cls.events = Events()
cls.rule_name = random_string(prefix='osbot_temp_rule-')
cls.rule_event_source = 'temp_event_source' # 'aws.ec2' #
cls.rule_description = 'temp_description'
cls.rule_tags = {'Name': 'osbot_aws-test_test_rule_create'}
cls.events.rule_create(rule_name=cls.rule_name,
event_source=cls.rule_event_source,
description=cls.rule_description,
tags=cls.rule_tags)
assert cls.events.rule_exists(cls.rule_name) is True
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_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 test_target_create(self, account_id, region):
rule_name = self.rule_name
target_id = random_string()
target_arn = f'arn:aws:sqs:{region}:{account_id}:an-queue-name'
result_create = self.events.target_create(rule_name=rule_name,
target_id=target_id,
target_arn=target_arn)
assert result_create == {'FailedEntries': [], 'FailedEntryCount': 0}
assert (self.events.target_exists(rule_name, target_id))
assert target_arn in self.events.targets(rule_name=self.rule_name,
index_by='Arn')
result_delete = self.events.target_delete(rule_name=rule_name,
target_id=target_id)
assert result_delete == {'FailedEntries': [], 'FailedEntryCount': 0}
def policies_create(self,
policies,
project_name=None,
recreate_policy=False):
policies_arns = []
existing_policies = self.role_policies()
existing_policies_names = list(existing_policies.keys())
project_name = project_name or random_string()
for base_name, policy in policies.items():
policy_name = "{0}_{1}".format(base_name, project_name)
if policy_name in existing_policies_names:
existing_policy_arn = existing_policies[policy_name]
if recreate_policy:
self.policy_delete(existing_policy_arn)
else:
policies_arns.append(existing_policy_arn)
continue
result = self.policy_create(policy_name, policy)
policies_arns.append(result.get('policy_arn'))
return policies_arns
def test_get_file(self):
headless = True
file_size = 10 # goes up nicely to more that 1Mb
random_text = random_string(length=file_size)
with Temp_File(contents=random_text) as temp_file:
root_folder = temp_file.tmp_folder
file_to_download = temp_file.tmp_file
with Temp_Web_Server(root_folder=root_folder) as web_server:
with Temp_Browser(headless=headless) as browser:
browser.set_auto_close(False)
browser.open(web_server.url())
full_link = urljoin(web_server.url(), file_to_download)
page = browser.page()
wait_for_download = Wait_For_Download(page)
wait_for_download.sync_set_browser_download_folder()
wait_for_download.sync_trigger_download(full_link)
downloaded_file = wait_for_download.sync_get_file()
assert random_text == file_contents(downloaded_file)
def test_folder_zip(self):
folder = temp_folder_with_temp_file(file_contents=random_string())
print()
zip_file = folder_zip(folder)
assert file_exists(zip_file)
assert file_extension(zip_file) == '.zip'
unziped_folder = Files.unzip_file(zip_file)
source_files = folder_files(folder)
target_files = folder_files(unziped_folder)
assert len(source_files) == 1
assert len(target_files) == 1
assert source_files[0] != target_files[0]
assert file_contents(source_files[0]) == file_contents(target_files[0])
assert zip_file_list(zip_file) == ['temp_file.txt']
def test_exists(self):
assert file_exists(random_string()) == False
assert file_exists({}) == False
assert file_exists(None) == False
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_save_string_as_file(self):
data = random_string()
temp_file = save_string_as_file(data)
assert file_contents(temp_file) == data
def setUpClass(cls) -> None:
cls.queue_name = random_string(prefix='unit_tests_temp_queue-')
cls.queue = SQS_Queue(cls.queue_name)
cls.queue_url = cls.queue.create()
assert cls.queue.exists() is True
def test_def_random_string(self):
assert len(random_string()) == 8
assert len(random_string(length=12)) == 12
assert len(random_string(prefix="prefix_")) == 15
assert random_string(prefix="prefix_")[:7] == "prefix_"
def test_serialize_to_form(self):
random_value = random_string()
html = f'<form><input name="order" value="{random_value}">' \
'<input name="order2" value="baked beans"></form>'
py_query = Py_Query(html)
assert py_query.serialize_to_form() == f'order={random_value}&order2=baked%20beans'
def test_image_info(self):
assert self.api_docker.image_info(random_string()) is None
def test_image_exists(self):
assert self.api_docker.image_exists(random_string()) is False
