def test_create_two_clusters_verify_time_stamps(self):
"""test time stamps times at creation and delete."""
api_cluster_1 = test_utils.create_api_test_cluster()
api_cluster_2 = test_utils.create_api_test_cluster()
# Create two clusters
data_1 = self.post_json('/clusters',
params=api_cluster_1,
headers=self.auth_headers,
status=202)
data_2 = self.post_json('/clusters',
params=api_cluster_2,
headers=self.auth_headers,
status=202)
# retrieve cluster objects
cluster_1 = objects.Cluster.get_cluster_by_id(self.context,
data_1.json["id"])
cluster_2 = objects.Cluster.get_cluster_by_id(self.context,
data_2.json["id"])
# verify second cluster was created after first by created_at time
self.assertTrue(cluster_2.created_at > cluster_1.created_at,
"Second cluster was not created after first")
cluster_1_created_at = cluster_1.created_at
# issue delete request cluster for cluster_1
self.delete('/clusters/' + data_1.json["id"],
headers=self.auth_headers)
# retrieve cluster_1
cluster_1 = objects.Cluster.get_cluster_by_id(self.context,
data_1.json["id"])
# verify updated_at time is after created_at
self.assertTrue(cluster_1.updated_at > cluster_1.created_at,
"Cluster updated at time is invalid")
# verify created_at time did not change
self.assertEqual(cluster_1_created_at, cluster_1.created_at,
"Cluster created_at time has changed")
# delete cluster_1
cluster = objects.Cluster(deleted=True, status=models.Status.DELETED)
cluster.update(self.context, data_1.json["id"])
# retrieve deleted (soft) cluster
cluster_query = db_api.model_query(
self.context, models.Cluster,
read_deleted=True).filter_by(id=data_1.json["id"])
cluster_1 = cluster_query.one()
# verify deleted_at time is after created_at
self.assertTrue(cluster_1.deleted_at > cluster_1.created_at,
"Cluster deleted_at time is invalid")
# verify updated_at time is after deleted_at
self.assertTrue(cluster_1.updated_at > cluster_1.deleted_at,
"Cluster deleted_at time is invalid")
def test_create_invalid_image(self):
"""test create a cluster with invalid image configured."""
# add a new broker image that is not in nova image-list
self.CONF.config(default_broker_name='rabbitmq1')
broker_values = {
'name': 'rabbitmq1',
'active': '1',
}
broker = objects.Broker(**broker_values)
broker.create_broker(None)
broker_list = broker.get_brokers(None)
metadata_value = {
'key': 'IMAGE',
'value': 'ea329926-b8bf-11e5-9912-ba0be0483c18',
'broker_id': broker_list[1]['id']
}
metadata = objects.BrokerMetadata(**metadata_value)
metadata.create_broker_metadata(None)
api_cluster = test_utils.create_api_test_cluster()
data = self.post_json('/clusters',
params=api_cluster,
headers=self.auth_headers,
expect_errors=True)
self.assertEqual(500, data.status_code,
'Invalid status code value received.')
def test_create_flavor_too_small_ram(self):
"""test create a cluster with flavor having too small ram for image."""
api_cluster = test_utils.create_api_test_cluster(flavor='x-tiny-ram')
data = self.post_json('/clusters',
params=api_cluster,
headers=self.auth_headers,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
def test_create_flavor_invalid(self):
"""test create a cluster with invalid flavor."""
api_cluster = test_utils.create_api_test_cluster(
flavor='invalid_flavor')
data = self.post_json('/clusters',
params=api_cluster,
headers=self.auth_headers,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
def test_create_rabbit_authentication_too_short_password(self):
"""test create a cluster with invalid authentication password."""
api_cluster = test_utils.create_api_test_cluster()
api_cluster['authentication']['token']['password'] = ''
data = self.post_json('/clusters',
headers=self.auth_headers,
params=api_cluster,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
def test_create_rabbit_authentication_username_missing(self):
"""test create a cluster with missing authentication username."""
api_cluster = test_utils.create_api_test_cluster()
del api_cluster['authentication']['token']['username']
data = self.post_json('/clusters',
headers=self.auth_headers,
params=api_cluster,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
def test_create_rabbit_authentication_too_long_username(self):
"""test create a cluster with invalid authentication username."""
m = auth_validate.MAX_USERNAME_LENGTH + 1
api_cluster = test_utils.create_api_test_cluster()
api_cluster['authentication']['token']['username'] = '******' * m
data = self.post_json('/clusters',
headers=self.auth_headers,
params=api_cluster,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
def test_create_network_id_size_not_one(self):
"""test create a cluster with size of network_id more than one."""
api_cluster = test_utils.create_api_test_cluster(network_id=(
[str(uuid.uuid4()), str(uuid.uuid4())]))
data = self.post_json('/clusters',
headers=self.auth_headers,
params=api_cluster,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
self.assertIn("Invalid number of network_id's",
data.namespace["faultstring"],
'Invalid faultstring received.')
def test_create_invalid_size_format(self):
"""test with invalid formatted size parameter."""
api_cluster = test_utils.create_api_test_cluster(size="a")
data = self.post_json('/clusters',
params=api_cluster,
headers=self.auth_headers,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
self.assertEqual('400 Bad Request', data.status,
'Invalid status value received.')
self.assertIn('invalid literal for int() with base 10:',
data.namespace["faultstring"],
'Invalid faultstring received.')
def test_create_size_zero(self):
"""test create an empty cluster."""
api_cluster = test_utils.create_api_test_cluster(size=0)
data = self.post_json('/clusters',
headers=self.auth_headers,
params=api_cluster,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
self.assertEqual('400 Bad Request', data.status,
'Invalid status value received.')
self.assertIn('Invalid cluster size provided',
data.namespace["faultstring"],
'Invalid faultstring received.')
def test_create_cluster_api(self):
"""This test verifies create cluster job is posted from REST API."""
api_cluster = test_utils.create_api_test_cluster(
size=1, network_id=[str(uuid.uuid4())])
pre_count = self.tf_client.jobboard.job_count
self.post_json('/clusters',
params=api_cluster,
headers=self.auth_headers,
status=202)
post_count = self.tf_client.jobboard.job_count
expected = pre_count + 1
self.assertEqual(
expected, post_count,
"expected %d jobs in the jobboard after a post, "
"got %d" % (expected, post_count))
def test_create_too_large(self):
"""test create cluster with size greater than limit."""
max_cluster_size = 3
self.CONF.config(max_cluster_size=max_cluster_size, group='api')
"""test create cluster with size larger than limit."""
api_cluster = test_utils.create_api_test_cluster(
size=(max_cluster_size + 1))
data = self.post_json('/clusters',
headers=self.auth_headers,
params=api_cluster,
expect_errors=True)
self.assertEqual(413, data.status_code,
'Invalid status code value received.')
self.assertIn(
'Invalid cluster size, max size is: ' + str(max_cluster_size),
data.namespace["faultstring"], 'Invalid faultstring received.')
def test_create_size_missing(self):
"""test create an empty cluster."""
api_cluster = test_utils.create_api_test_cluster(size=0)
request_body = api_cluster
# remove size field
del request_body['size']
data = self.post_json('/clusters',
headers=self.auth_headers,
params=request_body,
expect_errors=True)
self.assertEqual(400, data.status_code,
'Invalid status code value received.')
self.assertEqual('400 Bad Request', data.status,
'Invalid status value received.')
self.assertIn('Mandatory field missing', data.namespace["faultstring"],
'Invalid faultstring received.')
def test_create_size_three(self):
"""test create a cluster with three nodes.
Will verify cluster create from DB record then verifies cluster get
returns the same cluster from the API.
"""
api_cluster = test_utils.create_api_test_cluster(size=3)
data = self.post_json('/clusters',
params=api_cluster,
headers=self.auth_headers,
status=202)
cluster = objects.Cluster.get_cluster_by_id(self.context,
data.json["id"]).as_dict()
self.validate_cluster_values(cluster, data.json)
self.assertEqual(models.Status.BUILDING, data.json['status'])
data_api = self.get_json('/clusters/' + cluster['id'],
headers=self.auth_headers)
self.validate_cluster_values(cluster, data_api)
self.assertEqual(models.Status.BUILDING, data_api['status'])