def test_provision_db_instance():
client = RDSClient()
db_instance = RDSDBInstance({})
db_instance.region = AWSAccount.get_aws_region()
db_instance.id = "instance-db-test-1"
db_instance.db_instance_class = "db.t3.medium"
db_instance.db_cluster_identifier = "cluster-db-test"
db_instance.db_subnet_group_name = "db_subnet-test"
db_instance.db_parameter_group_name = "param-group-test"
db_instance.engine = "aurora-mysql"
db_instance.engine_version = "5.7.mysql_aurora.2.09.2"
db_instance.preferred_maintenance_window = "sun:03:30-sun:04:00"
db_instance.storage_encrypted = True
db_instance.copy_tags_to_snapshot = True
db_instance.tags = [{
'Key': 'lvl',
'Value': "tst"
}, {
'Key': 'name',
'Value': db_instance.id
}]
client.provision_db_instance(db_instance)
assert db_instance.arn is not None
def test_get_certificate_by_tags():
client = ACMClient()
domain_name = "*.test.comp.com"
ret = client.get_certificate_by_tags(AWSAccount.get_aws_region(), {"name": domain_name.replace("*", "star")})
assert ret is not None
def test_provision_replication_group():
client = ElasticacheClient()
replication_group = ElasticacheReplicationGroup({})
replication_group.region = AWSAccount.get_aws_region()
replication_group.id = "horey-test-redis"
replication_group.az_mode = "cross-az"
replication_group.description = "horey-test-redis replication group"
replication_group.preferred_cache_cluster_azs = mock_values[
"elasticache.replication_group.preferred_cache_cluster_azs"]
replication_group.num_cache_clusters = 2
replication_group.cache_node_type = "cache.t3.micro"
replication_group.engine = "redis"
replication_group.engine_version = "6.x"
#replication_group.security_group_ids = [redis_security_group.id]
replication_group.cache_parameter_group_name = "default.redis6.x"
replication_group.cache_subnet_group_name = "subnet-group-horey-test"
replication_group.preferred_maintenance_window = "sat:01:30-sat:02:30"
replication_group.auto_minor_version_upgrade = True
replication_group.snapshot_retention_limit = 2
replication_group.snapshot_window = "02:31-03:32"
replication_group.tags = [{
'Key': 'lvl',
'Value': "tst"
}, {
'Key': 'name',
'Value': replication_group.id
}]
client.provision_replication_group(replication_group)
assert replication_group.arn is not None
def yield_log_events(self, log_group, stream):
"""
:param log_group:
:return:
"""
if AWSAccount.get_aws_region() != log_group.region:
AWSAccount.set_aws_region(log_group.region)
self.NEXT_PAGE_RESPONSE_KEY = "nextForwardToken"
token = None
for response in self.execute(self.client.get_log_events,
"events",
raw_data=True,
filters_req={
"logGroupName": log_group.name,
"logStreamName": stream.name
}):
token = response["nextForwardToken"]
yield response
#todo: refactor
for response in self.execute(self.client.get_log_events,
"events",
raw_data=True,
filters_req={
"logGroupName": log_group.name,
"logStreamName": stream.name,
"nextToken": token
}):
if token != response["nextForwardToken"]:
raise ValueError()
def test_dispose_db_cluster():
client = RDSClient()
cluster = RDSDBCluster({})
cluster.region = AWSAccount.get_aws_region()
cluster.skip_final_snapshot = True
cluster.id = "cluster-db-test"
client.dispose_db_cluster(cluster)
def get_connection_id():
"""
Each connection has a unique id- in order to reuse it. This function generates it.
:return:
"""
aws_account = AWSAccount.get_aws_account()
aws_region = AWSAccount.get_aws_region()
region_mark = aws_region.region_mark if aws_region is not None else ""
return f"{aws_account.id}/{region_mark}"
def get_region_amis(self, region, full_information=True, custom_filters=None):
AWSAccount.set_aws_region(region)
final_result = list()
for response in self.execute(self.client.describe_images, "Images", filters_req=custom_filters):
obj = AMI(response)
obj.region = AWSAccount.get_aws_region()
if full_information is True:
pass
final_result.append(obj)
return final_result
def test_provision_queue():
client = SQSClient()
sqs_queue = SQSQueue({})
sqs_queue.region = AWSAccount.get_aws_region()
sqs_queue.name = "sqs_queue_horey_test"
sqs_queue.visibility_timeout = "30"
sqs_queue.maximum_message_size = "262144"
sqs_queue.message_retention_period = "604800"
sqs_queue.delay_seconds = "0"
sqs_queue.tags = {'name': sqs_queue.name}
client.provision_queue(sqs_queue)
assert sqs_queue.queue_url is not None
def get_client(self, client_name):
"""
If client to a specific region does not exists- creates it.
:param client_name:
:return:
"""
aws_region = AWSAccount.get_aws_region()
region_mark = aws_region.region_mark if aws_region is not None else self.session.region_name
logger.info(f"region_mark: {region_mark} client: {client_name}")
if region_mark not in self.clients or client_name not in self.clients[
region_mark]:
self.connect_client(region_mark, client_name)
return self.clients[region_mark][client_name]
def yield_log_group_streams(self, log_group):
"""
Yields streams - made to handle large log groups, in order to prevent the OOM collapse.
:param log_group:
:return:
"""
if AWSAccount.get_aws_region() != log_group.region:
AWSAccount.set_aws_region(log_group.region)
for response in self.execute(
self.client.describe_log_streams,
"logStreams",
filters_req={"logGroupName": log_group.name}):
yield response
def test_provision_subnet_group():
client = ElasticacheClient()
subnet_group = ElasticacheCacheSubnetGroup({})
subnet_group.region = AWSAccount.get_aws_region()
subnet_group.name = "subnet-group-horey-test"
subnet_group.cache_subnet_group_description = "db subnet test"
subnet_group.subnet_ids = mock_values[
"elasticache.subnet_group.subnet_ids"]
subnet_group.tags = [{
'Key': 'lvl',
'Value': "tst"
}, {
'Key': 'name',
'Value': subnet_group.name
}]
client.provision_subnet_group(subnet_group)
assert subnet_group.arn is not None
def test_provision_subnet_group():
client = RDSClient()
subnet_group = RDSDBSubnetGroup({})
subnet_group.region = AWSAccount.get_aws_region()
subnet_group.name = "db_subnet-test"
subnet_group.db_subnet_group_description = "db subnet test"
subnet_group.subnet_ids = ["subnet-yy", "subnet-xx"]
subnet_group.tags = [{
'Key': 'lvl',
'Value': "tst"
}, {
'Key': 'name',
'Value': subnet_group.name
}]
client.provision_db_subnet_group(subnet_group)
assert subnet_group.arn is not None
def test_provision_db_cluster_parameter_group():
client = RDSClient()
db_cluster_parameter_group = RDSDBClusterParameterGroup({})
db_cluster_parameter_group.region = AWSAccount.get_aws_region()
db_cluster_parameter_group.name = "cluster-param-group-test"
db_cluster_parameter_group.db_parameter_group_family = "aurora-mysql5.7"
db_cluster_parameter_group.description = "test"
db_cluster_parameter_group.tags = [{
'Key': 'lvl',
'Value': "tst"
}, {
'Key': 'name',
'Value': db_cluster_parameter_group.name
}]
client.provision_db_cluster_parameter_group(db_cluster_parameter_group)
assert db_cluster_parameter_group.arn is not None
def test_provision_cluster_from_snapshot():
client = RDSClient()
cluster = RDSDBCluster({})
cluster.region = AWSAccount.get_aws_region()
cluster.db_subnet_group_name = "db_subnet-test"
cluster.db_cluster_parameter_group_name = "cluster-param-group-test"
cluster.backup_retention_period = 35
cluster.database_name = "db_test"
cluster.id = "cluster-db-test"
cluster.vpc_security_group_ids = [
mock_values["cluster.vpc_security_group_ids"]
]
cluster.engine = "aurora-mysql"
cluster.engine_version = "5.7.mysql_aurora.2.09.2"
cluster.port = 3306
cluster.master_username = "******"
cluster.master_user_password = "******"
cluster.preferred_backup_window = "09:23-09:53"
cluster.preferred_maintenance_window = "sun:03:30-sun:04:00"
cluster.storage_encrypted = True
#cluster.kms_key_id = True
cluster.engine_mode = "provisioned"
cluster.deletion_protection = False
cluster.copy_tags_to_snapshot = True
cluster.enable_cloudwatch_logs_exports = [
"audit", "error", "general", "slowquery"
]
cluster.tags = [{
'Key': 'lvl',
'Value': "tst"
}, {
'Key': 'name',
'Value': cluster.id
}]
client.provision_db_cluster(cluster, snapshot_id="horey-test-snapshot-id")
assert cluster.arn is not None
def get_cloud_watch_alarms(self):
"""
Get all alarms in all regions.
:return:
"""
final_result = list()
for region in AWSAccount.get_aws_account().regions.values():
AWSAccount.set_aws_region(region)
for dict_src in self.execute(self.client.describe_alarms,
None,
raw_data=True):
if len(dict_src["CompositeAlarms"]) != 0:
raise NotImplementedError("CompositeAlarms")
for dict_alarm in dict_src["MetricAlarms"]:
alarm = CloudWatchAlarm(dict_alarm)
alarm.region = AWSAccount.get_aws_region()
final_result.append(alarm)
return final_result
def get_cloud_watch_log_group_metric_filters(self, full_information=False):
"""
Be sure you know what you do, when you set full_information=True.
This can kill your memory, if you have a lot of data in cloudwatch.
Better using yield_log_group_streams if you need.
:param full_information:
:return:
"""
final_result = list()
for region in AWSAccount.get_aws_account().regions.values():
AWSAccount.set_aws_region(region)
for result in self.execute(self.client.describe_metric_filters,
"metricFilters"):
obj = CloudWatchLogGroupMetricFilter(result)
if full_information:
self.update_log_group_full_information(obj)
obj.region = AWSAccount.get_aws_region()
final_result.append(obj)
return final_result
def test_provision_certificate():
client = ACMClient()
cert = ACMCertificate({})
cert.region = AWSAccount.get_aws_region()
cert.domain_name = "*.test.comp.com"
cert.tags = [
{
'Key': 'lvl',
'Value': "tst"
}, {
'Key': 'name',
'Value': cert.domain_name.replace("*", "star")
}
]
cert.validation_method = "DNS"
ret = client.provision_certificate(cert)
pdb.set_trace()
assert cert.arn is not None
def test_provision_launch_template():
ec2_client = EC2Client()
iam_instance_profile = Mock()
iam_instance_profile.arn = mock_values["iam_instance_profile.arn"]
security_group = Mock()
security_group.id = mock_values["security_group.id"]
ami = Mock()
ami.id = mock_values["ami.id"]
subnet = Mock()
subnet.id = mock_values["subnet.id"]
ssh_key_pair = Mock()
ssh_key_pair.name = mock_values["ssh_key_pair.name"]
user_data = ec2_client.generate_user_data_from_file(
"ecs_container_instance_user_data.sh")
#filter_request = dict()
# filter_request["Filters"] = [{'Name': 'name',
# 'Values': [
# "amzn2-ami-ecs-hvm-2.0.20201209-x86_64-ebs",
# ]}]
# ami = self.aws_api.ec2_client.get_region_amis(self.configuration.region, custom_filters=filter_request)[0]
launch_template = EC2LaunchTemplate({})
launch_template.name = "test_launch_template_name"
launch_template.tags = [{'Key': 'lvl', 'Value': "tst"}]
launch_template.region = AWSAccount.get_aws_region()
launch_template.tags.append({'Key': 'Name', 'Value': launch_template.name})
launch_template.launch_template_data = {
"EbsOptimized":
False,
"IamInstanceProfile": {
"Arn": iam_instance_profile.arn
},
"BlockDeviceMappings": [{
"DeviceName": "/dev/xvda",
"Ebs": {
"VolumeSize": 40,
"VolumeType": "gp2"
}
}],
'NetworkInterfaces': [
{
'AssociatePublicIpAddress': True,
'DeleteOnTermination': True,
'DeviceIndex': 0,
'Groups': [
security_group.id,
],
'SubnetId': subnet.id,
},
],
"ImageId":
ami.id,
"InstanceType":
"c5.large",
"KeyName":
ssh_key_pair.name,
"Monitoring": {
"Enabled": False
},
"UserData":
user_data
}
ec2_client.provision_launch_template(launch_template)
assert launch_template.id is not None
