def test_rule_without_backend_id_is_skipped_when_group_is_imported(self):
group1 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
group2 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
rule = openstack_factories.SecurityGroupRuleFactory(
security_group=group1, remote_group=group2, backend_id='')
self.assertFalse(
models.SecurityGroupRule.objects.filter(
backend_id=rule.backend_id,
security_group__backend_id=group1.backend_id,
remote_group__backend_id=group2.backend_id,
).exists())
def test_when_group_is_imported_remote_group_is_imported_too(self):
group1 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
group2 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
rule = openstack_factories.SecurityGroupRuleFactory(
security_group=group1, remote_group=group2)
self.assertTrue(
models.SecurityGroupRule.objects.filter(
backend_id=rule.backend_id,
security_group__backend_id=group1.backend_id,
remote_group__backend_id=group2.backend_id,
).exists())
def test_when_rule_is_updated_remote_group_is_synced(self):
group1 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
group2 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
rule = openstack_factories.SecurityGroupRuleFactory(
security_group=group1)
rule.remote_group = group2
rule.save(update_fields=['remote_group'])
self.assertTrue(
models.SecurityGroupRule.objects.filter(
backend_id=rule.backend_id,
security_group__backend_id=group1.backend_id,
remote_group__backend_id=group2.backend_id,
).exists())
def test_rule_without_backend_id_is_synced_when_backend_id_is_assigned(
self):
group1 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
group2 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
rule = openstack_factories.SecurityGroupRuleFactory(
security_group=group1, remote_group=group2, backend_id='')
rule.backend_id = 'valid_backend_id'
rule.save()
self.assertTrue(
models.SecurityGroupRule.objects.filter(
backend_id=rule.backend_id,
security_group__backend_id=group1.backend_id,
remote_group__backend_id=group2.backend_id,
).exists())
def test_security_group_rules_are_updated_when_one_more_rule_is_added(
self):
openstack_security_group = openstack_factories.SecurityGroupFactory(
tenant=self.tenant, state=StateMixin.States.UPDATING)
openstack_factories.SecurityGroupRuleFactory(
security_group=openstack_security_group)
security_group = factories.SecurityGroupFactory(
settings=self.service_settings,
backend_id=openstack_security_group.backend_id,
)
openstack_security_group.set_ok()
openstack_security_group.save()
self.assertEqual(security_group.rules.count(), 1,
'Security group rule has not been added')
self.assertEqual(
security_group.rules.first().protocol,
openstack_security_group.rules.first().protocol,
)
self.assertEqual(
security_group.rules.first().from_port,
openstack_security_group.rules.first().from_port,
)
self.assertEqual(
security_group.rules.first().to_port,
openstack_security_group.rules.first().to_port,
)
def test_security_group_create(self):
openstack_security_group = openstack_factories.SecurityGroupFactory(
tenant=self.tenant, state=StateMixin.States.CREATING)
openstack_security_rule = openstack_factories.SecurityGroupRuleFactory(
security_group=openstack_security_group)
self.assertEqual(models.SecurityGroup.objects.count(), 0)
openstack_security_group.set_ok()
openstack_security_group.save()
self.assertEqual(models.SecurityGroup.objects.count(), 1)
self.assertTrue(
models.SecurityGroup.objects.filter(
settings=self.service_settings,
backend_id=openstack_security_group.backend_id,
).exists())
security_group_property = models.SecurityGroup.objects.get(
settings=self.service_settings,
backend_id=openstack_security_group.backend_id,
)
self.assertTrue(
security_group_property.rules.filter(
backend_id=openstack_security_rule.backend_id).exists())
def test_when_security_group_is_created_remote_group_is_filled(self):
group1 = openstack_factories.SecurityGroupFactory(
tenant=self.tenant, state=StateMixin.States.CREATING)
group2 = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
openstack_security_rule = openstack_factories.SecurityGroupRuleFactory(
security_group=group1, remote_group=group2)
group1.set_ok()
group1.save()
self.assertTrue(
models.SecurityGroupRule.objects.filter(
backend_id=openstack_security_rule.backend_id,
security_group__backend_id=group1.backend_id,
remote_group__backend_id=group2.backend_id,
).exists())
def setUp(self):
super(SecurityGroupRetrieveTest, self).setUp()
self.security_group = factories.SecurityGroupFactory(
service_settings=self.fixture.openstack_service_settings,
project=self.fixture.project,
tenant=self.fixture.tenant,
)
self.url = factories.SecurityGroupFactory.get_url(self.security_group)
def test_pending_security_groups_are_not_duplicated(self):
original_security_group = factories.SecurityGroupFactory(tenant=self.tenant)
factories.SecurityGroupRuleFactory(security_group=original_security_group)
security_group_in_progress = factories.SecurityGroupFactory(
state=models.SecurityGroup.States.UPDATING, tenant=self.tenant
)
factories.SecurityGroupRuleFactory(security_group=security_group_in_progress)
security_groups = [original_security_group, security_group_in_progress]
self.mocked_neutron().list_security_groups.return_value = self._form_backend_security_groups(
security_groups
)
self.backend.pull_tenant_security_groups(self.tenant)
backend_ids = [sg.backend_id for sg in security_groups]
actual_security_groups_count = models.SecurityGroup.objects.filter(
backend_id__in=backend_ids
).count()
self.assertEqual(actual_security_groups_count, len(security_groups))
def setUp(self):
super(SecurityGroupSetRulesTest, self).setUp()
self.security_group = factories.SecurityGroupFactory(
service_settings=self.fixture.openstack_service_settings,
project=self.fixture.project,
tenant=self.fixture.tenant,
state=models.SecurityGroup.States.OK,
)
self.url = factories.SecurityGroupFactory.get_url(self.security_group,
action='set_rules')
def test_security_group_is_deleted_when_openstack_security_group_is_deleted(
self):
openstack_security_group = openstack_factories.SecurityGroupFactory(
tenant=self.tenant)
factories.SecurityGroupFactory(
settings=self.service_settings,
backend_id=openstack_security_group.backend_id)
openstack_security_group.delete()
self.assertEqual(models.SecurityGroup.objects.count(), 0)
def test_security_group_name_should_be_unique(self):
existing_group = factories.SecurityGroupFactory(
service_settings=self.fixture.openstack_service_settings,
project=self.fixture.project,
tenant=self.fixture.tenant,
state=models.SecurityGroup.States.OK,
)
self.client.force_authenticate(self.fixture.staff)
response = self.client.patch(self.url,
data={'name': existing_group.name})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_security_group_update(self):
openstack_security_group = openstack_factories.SecurityGroupFactory(
tenant=self.tenant,
name='New name',
description='New description',
state=StateMixin.States.UPDATING)
security_group = factories.SecurityGroupFactory(
settings=self.service_settings,
backend_id=openstack_security_group.backend_id)
openstack_security_group.set_ok()
openstack_security_group.save()
security_group.refresh_from_db()
self.assertIn(openstack_security_group.name, security_group.name)
self.assertIn(openstack_security_group.description,
security_group.description)
def test_security_group_rules_are_deleted(self):
# Arrange
openstack_security_group = openstack_factories.SecurityGroupFactory(
tenant=self.tenant, state=StateMixin.States.UPDATING)
rule = openstack_factories.SecurityGroupRuleFactory(
security_group=openstack_security_group)
security_group = factories.SecurityGroupFactory(
settings=self.service_settings,
backend_id=openstack_security_group.backend_id,
)
# Act
openstack_security_group.set_ok()
openstack_security_group.save()
rule.delete()
# Assert
self.assertEqual(security_group.rules.count(), 0,
'Security group rule has not been deleted')
def test_if_security_group_already_exists_duplicate_is_not_created(self):
"""
Consider the following case: there are two objects:
security group as a property and security group as a resource.
Property has been created by pull_security_groups method.
When resource switches state, property should be created too via signal handler.
But as security group already exists as a property it should not be created twice,
because otherwise it violates uniqueness constraint.
"""
security_group = factories.SecurityGroupFactory(
settings=self.service_settings,
backend_id='backend_id',
)
openstack_security_group = openstack_factories.SecurityGroupFactory(
tenant=self.tenant,
state=StateMixin.States.CREATING,
backend_id=security_group.backend_id,
)
openstack_security_group.set_ok()
openstack_security_group.save()
self.assertEqual(models.SecurityGroup.objects.count(), 1)
def test_security_group_is_deleted_when_openstack_security_group_is_deleted(self):
openstack_security_group = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
openstack_security_group.delete()
self.assertEqual(models.SecurityGroup.objects.count(), 0)
def test_security_group_import(self):
resource = openstack_factories.SecurityGroupFactory(tenant=self.tenant)
self.assertTrue(models.SecurityGroup.objects.filter(
settings=self.service_settings,
backend_id=resource.backend_id
).exists())
