5263334f4f
Fix for comments in https://review.openstack.org/#/c/201217/12 1. Add schema validation into NetworkGroup API validator. 2. Slight refactoring of objects.NetworkGroup methods. 3. Fix name of the test in unit/test_migration_fuel_7_0.TestStringNetworkGroupName And fix corresponding tests in unit/test_network_group_handler Change-Id: If2863c2bbf270f85a74cc784fa06844d710feb4d Closes-Bug: #1477648 Related-Bug: #1484929
822 lines
28 KiB
Python
822 lines
28 KiB
Python
# Copyright 2015 Mirantis, 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 datetime
|
|
|
|
import alembic
|
|
from oslo_serialization import jsonutils
|
|
import six
|
|
import sqlalchemy as sa
|
|
|
|
from nailgun.db import db
|
|
from nailgun.db import dropdb
|
|
from nailgun.db.migration import ALEMBIC_CONFIG
|
|
from nailgun.extensions.consts import extensions_migration_buffer_table_name
|
|
from nailgun.test import base
|
|
|
|
|
|
_prepare_revision = '37608259013'
|
|
_test_revision = '1e50a4903910'
|
|
|
|
|
|
def setup_module(module):
|
|
dropdb()
|
|
alembic.command.upgrade(ALEMBIC_CONFIG, _prepare_revision)
|
|
prepare()
|
|
alembic.command.upgrade(ALEMBIC_CONFIG, _test_revision)
|
|
|
|
|
|
def prepare():
|
|
meta = base.reflect_db_metadata()
|
|
db.execute(
|
|
meta.tables['plugins'].insert(),
|
|
[{
|
|
'name': 'test_plugin',
|
|
'title': 'Test plugin',
|
|
'version': '1.0.0',
|
|
'description': 'Test plugin for Fuel',
|
|
'homepage': 'http://fuel_plugins.test_plugin.com',
|
|
'package_version': '3.0.0',
|
|
'groups': jsonutils.dumps(['tgroup']),
|
|
'authors': jsonutils.dumps(['tauthor']),
|
|
'licenses': jsonutils.dumps(['tlicense']),
|
|
'releases': jsonutils.dumps([
|
|
{'repository_path': 'repositories/ubuntu'}
|
|
]),
|
|
'fuel_version': jsonutils.dumps(['6.1', '7.0']),
|
|
}])
|
|
|
|
result = db.execute(
|
|
meta.tables['releases'].insert(),
|
|
[{
|
|
'name': 'test_name',
|
|
'version': '2014.2.2-6.1',
|
|
'operating_system': 'ubuntu',
|
|
'state': 'available',
|
|
'roles': jsonutils.dumps([
|
|
'controller',
|
|
'compute',
|
|
'mongo',
|
|
]),
|
|
'roles_metadata': jsonutils.dumps({
|
|
'controller': {
|
|
'name': 'Controller',
|
|
'description': 'Controller role',
|
|
'has_primary': True,
|
|
},
|
|
'zabbix-server': {
|
|
'name': 'Zabbix Server',
|
|
'description': 'Zabbix Server role'
|
|
},
|
|
'cinder': {
|
|
'name': 'Cinder',
|
|
'description': 'Cinder role'
|
|
},
|
|
'mongo': {
|
|
'name': 'Telemetry - MongoDB',
|
|
'description': 'mongo is',
|
|
'has_primary': True,
|
|
}
|
|
}),
|
|
'attributes_metadata': jsonutils.dumps({}),
|
|
'networks_metadata': jsonutils.dumps({
|
|
'bonding': {
|
|
'properties': {
|
|
'linux': {
|
|
'mode': [
|
|
{
|
|
"values": ["balance-rr",
|
|
"active-backup",
|
|
"802.3ad"]
|
|
},
|
|
{
|
|
"values": ["balance-xor",
|
|
"broadcast",
|
|
"balance-tlb",
|
|
"balance-alb"],
|
|
"condition": "'experimental' in "
|
|
"version:feature_groups"
|
|
}
|
|
]
|
|
}
|
|
}
|
|
},
|
|
}),
|
|
'is_deployable': True,
|
|
}])
|
|
releaseid = result.inserted_primary_key[0]
|
|
|
|
result = db.execute(
|
|
meta.tables['releases'].insert(),
|
|
[{
|
|
'name': 'test_name_2',
|
|
'version': '2014.2-6.0',
|
|
'operating_system': 'ubuntu',
|
|
'state': 'available',
|
|
'roles': jsonutils.dumps([
|
|
'controller',
|
|
'compute',
|
|
'mongo',
|
|
]),
|
|
'roles_metadata': jsonutils.dumps({}),
|
|
'attributes_metadata': jsonutils.dumps({}),
|
|
'networks_metadata': jsonutils.dumps({
|
|
'bonding': {
|
|
'properties': {
|
|
'ovs': {
|
|
'mode': [
|
|
{
|
|
"values": ["active-backup",
|
|
"balance-slb",
|
|
"lacp-balance-tcp"]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
},
|
|
}),
|
|
'is_deployable': True
|
|
}])
|
|
|
|
result = db.execute(
|
|
meta.tables['clusters'].insert(),
|
|
[{
|
|
'name': 'test_env',
|
|
'release_id': releaseid,
|
|
'mode': 'ha_compact',
|
|
'status': 'new',
|
|
'net_provider': 'neutron',
|
|
'grouping': 'roles',
|
|
'fuel_version': '6.1',
|
|
}])
|
|
clusterid = result.inserted_primary_key[0]
|
|
|
|
result = db.execute(
|
|
meta.tables['networking_configs'].insert(),
|
|
[{
|
|
'cluster_id': None,
|
|
'dns_nameservers': ['8.8.8.8'],
|
|
'floating_ranges': [],
|
|
'configuration_template': None,
|
|
}])
|
|
db.execute(
|
|
meta.tables['neutron_config'].insert(),
|
|
[{
|
|
'id': result.inserted_primary_key[0],
|
|
'vlan_range': [],
|
|
'gre_id_range': [],
|
|
'base_mac': '00:00:00:00:00:00',
|
|
'internal_cidr': '10.10.10.00/24',
|
|
'internal_gateway': '10.10.10.01',
|
|
'segmentation_type': 'vlan',
|
|
'net_l23_provider': 'ovs'
|
|
}])
|
|
|
|
result = db.execute(
|
|
meta.tables['nodes'].insert(),
|
|
[
|
|
{
|
|
'uuid': 'one',
|
|
'cluster_id': clusterid,
|
|
'group_id': None,
|
|
'status': 'ready',
|
|
'meta': '{}',
|
|
'mac': 'aa:aa:aa:aa:aa:aa',
|
|
'pending_addition': True,
|
|
'pending_deletion': False,
|
|
'timestamp': datetime.datetime.utcnow(),
|
|
}
|
|
])
|
|
nodeid_a = result.inserted_primary_key[0]
|
|
|
|
result = db.execute(
|
|
meta.tables['nodes'].insert(),
|
|
[
|
|
{
|
|
'uuid': 'two',
|
|
'cluster_id': clusterid,
|
|
'group_id': None,
|
|
'status': 'discover',
|
|
'meta': '{}',
|
|
'mac': 'bb:bb:bb:bb:bb:bb',
|
|
'pending_addition': True,
|
|
'pending_deletion': False,
|
|
'timestamp': datetime.datetime.utcnow(),
|
|
}
|
|
])
|
|
nodeid_b = result.inserted_primary_key[0]
|
|
|
|
result = db.execute(
|
|
meta.tables['nodes'].insert(),
|
|
[
|
|
{
|
|
'uuid': 'three',
|
|
'cluster_id': None,
|
|
'group_id': None,
|
|
'status': 'discover',
|
|
'meta': '{}',
|
|
'mac': 'cc:cc:cc:cc:cc:cc',
|
|
'pending_addition': True,
|
|
'pending_deletion': False,
|
|
'timestamp': datetime.datetime.utcnow(),
|
|
}
|
|
])
|
|
nodeid_c = result.inserted_primary_key[0]
|
|
|
|
db.execute(
|
|
meta.tables['node_attributes'].insert(),
|
|
[
|
|
{
|
|
'node_id': nodeid_a,
|
|
'volumes': jsonutils.dumps([{'volume': nodeid_a}])
|
|
},
|
|
{
|
|
'node_id': nodeid_b,
|
|
'volumes': jsonutils.dumps([{'volume': nodeid_b}])
|
|
},
|
|
{
|
|
'node_id': nodeid_c,
|
|
'volumes': jsonutils.dumps([{'volume': nodeid_c}])
|
|
},
|
|
])
|
|
|
|
result = db.execute(
|
|
meta.tables['roles'].insert(),
|
|
[
|
|
{'release_id': releaseid, 'name': 'controller'},
|
|
])
|
|
controllerroleid = result.inserted_primary_key[0]
|
|
|
|
result = db.execute(
|
|
meta.tables['roles'].insert(),
|
|
[
|
|
{'release_id': releaseid, 'name': 'mongo'},
|
|
])
|
|
mongoroleid = result.inserted_primary_key[0]
|
|
|
|
result = db.execute(
|
|
meta.tables['node_roles'].insert(),
|
|
[
|
|
{'role': controllerroleid, 'node': nodeid_a, 'primary': False},
|
|
{'role': controllerroleid, 'node': nodeid_b, 'primary': False},
|
|
{'role': controllerroleid, 'node': nodeid_c, 'primary': True},
|
|
{'role': mongoroleid, 'node': nodeid_a, 'primary': False},
|
|
])
|
|
|
|
result = db.execute(
|
|
meta.tables['pending_node_roles'].insert(),
|
|
[
|
|
{'role': mongoroleid, 'node': nodeid_b, 'primary': True},
|
|
{'role': mongoroleid, 'node': nodeid_c, 'primary': False},
|
|
])
|
|
|
|
db.execute(
|
|
meta.tables['node_nic_interfaces'].insert(),
|
|
[
|
|
{
|
|
'id': 1,
|
|
'node_id': nodeid_a,
|
|
'name': 'test_interface',
|
|
'mac': '00:00:00:00:00:01',
|
|
'max_speed': 200,
|
|
'current_speed': 100,
|
|
'ip_addr': '10.20.0.2',
|
|
'netmask': '255.255.255.0',
|
|
'state': 'test_state',
|
|
'interface_properties': jsonutils.dumps(
|
|
{'test_property': 'test_value'}),
|
|
'driver': 'test_driver',
|
|
'bus_info': 'some_test_info'
|
|
},
|
|
{
|
|
'id': 2,
|
|
'node_id': nodeid_a,
|
|
'name': 'test_interface_2',
|
|
'mac': '00:00:00:00:00:02',
|
|
'max_speed': 200,
|
|
'current_speed': 100,
|
|
'ip_addr': '10.30.0.2',
|
|
'netmask': '255.255.255.0',
|
|
'state': 'test_state',
|
|
'interface_properties': jsonutils.dumps(
|
|
{'test_property': 'test_value'}),
|
|
'driver': 'test_driver',
|
|
'bus_info': 'some_test_info'
|
|
},
|
|
{
|
|
'id': 3,
|
|
'node_id': nodeid_a,
|
|
'name': 'test_interface_3',
|
|
'mac': '00:00:00:00:00:03',
|
|
'max_speed': 200,
|
|
'current_speed': 100,
|
|
'ip_addr': '10.30.0.2',
|
|
'netmask': '255.255.255.0',
|
|
'state': 'test_state',
|
|
'interface_properties': jsonutils.dumps(
|
|
{'test_property': 'test_value'}),
|
|
'driver': 'test_driver',
|
|
'bus_info': 'some_test_info'
|
|
}])
|
|
|
|
db.execute(
|
|
meta.tables['node_bond_interfaces'].insert(),
|
|
[{
|
|
'node_id': nodeid_a,
|
|
'name': 'test_bond_interface',
|
|
'mode': 'active-backup',
|
|
'bond_properties': jsonutils.dumps(
|
|
{'test_property': 'test_value'})
|
|
}])
|
|
|
|
db.execute(
|
|
meta.tables['network_groups'].insert(),
|
|
[
|
|
{
|
|
'id': 1,
|
|
'name': 'fuelweb_admin',
|
|
'vlan_start': None,
|
|
'cidr': '10.20.0.0/24',
|
|
'gateway': '10.20.0.200',
|
|
},
|
|
{
|
|
'id': 2,
|
|
'name': 'public',
|
|
'vlan_start': None,
|
|
'cidr': '10.30.0.0/24',
|
|
'gateway': '10.30.0.200'
|
|
}
|
|
]
|
|
)
|
|
|
|
db.execute(
|
|
meta.tables['net_nic_assignments'].insert(),
|
|
[
|
|
{
|
|
'network_id': 1,
|
|
'interface_id': 1
|
|
},
|
|
{
|
|
'network_id': 2,
|
|
'interface_id': 2
|
|
},
|
|
{
|
|
'network_id': 2,
|
|
'interface_id': 3
|
|
}
|
|
]
|
|
)
|
|
|
|
db.commit()
|
|
|
|
|
|
class TestPluginAttributesMigration(base.BaseAlembicMigrationTest):
|
|
|
|
def test_old_fields_exists(self):
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.name]))
|
|
self.assertEqual(
|
|
result.fetchone()[0], 'test_plugin')
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.title]))
|
|
self.assertEqual(
|
|
result.fetchone()[0], 'Test plugin')
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.version]))
|
|
self.assertEqual(
|
|
result.fetchone()[0], '1.0.0')
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.description]))
|
|
self.assertEqual(
|
|
result.fetchone()[0], 'Test plugin for Fuel')
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.homepage]))
|
|
self.assertEqual(
|
|
result.fetchone()[0], 'http://fuel_plugins.test_plugin.com')
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.package_version]))
|
|
self.assertEqual(
|
|
result.fetchone()[0], '3.0.0')
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.groups]))
|
|
self.assertEqual(
|
|
jsonutils.loads(result.fetchone()[0]), ['tgroup'])
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.authors]))
|
|
self.assertEqual(
|
|
jsonutils.loads(result.fetchone()[0]), ['tauthor'])
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.licenses]))
|
|
self.assertEqual(
|
|
jsonutils.loads(result.fetchone()[0]), ['tlicense'])
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.releases]))
|
|
self.assertEqual(
|
|
jsonutils.loads(result.fetchone()[0]),
|
|
[{'repository_path': 'repositories/ubuntu'}])
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['plugins'].c.fuel_version]))
|
|
self.assertEqual(
|
|
jsonutils.loads(result.fetchone()[0]), ['6.1', '7.0'])
|
|
|
|
def test_new_fields_exists_and_empty(self):
|
|
# check attributes_metadata field exists
|
|
plugin_table = self.meta.tables['plugins']
|
|
column_values = [
|
|
(plugin_table.c.attributes_metadata, {}),
|
|
(plugin_table.c.volumes_metadata, {}),
|
|
(plugin_table.c.roles_metadata, {}),
|
|
(plugin_table.c.network_roles_metadata, []),
|
|
(plugin_table.c.deployment_tasks, []),
|
|
(plugin_table.c.tasks, []),
|
|
]
|
|
result = db.execute(sa.select(
|
|
[item[0] for item in column_values]))
|
|
db_values = result.fetchone()
|
|
|
|
for idx, db_value in enumerate(db_values):
|
|
self.assertEqual(jsonutils.loads(db_value), column_values[idx][1])
|
|
|
|
|
|
class TestPublicIpRequired(base.BaseAlembicMigrationTest):
|
|
|
|
def test_public_ip_required(self):
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['releases'].c.roles_metadata]))
|
|
roles_metadata = jsonutils.loads(result.fetchone()[0])
|
|
for role, role_info in six.iteritems(roles_metadata):
|
|
if role in ['controller', 'zabbix-server']:
|
|
self.assertTrue(role_info['public_ip_required'])
|
|
else:
|
|
self.assertFalse(role_info.get('public_ip_required'))
|
|
|
|
|
|
class TestInterfacesOffloadingModesMigration(base.BaseAlembicMigrationTest):
|
|
def test_old_fields_exists(self):
|
|
# check node_nic_interfaces fields
|
|
nic_table = self.meta.tables['node_nic_interfaces']
|
|
result = db.execute(
|
|
sa.select([nic_table.c.node_id, nic_table.c.name, nic_table.c.mac,
|
|
nic_table.c.max_speed, nic_table.c.current_speed,
|
|
nic_table.c.ip_addr, nic_table.c.netmask,
|
|
nic_table.c.state, nic_table.c.interface_properties,
|
|
nic_table.c.driver, nic_table.c.bus_info]).
|
|
where(nic_table.c.id == 1))
|
|
res = result.fetchone()
|
|
check_res = [1, u'test_interface', u'00:00:00:00:00:01', 200, 100,
|
|
u'10.20.0.2', u'255.255.255.0', u'test_state',
|
|
u'{"test_property": "test_value"}',
|
|
u'test_driver', u'some_test_info']
|
|
self.assertListEqual(list(res), check_res)
|
|
|
|
def test_new_fields_exists_and_empty(self):
|
|
# check node_nic_interfaces fields
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['node_nic_interfaces']
|
|
.c.offloading_modes]))
|
|
self.assertEqual(
|
|
jsonutils.loads(result.fetchone()[0]), [])
|
|
# the same for bond interfaces
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['node_bond_interfaces']
|
|
.c.offloading_modes]))
|
|
self.assertEqual(
|
|
jsonutils.loads(result.fetchone()[0]), [])
|
|
|
|
|
|
class TestNetworkingTemplatesMigration(base.BaseAlembicMigrationTest):
|
|
def test_new_fields_exists_and_empty(self):
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['networking_configs']
|
|
.c.configuration_template]))
|
|
self.assertIsNone(result.fetchone()[0])
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['nodes']
|
|
.c.network_template]))
|
|
self.assertIsNone(result.fetchone()[0])
|
|
|
|
|
|
class TestNodeHostnamePropertyMigration(base.BaseAlembicMigrationTest):
|
|
|
|
def test_hostname_field_exists_and_contains_correct_values(self):
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['nodes'].c.id,
|
|
self.meta.tables['nodes'].c.hostname]))
|
|
|
|
for node_id, hostname in result:
|
|
self.assertEqual(
|
|
"node-{0}".format(node_id),
|
|
hostname)
|
|
|
|
def test_fqdn_field_is_dropped(self):
|
|
node_table = self.meta.tables['nodes']
|
|
self.assertNotIn('fqdn', node_table.c)
|
|
|
|
|
|
class TestInterfacesPxePropertyMigration(base.BaseAlembicMigrationTest):
|
|
|
|
def test_old_fields_exists(self):
|
|
# check node_nic_interfaces fields
|
|
ng_table = self.meta.tables['network_groups']
|
|
result = db.execute(
|
|
sa.select([ng_table.c.name, ng_table.c.vlan_start,
|
|
ng_table.c.cidr, ng_table.c.gateway]).
|
|
where(ng_table.c.id == 1))
|
|
res = result.fetchone()
|
|
check_res = [u'fuelweb_admin', None, u'10.20.0.0/24', u'10.20.0.200']
|
|
self.assertListEqual(list(res), check_res)
|
|
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['net_nic_assignments'].c.network_id]))
|
|
self.assertEqual(
|
|
result.fetchone()[0], 1)
|
|
|
|
def test_new_field_exists_and_filled(self):
|
|
nic_table = self.meta.tables['node_nic_interfaces']
|
|
result = db.execute(
|
|
sa.select([nic_table.c.pxe]).where(nic_table.c.id == 1))
|
|
# check 'pxe' property is true for admin interfaces
|
|
self.assertTrue(result.fetchone()[0])
|
|
result = db.execute(
|
|
sa.select([nic_table.c.pxe]).where(nic_table.c.id != 1))
|
|
# and 'false' for any others
|
|
for res in result.fetchall():
|
|
self.assertFalse(res[0])
|
|
|
|
|
|
class TestMigrateVolumesIntoExtension(base.BaseAlembicMigrationTest):
|
|
|
|
def test_data_are_moved_into_buffer_table(self):
|
|
# "volumes" column got deleted
|
|
columns = [t.name for t in self.meta.tables['node_attributes'].columns]
|
|
self.assertItemsEqual(columns, ['id', 'node_id', 'interfaces',
|
|
'vms_conf'])
|
|
|
|
# The data are stored in the buffer
|
|
table_name = extensions_migration_buffer_table_name
|
|
result = db.execute(
|
|
sa.select([
|
|
self.meta.tables[table_name].c.id,
|
|
self.meta.tables[table_name].c.extension_name,
|
|
self.meta.tables[table_name].c.data]))
|
|
records = list(result)
|
|
|
|
# Extension name is volume_manager
|
|
names = [r[1] for r in records]
|
|
self.assertEqual(
|
|
list(names),
|
|
['volume_manager'] * 3)
|
|
|
|
# Check the data, each dict has node_id and volumes
|
|
volumes = [jsonutils.loads(r[2]) for r in records]
|
|
for volume in volumes:
|
|
self.assertEqual(
|
|
volume['volumes'],
|
|
[{'volume': volume['node_id']}])
|
|
|
|
|
|
class TestSchemalessRoles(base.BaseAlembicMigrationTest):
|
|
|
|
def test_nodes_has_roles_attrs(self):
|
|
result = db.execute(
|
|
sa.select([
|
|
self.meta.tables['nodes'].c.roles,
|
|
self.meta.tables['nodes'].c.pending_roles,
|
|
self.meta.tables['nodes'].c.primary_roles,
|
|
]).order_by(self.meta.tables['nodes'].c.id))
|
|
|
|
nodes = [
|
|
(roles, pending_roles, primary_roles)
|
|
for roles, pending_roles, primary_roles in result
|
|
]
|
|
|
|
# node_a
|
|
roles, pending_roles, primary_roles = nodes[0]
|
|
|
|
self.assertItemsEqual(['controller', 'mongo'], roles)
|
|
self.assertItemsEqual([], pending_roles)
|
|
self.assertItemsEqual([], primary_roles)
|
|
|
|
# node_b
|
|
roles, pending_roles, primary_roles = nodes[1]
|
|
|
|
self.assertItemsEqual(['controller'], roles)
|
|
self.assertItemsEqual(['mongo'], pending_roles)
|
|
self.assertItemsEqual(['mongo'], primary_roles)
|
|
|
|
# node_c
|
|
roles, pending_roles, primary_roles = nodes[2]
|
|
|
|
self.assertItemsEqual(['controller'], roles)
|
|
self.assertItemsEqual(['mongo'], pending_roles)
|
|
self.assertItemsEqual(['controller'], primary_roles)
|
|
|
|
def test_old_tables_are_dropped(self):
|
|
self.assertNotIn('node_roles', self.meta.tables)
|
|
self.assertNotIn('pending_node_roles', self.meta.tables)
|
|
self.assertNotIn('roles', self.meta.tables)
|
|
|
|
def test_network_roles_metadata_exists_and_empty(self):
|
|
# check attributes_metadata field exists
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['releases'].c.network_roles_metadata]))
|
|
# check attributes_metadata value is empty
|
|
self.assertEqual(jsonutils.loads(result.fetchone()[0]), [])
|
|
|
|
def test_weight_is_injected_to_roles_meta(self):
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['releases'].c.roles_metadata])
|
|
)
|
|
rel_row = result.fetchone()
|
|
|
|
r_meta = jsonutils.loads(rel_row[0])
|
|
|
|
default_roles_weight = {
|
|
"controller": 10,
|
|
"compute": 20,
|
|
"cinder": 30,
|
|
"cinder-vmware": 40,
|
|
"ceph-osd": 50,
|
|
"mongo": 60,
|
|
"base-os": 70,
|
|
"virt": 80
|
|
}
|
|
|
|
for r_name in r_meta:
|
|
r_weight = r_meta[r_name].get('weight')
|
|
self.assertIsNotNone(r_weight)
|
|
|
|
if r_name in default_roles_weight:
|
|
self.assertEquals(
|
|
r_weight, default_roles_weight.get(r_name)
|
|
)
|
|
# role which is not present in list of default ones
|
|
else:
|
|
self.assertEquals(r_weight, 10000)
|
|
|
|
|
|
class TestClusterUISettingsMigration(base.BaseAlembicMigrationTest):
|
|
def test_grouping_field_removed(self):
|
|
clusters_table = self.meta.tables['clusters']
|
|
self.assertNotIn('grouping', clusters_table.c)
|
|
|
|
def test_ui_settings_field_exists_and_has_default_value(self):
|
|
clusters_table = self.meta.tables['clusters']
|
|
self.assertIn('ui_settings', clusters_table.c)
|
|
|
|
ui_settings = jsonutils.loads(
|
|
db.execute(
|
|
sa.select([clusters_table.c.ui_settings])
|
|
).fetchone()[0]
|
|
)
|
|
self.assertItemsEqual(ui_settings['view_mode'], 'standard')
|
|
self.assertItemsEqual(ui_settings['filter'], {})
|
|
self.assertItemsEqual(ui_settings['sort'], [{'roles': 'asc'}])
|
|
self.assertItemsEqual(ui_settings['filter_by_labels'], {})
|
|
self.assertItemsEqual(ui_settings['sort_by_labels'], [])
|
|
self.assertItemsEqual(ui_settings['search'], '')
|
|
|
|
|
|
class TestClusterBondMetaMigration(base.BaseAlembicMigrationTest):
|
|
def test_cluster_bond_meta_field_exists_and_has_proper_value_lnx(self):
|
|
lnx_meta = [
|
|
{
|
|
"values": ["balance-rr", "active-backup", "802.3ad"],
|
|
"condition": "interface:pxe == false"
|
|
},
|
|
{
|
|
"values": ["balance-xor", "broadcast", "balance-tlb",
|
|
"balance-alb"],
|
|
"condition": "interface:pxe == false and "
|
|
"'experimental' in version:feature_groups"
|
|
}
|
|
]
|
|
# check data for linux bonds (fuel 6.1 version)
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['releases'].c.networks_metadata]).
|
|
where(self.meta.tables['releases'].c.name == 'test_name'))
|
|
bond_meta = jsonutils.loads(result.fetchone()[0])['bonding']
|
|
self.assertEqual(bond_meta['properties']['linux']['mode'], lnx_meta)
|
|
|
|
def test_cluster_bond_meta_field_exists_and_has_proper_value_ovs(self):
|
|
ovs_meta = [
|
|
{
|
|
"values": ["active-backup", "balance-slb",
|
|
"lacp-balance-tcp"],
|
|
"condition": "interface:pxe == false"
|
|
}
|
|
]
|
|
# check data for ovs bonds (fuel < 6.1 version)
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['releases'].c.networks_metadata]).
|
|
where(self.meta.tables['releases'].c.name == 'test_name_2'))
|
|
bond_meta = jsonutils.loads(result.fetchone()[0])['bonding']
|
|
self.assertEqual(bond_meta['properties']['ovs']['mode'], ovs_meta)
|
|
|
|
|
|
class TestExtensionsField(base.BaseAlembicMigrationTest):
|
|
|
|
def test_extensions_field_with_default_data(self):
|
|
cluster_result = db.execute(
|
|
sa.select([self.meta.tables['clusters'].c.extensions])).fetchone()
|
|
release_result = db.execute(
|
|
sa.select([self.meta.tables['releases'].c.extensions])).fetchone()
|
|
|
|
self.assertEqual(list(cluster_result)[0], ['volume_manager'])
|
|
self.assertEqual(list(release_result)[0], ['volume_manager'])
|
|
|
|
|
|
class TestOldReleasesIsUndeployable(base.BaseAlembicMigrationTest):
|
|
|
|
def test_old_releases_has_deployable_false(self):
|
|
result = db.execute(
|
|
sa.select([self.meta.tables['releases'].c.is_deployable]).
|
|
where(self.meta.tables['releases'].c.version == '2014.2.2-6.1'))
|
|
|
|
for (is_deployable, ) in result:
|
|
self.assertFalse(is_deployable)
|
|
|
|
|
|
class TestNodeLabelsMigration(base.BaseAlembicMigrationTest):
|
|
def test_node_labels_field_exists_and_has_default_value(self):
|
|
nodes_table = self.meta.tables['nodes']
|
|
self.assertIn('labels', nodes_table.c)
|
|
|
|
default_labels = jsonutils.loads(
|
|
db.execute(
|
|
sa.select([nodes_table.c.labels])
|
|
).fetchone()[0]
|
|
)
|
|
self.assertEqual(default_labels, {})
|
|
|
|
|
|
class TestTunSegmentType(base.BaseAlembicMigrationTest):
|
|
|
|
def test_tun_segment_type_added(self):
|
|
result = db.execute(
|
|
self.meta.tables['networking_configs'].insert(),
|
|
[{
|
|
'cluster_id': None,
|
|
'dns_nameservers': ['8.8.8.8'],
|
|
'floating_ranges': [],
|
|
'configuration_template': None,
|
|
}])
|
|
db.execute(
|
|
self.meta.tables['neutron_config'].insert(),
|
|
[{
|
|
'id': result.inserted_primary_key[0],
|
|
'vlan_range': [],
|
|
'gre_id_range': [],
|
|
'base_mac': '00:00:00:00:00:00',
|
|
'internal_cidr': '10.10.10.00/24',
|
|
'internal_gateway': '10.10.10.01',
|
|
'segmentation_type': 'tun',
|
|
'net_l23_provider': 'ovs'
|
|
}])
|
|
types = db.execute(
|
|
sa.select(
|
|
[self.meta.tables['neutron_config'].c.segmentation_type])).\
|
|
fetchall()
|
|
self.assertIn(('tun',), types)
|
|
|
|
|
|
class TestStringNetworkGroupName(base.BaseAlembicMigrationTest):
|
|
|
|
def test_network_group_name_is_string(self):
|
|
db.execute(
|
|
self.meta.tables['network_groups'].insert(),
|
|
[{
|
|
'id': 3,
|
|
'name': 'custom_name',
|
|
'vlan_start': None,
|
|
'cidr': '10.20.0.0/24',
|
|
'gateway': '10.20.0.200',
|
|
}])
|
|
names = db.execute(
|
|
sa.select(
|
|
[self.meta.tables['network_groups'].c.name])). \
|
|
fetchall()
|
|
self.assertIn(('custom_name',), names)
|