class MakeDatabaseBackup(TestCase):
def setUp(self):
cache.clear()
self.admin = SnapshotAdmin(Snapshot, admin.sites.AdminSite())
self.param_backup_available = Configuration(
name='backup_available', value=1
)
self.param_backup_available.save()
def tearDown(self):
if self.param_backup_available.id:
self.param_backup_available.delete()
def test_is_backup_available(self):
self.assertTrue(self.admin.is_backup_available)
def test_is_backup_disable(self):
self.param_backup_available.value = 0
self.param_backup_available.save()
self.assertFalse(self.admin.is_backup_available)
def test_is_backup_disable_not_configured(self):
self.param_backup_available.delete()
self.assertFalse(self.admin.is_backup_available)
class EmailBaseTest(TestCase):
action = 'update_ssl'
def setUp(self):
cache.clear()
mail.outbox = []
self.email_from = Configuration(name='email_addr_from',
value='*****@*****.**')
self.email_from.save()
self.email_adm = Configuration(name='new_user_notify_email',
value='*****@*****.**')
self.email_adm.save()
self.team = mommy.make('Team',
name='team_1',
email='*****@*****.**',
contacts='contact_1',
role__name='fake_role',
organization__name='fake_organization')
self.database = DatabaseHelper.create(name='fake_db_name',
team=self.team)
self.task_schedule = mommy.make('TaskSchedule',
method_path=self.action,
database=self.database)
class PhysicalErrorsTestCase(TestCase):
def setUp(self):
self.auto_resize_max_size_in_gb = Configuration(
name='auto_resize_max_size_in_gb', value=100
)
self.auto_resize_max_size_in_gb.save()
def tearDown(self):
self.auto_resize_max_size_in_gb.delete()
def test_no_disk_offering(self):
size = 123
typo = 'testing'
message = 'No disk offering {} than {}kb'.format(typo, size)
no_disk_offering = NoDiskOfferingError(typo=typo, size=size)
self.assertEqual(no_disk_offering.message, message)
def test_no_disk_offering_lesser(self):
size = 456
message = 'No disk offering lesser than {}kb'.format(size)
no_disk_offering = NoDiskOfferingLesserError(size=size)
self.assertEqual(no_disk_offering.message, message)
def test_no_disk_offering_greater(self):
size = 789
message = 'No disk offering greater than {}kb'.format(size)
no_disk_offering = NoDiskOfferingGreaterError(size=size)
self.assertEqual(no_disk_offering.message, message)
def test_disk_auto_resize_max_value(self):
message = 'Disk auto resize can not be greater than {}GB'.format(
self.auto_resize_max_size_in_gb.value
)
no_disk_offering = DiskOfferingMaxAutoResize()
self.assertEqual(no_disk_offering.message, message)
class MakeDatabaseBackup(TestCase):
def setUp(self):
cache.clear()
self.admin = SnapshotAdmin(Snapshot, admin.sites.AdminSite())
self.param_backup_available = Configuration(name='backup_available',
value=1)
self.param_backup_available.save()
def tearDown(self):
if self.param_backup_available.id:
self.param_backup_available.delete()
def test_is_backup_available(self):
self.assertTrue(self.admin.is_backup_available)
def test_is_backup_disable(self):
self.param_backup_available.value = 0
self.param_backup_available.save()
self.assertFalse(self.admin.is_backup_available)
def test_is_backup_disable_not_configured(self):
self.param_backup_available.delete()
self.assertFalse(self.admin.is_backup_available)
class BaseTestCase(object):
engine_name = ''
port = None
replication_topology_class_path = None
instance_helper = InstanceHelper
instance_quantity = 1
instance_type = 1
def setUp(self):
self.team = TeamFactory()
self.threshold_database_notification = Configuration(
name='threshold_database_notification',
value=70,
description='Threshold infra notification')
self.threshold_database_notification.save()
self.new_user_notify_email = Configuration(
name='new_user_notify_email',
value='*****@*****.**',
description='New user notify e-mail')
self.new_user_notify_email.save()
self.database_big = DatabaseFactory(
databaseinfra__engine__engine_type__name=self.engine_name, )
self.database_big.team = self.team
self.database_big.save()
self.infra_big = self.database_big.databaseinfra
self.infra_big.plan.replication_topology.class_path = self.replication_topology_class_path
self.infra_big.plan.replication_topology.save()
self.infra_big.save()
self.database_small = DatabaseFactory(
databaseinfra__engine__engine_type__name=self.engine_name)
self.database_small.team = self.team
self.database_small.save()
self.infra_small = self.database_small.databaseinfra
self.infra_small.plan.replication_topology.class_path = self.replication_topology_class_path
self.infra_small.plan.replication_topology.save()
self.infra_small.save()
self.instance_helper.create_instances_by_quant(
qt=self.instance_quantity,
infra=self.infra_big,
total_size_in_bytes=10000,
used_size_in_bytes=9900,
port=self.port,
instance_type=self.instance_type)
self.instance_helper.create_instances_by_quant(
qt=self.instance_quantity,
infra=self.infra_small,
total_size_in_bytes=10000,
used_size_in_bytes=1900,
port=self.port,
instance_type=self.instance_type)
def test_team_can_receive_notification(self, check_master_mock):
database_notification_for_team(team=self.team)
self.assertEqual(len(mail.outbox), 2)
def test_team_do_not_want_receive_notification(self, check_master_mock):
self.database_big.subscribe_to_email_events = False
self.database_big.save()
database_notification_for_team(team=self.team)
self.assertEqual(len(mail.outbox), 0)
class DiskOfferingTestCase(TestCase):
def create_basic_disks(self):
for disk_offering in DiskOffering.objects.all():
disk_offering.plans.all().delete()
disk_offering.delete()
cache.clear()
self.bigger = DiskOfferingFactory()
self.bigger.size_kb *= 30
self.bigger.save()
self.medium = DiskOfferingFactory()
self.medium.size_kb *= 20
self.medium.save()
self.smaller = DiskOfferingFactory()
self.smaller.size_kb *= 10
self.smaller.save()
def setUp(self):
self.admin = DiskOfferingAdmin(DiskOffering, admin.sites.AdminSite())
self.auto_resize_max_size_in_gb = Configuration(
name='auto_resize_max_size_in_gb', value=100)
self.auto_resize_max_size_in_gb.save()
def tearDown(self):
if self.auto_resize_max_size_in_gb.id:
self.auto_resize_max_size_in_gb.delete()
def test_search_fields(self):
self.assertEqual(SEARCH_FIELDS, self.admin.search_fields)
def test_list_fields(self):
self.assertEqual(LIST_FIELDS, self.admin.list_display)
def test_save_position(self):
self.assertEqual(SAVE_ON_TOP, self.admin.save_on_top)
def test_adding_gb_to_kb(self):
disk_offering_form = DiskOfferingForm(data={
'name': 'disk_offering_small',
'size_gb': 0.5,
})
self.assertTrue(disk_offering_form.is_valid())
self.admin.save_model(request=None,
obj=disk_offering_form.instance,
form=disk_offering_form,
change=None)
disk_offering = DiskOffering.objects.get(name='disk_offering_small')
self.assertEqual(disk_offering.size_gb(), 0.5)
self.assertEqual(disk_offering.size_kb, 524288)
def test_editing_gb_to_kb(self):
disk_factory = DiskOfferingFactory()
disk_offering = DiskOffering.objects.get(pk=disk_factory.pk)
self.assertEqual(disk_offering.size_gb(), 1)
self.assertEqual(disk_offering.size_kb, 1048576)
disk_offering_form = DiskOfferingForm(data={
'name': disk_offering.name,
'size_gb': 1.5,
},
instance=disk_offering)
self.assertTrue(disk_offering_form.is_valid())
self.admin.save_model(request=None,
obj=disk_offering,
form=disk_offering_form,
change=None)
self.assertEqual(disk_offering.size_gb(), 1.5)
self.assertEqual(disk_offering.size_kb, 1572864)
def test_edit_initial_values(self):
disk_offering_form = DiskOfferingForm()
self.assertNotIn('name', disk_offering_form.initial)
self.assertIn('size_gb', disk_offering_form.initial)
self.assertIsNone(disk_offering_form.initial['size_gb'])
disk_factory = DiskOfferingFactory()
disk_offering = DiskOffering.objects.get(pk=disk_factory.pk)
disk_offering_form = DiskOfferingForm(instance=disk_offering)
self.assertEqual(disk_offering_form.initial['name'],
disk_offering.name)
self.assertEqual(disk_offering_form.initial['size_gb'],
disk_offering.size_gb())
def test_model_sizes(self):
disk_factory = DiskOfferingFactory()
self.assertEqual(disk_factory.size_kb, 1048576)
self.assertEqual(disk_factory.size_gb(), 1.0)
self.assertEqual(disk_factory.size_bytes(), 1073741824)
disk_offering = DiskOffering()
self.assertIsNone(disk_offering.size_kb)
self.assertIsNone(disk_offering.size_gb())
self.assertIsNone(disk_offering.size_bytes())
def test_model_converter(self):
disk_factory = DiskOfferingFactory()
self.assertEqual(disk_factory.converter_kb_to_gb(1572864), 1.5)
self.assertEqual(disk_factory.converter_kb_to_bytes(524288), 536870912)
self.assertEqual(disk_factory.converter_gb_to_kb(0.75), 786432)
self.assertIsNone(disk_factory.converter_kb_to_gb(0))
self.assertIsNone(disk_factory.converter_kb_to_bytes(0))
self.assertIsNone(disk_factory.converter_gb_to_kb(0))
def test_unicode(self):
disk_offering = DiskOffering()
expected_unicode = UNICODE_FORMAT.format(disk_offering.name)
self.assertEqual(expected_unicode, str(disk_offering))
def test_disk_offering_is_in_admin(self):
self.assertIn(DiskOffering, admin.site._registry)
admin_class = admin.site._registry[DiskOffering]
self.assertIsInstance(admin_class, DiskOfferingAdmin)
def test_can_found_greater_disk(self):
self.create_basic_disks()
found = DiskOffering.first_greater_than(self.smaller.size_kb)
self.assertEqual(self.medium, found)
found = DiskOffering.first_greater_than(self.medium.size_kb)
self.assertEqual(self.bigger, found)
def test_cannot_found_greater_disk(self):
self.create_basic_disks()
self.assertRaises(NoDiskOfferingGreaterError,
DiskOffering.first_greater_than, self.bigger.size_kb)
def test_can_found_greater_disk_with_exclude(self):
self.create_basic_disks()
found = DiskOffering.first_greater_than(self.smaller.size_kb,
exclude_id=self.medium.id)
self.assertEqual(self.bigger, found)
def test_can_found_disk_for_auto_resize(self):
self.create_basic_disks()
self.auto_resize_max_size_in_gb.value = int(self.bigger.size_gb())
self.auto_resize_max_size_in_gb.save()
found = DiskOffering.last_offering_available_for_auto_resize()
self.assertEqual(self.bigger, found)
self.auto_resize_max_size_in_gb.value = int(self.bigger.size_gb()) - 1
self.auto_resize_max_size_in_gb.save()
found = DiskOffering.last_offering_available_for_auto_resize()
self.assertEqual(self.medium, found)
def test_cannot_found_disk_for_auto_resize(self):
self.create_basic_disks()
self.auto_resize_max_size_in_gb.value = int(self.smaller.size_gb()) - 1
self.auto_resize_max_size_in_gb.save()
self.assertRaises(NoDiskOfferingLesserError,
DiskOffering.last_offering_available_for_auto_resize)
def test_compare_disks(self):
self.create_basic_disks()
self.assertGreater(self.bigger, self.smaller)
self.assertLess(self.smaller, self.bigger)
self.medium_twice = DiskOfferingFactory()
self.medium_twice.size_kb *= 20
self.medium_twice.save()
self.assertEqual(self.medium, self.medium)
self.assertNotEqual(self.medium, self.medium_twice)
self.medium_twice.delete()
def test_disk_is_last_offering(self):
self.create_basic_disks()
self.auto_resize_max_size_in_gb.value = int(self.medium.size_gb()) + 1
self.auto_resize_max_size_in_gb.save()
self.assertFalse(self.smaller.is_last_auto_resize_offering)
self.assertTrue(self.medium.is_last_auto_resize_offering)
self.assertFalse(self.bigger.is_last_auto_resize_offering)
def test_disk_is_last_offering_without_param(self):
self.create_basic_disks()
self.auto_resize_max_size_in_gb.delete()
self.assertFalse(self.smaller.is_last_auto_resize_offering)
self.assertFalse(self.medium.is_last_auto_resize_offering)
self.assertTrue(self.bigger.is_last_auto_resize_offering)
class DiskResizeTestCase(TestCase):
def setUp(self):
cache.clear()
mail.outbox = []
self.email_from = Configuration(
name='email_addr_from', value='*****@*****.**'
)
self.email_from.save()
self.email_adm = Configuration(
name='new_user_notify_email', value='*****@*****.**'
)
self.email_adm.save()
self.team = TeamFactory()
self.greater_disk = DiskOfferingFactory()
self.greater_disk.size_kb *= 2
self.greater_disk.save()
self.disk = DiskOfferingFactory()
def test_can_get_domain(self):
my_domain = Site.objects.get(id=1).domain
self.assertNotIn('http://', my_domain)
new_domain = get_domain()
self.assertIn('http://', new_domain)
def test_can_get_email_from(self):
self.assertEqual(self.email_from.value, email_from())
def test_can_get_email_to(self):
self.assertEqual(self.email_adm.value, email_to(team=None))
def test_can_get_email_to_with_team(self):
expected_emails = [self.team.email, self.email_adm.value]
self.assertEqual(expected_emails, email_to(team=self.team))
def test_can_get_email_to_with_team_without_email(self):
self.team.email = ''
self.assertEqual(self.email_adm.value, email_to(self.team))
def test_can_send_email_disk_auto_resize(self):
database = DatabaseFactory()
usage_percentage = 76.89
disk_resize_notification(
database=database, new_disk=self.disk,
usage_percentage=usage_percentage
)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(
mail.outbox[0].subject,
SUBJECT_DISK_AUTO_RESIZE.format(database, self.disk)
)
self.assertEqual(
mail.outbox[1].subject,
SUBJECT_DISK_AUTO_RESIZE.format(database, self.disk)
)
def test_can_send_email_disk_final_auto_resize(self):
database = DatabaseFactory()
new_disk = DiskOfferingFactory()
usage_percentage = 76.89
disk_resize_notification(
database=database, new_disk=self.greater_disk,
usage_percentage=usage_percentage
)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(
mail.outbox[0].subject,
SUBJECT_DISK_FINAL_AUTO_RESIZE.format(database, self.greater_disk)
)
self.assertEqual(
mail.outbox[1].subject,
SUBJECT_DISK_FINAL_AUTO_RESIZE.format(database, self.greater_disk)
)
class BaseTestCase(object):
engine_name = ''
port = None
replication_topology_class_path = None
instance_helper = InstanceHelper
instance_quantity = 1
instance_type = 1
def setUp(self):
self.team = TeamFactory()
self.threshold_database_notification = Configuration(
name='threshold_database_notification', value=70,
description='Threshold infra notification'
)
self.threshold_database_notification.save()
self.new_user_notify_email = Configuration(
name='new_user_notify_email', value='*****@*****.**',
description='New user notify e-mail'
)
self.new_user_notify_email.save()
self.database_big = DatabaseFactory(
databaseinfra__engine__engine_type__name=self.engine_name,
)
self.database_big.team = self.team
self.database_big.save()
self.infra_big = self.database_big.databaseinfra
self.infra_big.plan.replication_topology.class_path = self.replication_topology_class_path
self.infra_big.plan.replication_topology.save()
self.infra_big.save()
self.database_small = DatabaseFactory(
databaseinfra__engine__engine_type__name=self.engine_name
)
self.database_small.team = self.team
self.database_small.save()
self.infra_small = self.database_small.databaseinfra
self.infra_small.plan.replication_topology.class_path = self.replication_topology_class_path
self.infra_small.plan.replication_topology.save()
self.infra_small.save()
self.instance_helper.create_instances_by_quant(
qt=self.instance_quantity, infra=self.infra_big,
total_size_in_bytes=10000, used_size_in_bytes=9900,
port=self.port, instance_type=self.instance_type
)
self.instance_helper.create_instances_by_quant(
qt=self.instance_quantity, infra=self.infra_small,
total_size_in_bytes=10000, used_size_in_bytes=1900,
port=self.port, instance_type=self.instance_type
)
def test_team_can_receive_notification(self, check_master_mock):
database_notification_for_team(team=self.team)
self.assertEqual(len(mail.outbox), 2)
def test_team_do_not_want_receive_notification(self, check_master_mock):
self.database_big.subscribe_to_email_events = False
self.database_big.save()
database_notification_for_team(team=self.team)
self.assertEqual(len(mail.outbox), 0)
class DiskOfferingTestCase(TestCase):
def create_basic_disks(self):
for disk_offering in DiskOffering.objects.all():
for plan in disk_offering.plans.all():
plan.databaseinfras.all().delete()
disk_offering.plans.all().delete()
disk_offering.delete()
cache.clear()
self.bigger = DiskOfferingFactory()
self.bigger.size_kb *= 30
self.bigger.save()
self.medium = DiskOfferingFactory()
self.medium.size_kb *= 20
self.medium.save()
self.smaller = DiskOfferingFactory()
self.smaller.size_kb *= 10
self.smaller.save()
def setUp(self):
self.admin = DiskOfferingAdmin(DiskOffering, admin.sites.AdminSite())
self.auto_resize_max_size_in_gb = Configuration(
name='auto_resize_max_size_in_gb', value=100
)
self.auto_resize_max_size_in_gb.save()
def tearDown(self):
if self.auto_resize_max_size_in_gb.id:
self.auto_resize_max_size_in_gb.delete()
def test_search_fields(self):
self.assertEqual(SEARCH_FIELDS, self.admin.search_fields)
def test_list_fields(self):
self.assertEqual(LIST_FIELDS, self.admin.list_display)
def test_save_position(self):
self.assertEqual(SAVE_ON_TOP, self.admin.save_on_top)
def test_adding_gb_to_kb(self):
disk_offering_form = DiskOfferingForm(
data={
'name': 'disk_offering_small',
'size_gb': 0.5,
}
)
self.assertTrue(disk_offering_form.is_valid())
self.admin.save_model(
request=None, obj=disk_offering_form.instance,
form=disk_offering_form, change=None
)
disk_offering = DiskOffering.objects.get(name='disk_offering_small')
self.assertEqual(disk_offering.size_gb(), 0.5)
self.assertEqual(disk_offering.size_kb, 524288)
def test_editing_gb_to_kb(self):
disk_factory = DiskOfferingFactory()
disk_offering = DiskOffering.objects.get(pk=disk_factory.pk)
self.assertEqual(disk_offering.size_gb(), 1)
self.assertEqual(disk_offering.size_kb, 1048576)
disk_offering_form = DiskOfferingForm(
data={
'name': disk_offering.name,
'size_gb': 1.5,
},
instance=disk_offering
)
self.assertTrue(disk_offering_form.is_valid())
self.admin.save_model(
request=None, obj=disk_offering,
form=disk_offering_form, change=None
)
self.assertEqual(disk_offering.size_gb(), 1.5)
self.assertEqual(disk_offering.size_kb, 1572864)
def test_edit_initial_values(self):
disk_offering_form = DiskOfferingForm()
self.assertNotIn('name', disk_offering_form.initial)
self.assertIn('size_gb', disk_offering_form.initial)
self.assertIsNone(disk_offering_form.initial['size_gb'])
disk_factory = DiskOfferingFactory()
disk_offering = DiskOffering.objects.get(pk=disk_factory.pk)
disk_offering_form = DiskOfferingForm(instance=disk_offering)
self.assertEqual(
disk_offering_form.initial['name'], disk_offering.name
)
self.assertEqual(
disk_offering_form.initial['size_gb'], disk_offering.size_gb()
)
def test_model_sizes(self):
disk_factory = DiskOfferingFactory()
self.assertEqual(disk_factory.size_kb, 1048576)
self.assertEqual(disk_factory.size_gb(), 1.0)
self.assertEqual(disk_factory.size_bytes(), 1073741824)
disk_offering = DiskOffering()
self.assertIsNone(disk_offering.size_kb)
self.assertIsNone(disk_offering.size_gb())
self.assertIsNone(disk_offering.size_bytes())
def test_model_converter(self):
disk_factory = DiskOfferingFactory()
self.assertEqual(disk_factory.converter_kb_to_gb(1572864), 1.5)
self.assertEqual(disk_factory.converter_kb_to_bytes(524288), 536870912)
self.assertEqual(disk_factory.converter_gb_to_kb(0.75), 786432)
self.assertIsNone(disk_factory.converter_kb_to_gb(0))
self.assertIsNone(disk_factory.converter_kb_to_bytes(0))
self.assertIsNone(disk_factory.converter_gb_to_kb(0))
def test_unicode(self):
disk_offering = DiskOffering()
expected_unicode = UNICODE_FORMAT.format(disk_offering.name)
self.assertEqual(expected_unicode, str(disk_offering))
def test_disk_offering_is_in_admin(self):
self.assertIn(DiskOffering, admin.site._registry)
admin_class = admin.site._registry[DiskOffering]
self.assertIsInstance(admin_class, DiskOfferingAdmin)
def test_can_found_greater_disk(self):
self.create_basic_disks()
found = DiskOffering.first_greater_than(self.smaller.size_kb)
self.assertEqual(self.medium, found)
found = DiskOffering.first_greater_than(self.medium.size_kb)
self.assertEqual(self.bigger, found)
def test_cannot_found_greater_disk(self):
self.create_basic_disks()
self.assertRaises(
NoDiskOfferingGreaterError,
DiskOffering.first_greater_than, self.bigger.size_kb
)
def test_can_found_greater_disk_with_exclude(self):
self.create_basic_disks()
found = DiskOffering.first_greater_than(
self.smaller.size_kb, exclude_id=self.medium.id
)
self.assertEqual(self.bigger, found)
def test_can_found_disk_for_auto_resize(self):
self.create_basic_disks()
self.auto_resize_max_size_in_gb.value = int(self.bigger.size_gb())
self.auto_resize_max_size_in_gb.save()
found = DiskOffering.last_offering_available_for_auto_resize()
self.assertEqual(self.bigger, found)
self.auto_resize_max_size_in_gb.value = int(self.bigger.size_gb()) - 1
self.auto_resize_max_size_in_gb.save()
found = DiskOffering.last_offering_available_for_auto_resize()
self.assertEqual(self.medium, found)
def test_cannot_found_disk_for_auto_resize(self):
self.create_basic_disks()
self.auto_resize_max_size_in_gb.value = int(self.smaller.size_gb()) - 1
self.auto_resize_max_size_in_gb.save()
self.assertRaises(
NoDiskOfferingLesserError,
DiskOffering.last_offering_available_for_auto_resize
)
def test_compare_disks(self):
self.create_basic_disks()
self.assertGreater(self.bigger, self.smaller)
self.assertLess(self.smaller, self.bigger)
self.medium_twice = DiskOfferingFactory()
self.medium_twice.size_kb *= 20
self.medium_twice.save()
self.assertEqual(self.medium, self.medium)
self.assertNotEqual(self.medium, self.medium_twice)
self.medium_twice.delete()
def test_disk_is_last_offering(self):
self.create_basic_disks()
self.auto_resize_max_size_in_gb.value = int(self.medium.size_gb()) + 1
self.auto_resize_max_size_in_gb.save()
self.assertFalse(self.smaller.is_last_auto_resize_offering)
self.assertTrue(self.medium.is_last_auto_resize_offering)
self.assertFalse(self.bigger.is_last_auto_resize_offering)
def test_disk_is_last_offering_without_param(self):
self.create_basic_disks()
self.auto_resize_max_size_in_gb.delete()
self.assertFalse(self.smaller.is_last_auto_resize_offering)
self.assertFalse(self.medium.is_last_auto_resize_offering)
self.assertTrue(self.bigger.is_last_auto_resize_offering)
