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