def test_custom_security_groups_are_propagated_to_initial_data(self):
security_group1 = openstack_tenant_factories.SecurityGroupFactory(
settings=self.fixture.tenant_settings,
)
security_group2 = openstack_tenant_factories.SecurityGroupFactory(
settings=self.fixture.tenant_settings,
)
self.client.force_authenticate(self.fixture.owner)
payload = {
'security_groups': [
{
'url': openstack_tenant_factories.SecurityGroupFactory.get_url(
security_group1
)
},
{
'url': openstack_tenant_factories.SecurityGroupFactory.get_url(
security_group2
)
},
]
}
self._create_request_('new-cluster', add_payload=payload)
cluster = models.Cluster.objects.get(name='new-cluster')
self.assertEqual(
cluster.node_set.first().initial_data['security_groups'],
[security_group1.uuid.hex, security_group2.uuid.hex],
)
def setUp(self):
super(BaseClusterCreateTest, self).setUp()
self.fixture = fixtures.RancherFixture()
self.url = factories.ClusterFactory.get_list_url()
openstack_service_settings = openstack_factories.OpenStackServiceSettingsFactory(
customer=self.fixture.customer
)
self.tenant = openstack_factories.TenantFactory(
service_settings=openstack_service_settings
)
openstack_tenant_factories.FlavorFactory(settings=self.fixture.tenant_settings)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.tenant_settings
)
self.default_security_group = openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=self.fixture.tenant_settings
)
self.fixture.settings.options['base_image_name'] = image.name
self.fixture.settings.save()
self.network = openstack_tenant_factories.NetworkFactory(
settings=self.fixture.tenant_settings
)
self.subnet = openstack_tenant_factories.SubNetFactory(
network=self.network, settings=self.fixture.tenant_settings
)
self.flavor = Flavor.objects.get(settings=self.fixture.tenant_settings)
self.flavor.ram = 1024 * 8
self.flavor.cores = 2
self.flavor.save()
self.fixture.settings.options['base_subnet_name'] = self.subnet.name
self.fixture.settings.save()
def setUp(self):
super(BaseClusterCreateTest, self).setUp()
self.fixture = fixtures.RancherFixture()
self.url = factories.ClusterFactory.get_list_url()
openstack_service_settings = openstack_factories.OpenStackServiceSettingsFactory(
customer=self.fixture.customer)
openstack_service = openstack_factories.OpenStackServiceFactory(
customer=self.fixture.customer,
settings=openstack_service_settings)
openstack_spl = openstack_factories.OpenStackServiceProjectLinkFactory(
project=self.fixture.project, service=openstack_service)
self.tenant = openstack_factories.TenantFactory(
service_project_link=openstack_spl)
settings = ServiceSettings.objects.get(scope=self.tenant)
project = self.fixture.project
instance_spl = OpenStackTenantServiceProjectLink.objects.get(
project=project, service__settings=settings)
openstack_tenant_factories.FlavorFactory(
settings=instance_spl.service.settings)
image = openstack_tenant_factories.ImageFactory(
settings=instance_spl.service.settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=instance_spl.service.settings)
self.fixture.settings.options['base_image_name'] = image.name
self.fixture.settings.save()
network = openstack_tenant_factories.NetworkFactory(
settings=instance_spl.service.settings)
self.subnet = openstack_tenant_factories.SubNetFactory(
network=network, settings=instance_spl.service.settings)
self.fixture.settings.options['base_subnet_name'] = self.subnet.name
self.fixture.settings.save()
def test_security_group_rules_are_created_when_one_more_rule_is_added(
self):
openstack_security_group = openstack_factories.SecurityGroupFactory(
tenant=self.tenant, state=StateMixin.States.CREATING)
security_group = factories.SecurityGroupFactory(
settings=self.service_settings,
backend_id=openstack_security_group.backend_id,
)
openstack_factories.SecurityGroupRuleFactory(
security_group=openstack_security_group)
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_change_instance_security_groups_single_field(
self, mocked_execute_method):
new_security_group = factories.SecurityGroupFactory(
name='test-group',
settings=self.settings,
)
data = {
'security_groups': [
self._get_valid_security_group_payload(new_security_group),
]
}
response = self.client.post(
factories.InstanceFactory.get_url(self.instance,
action='update_security_groups'),
data=data,
)
self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
reread_instance = models.Instance.objects.get(pk=self.instance.pk)
reread_security_groups = list(reread_instance.security_groups.all())
self.assertEquals(
reread_security_groups,
[new_security_group],
'Security groups should have changed',
)
mocked_execute_method.assert_called_once()
def test_resource_is_created_when_order_item_is_processed(self):
service_settings = rancher_factories.RancherServiceSettingsFactory()
offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, scope=service_settings)
openstack_tenant_factories.FlavorFactory(
settings=self.fixture.openstack_tenant_service_settings,
ram=1024 * 8,
cores=8,
)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.openstack_tenant_service_settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default',
settings=self.fixture.openstack_tenant_service_settings)
service_settings.options['base_image_name'] = image.name
service_settings.save()
order = marketplace_factories.OrderFactory(
project=self.fixture.project, created_by=self.fixture.owner)
ssh_public_key = SshPublicKeyFactory(user=self.fixture.staff)
order_item = marketplace_factories.OrderItemFactory(
order=order,
offering=offering,
attributes={
'name':
'name',
'tenant_settings':
openstack_tenant_factories.
OpenStackTenantServiceSettingsFactory.get_url(
self.fixture.openstack_tenant_service_settings),
'project':
ProjectFactory.get_url(self.fixture.project),
'ssh_public_key':
SshPublicKeyFactory.get_url(ssh_public_key),
'nodes': [{
'subnet':
openstack_tenant_factories.SubNetFactory.get_url(
self.fixture.subnet),
'system_volume_size':
1024,
'memory':
1,
'cpu':
1,
'roles': ['controlplane', 'etcd', 'worker'],
}],
},
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(self.fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.assertTrue(
marketplace_models.Resource.objects.filter(name='name').exists())
self.assertTrue(
rancher_models.Cluster.objects.filter(name='name').exists())
def test_validate_security_groups_negative(self):
security_group1 = openstack_tenant_factories.SecurityGroupFactory()
security_group2 = openstack_tenant_factories.SecurityGroupFactory()
self.client.force_authenticate(self.fixture.owner)
payload = {
'security_groups': [
{
'url': openstack_tenant_factories.SecurityGroupFactory.get_url(
security_group1
)
},
{
'url': openstack_tenant_factories.SecurityGroupFactory.get_url(
security_group2
)
},
]
}
response = self._create_request_('new-cluster', add_payload=payload)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_validate_security_groups_positive(self):
security_group1 = openstack_tenant_factories.SecurityGroupFactory(
settings=self.fixture.tenant_spl.service.settings, )
security_group2 = openstack_tenant_factories.SecurityGroupFactory(
settings=self.fixture.tenant_spl.service.settings, )
self.client.force_authenticate(self.fixture.staff)
payload = {
'security_groups': [
{
'url':
openstack_tenant_factories.SecurityGroupFactory.get_url(
security_group1)
},
{
'url':
openstack_tenant_factories.SecurityGroupFactory.get_url(
security_group2)
},
]
}
response = self._create_request_('new-cluster', add_payload=payload)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
def test_security_group_has_been_associated_with_an_instance(self):
security_group1 = factories.SecurityGroupFactory(settings=self.service_settings)
payload = self._get_valid_payload(
security_groups=[
{'url': factories.SecurityGroupFactory.get_url(security_group1)}
]
)
response = self.client.post(self.url, payload)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertIsNotNone(response.data['security_groups'])
self.assertEqual(
response.data['security_groups'][0]['name'], security_group1.name
)
def test_security_groups_cannot_be_associated_if_they_belong_to_another_settings(
self,
):
security_group = factories.SecurityGroupFactory()
self.assertNotEqual(self.backup.service_settings, security_group.settings)
payload = self._get_valid_payload(
security_groups=[
{'url': factories.SecurityGroupFactory.get_url(security_group)}
]
)
response = self.client.post(self.url, payload)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('security_groups', response.data)
def setUp(self):
self.fixture = openstack_tenant_fixtures.OpenStackTenantFixture()
self.patcher = mock.patch(
'waldur_rancher.backend.RancherBackend.get_cluster_nodes')
self.mocked_get_cluster_nodes = self.patcher.start()
self.mocked_get_cluster_nodes.return_value = [{
'backend_id':
'node_backend_id',
'name':
'name-rancher-node-1'
}]
self.patcher_client = mock.patch(
'waldur_rancher.backend.RancherBackend.client')
self.mock_client = self.patcher_client.start()
self.mock_client.get_node.return_value = backend_node_response
service = rancher_factories.RancherServiceFactory(
customer=self.fixture.customer)
spl = rancher_factories.RancherServiceProjectLinkFactory(
project=self.fixture.project, service=service)
service_settings = spl.service.settings
self.offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, scope=service_settings)
self.plan = marketplace_factories.PlanFactory(offering=self.offering, )
self.offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering,
type='node',
billing_type=marketplace_models.OfferingComponent.BillingTypes.
USAGE,
)
self.plan_component = marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=self.offering_component,
)
openstack_tenant_factories.FlavorFactory(
settings=self.fixture.spl.service.settings, ram=1024 * 8, cores=8)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.spl.service.settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=self.fixture.spl.service.settings)
service_settings.options['base_image_name'] = image.name
service_settings.save()
self.resource = None
self.cluster = None
self.plan_period = None
def test_resource_is_created_when_order_item_is_processed(self):
service = rancher_factories.RancherServiceFactory(
customer=self.fixture.customer)
spl = rancher_factories.RancherServiceProjectLinkFactory(
project=self.fixture.project, service=service)
service_settings = spl.service.settings
offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, scope=service_settings)
openstack_tenant_factories.FlavorFactory(
settings=self.fixture.spl.service.settings)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.spl.service.settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=self.fixture.spl.service.settings)
service_settings.options['base_image_name'] = image.name
service_settings.save()
order = marketplace_factories.OrderFactory(
project=self.fixture.project, created_by=self.fixture.owner)
order_item = marketplace_factories.OrderItemFactory(
order=order,
offering=offering,
attributes={
'name':
'name',
'nodes': [{
'subnet':
openstack_tenant_factories.SubNetFactory.get_url(
self.fixture.subnet),
'storage':
1024,
'memory':
1,
'cpu':
1,
'roles': ['controlplane', 'etcd', 'worker']
}],
})
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(self.fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.assertTrue(
marketplace_models.Resource.objects.filter(name='name').exists())
self.assertTrue(
rancher_models.Cluster.objects.filter(name='name').exists())
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_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_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_change_instance_security_groups(self, mocked_execute_method):
response = self.client.get(
factories.InstanceFactory.get_url(self.instance))
self.assertEqual(response.status_code, status.HTTP_200_OK)
security_group = factories.SecurityGroupFactory(settings=self.settings)
data = {
'security_groups':
[self._get_valid_security_group_payload(security_group)]
}
response = self.client.post(
factories.InstanceFactory.get_url(self.instance,
action='update_security_groups'),
data=data,
)
self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
reread_instance = models.Instance.objects.get(pk=self.instance.pk)
reread_security_groups = list(reread_instance.security_groups.all())
self.assertEquals(reread_security_groups, [security_group])
mocked_execute_method.assert_called_once()
