492 lines
24 KiB
Python
492 lines
24 KiB
Python
# Copyright 2019 Red Hat, Inc.
|
|
# All Rights Reserved.
|
|
#
|
|
# 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 copy
|
|
import mock
|
|
import yaml
|
|
|
|
import openstack
|
|
|
|
from tripleo_ansible.tests import base as tests_base
|
|
|
|
from tripleo_ansible.ansible_plugins.module_utils import network_data_v2
|
|
from tripleo_ansible.tests import stubs
|
|
|
|
|
|
NET_DATA = yaml.safe_load('''
|
|
---
|
|
name: Storage
|
|
name_lower: storage
|
|
admin_state_up: false
|
|
dns_domain: storage.localdomain.
|
|
mtu: 1442
|
|
shared: false
|
|
service_net_map_replace: storage
|
|
ipv6: true
|
|
vip: true
|
|
subnets:
|
|
subnet01:
|
|
ip_subnet: 172.18.1.0/24
|
|
gateway_ip: 172.18.1.254
|
|
allocation_pools:
|
|
- start: 172.18.1.1
|
|
end: 172.18.1.250
|
|
routes:
|
|
- destination: 172.18.0.0/24
|
|
nexthop: 172.18.1.254
|
|
ipv6_subnet: 2001:db8:a::/64
|
|
gateway_ipv6: 2001:db8:a::1
|
|
ipv6_allocation_pools:
|
|
- start: 2001:db8:a::0010
|
|
end: 2001:db8:a::fff9
|
|
routes_ipv6:
|
|
- destination: 2001:db8:b::/64
|
|
nexthop: 2001:db8:a::1
|
|
ipv6_address_mode: null
|
|
ipv6_ra_mode: null
|
|
enable_dhcp: false
|
|
physical_network: storage_subnet01
|
|
network_type: flat
|
|
segmentation_id: 21
|
|
vlan: 21
|
|
subnet02:
|
|
ip_subnet: 172.18.0.0/24
|
|
gateway_ip: 172.18.0.254
|
|
allocation_pools:
|
|
- start: 172.18.0.10
|
|
end: 172.18.0.250
|
|
routes:
|
|
- destination: 172.18.1.0/24
|
|
nexthop: 172.18.0.254
|
|
ipv6_subnet: 2001:db8:b::/64
|
|
gateway_ipv6: 2001:db8:b::1
|
|
ipv6_allocation_pools:
|
|
- start: 2001:db8:b::0010
|
|
end: 2001:db8:b::fff9
|
|
routes_ipv6:
|
|
- destination: 2001:db8:a::/64
|
|
nexthop: 2001:db8:b::1
|
|
ipv6_address_mode: null
|
|
ipv6_ra_mode: null
|
|
enable_dhcp: false
|
|
physical_network: storage_subnet01
|
|
network_type: flat
|
|
segmentation_id: 21
|
|
vlan: 20
|
|
''')
|
|
|
|
IPV4_SUBNET_KEYS = {'ip_subnet', 'allocation_pools', 'routes', 'gateway_ip'}
|
|
IPV6_SUBNET_KEYS = {'ipv6_subnet', 'ipv6_allocation_pools', 'routes_ipv6',
|
|
'gateway_ipv6', 'ipv6_address_mode', 'ipv6_ra_mode'}
|
|
|
|
|
|
class TestNetworkDataV2(tests_base.TestCase):
|
|
|
|
def setUp(self):
|
|
super(TestNetworkDataV2, self).setUp()
|
|
# Helper function to convert array to generator
|
|
self.a2g = lambda x: (n for n in x)
|
|
|
|
def test_validator_ok(self):
|
|
ipv4_only = copy.deepcopy(NET_DATA)
|
|
ipv6_only = copy.deepcopy(NET_DATA)
|
|
ipv4_only.pop('ipv6')
|
|
for name, subnet in ipv4_only['subnets'].items():
|
|
[subnet.pop(k) for k in IPV6_SUBNET_KEYS]
|
|
for name, subnet in ipv6_only['subnets'].items():
|
|
[subnet.pop(k) for k in IPV4_SUBNET_KEYS]
|
|
|
|
error_messages = network_data_v2.validate_json_schema(NET_DATA)
|
|
self.assertEqual([], error_messages)
|
|
error_messages = network_data_v2.validate_json_schema(ipv4_only)
|
|
self.assertEqual([], error_messages)
|
|
error_messages = network_data_v2.validate_json_schema(ipv6_only)
|
|
self.assertEqual([], error_messages)
|
|
|
|
def test_validator_fail(self):
|
|
dual = copy.deepcopy(NET_DATA)
|
|
dual.pop('name') # Required
|
|
dual['mtu'] = 400 # too low
|
|
dual['ipv6'] = 'not_bool'
|
|
dual['vip'] = 'not_bool'
|
|
dual['admin_state_up'] = 'not_bool'
|
|
dual['shared'] = 'not_bool'
|
|
dual['invalid_key'] = 'foo'
|
|
s02 = dual['subnets']['subnet02']
|
|
s02['ip_subnet'] = 'invalid'
|
|
s02['gateway_ip'] = '2001:db8:a::1' # Wrong ip version
|
|
s02['allocation_pools'][0]['foo'] = 'foo' # Invalid key
|
|
s02['allocation_pools'][0]['start'] = '2001:db8:a::1'
|
|
s02['routes'][0]['foo'] = 'foo' # Invalid key
|
|
s02['routes'][0]['nexthop'] = '172222.18.1.254'
|
|
s02['routes'][0]['destination'] = '172.18.0.0/99' # netmask error
|
|
s02['enable_dhcp'] = 'not_a_bool'
|
|
s02['physical_network'] = dict() # Invalid, should be string
|
|
s02['network_type'] = 'invalid'
|
|
s02['vlan'] = 'not_an_int'
|
|
s02['ipv6_subnet'] = 'invalid'
|
|
s02['gateway_ipv6'] = '172.18.1.254' # Wrong ip version
|
|
s02['ipv6_allocation_pools'][0]['v6_invalid_key'] = 'foo'
|
|
s02['ipv6_allocation_pools'][0]['end'] = '172.18.1.20'
|
|
s02['routes_ipv6'][0]['v6_invalid_key'] = 'foo'
|
|
s02['routes_ipv6'][0]['destination'] = '2001:XXX8:X::/64'
|
|
s02['ipv6_address_mode'] = 'invalid'
|
|
s02['ipv6_ra_mode'] = 'invalid'
|
|
|
|
ipv4_only = copy.deepcopy(dual)
|
|
ipv6_only = copy.deepcopy(dual)
|
|
for name, subnet in ipv4_only['subnets'].items():
|
|
[subnet.pop(k) for k in IPV6_SUBNET_KEYS]
|
|
for name, subnet in ipv6_only['subnets'].items():
|
|
[subnet.pop(k) for k in IPV4_SUBNET_KEYS]
|
|
ipv4_only['subnets']['subnet01'].pop('ip_subnet') # Required
|
|
ipv6_only['subnets']['subnet01'].pop('ipv6_subnet') # Required
|
|
|
|
error_messages_dual = network_data_v2.validate_json_schema(dual)
|
|
error_messages_dual = '\n'.join(error_messages_dual)
|
|
error_messages_ipv4 = network_data_v2.validate_json_schema(ipv4_only)
|
|
error_messages_ipv4 = '\n'.join(error_messages_ipv4)
|
|
error_messages_ipv6 = network_data_v2.validate_json_schema(ipv6_only)
|
|
error_messages_ipv6 = '\n'.join(error_messages_ipv6)
|
|
|
|
self.assertRegex(error_messages_dual,
|
|
(r"Failed schema validation at admin_state_up:\n"
|
|
r" 'not_bool' is not of type 'boolean'\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"Failed schema validation at mtu:\n"
|
|
r" 400 is less than the minimum of 1000\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"Failed schema validation at shared:\n"
|
|
r" 'not_bool' is not of type 'boolean'\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"Failed schema validation at ipv6:\n"
|
|
r" 'not_bool' is not of type 'boolean'\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"Failed schema validation at vip:\n"
|
|
r" 'not_bool' is not of type 'boolean'\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"Failed schema validation at :\n"
|
|
r".*Additional properties are not allowed "
|
|
r"\('invalid_key' was unexpected\)\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"Failed schema validation at :\n"
|
|
r".*'name' is a required property"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/allocation_pools/items/additionalProperties: "
|
|
r"Additional properties are not allowed \('foo' was "
|
|
r"unexpected\)\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/allocation_pools/items/start/ip_address_version: "
|
|
r"2001:db8:a::1 does not appear to be an IPv4 "
|
|
r"address\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/enable_dhcp/type: 'not_a_bool' is not of type "
|
|
r"'boolean'\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/gateway_ip/ip_address_version: 2001:db8:a::1 "
|
|
r"does not appear to be an IPv4 address\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/gateway_ipv6/ip_address_version: 172.18.1.254 "
|
|
r"does not appear to be an IPv6 address\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/ip_subnet/ip_subnet_version: invalid does not "
|
|
r"appear to be an IPv4 subnet\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/ipv6_address_mode/enum: 'invalid' is not one of "
|
|
r"\[None, 'dhcpv6-stateful', 'dhcpv6-stateless'\]"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/ipv6_allocation_pools/items"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \('v6_invalid_key' was unexpected\)"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/ipv6_allocation_pools/items/end"
|
|
r"/ip_address_version: 172.18.1.20 does not appear "
|
|
r"to be an IPv6 address\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/ipv6_ra_mode/enum: 'invalid' is not one of "
|
|
r"\[None, 'dhcpv6-stateful', 'dhcpv6-stateless'\]\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/ipv6_subnet/ip_subnet_version: invalid does not "
|
|
r"appear to be an IPv6 subnet\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/network_type/enum: 'invalid' is not one of "
|
|
r"\['flat', 'vlan'\]\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/physical_network/type: {} is not of type 'string'"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/routes/items/additionalProperties: Additional "
|
|
r"properties are not allowed \('foo' was unexpected\)"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/routes/items/destination/ip_subnet_version: "
|
|
r"172.18.0.0/99 does not appear to be an IPv4 subnet"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/routes/items/nexthop/ip_address_version: "
|
|
r"172222.18.1.254 does not appear to be an IPv4 "
|
|
r"address\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/routes_ipv6/items/additionalProperties: "
|
|
r"Additional properties are not allowed \("
|
|
r"'v6_invalid_key' was unexpected\)\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/routes_ipv6/items/destination/ip_subnet_version: "
|
|
r"2001:XXX8:X::/64 does not appear to be an IPv6 "
|
|
r"subnet\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/dual_subnet"
|
|
r"/vlan/type: 'not_an_int' is not of type 'integer'"
|
|
r"\n"))
|
|
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \(.*'routes'.* were unexpected\)\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \(.*'allocation_pools'.* were "
|
|
r"unexpected\)\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \(.*'ip_subnet'.* were unexpected\)\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \(.*'gateway_ip'.* were unexpected\)"
|
|
r"\n"))
|
|
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \(.*'routes_ipv6'.* were unexpected\)"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \(.*'ipv6_allocation_pools'.* were "
|
|
r"unexpected\)\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \(.*'ipv6_subnet'.* were unexpected\)"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_dual,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \(.*'gateway_ipv6'.* were unexpected\)"
|
|
r"\n"))
|
|
|
|
self.assertRegex(error_messages_ipv4,
|
|
r"Failed schema validation at subnets/subnet01:\n")
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/required: 'ip_subnet' is a required property\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
r"Failed schema validation at subnets/subnet02:\n")
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/allocation_pools/items/additionalProperties: "
|
|
r"Additional properties are not allowed \('foo' was "
|
|
r"unexpected\)\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/allocation_pools/items/start/ip_address_version: "
|
|
r"2001:db8:a::1 does not appear to be an IPv4 "
|
|
r"address\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet/"
|
|
r"enable_dhcp/type: \'not_a_bool\' is not of type "
|
|
r"\'boolean\'\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/gateway_ip/ip_address_version: 2001:db8:a::1 does "
|
|
r"not appear to be an IPv4 address\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/ip_subnet/ip_subnet_version: invalid does not "
|
|
r"appear to be an IPv4 subnet\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/network_type/enum: 'invalid' is not one of "
|
|
r"\['flat', 'vlan'\].*"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/physical_network/type: {} is not of type 'string'"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/routes/items/additionalProperties: Additional "
|
|
r"properties are not allowed \('foo' was "
|
|
r"unexpected\)\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/routes/items/destination/ip_subnet_version: "
|
|
r"172.18.0.0/99 does not appear to be an IPv4 subnet"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/routes/items/nexthop/ip_address_version: "
|
|
r"172222.18.1.254 does not appear to be an IPv4 "
|
|
r"address\n"))
|
|
self.assertRegex(error_messages_ipv4,
|
|
(r"- subnets/additionalProperties/oneOf/ipv4_subnet"
|
|
r"/vlan/type: 'not_an_int' is not of type 'integer'"
|
|
r"\n"))
|
|
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/enable_dhcp/type: 'not_a_bool' is not of type "
|
|
r"'boolean'\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/gateway_ipv6/ip_address_version: 172.18.1.254 "
|
|
r"does not appear to be an IPv6 address\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/ipv6_address_mode/enum: 'invalid' is not one of "
|
|
r"\[None, 'dhcpv6-stateful', 'dhcpv6-stateless'\]"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/ipv6_allocation_pools/items"
|
|
r"/additionalProperties: Additional properties are "
|
|
r"not allowed \('v6_invalid_key' was unexpected\)"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/ipv6_allocation_pools/items/end"
|
|
r"/ip_address_version: 172.18.1.20 does not appear "
|
|
r"to be an IPv6 address\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/ipv6_subnet/ip_subnet_version: invalid does not "
|
|
r"appear to be an IPv6 subnet\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/network_type/enum: 'invalid' is not one of "
|
|
r"\['flat', 'vlan'\]\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/physical_network/type: {} is not of type 'string'"
|
|
r"\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/routes_ipv6/items/additionalProperties: "
|
|
r"Additional properties are not allowed "
|
|
r"\('v6_invalid_key' was unexpected\)\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/routes_ipv6/items/destination/ip_subnet_version: "
|
|
r"2001:XXX8:X::/64 does not appear to be an IPv6 "
|
|
r"subnet\n"))
|
|
self.assertRegex(error_messages_ipv6,
|
|
(r"- subnets/additionalProperties/oneOf/ipv6_subnet"
|
|
r"/vlan/type: 'not_an_int' is not of type 'integer'"
|
|
r"\n"))
|
|
|
|
def test_tripleo_resource_tags_to_dict(self):
|
|
tags = ['foo=bar', 'baz=qux', 'tripleo_foo=bar', 'tripleo_baz=qux',
|
|
'tripleo_net_idx=3']
|
|
expected = {'tripleo_foo': 'bar', 'tripleo_baz': 'qux',
|
|
'tripleo_net_idx': 3}
|
|
result = network_data_v2.tags_to_dict(tags)
|
|
self.assertEqual(expected, result)
|
|
|
|
@mock.patch.object(openstack.connection, 'Connection', autospec=True)
|
|
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'])
|