1450 lines
46 KiB
Python
1450 lines
46 KiB
Python
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||
|
|
# not use this file except in compliance with the License. You may obtain
|
||
|
|
# a copy of the License at
|
||
|
|
#
|
||
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
#
|
||
|
|
# Unless required by applicable law or agreed to in writing, software
|
||
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||
|
|
# License for the specific language governing permissions and limitations
|
||
|
|
# under the License.
|
||
|
|
|
||
|
|
"""
|
||
|
|
test_clustering
|
||
|
|
----------------------------------
|
||
|
|
|
||
|
|
Functional tests for `shade` clustering methods.
|
||
|
|
"""
|
||
|
|
|
||
|
|
import time
|
||
|
|
|
||
|
|
from testtools import content
|
||
|
|
|
||
|
|
from openstack.tests.functional import base
|
||
|
|
|
||
|
|
|
||
|
|
def wait_for_status(
|
||
|
|
client, client_args, field, value, check_interval=1, timeout=60
|
||
|
|
):
|
||
|
|
"""Wait for an OpenStack resource to enter a specified state
|
||
|
|
|
||
|
|
:param client: An uncalled client resource to be called with resource_args
|
||
|
|
:param client_args: Arguments to be passed to client
|
||
|
|
:param field: Dictionary field to check
|
||
|
|
:param value: Dictionary value to look for
|
||
|
|
:param check_interval: Interval between checks
|
||
|
|
:param timeout: Time in seconds to wait for status to update.
|
||
|
|
:returns: True if correct status was reached
|
||
|
|
:raises: TimeoutException
|
||
|
|
"""
|
||
|
|
resource_status = client(**client_args)[field]
|
||
|
|
start = time.time()
|
||
|
|
|
||
|
|
while resource_status != value:
|
||
|
|
time.sleep(check_interval)
|
||
|
|
resource = client(**client_args)
|
||
|
|
resource_status = resource[field]
|
||
|
|
|
||
|
|
timed_out = time.time() - start >= timeout
|
||
|
|
|
||
|
|
if resource_status != value and timed_out:
|
||
|
|
return False
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def wait_for_create(client, client_args, check_interval=1, timeout=60):
|
||
|
|
"""Wait for an OpenStack resource to be created
|
||
|
|
|
||
|
|
:param client: An uncalled client resource to be called with resource_args
|
||
|
|
:param client_args: Arguments to be passed to client
|
||
|
|
:param name: Name of the resource (for logging)
|
||
|
|
:param check_interval: Interval between checks
|
||
|
|
:param timeout: Time in seconds to wait for status to update.
|
||
|
|
:returns: True if openstack.exceptions.NotFoundException is caught
|
||
|
|
:raises: TimeoutException
|
||
|
|
|
||
|
|
"""
|
||
|
|
|
||
|
|
resource = client(**client_args)
|
||
|
|
start = time.time()
|
||
|
|
|
||
|
|
while not resource:
|
||
|
|
time.sleep(check_interval)
|
||
|
|
resource = client(**client_args)
|
||
|
|
|
||
|
|
timed_out = time.time() - start >= timeout
|
||
|
|
|
||
|
|
if (not resource) and timed_out:
|
||
|
|
return False
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def wait_for_delete(client, client_args, check_interval=1, timeout=60):
|
||
|
|
"""Wait for an OpenStack resource to 404/delete
|
||
|
|
|
||
|
|
:param client: An uncalled client resource to be called with resource_args
|
||
|
|
:param client_args: Arguments to be passed to client
|
||
|
|
:param name: Name of the resource (for logging)
|
||
|
|
:param check_interval: Interval between checks
|
||
|
|
:param timeout: Time in seconds to wait for status to update.
|
||
|
|
:returns: True if openstack.exceptions.NotFoundException is caught
|
||
|
|
:raises: TimeoutException
|
||
|
|
|
||
|
|
"""
|
||
|
|
resource = client(**client_args)
|
||
|
|
start = time.time()
|
||
|
|
|
||
|
|
while resource:
|
||
|
|
time.sleep(check_interval)
|
||
|
|
resource = client(**client_args)
|
||
|
|
|
||
|
|
timed_out = time.time() - start >= timeout
|
||
|
|
|
||
|
|
if resource and timed_out:
|
||
|
|
return False
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
class TestClustering(base.BaseFunctionalTest):
|
||
|
|
def setUp(self):
|
||
|
|
super(TestClustering, self).setUp()
|
||
|
|
self.skipTest('clustering service not supported by cloud')
|
||
|
|
|
||
|
|
def test_create_profile(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
self.assertEqual(profile['name'], profile_name)
|
||
|
|
self.assertEqual(profile['spec'], spec)
|
||
|
|
|
||
|
|
def test_create_cluster(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
self.assertEqual(cluster['cluster']['name'], cluster_name)
|
||
|
|
self.assertEqual(cluster['cluster']['profile_id'], profile['id'])
|
||
|
|
self.assertEqual(
|
||
|
|
cluster['cluster']['desired_capacity'], desired_capacity
|
||
|
|
)
|
||
|
|
|
||
|
|
def test_get_cluster_by_id(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
# Test that we get the same cluster with the get_cluster method
|
||
|
|
cluster_get = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
self.assertEqual(cluster_get['id'], cluster['cluster']['id'])
|
||
|
|
|
||
|
|
def test_update_cluster(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
# Test that we can update a field on the cluster and only that field
|
||
|
|
# is updated
|
||
|
|
|
||
|
|
self.user_cloud.update_cluster(
|
||
|
|
cluster['cluster']['id'], new_name='new_cluster_name'
|
||
|
|
)
|
||
|
|
|
||
|
|
wait = wait_for_status(
|
||
|
|
self.user_cloud.get_cluster_by_id,
|
||
|
|
{'name_or_id': cluster['cluster']['id']},
|
||
|
|
'status',
|
||
|
|
'ACTIVE',
|
||
|
|
)
|
||
|
|
|
||
|
|
self.assertTrue(wait)
|
||
|
|
cluster_update = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
self.assertEqual(cluster_update['id'], cluster['cluster']['id'])
|
||
|
|
self.assertEqual(cluster_update['name'], 'new_cluster_name')
|
||
|
|
self.assertEqual(
|
||
|
|
cluster_update['profile_id'], cluster['cluster']['profile_id']
|
||
|
|
)
|
||
|
|
self.assertEqual(
|
||
|
|
cluster_update['desired_capacity'],
|
||
|
|
cluster['cluster']['desired_capacity'],
|
||
|
|
)
|
||
|
|
|
||
|
|
def test_create_cluster_policy(self):
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_policy, policy['id'])
|
||
|
|
|
||
|
|
self.assertEqual(policy['name'], policy_name)
|
||
|
|
self.assertEqual(policy['spec'], spec)
|
||
|
|
|
||
|
|
def test_attach_policy_to_cluster(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(
|
||
|
|
self.cleanup_policy, policy['id'], cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
# Test that we can attach policy to cluster and get True returned
|
||
|
|
|
||
|
|
attach_cluster = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
attach_policy = self.user_cloud.get_cluster_policy_by_id(policy['id'])
|
||
|
|
|
||
|
|
policy_attach = self.user_cloud.attach_policy_to_cluster(
|
||
|
|
attach_cluster, attach_policy, is_enabled=True
|
||
|
|
)
|
||
|
|
self.assertTrue(policy_attach)
|
||
|
|
|
||
|
|
def test_detach_policy_from_cluster(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(
|
||
|
|
self.cleanup_policy, policy['id'], cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
attach_cluster = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
attach_policy = self.user_cloud.get_cluster_policy_by_id(policy['id'])
|
||
|
|
|
||
|
|
self.user_cloud.attach_policy_to_cluster(
|
||
|
|
attach_cluster, attach_policy, is_enabled=True
|
||
|
|
)
|
||
|
|
|
||
|
|
wait = wait_for_status(
|
||
|
|
self.user_cloud.get_cluster_by_id,
|
||
|
|
{'name_or_id': cluster['cluster']['id']},
|
||
|
|
'policies',
|
||
|
|
['{policy}'.format(policy=policy['id'])],
|
||
|
|
)
|
||
|
|
|
||
|
|
policy_detach = self.user_cloud.detach_policy_from_cluster(
|
||
|
|
attach_cluster, attach_policy
|
||
|
|
)
|
||
|
|
|
||
|
|
self.assertTrue(policy_detach)
|
||
|
|
self.assertTrue(wait)
|
||
|
|
|
||
|
|
def test_get_policy_on_cluster_by_id(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(
|
||
|
|
self.cleanup_policy, policy['id'], cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
# Test that we can attach policy to cluster and get True returned
|
||
|
|
|
||
|
|
attach_cluster = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
attach_policy = self.user_cloud.get_cluster_policy_by_id(policy['id'])
|
||
|
|
|
||
|
|
policy_attach = self.user_cloud.attach_policy_to_cluster(
|
||
|
|
attach_cluster, attach_policy, is_enabled=True
|
||
|
|
)
|
||
|
|
self.assertTrue(policy_attach)
|
||
|
|
|
||
|
|
wait = wait_for_status(
|
||
|
|
self.user_cloud.get_cluster_by_id,
|
||
|
|
{'name_or_id': cluster['cluster']['id']},
|
||
|
|
'policies',
|
||
|
|
["{policy}".format(policy=policy['id'])],
|
||
|
|
)
|
||
|
|
|
||
|
|
# Test that we get the same policy with the get_policy_on_cluster
|
||
|
|
# method
|
||
|
|
|
||
|
|
cluster_policy_get = self.user_cloud.get_policy_on_cluster(
|
||
|
|
cluster['cluster']["id"], policy['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
self.assertEqual(
|
||
|
|
cluster_policy_get['cluster_id'], cluster['cluster']["id"]
|
||
|
|
)
|
||
|
|
self.assertEqual(
|
||
|
|
cluster_policy_get['cluster_name'], cluster['cluster']["name"]
|
||
|
|
)
|
||
|
|
self.assertEqual(cluster_policy_get['policy_id'], policy['id']),
|
||
|
|
self.assertEqual(cluster_policy_get['policy_name'], policy['name'])
|
||
|
|
self.assertTrue(wait)
|
||
|
|
|
||
|
|
def test_list_policies_on_cluster(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(
|
||
|
|
self.cleanup_policy, policy['id'], cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
attach_cluster = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
attach_policy = self.user_cloud.get_cluster_policy_by_id(policy['id'])
|
||
|
|
|
||
|
|
self.user_cloud.attach_policy_to_cluster(
|
||
|
|
attach_cluster, attach_policy, is_enabled=True
|
||
|
|
)
|
||
|
|
|
||
|
|
wait = wait_for_status(
|
||
|
|
self.user_cloud.get_cluster_by_id,
|
||
|
|
{'name_or_id': cluster['cluster']['id']},
|
||
|
|
'policies',
|
||
|
|
["{policy}".format(policy=policy['id'])],
|
||
|
|
)
|
||
|
|
|
||
|
|
cluster_policy = self.user_cloud.get_policy_on_cluster(
|
||
|
|
name_or_id=cluster['cluster']['id'], policy_name_or_id=policy['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
policy_list = {"cluster_policies": [cluster_policy]}
|
||
|
|
|
||
|
|
# Test that we can list the policies on a cluster
|
||
|
|
cluster_policies = self.user_cloud.list_policies_on_cluster(
|
||
|
|
cluster['cluster']["id"]
|
||
|
|
)
|
||
|
|
self.assertEqual(cluster_policies, policy_list)
|
||
|
|
self.assertTrue(wait)
|
||
|
|
|
||
|
|
def test_create_cluster_receiver(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
receiver_name = "example_receiver"
|
||
|
|
receiver_type = "webhook"
|
||
|
|
|
||
|
|
self.addDetail('receiver', content.text_content(receiver_name))
|
||
|
|
|
||
|
|
# Test that we can create a receiver and we get it returned
|
||
|
|
|
||
|
|
receiver = self.user_cloud.create_cluster_receiver(
|
||
|
|
name=receiver_name,
|
||
|
|
receiver_type=receiver_type,
|
||
|
|
cluster_name_or_id=cluster['cluster']['id'],
|
||
|
|
action='CLUSTER_SCALE_OUT',
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_receiver, receiver['id'])
|
||
|
|
|
||
|
|
self.assertEqual(receiver['name'], receiver_name)
|
||
|
|
self.assertEqual(receiver['type'], receiver_type)
|
||
|
|
self.assertEqual(receiver['cluster_id'], cluster['cluster']["id"])
|
||
|
|
|
||
|
|
def test_list_cluster_receivers(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
receiver_name = "example_receiver"
|
||
|
|
receiver_type = "webhook"
|
||
|
|
|
||
|
|
self.addDetail('receiver', content.text_content(receiver_name))
|
||
|
|
|
||
|
|
# Test that we can create a receiver and we get it returned
|
||
|
|
|
||
|
|
receiver = self.user_cloud.create_cluster_receiver(
|
||
|
|
name=receiver_name,
|
||
|
|
receiver_type=receiver_type,
|
||
|
|
cluster_name_or_id=cluster['cluster']['id'],
|
||
|
|
action='CLUSTER_SCALE_OUT',
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_receiver, receiver['id'])
|
||
|
|
|
||
|
|
get_receiver = self.user_cloud.get_cluster_receiver_by_id(
|
||
|
|
receiver['id']
|
||
|
|
)
|
||
|
|
receiver_list = {"receivers": [get_receiver]}
|
||
|
|
|
||
|
|
# Test that we can list receivers
|
||
|
|
|
||
|
|
receivers = self.user_cloud.list_cluster_receivers()
|
||
|
|
self.assertEqual(receivers, receiver_list)
|
||
|
|
|
||
|
|
def test_delete_cluster(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_policy, policy['id'])
|
||
|
|
|
||
|
|
# Test that we can attach policy to cluster and get True returned
|
||
|
|
attach_cluster = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
attach_policy = self.user_cloud.get_cluster_policy_by_id(policy['id'])
|
||
|
|
|
||
|
|
self.user_cloud.attach_policy_to_cluster(
|
||
|
|
attach_cluster, attach_policy, is_enabled=True
|
||
|
|
)
|
||
|
|
|
||
|
|
receiver_name = "example_receiver"
|
||
|
|
receiver_type = "webhook"
|
||
|
|
|
||
|
|
self.addDetail('receiver', content.text_content(receiver_name))
|
||
|
|
|
||
|
|
# Test that we can create a receiver and we get it returned
|
||
|
|
|
||
|
|
self.user_cloud.create_cluster_receiver(
|
||
|
|
name=receiver_name,
|
||
|
|
receiver_type=receiver_type,
|
||
|
|
cluster_name_or_id=cluster['cluster']['id'],
|
||
|
|
action='CLUSTER_SCALE_OUT',
|
||
|
|
)
|
||
|
|
|
||
|
|
# Test that we can delete cluster and get True returned
|
||
|
|
cluster_delete = self.user_cloud.delete_cluster(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
self.assertTrue(cluster_delete)
|
||
|
|
|
||
|
|
def test_list_clusters(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
wait = wait_for_status(
|
||
|
|
self.user_cloud.get_cluster_by_id,
|
||
|
|
{'name_or_id': cluster['cluster']['id']},
|
||
|
|
'status',
|
||
|
|
'ACTIVE',
|
||
|
|
)
|
||
|
|
|
||
|
|
get_cluster = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
# Test that we can list clusters
|
||
|
|
clusters = self.user_cloud.list_clusters()
|
||
|
|
self.assertEqual(clusters, [get_cluster])
|
||
|
|
self.assertTrue(wait)
|
||
|
|
|
||
|
|
def test_update_policy_on_cluster(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(
|
||
|
|
self.cleanup_policy, policy['id'], cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
# Test that we can attach policy to cluster and get True returned
|
||
|
|
|
||
|
|
attach_cluster = self.user_cloud.get_cluster_by_id(
|
||
|
|
cluster['cluster']['id']
|
||
|
|
)
|
||
|
|
attach_policy = self.user_cloud.get_cluster_policy_by_id(policy['id'])
|
||
|
|
|
||
|
|
self.user_cloud.attach_policy_to_cluster(
|
||
|
|
attach_cluster, attach_policy, is_enabled=True
|
||
|
|
)
|
||
|
|
|
||
|
|
wait_attach = wait_for_status(
|
||
|
|
self.user_cloud.get_cluster_by_id,
|
||
|
|
{'name_or_id': cluster['cluster']['id']},
|
||
|
|
'policies',
|
||
|
|
["{policy}".format(policy=policy['id'])],
|
||
|
|
)
|
||
|
|
|
||
|
|
get_old_policy = self.user_cloud.get_policy_on_cluster(
|
||
|
|
cluster['cluster']["id"], policy['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
# Test that we can update the policy on cluster
|
||
|
|
policy_update = self.user_cloud.update_policy_on_cluster(
|
||
|
|
attach_cluster, attach_policy, is_enabled=False
|
||
|
|
)
|
||
|
|
|
||
|
|
get_old_policy.update({'enabled': False})
|
||
|
|
|
||
|
|
wait_update = wait_for_status(
|
||
|
|
self.user_cloud.get_policy_on_cluster,
|
||
|
|
{
|
||
|
|
'name_or_id': cluster['cluster']['id'],
|
||
|
|
'policy_name_or_id': policy['id'],
|
||
|
|
},
|
||
|
|
'enabled',
|
||
|
|
False,
|
||
|
|
)
|
||
|
|
|
||
|
|
get_new_policy = self.user_cloud.get_policy_on_cluster(
|
||
|
|
cluster['cluster']["id"], policy['id']
|
||
|
|
)
|
||
|
|
|
||
|
|
get_old_policy['last_op'] = None
|
||
|
|
get_new_policy['last_op'] = None
|
||
|
|
|
||
|
|
self.assertTrue(policy_update)
|
||
|
|
self.assertEqual(get_new_policy, get_old_policy)
|
||
|
|
self.assertTrue(wait_attach)
|
||
|
|
self.assertTrue(wait_update)
|
||
|
|
|
||
|
|
def test_list_cluster_profiles(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
# Test that we can list profiles
|
||
|
|
|
||
|
|
wait = wait_for_create(
|
||
|
|
self.user_cloud.get_cluster_profile_by_id,
|
||
|
|
{'name_or_id': profile['id']},
|
||
|
|
)
|
||
|
|
|
||
|
|
get_profile = self.user_cloud.get_cluster_profile_by_id(profile['id'])
|
||
|
|
|
||
|
|
profiles = self.user_cloud.list_cluster_profiles()
|
||
|
|
self.assertEqual(profiles, [get_profile])
|
||
|
|
self.assertTrue(wait)
|
||
|
|
|
||
|
|
def test_get_cluster_profile_by_id(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
profile_get = self.user_cloud.get_cluster_profile_by_id(profile['id'])
|
||
|
|
|
||
|
|
# Test that we get the same profile with the get_profile method
|
||
|
|
# Format of the created_at variable differs between policy create
|
||
|
|
# and policy get so if we don't ignore this variable, comparison will
|
||
|
|
# always fail
|
||
|
|
profile['created_at'] = 'ignore'
|
||
|
|
profile_get['created_at'] = 'ignore'
|
||
|
|
|
||
|
|
self.assertEqual(profile_get, profile)
|
||
|
|
|
||
|
|
def test_update_cluster_profile(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
# Test that we can update a field on the profile and only that field
|
||
|
|
# is updated
|
||
|
|
|
||
|
|
profile_update = self.user_cloud.update_cluster_profile(
|
||
|
|
profile['id'], new_name='new_profile_name'
|
||
|
|
)
|
||
|
|
self.assertEqual(profile_update['profile']['id'], profile['id'])
|
||
|
|
self.assertEqual(profile_update['profile']['spec'], profile['spec'])
|
||
|
|
self.assertEqual(profile_update['profile']['name'], 'new_profile_name')
|
||
|
|
|
||
|
|
def test_delete_cluster_profile(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
# Test that we can delete a profile and get True returned
|
||
|
|
profile_delete = self.user_cloud.delete_cluster_profile(profile['id'])
|
||
|
|
self.assertTrue(profile_delete)
|
||
|
|
|
||
|
|
def test_list_cluster_policies(self):
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_policy, policy['id'])
|
||
|
|
|
||
|
|
policy_get = self.user_cloud.get_cluster_policy_by_id(policy['id'])
|
||
|
|
|
||
|
|
# Test that we can list policies
|
||
|
|
|
||
|
|
policies = self.user_cloud.list_cluster_policies()
|
||
|
|
|
||
|
|
# Format of the created_at variable differs between policy create
|
||
|
|
# and policy get so if we don't ignore this variable, comparison will
|
||
|
|
# always fail
|
||
|
|
policies[0]['created_at'] = 'ignore'
|
||
|
|
policy_get['created_at'] = 'ignore'
|
||
|
|
|
||
|
|
self.assertEqual(policies, [policy_get])
|
||
|
|
|
||
|
|
def test_get_cluster_policy_by_id(self):
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_policy, policy['id'])
|
||
|
|
|
||
|
|
# Test that we get the same policy with the get_policy method
|
||
|
|
|
||
|
|
policy_get = self.user_cloud.get_cluster_policy_by_id(policy['id'])
|
||
|
|
|
||
|
|
# Format of the created_at variable differs between policy create
|
||
|
|
# and policy get so if we don't ignore this variable, comparison will
|
||
|
|
# always fail
|
||
|
|
policy['created_at'] = 'ignore'
|
||
|
|
policy_get['created_at'] = 'ignore'
|
||
|
|
|
||
|
|
self.assertEqual(policy_get, policy)
|
||
|
|
|
||
|
|
def test_update_cluster_policy(self):
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_policy, policy['id'])
|
||
|
|
|
||
|
|
# Test that we can update a field on the policy and only that field
|
||
|
|
# is updated
|
||
|
|
|
||
|
|
policy_update = self.user_cloud.update_cluster_policy(
|
||
|
|
policy['id'], new_name='new_policy_name'
|
||
|
|
)
|
||
|
|
self.assertEqual(policy_update['policy']['id'], policy['id'])
|
||
|
|
self.assertEqual(policy_update['policy']['spec'], policy['spec'])
|
||
|
|
self.assertEqual(policy_update['policy']['name'], 'new_policy_name')
|
||
|
|
|
||
|
|
def test_delete_cluster_policy(self):
|
||
|
|
policy_name = 'example_policy'
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"adjustment": {
|
||
|
|
"min_step": 1,
|
||
|
|
"number": 1,
|
||
|
|
"type": "CHANGE_IN_CAPACITY",
|
||
|
|
},
|
||
|
|
"event": "CLUSTER_SCALE_IN",
|
||
|
|
},
|
||
|
|
"type": "senlin.policy.scaling",
|
||
|
|
"version": "1.0",
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('policy', content.text_content(policy_name))
|
||
|
|
|
||
|
|
# Test that we can create a policy and we get it returned
|
||
|
|
|
||
|
|
policy = self.user_cloud.create_cluster_policy(
|
||
|
|
name=policy_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_policy, policy['id'])
|
||
|
|
|
||
|
|
# Test that we can delete a policy and get True returned
|
||
|
|
policy_delete = self.user_cloud.delete_cluster_policy(policy['id'])
|
||
|
|
self.assertTrue(policy_delete)
|
||
|
|
|
||
|
|
def test_get_cluster_receiver_by_id(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
receiver_name = "example_receiver"
|
||
|
|
receiver_type = "webhook"
|
||
|
|
|
||
|
|
self.addDetail('receiver', content.text_content(receiver_name))
|
||
|
|
|
||
|
|
# Test that we can create a receiver and we get it returned
|
||
|
|
|
||
|
|
receiver = self.user_cloud.create_cluster_receiver(
|
||
|
|
name=receiver_name,
|
||
|
|
receiver_type=receiver_type,
|
||
|
|
cluster_name_or_id=cluster['cluster']['id'],
|
||
|
|
action='CLUSTER_SCALE_OUT',
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_receiver, receiver['id'])
|
||
|
|
|
||
|
|
# Test that we get the same receiver with the get_receiver method
|
||
|
|
|
||
|
|
receiver_get = self.user_cloud.get_cluster_receiver_by_id(
|
||
|
|
receiver['id']
|
||
|
|
)
|
||
|
|
self.assertEqual(receiver_get['id'], receiver["id"])
|
||
|
|
|
||
|
|
def test_update_cluster_receiver(self):
|
||
|
|
profile_name = "test_profile"
|
||
|
|
spec = {
|
||
|
|
"properties": {
|
||
|
|
"flavor": self.flavor.name,
|
||
|
|
"image": self.image.name,
|
||
|
|
"networks": [{"network": "private"}],
|
||
|
|
"security_groups": ["default"],
|
||
|
|
},
|
||
|
|
"type": "os.nova.server",
|
||
|
|
"version": 1.0,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.addDetail('profile', content.text_content(profile_name))
|
||
|
|
# Test that we can create a profile and we get it returned
|
||
|
|
|
||
|
|
profile = self.user_cloud.create_cluster_profile(
|
||
|
|
name=profile_name, spec=spec
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_profile, profile['id'])
|
||
|
|
|
||
|
|
cluster_name = 'example_cluster'
|
||
|
|
desired_capacity = 0
|
||
|
|
|
||
|
|
self.addDetail('cluster', content.text_content(cluster_name))
|
||
|
|
|
||
|
|
# Test that we can create a cluster and we get it returned
|
||
|
|
cluster = self.user_cloud.create_cluster(
|
||
|
|
name=cluster_name,
|
||
|
|
profile=profile,
|
||
|
|
desired_capacity=desired_capacity,
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_cluster, cluster['cluster']['id'])
|
||
|
|
|
||
|
|
receiver_name = "example_receiver"
|
||
|
|
receiver_type = "webhook"
|
||
|
|
|
||
|
|
self.addDetail('receiver', content.text_content(receiver_name))
|
||
|
|
|
||
|
|
# Test that we can create a receiver and we get it returned
|
||
|
|
|
||
|
|
receiver = self.user_cloud.create_cluster_receiver(
|
||
|
|
name=receiver_name,
|
||
|
|
receiver_type=receiver_type,
|
||
|
|
cluster_name_or_id=cluster['cluster']['id'],
|
||
|
|
action='CLUSTER_SCALE_OUT',
|
||
|
|
)
|
||
|
|
|
||
|
|
self.addCleanup(self.cleanup_receiver, receiver['id'])
|
||
|
|
|
||
|
|
# Test that we can update a field on the receiver and only that field
|
||
|
|
# is updated
|
||
|
|
|
||
|
|
receiver_update = self.user_cloud.update_cluster_receiver(
|
||
|
|
receiver['id'], new_name='new_receiver_name'
|
||
|
|
)
|
||
|
|
self.assertEqual(receiver_update['receiver']['id'], receiver['id'])
|
||
|
|
self.assertEqual(receiver_update['receiver']['type'], receiver['type'])
|
||
|
|
self.assertEqual(
|
||
|
|
receiver_update['receiver']['cluster_id'], receiver['cluster_id']
|
||
|
|
)
|
||
|
|
self.assertEqual(
|
||
|
|
receiver_update['receiver']['name'], 'new_receiver_name'
|
||
|
|
)
|
||
|
|
|
||
|
|
def cleanup_profile(self, name):
|
||
|
|
time.sleep(5)
|
||
|
|
for cluster in self.user_cloud.list_clusters():
|
||
|
|
if name == cluster["profile_id"]:
|
||
|
|
self.user_cloud.delete_cluster(cluster["id"])
|
||
|
|
self.user_cloud.delete_cluster_profile(name)
|
||
|
|
|
||
|
|
def cleanup_cluster(self, name):
|
||
|
|
self.user_cloud.delete_cluster(name)
|
||
|
|
|
||
|
|
def cleanup_policy(self, name, cluster_name=None):
|
||
|
|
if cluster_name is not None:
|
||
|
|
cluster = self.user_cloud.get_cluster_by_id(cluster_name)
|
||
|
|
policy = self.user_cloud.get_cluster_policy_by_id(name)
|
||
|
|
policy_status = self.user_cloud.get_cluster_by_id(cluster['id'])[
|
||
|
|
'policies'
|
||
|
|
]
|
||
|
|
if policy_status != []:
|
||
|
|
self.user_cloud.detach_policy_from_cluster(cluster, policy)
|
||
|
|
self.user_cloud.delete_cluster_policy(name)
|
||
|
|
|
||
|
|
def cleanup_receiver(self, name):
|
||
|
|
self.user_cloud.delete_cluster_receiver(name)
|