def test_update_network(self, mock_conn):
mock_module = mock.Mock()
net_spec = {
'admin_state_up': plugin.DEFAULT_ADMIN_STATE,
'dns_domain': '.'.join(['netname', plugin.DEFAULT_DOMAIN]),
'mtu': plugin.DEFAULT_MTU,
'name': 'new_name',
'shared': plugin.DEFAULT_SHARED,
'provider:physical_network': 'netname',
'provider:network_type': plugin.DEFAULT_NETWORK_TYPE,
'tags': ['tripleo_foo=bar'],
}
fake_network = stubs.FakeNeutronNetwork(
id='foo',
name='netname',
is_shared=False,
dns_domain='.'.join(['netname', plugin.DEFAULT_DOMAIN]),
mtu=plugin.DEFAULT_MTU,
is_admin_state_up=plugin.DEFAULT_ADMIN_STATE,
physical_network='netname',
network_type=plugin.DEFAULT_NETWORK_TYPE,
tags=[],
)
mock_conn.network.find_network.return_value = fake_network
changed, network = plugin.create_or_update_network(
mock_conn, mock_module, net_spec)
mock_conn.network.update_network.assert_called_once_with(
'foo', **{'name': 'new_name'})
mock_conn.network.set_tags.assert_called_once_with(
network, ['tripleo_foo=bar'])
self.assertEqual(True, changed)
def test_fail_if_no_fixed_ips(self, mock_conn):
fake_net = stubs.FakeNeutronNetwork(name='test', id='net_id')
msg = ('ERROR: No IP allocation definition provided. '
'Please provide at least one IP allocation '
'definition using the fixed_ips argument.')
self.assertRaisesRegex(Exception, msg, plugin.create_or_update_port,
mock_conn, fake_net)
def test_find_ctlplane_vip(self, mock_conn):
fake_network = stubs.FakeNeutronNetwork(id='ctlplane_id',
name='ctlplane')
fake_subnet = stubs.FakeNeutronSubnet(id='ctlplane_subnet_id',
name='ctlplane-subnet')
fake_vip_port = stubs.FakeNeutronPort(id='ctlplane_vip_id',
name='control_virtual_ip',
fixed_ips=[{
'subnet_id':
'ctlplane_subnet_id',
'ip_address':
'4.3.2.1'
}],
dns_name='ctlplane.localdomain')
mock_conn.network.find_network.return_value = fake_network
mock_conn.network.get_subnet.return_value = fake_subnet
mock_conn.network.ports.return_value = self.a2g([fake_vip_port])
vip_data = list()
plugin.find_ctlplane_vip(mock_conn, vip_data)
self.assertEqual([{
'name': 'control_virtual_ip',
'network': 'ctlplane',
'subnet': 'ctlplane-subnet',
'ip_address': '4.3.2.1',
'dns_name': 'ctlplane.localdomain'
}], vip_data)
def test_update_port(self, mock_conn):
fixed_ips = [{'subnet': 'test'}]
fake_net = stubs.FakeNeutronNetwork(name='test', id='net_id')
fake_subnet = stubs.FakeNeutronSubnet(name='test', id='subnet_id')
fake_port = stubs.FakeNeutronPort(name='test_virtual_ip',
id='port_id',
fixed_ips=[{
'ip_address': '10.0.0.10',
'subnet_id': 'subnet_id'
}],
tags=[])
mock_conn.network.find_subnet.return_value = fake_subnet
mock_conn.network.ports.return_value = self.a2g([fake_port])
mock_conn.network.update_port.return_value = fake_port
plugin.create_or_update_port(mock_conn,
fake_net,
stack='test',
service='test',
fixed_ips=fixed_ips)
mock_conn.network.create_port.assert_not_called()
mock_conn.network.update_port.assert_called_once_with(
fake_port,
name='test_virtual_ip',
network_id='net_id',
fixed_ips=[{
'subnet_id': 'subnet_id'
}])
mock_conn.network.set_tags.assert_called_once_with(
fake_port, [mock.ANY, mock.ANY])
def test_is_vip_network_false(self, conn_mock):
net_name = 'external'
net_id = '132f871f-eaec-4fed-9475-0d54465e0f00'
fake_network = stubs.FakeNeutronNetwork(id=net_id, name=net_name)
conn_mock.network.get_network.return_value = fake_network
conn_mock.network.ports.return_value = (x for x in [])
result = plugin.is_vip_network(conn_mock, net_id)
self.assertEqual(False, result)
def test_get_network_attrs(self):
expected = {
'name': 'net_name',
'mtu': 1500,
'dns_domain': 'netname.localdomain.',
'tags': ['tripleo_vlan_id=100']
}
fake_network = stubs.FakeNeutronNetwork(
id='net_id',
name='net_name',
mtu=1500,
dns_domain='netname.localdomain.',
tags=['tripleo_vlan_id=100'])
self.assertEqual(expected, plugin.get_network_attrs(fake_network))
def test_is_vip_network_true(self, conn_mock):
net_name = 'external'
net_id = '132f871f-eaec-4fed-9475-0d54465e0f00'
fake_network = stubs.FakeNeutronNetwork(id=net_id, name=net_name)
fake_port = stubs.FakeNeutronPort(name='{}{}'.format(
net_name, plugin.NET_VIP_SUFFIX),
fixed_ips=[{
'ip_address': '10.10.10.10',
'subnet_id': 'foo'
}])
conn_mock.network.get_network.return_value = fake_network
conn_mock.network.ports.return_value = (x for x in [fake_port])
result = plugin.is_vip_network(conn_mock, net_id)
self.assertEqual(True, result)
def test_get_network_info(self, conn_mock, is_vip_net_mock):
fake_network = stubs.FakeNeutronNetwork(
id='132f871f-eaec-4fed-9475-0d54465e0f00',
name='public',
dns_domain='public.localdomain.',
mtu=1500,
is_shared=False,
is_admin_state_up=False,
tags=['tripleo_service_net_map_replace=external'])
conn_mock.network.get_network.return_value = fake_network
expected = {
'name_lower': 'public',
'dns_domain': 'public.localdomain.',
'service_net_map_replace': 'external',
}
result = plugin.get_network_info(
conn_mock, '132f871f-eaec-4fed-9475-0d54465e0f00')
self.assertEqual(expected, result)
def test_find_net_vips(self, mock_conn):
fake_net_resources = {
'StorageNetwork': {
'InternalApiNetwork': {
'physical_resource_id': 'fake-id',
'resource_type': n_utils.TYPE_NET
},
'StorageSubnet': {
'physical_resource_id': 'fake-id',
'resource_type': n_utils.TYPE_SUBNET
},
'StorageSubnet_leaf1': {
'physical_resource_id': 'fake-id',
'resource_type': n_utils.TYPE_SUBNET
}
}
}
fake_network = stubs.FakeNeutronNetwork(id='internal_api_id',
name='internal_api')
fake_subnet = stubs.FakeNeutronSubnet(id='internal_api_subnet_id',
name='internal_api_subnet')
fake_vip_port = stubs.FakeNeutronPort(
id='internal_api_vip_id',
name='internal_api_virtual_ip',
fixed_ips=[{
'subnet_id': 'internal_api_subnet_id',
'ip_address': '1.2.3.4'
}],
dns_name='internalapi.localdomain')
mock_conn.network.get_network.return_value = fake_network
mock_conn.network.get_subnet.return_value = fake_subnet
mock_conn.network.ports.return_value = self.a2g([fake_vip_port])
vip_data = list()
plugin.find_net_vips(mock_conn, fake_net_resources, vip_data)
self.assertEqual([{
'name': 'internal_api_virtual_ip',
'network': 'internal_api',
'subnet': 'internal_api_subnet',
'ip_address': '1.2.3.4',
'dns_name': 'internalapi.localdomain'
}], vip_data)
def test_validate_network_update(self):
net_spec = {
'admin_state_up': True,
'dns_domain': 'netname.localdomain',
'mtu': 1450,
'name': 'new_name',
'shared': True,
'provider:physical_network': 'NEWNAME',
'provider:network_type': 'vlan',
'provider:segmentation_id': 101
}
fake_network = stubs.FakeNeutronNetwork(
**{
'is_admin_state_up': False,
'mtu': 1500,
'is_shared': False,
'provider:network_type': 'flat',
'provider:physical_network': 'netname',
'provider:segmentation_id': 100,
'is_admin_state_up': False,
'dns_domain': 'netname.localdomain',
'name': 'netname'
})
module = mock.Mock()
module.fail_json = mock.Mock()
result = plugin.validate_network_update(module, fake_network, net_spec)
module.fail_json.assert_has_calls([
mock.call(msg=('Cannot update provider:network_type in existing '
'network')),
mock.call(msg=('Cannot update provider:physical_network in '
'existing network'))
])
expected = {
'mtu': 1450,
'shared': True,
'admin_state_up': True,
'name': 'new_name',
'provider:segmentation_id': 101
}
self.assertEqual(expected, result)
def test_get_overcloud_domain_name_no_ctlplane_dns_domain(self, mock_conn):
mock_conn.network.find_network.return_value = stubs.FakeNeutronNetwork(
dns_domain='')
self.assertEqual(
plugin.DEFAULT_DOMAIN,
plugin.get_overcloud_domain_name(mock_conn, 'ctlplane'))
def test_get_overcloud_domain_name(self, mock_conn):
mock_conn.network.find_network.return_value = stubs.FakeNeutronNetwork(
dns_domain='ctlplane.example.com.')
self.assertEqual(
'example.com.',
plugin.get_overcloud_domain_name(mock_conn, 'ctlplane'))
import copy
import mock
import openstack
try:
from ansible.module_utils import network_data_v2 as n_utils
except ImportError:
from tripleo_ansible.ansible_plugins.module_utils import network_data_v2 as n_utils # noqa
from tripleo_ansible.ansible_plugins.modules import (tripleo_ovn_mac_addresses
as plugin)
from tripleo_ansible.tests import base as tests_base
from tripleo_ansible.tests import stubs
FAKE_NETWORK = stubs.FakeNeutronNetwork(name=plugin.NET_NAME,
id='fake_ovn_mac_addr_net_id',
description=plugin.NET_DESCRIPTION)
FAKE_PORT = stubs.FakeNeutronPort(name='server-01_ovn_physnet_network01',
dns_name='server-01',
tags=[
'tripleo_ovn_physnet=network01',
'tripleo_stack_name=stack',
'tripleo_role_name=Compute'
])
@mock.patch.object(openstack.connection, 'Connection', autospec=True)
class TestTripleoOVNMacAddresses(tests_base.TestCase):
def setUp(self):
super(TestTripleoOVNMacAddresses, self).setUp()
'storage_mgmt_subnet': 'storage_mgmt_subnet_id',
}
},
'external': {
'id': 'external_id',
'subnets': {
'external_subnet': 'external_subnet_id',
}
},
}
NET_MAPS = {'by_name': BY_NAME_MAP}
fake_internal_api = stubs.FakeNeutronNetwork(
id='internal_api_id',
name='internal_api',
dns_domain='internalapi.localdomain.',
tags=['tripleo_network_name=InternalApi', 'tripleo_stack_name=stack'])
fake_storage_mgmt = stubs.FakeNeutronNetwork(
id='storage_mgmt_id',
name='storage_mgmt',
dns_domain='storagemgmt.localdomain.',
tags=['tripleo_network_name=StorageMgmt', 'tripleo_stack_name=stack'])
fake_external = stubs.FakeNeutronNetwork(
id='external_id',
name='external',
dns_domain='external.localdomain.',
tags=['tripleo_network_name=External', 'tripleo_stack_name=stack'])
fake_ctlplane = stubs.FakeNeutronNetwork(id='ctlplane_id',
name='ctlplane',
dns_domain='ctlplane.localdomain.',
def test_set_composable_network_attrs(self, mock_conn):
module = mock.Mock()
net_data = {'name': 'NetName'}
fake_network = stubs.FakeNeutronNetwork(
id='net_id',
name='netname',
mtu=1500,
dns_domain='netname.localdomain.',
tags=['tripleo_vlan_id=100'],
subnet_ids=['subnet01_id', 'subnet02_id'])
fake_subnets = [
stubs.FakeNeutronSubnet(
name='subnet01',
cidr='192.168.24.0/24',
gateway_ip='192.168.24.1',
host_routes=[{
'destination': '192.168.24.0/24',
'nexthop': '192.168.25.1'
}],
dns_nameservers=['192.168.24.254', '192.168.24.253'],
ip_version=4,
tags=['tripleo_vlan_id=24']),
stubs.FakeNeutronSubnet(
name='subnet02',
cidr='192.168.25.0/24',
gateway_ip='192.168.25.1',
host_routes=[{
'destination': '192.168.24.0/24',
'nexthop': '192.168.25.1'
}],
dns_nameservers=['192.168.25.254', '192.168.25.253'],
ip_version=4,
tags=['tripleo_vlan_id=25'])
]
mock_conn.network.find_network.return_value = fake_network
mock_conn.network.get_subnet.side_effect = fake_subnets
attrs = dict()
cidr_map = dict()
ip_version_map = dict()
plugin.set_composable_network_attrs(module,
mock_conn,
net_data['name'].lower(),
net_data,
attrs=attrs,
cidr_map=cidr_map,
ip_version_map=ip_version_map)
mock_conn.network.find_network.assert_called_with(
net_data['name'].lower())
mock_conn.network.get_subnet.assert_has_calls(
[mock.call('subnet01_id'),
mock.call('subnet02_id')])
self.assertEqual(
{
'network': {
'dns_domain': 'netname.localdomain.',
'mtu': 1500,
'name': 'netname',
'tags': ['tripleo_vlan_id=100']
},
'subnets': {
'subnet01': {
'name':
'subnet01',
'cidr':
'192.168.24.0/24',
'gateway_ip':
'192.168.24.1',
'host_routes': [{
'destination': '192.168.24.0/24',
'nexthop': '192.168.25.1'
}],
'dns_nameservers':
['192.168.24.254', '192.168.24.253'],
'ip_version':
4,
'tags': ['tripleo_vlan_id=24']
},
'subnet02': {
'name':
'subnet02',
'cidr':
'192.168.25.0/24',
'gateway_ip':
'192.168.25.1',
'host_routes': [{
'destination': '192.168.24.0/24',
'nexthop': '192.168.25.1'
}],
'dns_nameservers':
['192.168.25.254', '192.168.25.253'],
'ip_version':
4,
'tags': ['tripleo_vlan_id=25']
}
}
}, attrs)
self.assertEqual({'netname': 4}, ip_version_map)
self.assertEqual({'netname': ['192.168.24.0/24', '192.168.25.0/24']},
cidr_map)
def test_create_name_id_maps(self, conn_mock):
subnet1 = stubs.FakeNeutronSubnet(id='subnet1_id',
name='subnet1',
cidr='192.168.24.0/24')
subnet2 = stubs.FakeNeutronSubnet(id='subnet2_id',
name='subnet2',
cidr='192.168.25.0/25')
subnet3 = stubs.FakeNeutronSubnet(id='subnet3_id',
name='subnet3',
cidr='192.168.26.0/26')
subnet4 = stubs.FakeNeutronSubnet(id='subnet4_id',
name='subnet4',
cidr='192.168.27.0/27')
network1 = stubs.FakeNeutronNetwork(
id='network1_id',
name='network1',
subnet_ids=['subnet1_id', 'subnet2_id'],
tags=['tripleo_network_name=Network1']
)
network2 = stubs.FakeNeutronNetwork(
id='network2_id',
name='network2',
subnet_ids=['subnet3_id', 'subnet4_id'],
tags=['tripleo_network_name=Network2']
)
conn_mock.network.networks.return_value = self.a2g([network1,
network2])
conn_mock.network.subnets.side_effect = [self.a2g([subnet1, subnet2]),
self.a2g([subnet3, subnet4])]
net_maps = network_data_v2.create_name_id_maps(conn_mock)
expected_by_name_map = {
'network1': {
'id': 'network1_id',
'name_upper': 'Network1',
'subnets': {
'subnet1': 'subnet1_id',
'subnet2': 'subnet2_id'
}
},
'network2': {
'id': 'network2_id',
'name_upper': 'Network2',
'subnets': {
'subnet3': 'subnet3_id',
'subnet4': 'subnet4_id'
}
}
}
expected_by_id_map = {
'network1_id': 'network1',
'network2_id': 'network2',
}
expected_cidr_prefix_map = {
'subnet1_id': '24',
'subnet2_id': '25',
'subnet3_id': '26',
'subnet4_id': '27',
}
self.assertEqual(expected_by_name_map, net_maps['by_name'])
self.assertEqual(expected_by_id_map, net_maps['by_id'])
self.assertEqual(expected_cidr_prefix_map, net_maps['cidr_prefix_map'])
