185 lines
7.3 KiB
Python
185 lines
7.3 KiB
Python
# Copyright 2016 Brocade Communications System, Inc.
|
|
#
|
|
# 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.
|
|
|
|
import time
|
|
import yaml
|
|
|
|
from tacker.plugins.common import constants as evt_constants
|
|
from tacker.tests.functional import base
|
|
from tacker.tests.utils import read_file
|
|
|
|
from tackerclient.common import exceptions
|
|
|
|
SECRET_PASSWORD = '***'
|
|
|
|
|
|
class VimTestCreate(base.BaseTackerTest):
|
|
|
|
def _test_create_delete_vim(self, vim_file, name, description, vim_type,
|
|
version=None):
|
|
|
|
data, vim_arg = self._generate_vim_data(
|
|
'local-vim.yaml', name, description, vim_type, version)
|
|
# updated args
|
|
new_name = "fake %s" % name
|
|
new_desc = "fake %s" % description
|
|
update_vim_arg = {'vim': {'name': new_name,
|
|
'description': new_desc}}
|
|
|
|
# Register vim
|
|
vim_res = self.client.create_vim(vim_arg)
|
|
vim_obj = vim_res['vim']
|
|
vim_id = vim_obj['id']
|
|
self.verify_vim(vim_obj, data, name, description, version)
|
|
self.verify_vim_events(vim_id, evt_constants.RES_EVT_CREATE)
|
|
|
|
# Read vim
|
|
vim_show_res = self.client.show_vim(vim_id)
|
|
self.verify_vim(vim_show_res['vim'], data, name, description, version)
|
|
|
|
# Update vim
|
|
vim_update = self.client.update_vim(vim_id, update_vim_arg)
|
|
vim_obj = vim_update['vim']
|
|
self.verify_vim(vim_obj, data, new_name, new_desc, version)
|
|
self.verify_vim_events(vim_id, evt_constants.RES_EVT_UPDATE)
|
|
|
|
# With the updated name above, create another VIM with the
|
|
# same name and check for Duplicate name exception.
|
|
vim_arg['vim']['name'] = update_vim_arg['vim']['name']
|
|
msg = "vim already exist with given ['tenant_id', 'name', "\
|
|
"'deleted_at']"
|
|
try:
|
|
self.client.create_vim(vim_arg)
|
|
except Exception as err:
|
|
self.assertEqual(err.message, msg)
|
|
|
|
# Since there already exists a DEFAULT VM, Verify that a update
|
|
# to is_default to TRUE for another VIM raises an exception.
|
|
update_arg = {'vim': {'is_default': True}}
|
|
msg = "Default VIM already exists."
|
|
self.assertRaisesRegex(exceptions.InternalServerError, msg,
|
|
self.client.update_vim,
|
|
vim_id, update_arg)
|
|
|
|
# Delete vim
|
|
try:
|
|
self.client.delete_vim(vim_id)
|
|
except Exception:
|
|
self.assertFalse(True, "Failed to delete vim %s" % vim_id)
|
|
self.verify_vim_events(vim_id, evt_constants.RES_EVT_DELETE)
|
|
|
|
def verify_vim(self, vim_instance, config_data, name, description,
|
|
version):
|
|
expected_regions = ['RegionOne']
|
|
self.assertIsNotNone(vim_instance)
|
|
self.assertEqual(description, vim_instance['description'])
|
|
self.assertEqual(name, vim_instance['name'])
|
|
self.assertIsNotNone(vim_instance['tenant_id'])
|
|
self.assertIsNotNone(vim_instance['id'])
|
|
self.assertEqual(config_data['username'],
|
|
vim_instance['auth_cred']['username'])
|
|
self.assertEqual(SECRET_PASSWORD,
|
|
vim_instance['auth_cred']['password'])
|
|
self.assertEqual(expected_regions,
|
|
vim_instance['placement_attr']['regions'])
|
|
if version:
|
|
method_name = 'verify_vim_' + version
|
|
getattr(self, method_name)(vim_instance, config_data)
|
|
|
|
def verify_vim_events(self, vim_id, evt_type, tstamp=None, cnt=1):
|
|
params = {'resource_id': vim_id,
|
|
'resource_type': evt_constants.RES_TYPE_VIM,
|
|
'event_type': evt_type}
|
|
if tstamp:
|
|
params['timestamp'] = tstamp
|
|
|
|
vim_evt_list = self.client.list_vim_events(**params)
|
|
|
|
self.assertIsNotNone(vim_evt_list['vim_events'],
|
|
"List of VIM events are Empty")
|
|
self.assertEqual(cnt, len(vim_evt_list['vim_events']))
|
|
|
|
def verify_vim_v3(self, vim_instance, config_data):
|
|
self.assertEqual(config_data['project_name'],
|
|
vim_instance['auth_cred']['project_name'])
|
|
|
|
def test_create_delete_local_vim(self):
|
|
name = 'Default vim'
|
|
description = 'Local vim description'
|
|
vim_type = 'openstack'
|
|
ks_version = 'v3'
|
|
self._test_create_delete_vim('local-vim.yaml', name, description,
|
|
vim_type, ks_version)
|
|
|
|
def _generate_vim_data(self, vim_file, name, description, vim_type,
|
|
version=None):
|
|
|
|
data = yaml.safe_load(read_file(vim_file))
|
|
password = data['password']
|
|
username = data['username']
|
|
project_name = data['project_name']
|
|
auth_url = data['auth_url']
|
|
if version:
|
|
if (not auth_url.endswith("/v3") or
|
|
not auth_url.endswith("/v3/")):
|
|
auth_url += "/v3"
|
|
domain_name = data.get('domain_name', None)
|
|
vim_arg = {'vim': {'name': name, 'description': description,
|
|
'type': vim_type,
|
|
'auth_url': auth_url,
|
|
'auth_cred': {'username': username,
|
|
'password': password,
|
|
'user_domain_name': domain_name},
|
|
'vim_project': {'name': project_name,
|
|
'project_domain_name':
|
|
domain_name},
|
|
'is_default': False}}
|
|
return data, vim_arg
|
|
|
|
def test_re_create_delete_local_vim(self):
|
|
name = 'test_vim'
|
|
description = 'Test vim description'
|
|
vim_type = 'openstack'
|
|
ks_version = 'v3'
|
|
self._test_create_delete_vim('local-vim.yaml', name, description,
|
|
vim_type, ks_version)
|
|
time.sleep(1)
|
|
self._test_create_delete_vim('local-vim.yaml', name, description,
|
|
vim_type, ks_version)
|
|
|
|
def test_duplicate_vim(self):
|
|
name = 'test_duplicate_vim'
|
|
description = 'Test duplicate vim description'
|
|
vim_type = 'openstack'
|
|
version = 'v3'
|
|
data, vim_arg = self._generate_vim_data(
|
|
'local-vim.yaml', name, description, vim_type, version)
|
|
|
|
# Register vim
|
|
vim_res = self.client.create_vim(vim_arg)
|
|
vim_obj = vim_res['vim']
|
|
vim_id = vim_obj['id']
|
|
|
|
# Read vim
|
|
vim_show_res = self.client.show_vim(vim_id)
|
|
self.verify_vim(vim_show_res['vim'], data, name, description, version)
|
|
msg = "vim already exist with given ['tenant_id', 'name', "\
|
|
"'deleted_at']"
|
|
err_msg = None
|
|
try:
|
|
self.client.create_vim(vim_arg)
|
|
except Exception as err:
|
|
err_msg = err.message
|
|
self.assertEqual(err_msg, msg)
|