def test_cleanup_soft_deletes_transport_keys(self):
"""Test Cleaning up soft deleted transport keys"""
# create transport key
transport_key = _setup_entry('transport_key')
# delete transport key
transport_key.delete()
clean.cleanup_all()
self.assertFalse(_entry_exists(transport_key))
def test_cleanup_soft_deletes_transport_keys(self):
"""Test Cleaning up soft deleted transport keys"""
# create transport key
transport_key = _setup_entry('transport_key')
# delete transport key
transport_key.delete()
clean.cleanup_all()
self.assertFalse(_entry_exists(transport_key))
def test_cleaning_unassociated_projects(self):
"""Test cleaning projects that have no child entries"""
childless_project = _setup_entry('project',
external_id="childless project")
project_with_children = _setup_entry(
'project',
external_id="project with children")
project_children_list = list()
project_children_list.append(
_setup_entry('kek_datum', project=project_with_children))
project_children_list.append(
_setup_entry('secret', project=project_with_children))
container = _setup_entry('container', project=project_with_children)
project_children_list.append(container)
project_children_list.append(
_setup_entry('container_consumer_meta', container=container))
cert_authority = _setup_entry('certificate_authority',
project=project_with_children)
project_children_list.append(cert_authority)
project_children_list.append(
_setup_entry('preferred_cert_authority',
cert_authority=cert_authority))
project_children_list.append(
_setup_entry('project_cert_authority',
certificate_authority=cert_authority))
project_children_list.append(_setup_entry('project_quotas',
project=project_with_children))
clean.cleanup_unassociated_projects()
self.assertTrue(_entry_exists(project_with_children))
self.assertFalse(_entry_exists(childless_project))
container.delete()
for child in project_children_list:
child.delete()
clean.cleanup_all()
clean.cleanup_unassociated_projects()
self.assertFalse(_entry_exists(project_with_children))
def test_cleanup_soft_deletes_secrets(self, project):
"""Test cleaning up secrets and secret_meta"""
# create secret and secret_meta
secret = _setup_entry('secret', project=project)
secret_metadatum = _setup_entry('secret_metadatum', secret=secret)
secret_user_metadatum = _setup_entry('secret_user_metadatum',
secret=secret)
kek_datum = _setup_entry('kek_datum', project=project)
enc_datum = _setup_entry('encrypted_datum', secret=secret,
kek_datum=kek_datum)
# delete secret, it should automatically delete
# secret_metadatum, enc_datum, and secret_user_metadatum
# kek_datum should still exist
secret.delete()
clean.cleanup_all()
self.assertFalse(_entry_exists(secret))
self.assertFalse(_entry_exists(secret_metadatum))
self.assertFalse(_entry_exists(secret_user_metadatum))
self.assertFalse(_entry_exists(enc_datum))
self.assertTrue(_entry_exists(kek_datum))
def test_cleaning_unassociated_projects(self):
"""Test cleaning projects that have no child entries"""
childless_project = _setup_entry('project',
external_id="childless project")
project_with_children = _setup_entry(
'project', external_id="project with children")
project_children_list = list()
project_children_list.append(
_setup_entry('kek_datum', project=project_with_children))
project_children_list.append(
_setup_entry('secret', project=project_with_children))
container = _setup_entry('container', project=project_with_children)
project_children_list.append(container)
project_children_list.append(
_setup_entry('container_consumer_meta', container=container))
cert_authority = _setup_entry('certificate_authority',
project=project_with_children)
project_children_list.append(cert_authority)
project_children_list.append(
_setup_entry('preferred_cert_authority',
cert_authority=cert_authority))
project_children_list.append(
_setup_entry('project_cert_authority',
certificate_authority=cert_authority))
project_children_list.append(
_setup_entry('project_quotas', project=project_with_children))
clean.cleanup_unassociated_projects()
self.assertTrue(_entry_exists(project_with_children))
self.assertFalse(_entry_exists(childless_project))
container.delete()
for child in project_children_list:
child.delete()
clean.cleanup_all()
clean.cleanup_unassociated_projects()
self.assertFalse(_entry_exists(project_with_children))
def test_cleanup_order_with_child(self, project):
"""Test cleaning up an order with a child"""
# create order and retry task
order = _setup_entry('order', project=project)
order_retry_task = _setup_entry('order_retry', order=order)
# soft delete order and retry task,
# it should automatically delete the children
order.delete()
clean.cleanup_all()
# assert that the order was not cleaned due to child
self.assertTrue(_entry_exists(order))
self.assertTrue(_entry_exists(order_retry_task))
order_retry_task.delete()
clean.cleanup_all()
# assert everything has been cleaned up
self.assertFalse(_entry_exists(order))
self.assertFalse(_entry_exists(order_retry_task))
def test_cleanup_orders(self, project):
"""Test cleaning up an order and it's children"""
# create order, order meta, and plugin meta, and retry task
order = _setup_entry('order', project=project)
order_barbican_meta_data = _setup_entry('order_meta_datum',
order=order)
order_plugin_metadata = _setup_entry('order_plugin_metadatum',
order=order)
order_retry_task = _setup_entry('order_retry', order=order)
# soft delete order and retry task,
# it should automatically delete the children
order.delete()
order_retry_task.delete()
clean.cleanup_all()
# assert everything has been cleaned up
self.assertFalse(_entry_exists(order))
self.assertFalse(_entry_exists(order_plugin_metadata))
self.assertFalse(_entry_exists(order_retry_task))
self.assertFalse(_entry_exists(order_barbican_meta_data))
def test_cleanup_order_with_child(self, project):
"""Test cleaning up an order with a child"""
# create order and retry task
order = _setup_entry('order', project=project)
order_retry_task = _setup_entry('order_retry', order=order)
# soft delete order and retry task,
# it should automatically delete the children
order.delete()
clean.cleanup_all()
# assert that the order was not cleaned due to child
self.assertTrue(_entry_exists(order))
self.assertTrue(_entry_exists(order_retry_task))
order_retry_task.delete()
clean.cleanup_all()
# assert everything has been cleaned up
self.assertFalse(_entry_exists(order))
self.assertFalse(_entry_exists(order_retry_task))
def test_cleanup_orders(self, project):
"""Test cleaning up an order and it's children"""
# create order, order meta, and plugin meta, and retry task
order = _setup_entry('order', project=project)
order_barbican_meta_data = _setup_entry('order_meta_datum',
order=order)
order_plugin_metadata = _setup_entry('order_plugin_metadatum',
order=order)
order_retry_task = _setup_entry('order_retry', order=order)
# soft delete order and retry task,
# it should automatically delete the children
order.delete()
order_retry_task.delete()
clean.cleanup_all()
# assert everything has been cleaned up
self.assertFalse(_entry_exists(order))
self.assertFalse(_entry_exists(order_plugin_metadata))
self.assertFalse(_entry_exists(order_retry_task))
self.assertFalse(_entry_exists(order_barbican_meta_data))
def test_cleanup_soft_deletes_secrets(self, project):
"""Test cleaning up secrets and secret_meta"""
# create secret and secret_meta
secret = _setup_entry('secret', project=project)
secret_metadatum = _setup_entry('secret_metadatum', secret=secret)
secret_user_metadatum = _setup_entry('secret_user_metadatum',
secret=secret)
kek_datum = _setup_entry('kek_datum', project=project)
enc_datum = _setup_entry('encrypted_datum',
secret=secret,
kek_datum=kek_datum)
# delete secret, it should automatically delete
# secret_metadatum, enc_datum, and secret_user_metadatum
# kek_datum should still exist
secret.delete()
clean.cleanup_all()
self.assertFalse(_entry_exists(secret))
self.assertFalse(_entry_exists(secret_metadatum))
self.assertFalse(_entry_exists(secret_user_metadatum))
self.assertFalse(_entry_exists(enc_datum))
self.assertTrue(_entry_exists(kek_datum))
def test_cleanup_container_with_order_child(self, project):
container = _setup_entry('container', project=project)
secret = _setup_entry('secret', project=project)
secret_container = _setup_entry('container_secret',
container=container, secret=secret)
order = _setup_entry('order', project=project, secret=secret,
container=container)
container.delete()
clean.cleanup_all()
# only the secret_container should be removed from the database
# since it is a child of the container
self.assertFalse(_entry_exists(secret_container))
self.assertTrue(_entry_exists(secret))
self.assertTrue(_entry_exists(order))
# container should still exist since child order still exists
self.assertTrue(_entry_exists(container))
order.delete()
clean.cleanup_all()
# assert that only the secret exists
self.assertFalse(_entry_exists(order))
self.assertFalse(_entry_exists(container))
self.assertTrue(_entry_exists(secret))
secret.delete()
clean.cleanup_all()
# the secret should now be able to be removed
self.assertFalse(_entry_exists(secret))
def test_cleanup_container_with_order_child(self, project):
container = _setup_entry('container', project=project)
secret = _setup_entry('secret', project=project)
secret_container = _setup_entry('container_secret',
container=container,
secret=secret)
order = _setup_entry('order',
project=project,
secret=secret,
container=container)
container.delete()
clean.cleanup_all()
# only the secret_container should be removed from the database
# since it is a child of the container
self.assertFalse(_entry_exists(secret_container))
self.assertTrue(_entry_exists(secret))
self.assertTrue(_entry_exists(order))
# container should still exist since child order still exists
self.assertTrue(_entry_exists(container))
order.delete()
clean.cleanup_all()
# assert that only the secret exists
self.assertFalse(_entry_exists(order))
self.assertFalse(_entry_exists(container))
self.assertTrue(_entry_exists(secret))
secret.delete()
clean.cleanup_all()
# the secret should now be able to be removed
self.assertFalse(_entry_exists(secret))
def test_soft_deleted_secret_orders(self, project):
"""Test that secrets without child order get deleted"""
# Create a secret tied to an order and one secret that is not
secret1 = _setup_entry('secret', project=project)
secret2 = _setup_entry('secret', project=project)
order = _setup_entry('order', project=project, secret=secret1)
# Delete secrets
secret1.delete()
secret2.delete()
clean.cleanup_parent_with_no_child(models.Secret, models.Order)
# Assert that only secret2 is removed
self.assertTrue(_entry_exists(secret1))
self.assertFalse(_entry_exists(secret2))
# delete order and secret
order.delete()
clean.cleanup_all()
self.assertFalse(_entry_exists(order))
self.assertFalse(_entry_exists(secret2))
def test_cleanup_soft_deletes_containers(self, project):
"""Test cleaning up containers and secrets"""
# create container, secret, and container_secret
container = _setup_entry('container', project=project)
secret = _setup_entry('secret', project=project)
container_secret = _setup_entry('container_secret',
container=container, secret=secret)
# delete container secret and container
container.delete()
clean.cleanup_all()
# check that container secret and container are deleted
# but secret still exists
self.assertFalse(_entry_exists(container_secret))
self.assertFalse(_entry_exists(container))
self.assertTrue(_entry_exists(secret))
# cleanup secrets
secret.delete()
clean.cleanup_all()
self.assertFalse(_entry_exists(secret))
def test_soft_deleted_secret_orders(self, project):
"""Test that secrets without child order get deleted"""
# Create a secret tied to an order and one secret that is not
secret1 = _setup_entry('secret', project=project)
secret2 = _setup_entry('secret', project=project)
order = _setup_entry('order', project=project, secret=secret1)
# Delete secrets
secret1.delete()
secret2.delete()
clean.cleanup_parent_with_no_child(models.Secret, models.Order)
# Assert that only secret2 is removed
self.assertTrue(_entry_exists(secret1))
self.assertFalse(_entry_exists(secret2))
# delete order and secret
order.delete()
clean.cleanup_all()
self.assertFalse(_entry_exists(order))
self.assertFalse(_entry_exists(secret2))
def test_cleanup_soft_deletes_containers(self, project):
"""Test cleaning up containers and secrets"""
# create container, secret, and container_secret
container = _setup_entry('container', project=project)
secret = _setup_entry('secret', project=project)
container_secret = _setup_entry('container_secret',
container=container,
secret=secret)
# delete container secret and container
container.delete()
clean.cleanup_all()
# check that container secret and container are deleted
# but secret still exists
self.assertFalse(_entry_exists(container_secret))
self.assertFalse(_entry_exists(container))
self.assertTrue(_entry_exists(secret))
# cleanup secrets
secret.delete()
clean.cleanup_all()
self.assertFalse(_entry_exists(secret))
