def test_copy_default_key_encrypted_snapshot_same_region(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
self.logger.test("Creating source snapshot")
source_snapshot_encrypted_default = self.ec2.create_snapshot(
self.volume_encrypted_default,
tags={
"Name": "Ec2CopySnapshot_{}".format(test_method),
tasklist_tagname(TESTED_ACTION): test_method
},
description="Snapshot for testing Ec2CopySnapshot : {}".format(
test_method))
self.snapshots.append(source_snapshot_encrypted_default["SnapshotId"])
parameters = {copy_snapshot.PARAM_DESTINATION_REGION: region()}
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=10)
self.assertTrue(self.task_runner.success(),
"Task executed successfully")
snapshot_copy_id = self.task_runner.results[0].result[
"copy-snapshot-id"]
self.snapshots.append(snapshot_copy_id)
self.logger.test("[X] Task completed")
self.logger.test("Checking snapshot copy")
snapshot_copy = self.ec2.get_snapshot(snapshot_copy_id)
self.assertIsNotNone(snapshot_copy, "Snapshot created")
def test_delete_by_retention_days_all_deleted(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
snapshot = self.ec2.create_snapshot(self.volume_id, tags={
tasklist_tagname(TESTED_ACTION): test_method
}, wait_to_complete=300)
assert (snapshot is not None)
self.created_snapshots.append(snapshot["SnapshotId"])
try:
parameters = {
delete_snapshot_action.PARAM_RETENTION_COUNT: 0,
delete_snapshot_action.PARAM_RETENTION_DAYS: 2
}
test_method = inspect.stack()[0][3]
self.logger.test("Running task at simulated date +3 days")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=30,
datetime_delta=timedelta(days=3))
self.assertTrue(self.task_runner.success(expected_executed_tasks=1), "Task executed successfully")
self.logger.test("[X] Task completed")
self.assertEqual(1, getattr(self.task_runner.results[0], "result", {}).get("snapshots-deleted"),
"Snapshot is deleted")
self.assertIsNone(self.ec2.get_snapshot(snapshot["SnapshotId"]), "Snapshot no longer exists")
self.logger.test("[X] Snapshot deleted")
finally:
self.delete_volume_snapshots()
def test_snapshot_not_longer_available(self):
def delete_snapshot_after_select(tracker):
for item in tracker.task_items:
self.ec2.delete_snapshots(snapshot_ids=[item.get(handlers.TASK_TR_RESOURCES, {}).get("SnapshotId")])
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
self.logger.test("Creating source snapshot")
source_snapshot = self.ec2.create_snapshot(self.volume_unencrypted, tags={
"Name": "Ec2CopySnapshot_{}".format(test_method),
tasklist_tagname(TESTED_ACTION): test_method
}, description="Snapshot for testing Ec2CopySnapshot : {}".format(test_method))
assert (source_snapshot is not None)
self.snapshots.append(source_snapshot["SnapshotId"])
parameters = {
copy_snapshot.PARAM_DESTINATION_REGION: region(),
}
self.logger.test("Running task to copy snapshot")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=10, run_after_select=delete_snapshot_after_select)
self.logger.test("[X] Task completed")
self.assertEqual(1, len(self.task_runner.results), "Snapshot not longer available")
self.logger.test("[X] Snapshot was not longer available")
def test_copy_unencrypted_snapshot_other_region(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
destination_ec2 = Ec2(region=remote_region())
remote_snapshot_copy_id = None
try:
self.logger.test("Creating source snapshot")
source_snapshot_unencrypted = self.ec2.create_snapshot(self.volume_unencrypted, tags={
"Name": "Ec2CopySnapshot_{}".format(test_method),
"copied-tag": "copied-value",
"not-copied-tag": "not-copied-value",
tasklist_tagname(TESTED_ACTION): test_method
}, description="Snapshot for testing Ec2CopySnapshot : {}".format(test_method))
self.snapshots.append(source_snapshot_unencrypted["SnapshotId"])
parameters = {
copy_snapshot.PARAM_DESTINATION_REGION: remote_region(),
copy_snapshot.PARAM_ACCOUNTS_VOLUME_CREATE_PERMISSIONS: ["123456789012"],
copy_snapshot.PARAM_COPIED_SNAPSHOT_TAGS: "copied-tag",
copy_snapshot.PARAM_SNAPSHOT_DESCRIPTION: "{{{}}}".format(copy_snapshot.TAG_PLACEHOLDER_SOURCE_DESCRIPTION),
copy_snapshot.PARAM_SNAPSHOT_TAGS: testing.tags.common_placeholder_tags(
test_delete=False,
placeholders=[
copy_snapshot.TAG_PLACEHOLDER_SOURCE_REGION,
copy_snapshot.TAG_PLACEHOLDER_SOURCE_SNAPSHOT_ID,
copy_snapshot.TAG_PLACEHOLDER_SOURCE_VOLUME,
copy_snapshot.TAG_PLACEHOLDER_OWNER_ACCOUNT]),
copy_snapshot.PARAM_SOURCE_TAGS: testing.tags.common_placeholder_tags([
copy_snapshot.TAG_PLACEHOLDER_COPIED_SNAPSHOT_ID,
copy_snapshot.TAG_PLACEHOLDER_COPIED_REGION
])
}
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=10)
self.assertTrue(self.task_runner.success(), "Task executed successfully")
remote_snapshot_copy_id = self.task_runner.results[0].result["copy-snapshot-id"]
self.logger.test("[X] Task completed")
self.logger.test("Checking snapshot copy")
snapshot_copy = destination_ec2.get_snapshot(remote_snapshot_copy_id)
self.assertIsNotNone(snapshot_copy, "Snapshot created in destination region")
self.check_copy_snapshot(remote_snapshot_copy_id, source_snapshot_unencrypted, remote_region())
self.check_source_snapshot(source_snapshot_unencrypted["SnapshotId"],
remote_snapshot_copy_id, test_method,
remote_region())
finally:
if remote_snapshot_copy_id is not None:
destination_ec2.delete_snapshots([remote_snapshot_copy_id])
def test_snapshot_only_copied_once(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
self.logger.test("Creating source snapshot")
source_snapshot = self.ec2.create_snapshot(self.volume_unencrypted, tags={
"Name": "Ec2CopySnapshot_{}".format(test_method),
tasklist_tagname(TESTED_ACTION): test_method
}, description="Snapshot for testing Ec2CopySnapshot : {}".format(test_method))
assert (source_snapshot is not None)
self.snapshots.append(source_snapshot["SnapshotId"])
parameters = {
copy_snapshot.PARAM_DESTINATION_REGION: region(),
}
self.logger.test("Running task to copy snapshot")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=10)
self.assertTrue(self.task_runner.success(), "Task executed successfully")
snapshot_copy_id = self.task_runner.results[0].result["copy-snapshot-id"]
self.snapshots.append(snapshot_copy_id)
self.logger.test("Running task again")
self.task_runner.run(parameters, task_name=test_method, complete_check_polling_interval=10)
self.logger.test("[X] Task completed")
self.assertEqual(0, len(self.task_runner.results), "Snapshot already copied")
self.logger.test("[X] Snapshot was not copied for second time")
def test_copy_snapshot_description(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
self.logger.test("Creating source snapshot")
source_snapshot = self.ec2.create_snapshot(self.volume_unencrypted,
tags={
"Name": "Ec2CopySnapshot_{}".format(test_method),
tasklist_tagname(TESTED_ACTION): test_method
}, description="Snapshot for testing Ec2CopySnapshot : {}".format(test_method))
self.snapshots.append(source_snapshot["SnapshotId"])
parameters = {
copy_snapshot.PARAM_DESTINATION_REGION: region(),
copy_snapshot.PARAM_COPIED_SNAPSHOTS: copy_snapshot.COPIED_OWNED_BY_ACCOUNT,
copy_snapshot.PARAM_DELETE_AFTER_COPY: False,
copy_snapshot.PARAM_ENCRYPTED: False
}
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=10)
self.assertTrue(self.task_runner.success(), "Task executed successfully")
snapshot_copy_id = self.task_runner.results[0].result["copy-snapshot-id"]
self.snapshots.append(snapshot_copy_id)
self.logger.test("[X] Task completed")
copied_snapshot = self.ec2.get_snapshot(snapshot_copy_id)
self.assertEqual(source_snapshot.get("Description"), copied_snapshot.get("Description"), "Description copied as default")
self.logger.test("[X]Source description copied")
def test_delete_by_retention_count_all_retained(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
self.logger.test("Creating (source) snapshot")
snapshot = self.ec2.create_snapshot(self.volume_id, tags={
tasklist_tagname(TESTED_ACTION): test_method
}, wait_to_complete=300)
assert (snapshot is not None)
self.created_snapshots.append(snapshot["SnapshotId"])
try:
parameters = {
delete_snapshot_action.PARAM_RETENTION_COUNT: 1,
delete_snapshot_action.PARAM_RETENTION_DAYS: 0
}
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method)
self.assertTrue(self.task_runner.success(expected_executed_tasks=1), "Task executed successfully")
self.logger.test("[X] Task completed")
self.logger.test("Checking retained snapshot")
self.assertEqual(0, getattr(self.task_runner.results[0], "result", {}).get("snapshots-deleted"),
"Snapshot is not deleted")
self.assertIsNotNone(self.ec2.get_snapshot(snapshot["SnapshotId"]), "Snapshot still exists")
self.logger.test("[X] Snapshot is retained")
finally:
self.delete_volume_snapshots()
def test_copy_snapshot_encrypted_with_default_key(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
snapshot_unencrypted = self.ec2.create_snapshot(self.volume_unencrypted, tags={
"Name": "Ec2CopySnapshot_{}".format(test_method),
tasklist_tagname(TESTED_ACTION): test_method
}, description="Snapshot for testing Ec2CopySnapshot : {}".format(test_method))
assert (snapshot_unencrypted is not None)
self.snapshots.append(snapshot_unencrypted["SnapshotId"])
parameters = {
copy_snapshot.PARAM_DESTINATION_REGION: region(),
copy_snapshot.PARAM_ENCRYPTED: True
}
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=10)
self.assertTrue(self.task_runner.success(), "Task executed successfully")
snapshot_copy_id = self.task_runner.results[0].result["copy-snapshot-id"]
self.snapshots.append(snapshot_copy_id)
self.logger.test("[X] Task completed")
self.logger.test("Checking snapshot copy")
snapshot_copy = self.ec2.get_snapshot(snapshot_copy_id)
self.assertIsNotNone(snapshot_copy, "Snapshot created")
self.assertTrue(snapshot_copy["Encrypted"], "Snapshot is encrypted")
self.assertEqual(snapshot_copy["KmsKeyId"], self.ec2.ebs_default_key_arn, "Default EBS encryption key is used")
self.logger.test("[X] Snapshot created and encrypted")
def test_delete_by_retention_count_with_copied_snapshot(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
self.logger.test("Creating (source) snapshot")
snapshot_source = self.ec2.create_snapshot(self.volume_id, tags={
tasklist_tagname(TESTED_ACTION): test_method
}, wait_to_complete=300)
assert (snapshot_source is not None)
self.created_snapshots.append(snapshot_source["SnapshotId"])
self.logger.test("Copying snapshot")
snapshot_copy = self.ec2.copy_snapshot(snapshot_id=snapshot_source["SnapshotId"], destination_region=region(), tags={
tasklist_tagname(TESTED_ACTION): test_method
})
assert (snapshot_copy is not None)
self.created_snapshots.append(snapshot_copy["SnapshotId"])
set_snapshot_sources_tags(snapshot_id=snapshot_copy["SnapshotId"], source_volume_id=self.volume_id,
source_snapshot_id=snapshot_source["SnapshotId"])
try:
parameters = {
delete_snapshot_action.PARAM_RETENTION_COUNT: 1,
delete_snapshot_action.PARAM_RETENTION_DAYS: 0
}
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method)
self.assertTrue(self.task_runner.success(expected_executed_tasks=1), "Task executed successfully")
self.logger.test("[X] Task completed")
self.deleted_snapshots = getattr(self.task_runner.results[0], "result", {})["deleted"][region()]
self.logger.test("Checking deleted snapshot")
self.assertEqual(1, len(self.deleted_snapshots), "Deleted single snapshot")
self.assertEqual(self.deleted_snapshots[0], snapshot_source["SnapshotId"], "Oldest (source) snapshot deleted")
self.logger.test("[X] Source snapshot deleted ")
remaining_snapshot = self.ec2.get_snapshot(snapshot_copy["SnapshotId"])
self.assertIsNotNone(remaining_snapshot, "Copied snapshot still exists")
self.logger.test("[X] Copied snapshot still exists")
finally:
self.delete_volume_snapshots()
def create_replaced_instance():
def register_to_load_balancers():
self.elb.register_instance(load_balancer_name=self.v1_elb_name, instance_id=self.replaced_instance_id)
self.elbv2.register_instance(target_group_arn=self.v2_target_group_arn, instance_id=self.replaced_instance_id)
def tag_instance_volumes():
volumes = list(self.ec2.get_instance_volumes(self.replaced_instance_id))
if same_volume_tags:
volume_ids = [v["VolumeId"] for v in volumes]
vol_tags = {"Tag": TESTED_ACTION}
self.ec2.ec2_client.create_tags(Resources=volume_ids, Tags=tag_key_value_list(vol_tags))
self.tags_on_replaced_instance = {v["Attachments"][0]["Device"]: vol_tags for v in volumes}
else:
self.tags_on_replaced_instance = {}
for v in volumes:
dev = v["Attachments"][0]["Device"]
vol_tags = {"Tag": dev}
self.ec2.ec2_client.create_tags(Resources=[v["VolumeId"]], Tags=tag_key_value_list(vol_tags))
self.tags_on_replaced_instance[dev] = vol_tags
ami = self.get_multi_volume_ami() if multiple_volumes else self.ami_single_volume
self.logger.test("Start creating replaced instance from AMI {}", ami)
if replaced_type is not None:
self.start_type = replaced_type
else:
self.start_type = TEST_INSTANCE_TYPES[0 if mode == replace_instance.REPLACE_BY_SPECIFIED_TYPE else 1]
instance_tags = {
"Name": test_method,
tasklist_tagname(TESTED_ACTION): test_method
}
if tags is not None:
instance_tags.update(tags)
self.replaced_instance = self.ec2.create_instance(self.start_type,
image_id=ami,
key_pair=self.key_pair,
role_name=self.instance_profile,
tags=instance_tags)
self.replaced_instance_id = self.replaced_instance["InstanceId"]
self.logger.test("Created instance {}", self.replaced_instance_id)
tag_instance_volumes()
self.new_instance_id = None
if load_balancing:
self.logger.test("Registering instance to load balancer(s)")
register_to_load_balancers()
if stopped_instance:
self.ec2.stop_instance(self.replaced_instance_id)
def test_copy_snapshot_encrypt_with_custom_key_other_region(self):
destination_ec2 = Ec2(region=remote_region())
self.logger.test("Creating stack in destination region with custom encryption key")
remote_stack = get_resource_stack(TESTED_ACTION, create_resource_stack_func=self.create_remote_resource_stack,
use_existing=KEEP_AND_USE_EXISTING_RESOURCES_STACK, region_name=remote_region())
remote_snapshot_copy_id = None
try:
remote_custom_key_arn = remote_stack.stack_outputs["EncryptionKeyArn"]
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
self.logger.test("Creating source snapshot")
source_snapshot_unencrypted = self.ec2.create_snapshot(self.volume_unencrypted, tags={
"Name": "Ec2CopySnapshot_{}".format(test_method),
tasklist_tagname(TESTED_ACTION): test_method
}, description="Snapshot for testing Ec2CopySnapshot : {}".format(test_method))
assert (source_snapshot_unencrypted is not None)
self.snapshots.append(source_snapshot_unencrypted["SnapshotId"])
parameters = {
copy_snapshot.PARAM_DESTINATION_REGION: remote_region(),
copy_snapshot.PARAM_ENCRYPTED: True,
copy_snapshot.PARAM_KMS_KEY_ID: remote_custom_key_arn
}
self.snapshots.append(source_snapshot_unencrypted["SnapshotId"])
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=10)
self.assertTrue(self.task_runner.success(), "Task executed successfully")
remote_snapshot_copy_id = self.task_runner.results[0].result["copy-snapshot-id"]
self.logger.test("[X] Task completed")
self.logger.test("Checking snapshot copy")
snapshot_copy = destination_ec2.get_snapshot(remote_snapshot_copy_id)
self.assertIsNotNone(snapshot_copy, "Snapshot created in destination region")
self.assertTrue(snapshot_copy["Encrypted"], "Snapshot is encrypted")
self.assertEqual(snapshot_copy["KmsKeyId"], remote_custom_key_arn, "Custom encryption key is used")
self.logger.test("[X] Snapshot created and encrypted")
finally:
if not KEEP_AND_USE_EXISTING_RESOURCES_STACK and remote_stack is not None:
remote_stack.delete_stack(600)
if remote_snapshot_copy_id is not None:
destination_ec2.delete_snapshots([remote_snapshot_copy_id])
def test_copy_unencrypted_snapshot_same_region(self):
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
self.logger.test("Creating source snapshot")
source_snapshot_unencrypted = self.ec2.create_snapshot(self.volume_unencrypted, tags={
"copied-tag": "copied-value",
"not-copied-tag": "not-copied-value",
"Name": "Ec2CopySnapshot_{}".format(test_method),
tasklist_tagname(TESTED_ACTION): test_method
}, description="Snapshot for testing Ec2CopySnapshot : {}".format(test_method))
self.snapshots.append(source_snapshot_unencrypted["SnapshotId"])
testing.tags.set_ec2_tag_to_delete(self.ec2, [source_snapshot_unencrypted["SnapshotId"]])
parameters = {
copy_snapshot.PARAM_DESTINATION_REGION: region(),
copy_snapshot.PARAM_ACCOUNTS_VOLUME_CREATE_PERMISSIONS: ["123456789012"],
copy_snapshot.PARAM_COPIED_SNAPSHOT_TAGS: "copied-tag",
copy_snapshot.PARAM_SNAPSHOT_DESCRIPTION: "{{{}}}".format(copy_snapshot.TAG_PLACEHOLDER_SOURCE_DESCRIPTION),
copy_snapshot.PARAM_SNAPSHOT_TAGS: testing.tags.common_placeholder_tags(
test_delete=False,
placeholders=[
copy_snapshot.TAG_PLACEHOLDER_SOURCE_REGION,
copy_snapshot.TAG_PLACEHOLDER_SOURCE_SNAPSHOT_ID,
copy_snapshot.TAG_PLACEHOLDER_SOURCE_VOLUME,
copy_snapshot.TAG_PLACEHOLDER_OWNER_ACCOUNT]),
copy_snapshot.PARAM_SOURCE_TAGS: testing.tags.common_placeholder_tags([
copy_snapshot.TAG_PLACEHOLDER_COPIED_SNAPSHOT_ID,
copy_snapshot.TAG_PLACEHOLDER_COPIED_REGION
]),
copy_snapshot.PARAM_COPIED_SNAPSHOTS: copy_snapshot.COPIED_OWNED_BY_ACCOUNT,
copy_snapshot.PARAM_DELETE_AFTER_COPY: False,
copy_snapshot.PARAM_ENCRYPTED: False
}
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=10)
self.assertTrue(self.task_runner.success(), "Task executed successfully")
snapshot_copy_id = self.task_runner.results[0].result["copy-snapshot-id"]
self.snapshots.append(snapshot_copy_id)
self.logger.test("[X] Task completed")
self.check_copy_snapshot(snapshot_copy_id, source_snapshot_unencrypted, region())
self.check_source_snapshot(source_snapshot_unencrypted["SnapshotId"], snapshot_copy_id, test_method, region())
assert (self.task_runner.max_concurrency == 5)
assert (self.task_runner.concurrency_key == "ec2:CopySnapshot:{}:{}".format(self.task_runner.tested_account,
self.task_runner.tested_region))
def create_resource_stack(cls, resource_stack_name):
try:
cls.logger.test("Creating test resources stack {}", resource_stack_name)
ami = Ec2(region()).latest_aws_linux_image["ImageId"]
resource_stack = Stack(resource_stack_name, region=region())
resource_stack.create_stack(template_file=template_path(__file__, TEST_RESOURCES_TEMPLATE), iam_capability=True,
params={
"InstanceAmi": ami,
"InstanceType": "t2.micro",
"TaskListTagName": tasklist_tagname(TESTED_ACTION),
"TaskListTagValue": ",".join(cls.get_methods())
})
return resource_stack
except Exception as ex:
cls.logger.test("Error creating stack {}, {}", resource_stack_name, ex)
return None
def test_delete_by_retention_count(self):
snapshots_to_create = 4
snapshots_to_keep = 2
test_method = inspect.stack()[0][3]
self.cleanup_leftover_source_snapshots(test_method)
for i in range(0, snapshots_to_create):
snapshot = self.ec2.create_snapshot(self.volume_id, tags={
tasklist_tagname(TESTED_ACTION): test_method
}, wait_to_complete=300)
assert (snapshot is not None)
self.created_snapshots.append(snapshot["SnapshotId"])
try:
parameters = {
delete_snapshot_action.PARAM_RETENTION_COUNT: snapshots_to_keep,
delete_snapshot_action.PARAM_RETENTION_DAYS: 0
}
test_method = inspect.stack()[0][3]
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method, debug=False)
self.assertTrue(self.task_runner.success(expected_executed_tasks=1), "Task executed successfully")
self.logger.test("[X] Task completed")
self.deleted_snapshots = getattr(self.task_runner.results[0], "result", {})["deleted"][region()]
self.assertEqual(sorted(self.created_snapshots[0:snapshots_to_create - snapshots_to_keep]),
sorted(self.deleted_snapshots), "Expected snapshots deleted")
self.logger.test("[X] {} oldest snapshots deleted out of {}", len(self.deleted_snapshots), len(self.created_snapshots))
remaining_snapshots = [s["SnapshotId"] for s in self.ec2.get_snapshots_for_volume(volume_id=self.volume_id)]
self.assertEqual(sorted(self.created_snapshots[snapshots_to_create - snapshots_to_keep:]),
sorted(remaining_snapshots), "Expected snapshots retained")
self.logger.test("[X] {} latest snapshots retained out of {}", len(remaining_snapshots), len(self.created_snapshots))
finally:
self.delete_volume_snapshots()
def create_resource_stack(cls, resource_stack_name):
try:
cls.logger.test("Creating test resources stack {}",
resource_stack_name)
resource_stack = Stack(resource_stack_name, region=region())
resource_stack.create_stack(template_file=template_path(
__file__, TEST_RESOURCES_TEMPLATE),
iam_capability=False,
params={
"IndexName":
INDEX_NAME,
"TaskListTagName":
tasklist_tagname(TESTED_ACTION),
"TaskListTagValue":
"/".join(cls.get_methods())
})
return resource_stack
except Exception as ex:
cls.logger.test("Error creating stack {}, {}", resource_stack_name,
ex)
return None
def cleanup_leftover_source_snapshots(self, test_method):
self.ec2.delete_snapshots_by_tags(tag_filter_expression="{}={}".format(tasklist_tagname(TESTED_ACTION), test_method))
def do_test_resize(self,
test_method,
resize_mode,
start_type,
expected_type,
resized_types=None,
scaling_range=None,
unavailable_types=None,
tags=None,
assumed_type=None,
try_next_in_range=None,
running=True):
if not running:
self.ec2.stop_instance(self.instance_id)
self.reset_instance_type(start_type)
if running:
time.sleep(10)
self.ec2.start_instance(self.instance_id)
org_size = self.ec2.get_instance(instance_id=self.instance_id)["InstanceType"]
try:
instance_tags = {tasklist_tagname(TESTED_ACTION): test_method}
if tags:
instance_tags.update(tags)
self.ec2.create_tags(self.instance_id, tags=instance_tags)
parameters = {
r.PARAM_RESIZED_INSTANCE_TAGS: testing.tags.common_placeholder_tags(placeholders=[
r.TAG_PLACEHOLDER_NEW_INSTANCE_TYPE,
r.TAG_PLACEHOLDER_ORG_INSTANCE_TYPE]),
r.PARAM_RESIZE_MODE: resize_mode
}
if resize_mode == r.RESIZE_BY_SPECIFIED_TYPE:
parameters[r.PARAM_INSTANCE_TYPES] = resized_types
else:
parameters[r.PARAM_SCALING_RANGE] = scaling_range
parameters[r.PARAM_TAGFILTER_SCALE_UP] = "scaling=up"
parameters[r.PARAM_TAGFILTER_SCALE_DOWN] = "scaling=down"
if assumed_type is not None:
parameters[r.PARAM_ASSUMED_TYPE] = assumed_type
parameters[r.PARAM_TRY_NEXT_IN_RANGE] = try_next_in_range
if unavailable_types is not None:
parameters[r.PARAM_TEST_UNAVAILABLE_TYPES] = unavailable_types if isinstance(unavailable_types, list) else [
unavailable_types]
events = {
handlers.ec2_tag_event_handler.EC2_TAG_EVENT_SOURCE: {
handlers.TAG_CHANGE_EVENT: [
handlers.ec2_tag_event_handler.EC2_CHANGED_INSTANCE_TAGS_EVENT
]
}
}
self.logger.test("Running task")
self.task_runner.run(parameters,
task_name=test_method,
complete_check_polling_interval=15,
events=events)
self.assertTrue(self.task_runner.success(expected_executed_tasks=1), "Task executed successfully")
self.logger.test("[X] Task completed")
# test instance type here
instance = self.ec2.get_instance(self.instance_id)
new_type = instance["InstanceType"]
self.assertEqual(expected_type, new_type, "Expected instance type")
self.assertTrue(self.ec2.get_instance_status(self.instance_id) == "running" if running else "stopped", "Instance state")
self.assertEqual(expected_type, new_type, "Expected instance state")
instance_tags = self.ec2.get_instance_tags(self.instance_id)
if not self.task_runner.executed_tasks[0].ActionResult.get("not-resized", False):
self.assertTrue(testing.tags.verify_placeholder_tags(instance_tags,
action_placeholders={
r.TAG_PLACEHOLDER_NEW_INSTANCE_TYPE: new_type,
r.TAG_PLACEHOLDER_ORG_INSTANCE_TYPE: org_size
}),
"All placeholder tags set on resized instance")
self.logger.test("[X] Instance placeholder tags created")
if resize_mode == r.RESIZE_BY_STEP:
self.assertFalse("scaling" in instance_tags, 'Scaling tags removed')
self.logger.test("[X] Scaling filter tags removed")
finally:
self.restore_tags()
