Add network_id to VIP to match neutron-lbaas
Change-Id: I5d9e46ddd38d41c0c535a2da6a62a57c71b105ba
This commit is contained in:
Adam Harwell
parent
15e9b51b7b
commit
2ec4460cd9
|
|
@ -29,10 +29,11 @@ from octavia.api.v1.types import load_balancer as lb_types
|
|||
from octavia.common import constants
|
||||
from octavia.common import data_models
|
||||
from octavia.common import exceptions
|
||||
from octavia.common import utils
|
||||
import octavia.common.validate as validate
|
||||
from octavia.db import api as db_api
|
||||
from octavia.db import prepare as db_prepare
|
||||
from octavia.i18n import _LI
|
||||
from octavia.i18n import _, _LI
|
||||
|
||||
CONF = cfg.CONF
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
|
@ -99,6 +100,27 @@ class LoadBalancersController(base.BaseController):
|
|||
return self._convert_db_to_type(db_lb, lb_types.LoadBalancerResponse,
|
||||
children=True)
|
||||
|
||||
@staticmethod
|
||||
def _validate_network_and_fill_or_validate_subnet(load_balancer):
|
||||
network = validate.network_exists_optionally_contains_subnet(
|
||||
network_id=load_balancer.vip.network_id,
|
||||
subnet_id=load_balancer.vip.subnet_id)
|
||||
# If subnet is not provided, pick the first subnet, preferring ipv4
|
||||
if not load_balancer.vip.subnet_id:
|
||||
network_driver = utils.get_network_driver()
|
||||
for subnet_id in network.subnets:
|
||||
# Use the first subnet, in case there are no ipv4 subnets
|
||||
if not load_balancer.vip.subnet_id:
|
||||
load_balancer.vip.subnet_id = subnet_id
|
||||
subnet = network_driver.get_subnet(subnet_id)
|
||||
if subnet.ip_version == 4:
|
||||
load_balancer.vip.subnet_id = subnet_id
|
||||
break
|
||||
if not load_balancer.vip.subnet_id:
|
||||
raise exceptions.ValidationException(detail=_(
|
||||
"Supplied network does not contain a subnet."
|
||||
))
|
||||
|
||||
@wsme_pecan.wsexpose(lb_types.LoadBalancerResponse,
|
||||
body=lb_types.LoadBalancerPOST, status_code=202)
|
||||
def post(self, load_balancer):
|
||||
|
|
@ -111,15 +133,29 @@ class LoadBalancersController(base.BaseController):
|
|||
project_id = load_balancer.project_id
|
||||
|
||||
if not project_id:
|
||||
raise exceptions.MissingAPIProjectID()
|
||||
raise exceptions.ValidationException(detail=_(
|
||||
"Missing project ID in request where one is required."))
|
||||
|
||||
load_balancer.project_id = project_id
|
||||
|
||||
# Validate the subnet id
|
||||
if load_balancer.vip.subnet_id:
|
||||
if not validate.subnet_exists(load_balancer.vip.subnet_id):
|
||||
raise exceptions.NotFound(resource='Subnet',
|
||||
id=load_balancer.vip.subnet_id)
|
||||
if not (load_balancer.vip.port_id
|
||||
or load_balancer.vip.network_id
|
||||
or load_balancer.vip.subnet_id):
|
||||
raise exceptions.ValidationException(detail=_(
|
||||
"VIP must contain one of: port_id, network_id, subnet_id."))
|
||||
|
||||
# Validate the port id
|
||||
if load_balancer.vip.port_id:
|
||||
port = validate.port_exists(port_id=load_balancer.vip.port_id)
|
||||
load_balancer.vip.network_id = port.network_id
|
||||
# If no port id, validate the network id (and subnet if provided)
|
||||
elif load_balancer.vip.network_id:
|
||||
self._validate_network_and_fill_or_validate_subnet(load_balancer)
|
||||
# Validate just the subnet id
|
||||
elif load_balancer.vip.subnet_id:
|
||||
subnet = validate.subnet_exists(
|
||||
subnet_id=load_balancer.vip.subnet_id)
|
||||
load_balancer.vip.network_id = subnet.network_id
|
||||
|
||||
lock_session = db_api.get_session(autocommit=False)
|
||||
if self.repositories.check_quota_met(
|
||||
|
|
|
|||
|
|
@ -99,9 +99,8 @@ class MembersController(base.BaseController):
|
|||
self.load_balancer_id)
|
||||
|
||||
# Validate member subnet
|
||||
if member.subnet_id and not validate.subnet_exists(member.subnet_id):
|
||||
raise exceptions.NotFound(resource='Subnet',
|
||||
id=member.subnet_id)
|
||||
if member.subnet_id:
|
||||
validate.subnet_exists(member.subnet_id)
|
||||
|
||||
lock_session = db_api.get_session(autocommit=False)
|
||||
if self.repositories.check_quota_met(
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class VIP(base.BaseType):
|
|||
ip_address = wtypes.wsattr(base.IPAddressType())
|
||||
port_id = wtypes.wsattr(wtypes.UuidType())
|
||||
subnet_id = wtypes.wsattr(wtypes.UuidType())
|
||||
network_id = wtypes.wsattr(wtypes.UuidType())
|
||||
|
||||
|
||||
class LoadBalancerResponse(base.BaseType):
|
||||
|
|
|
|||
|
|
@ -417,10 +417,12 @@ class VRRPGroup(BaseDataModel):
|
|||
class Vip(BaseDataModel):
|
||||
|
||||
def __init__(self, load_balancer_id=None, ip_address=None,
|
||||
subnet_id=None, port_id=None, load_balancer=None):
|
||||
subnet_id=None, network_id=None, port_id=None,
|
||||
load_balancer=None):
|
||||
self.load_balancer_id = load_balancer_id
|
||||
self.ip_address = ip_address
|
||||
self.subnet_id = subnet_id
|
||||
self.network_id = network_id
|
||||
self.port_id = port_id
|
||||
self.load_balancer = load_balancer
|
||||
|
||||
|
|
|
|||
|
|
@ -255,6 +255,11 @@ class MissingProjectID(OctaviaException):
|
|||
message = _('Missing project ID in request where one is required.')
|
||||
|
||||
|
||||
class MissingAPIProjectID(APIException):
|
||||
msg = _('Missing project ID in request where one is required.')
|
||||
class InvalidSubresource(APIException):
|
||||
msg = _('%(resource)s %(id)s not found.')
|
||||
code = 400
|
||||
|
||||
|
||||
class ValidationException(APIException):
|
||||
msg = _('Validation failure: %(detail)s')
|
||||
code = 400
|
||||
|
|
|
|||
|
|
@ -202,12 +202,38 @@ def sanitize_l7policy_api_args(l7policy, create=False):
|
|||
return l7policy
|
||||
|
||||
|
||||
def subnet_exists(subnet_id):
|
||||
def port_exists(port_id):
|
||||
"""Raises an exception when a port does not exist."""
|
||||
network_driver = utils.get_network_driver()
|
||||
# Throws an exception when trying to get a subnet which
|
||||
# does not exist.
|
||||
try:
|
||||
network_driver.get_subnet(subnet_id)
|
||||
port = network_driver.get_port(port_id)
|
||||
except Exception:
|
||||
return False
|
||||
return True
|
||||
raise exceptions.InvalidSubresource(resource='Port', id=port_id)
|
||||
return port
|
||||
|
||||
|
||||
def subnet_exists(subnet_id):
|
||||
"""Raises an exception when a subnet does not exist."""
|
||||
network_driver = utils.get_network_driver()
|
||||
try:
|
||||
subnet = network_driver.get_subnet(subnet_id)
|
||||
except Exception:
|
||||
raise exceptions.InvalidSubresource(resource='Subnet', id=subnet_id)
|
||||
return subnet
|
||||
|
||||
|
||||
def network_exists_optionally_contains_subnet(network_id, subnet_id=None):
|
||||
"""Raises an exception when a network does not exist.
|
||||
|
||||
If a subnet is provided, also validate the network contains that subnet.
|
||||
"""
|
||||
network_driver = utils.get_network_driver()
|
||||
try:
|
||||
network = network_driver.get_network(network_id)
|
||||
except Exception:
|
||||
raise exceptions.InvalidSubresource(resource='Network', id=network_id)
|
||||
if subnet_id:
|
||||
if not network.subnets or subnet_id not in network.subnets:
|
||||
raise exceptions.InvalidSubresource(resource='Subnet',
|
||||
id=subnet_id)
|
||||
return network
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
# Copyright 2017 GoDaddy
|
||||
#
|
||||
# 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.
|
||||
"""Add a column network_id in table vip
|
||||
|
||||
Revision ID: 443fe6676637
|
||||
Revises: 3f8ff3be828e
|
||||
Create Date: 2017-02-06 15:21:25.637744
|
||||
|
||||
"""
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision = '443fe6676637'
|
||||
down_revision = '3f8ff3be828e'
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
|
||||
def upgrade():
|
||||
op.add_column(u'vip',
|
||||
sa.Column(u'network_id', sa.String(36), nullable=True))
|
||||
|
|
@ -332,6 +332,7 @@ class Vip(base_models.BASE):
|
|||
ip_address = sa.Column(sa.String(64), nullable=True)
|
||||
port_id = sa.Column(sa.String(36), nullable=True)
|
||||
subnet_id = sa.Column(sa.String(36), nullable=True)
|
||||
network_id = sa.Column(sa.String(36), nullable=True)
|
||||
load_balancer = orm.relationship("LoadBalancer", uselist=False,
|
||||
backref=orm.backref("vip", uselist=False,
|
||||
cascade="delete"))
|
||||
|
|
|
|||
|
|
@ -323,22 +323,15 @@ class AllowedAddressPairsDriver(neutron_base.BaseNeutronDriver):
|
|||
return plugged_amphorae
|
||||
|
||||
def allocate_vip(self, load_balancer):
|
||||
if not load_balancer.vip.port_id and not load_balancer.vip.subnet_id:
|
||||
raise base.AllocateVIPException('Cannot allocate a vip '
|
||||
'without a port_id or '
|
||||
'a subnet_id.')
|
||||
if load_balancer.vip.port_id:
|
||||
LOG.info(_LI('Port %s already exists. Nothing to be done.'),
|
||||
load_balancer.vip.port_id)
|
||||
port = self.get_port(load_balancer.vip.port_id)
|
||||
return self._port_to_vip(port, load_balancer)
|
||||
|
||||
# Must retrieve the network_id from the subnet
|
||||
subnet = self.get_subnet(load_balancer.vip.subnet_id)
|
||||
|
||||
# It can be assumed that network_id exists
|
||||
port = {'port': {'name': 'octavia-lb-' + load_balancer.id,
|
||||
'network_id': subnet.network_id,
|
||||
'network_id': load_balancer.vip.network_id,
|
||||
'admin_state_up': False,
|
||||
'device_id': 'lb-{0}'.format(load_balancer.id),
|
||||
'device_owner': OCTAVIA_OWNER}}
|
||||
|
|
@ -347,7 +340,7 @@ class AllowedAddressPairsDriver(neutron_base.BaseNeutronDriver):
|
|||
except Exception:
|
||||
message = _('Error creating neutron port on network '
|
||||
'{network_id}.').format(
|
||||
network_id=subnet.network_id)
|
||||
network_id=load_balancer.vip.network_id)
|
||||
LOG.exception(message)
|
||||
raise base.AllocateVIPException(message)
|
||||
new_port = utils.convert_port_dict_to_model(new_port)
|
||||
|
|
@ -488,7 +481,6 @@ class AllowedAddressPairsDriver(neutron_base.BaseNeutronDriver):
|
|||
raise base.PortNotFound()
|
||||
|
||||
def plug_port(self, amphora, port):
|
||||
plugged_interface = None
|
||||
try:
|
||||
interface = self.nova_client.servers.interface_attach(
|
||||
server=amphora.compute_id, net_id=None,
|
||||
|
|
|
|||
|
|
@ -22,7 +22,8 @@ class TestHealthMonitor(base.BaseAPITest):
|
|||
|
||||
def setUp(self):
|
||||
super(TestHealthMonitor, self).setUp()
|
||||
self.lb = self.create_load_balancer({})
|
||||
self.lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.set_lb_status(self.lb.get('id'))
|
||||
self.listener = self.create_listener(self.lb.get('id'),
|
||||
constants.PROTOCOL_HTTP, 80)
|
||||
|
|
|
|||
|
|
@ -22,7 +22,8 @@ class TestL7Policy(base.BaseAPITest):
|
|||
|
||||
def setUp(self):
|
||||
super(TestL7Policy, self).setUp()
|
||||
self.lb = self.create_load_balancer({})
|
||||
self.lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.set_lb_status(self.lb.get('id'))
|
||||
self.listener = self.create_listener(self.lb.get('id'),
|
||||
constants.PROTOCOL_HTTP, 80)
|
||||
|
|
|
|||
|
|
@ -22,7 +22,8 @@ class TestL7Rule(base.BaseAPITest):
|
|||
|
||||
def setUp(self):
|
||||
super(TestL7Rule, self).setUp()
|
||||
self.lb = self.create_load_balancer({})
|
||||
self.lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.set_lb_status(self.lb.get('id'))
|
||||
self.listener = self.create_listener(self.lb.get('id'),
|
||||
constants.PROTOCOL_HTTP, 80)
|
||||
|
|
|
|||
|
|
@ -23,7 +23,8 @@ class TestListener(base.BaseAPITest):
|
|||
|
||||
def setUp(self):
|
||||
super(TestListener, self).setUp()
|
||||
self.lb = self.create_load_balancer({})
|
||||
self.lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.set_lb_status(self.lb.get('id'))
|
||||
self.listeners_path = self.LISTENERS_PATH.format(
|
||||
lb_id=self.lb.get('id'))
|
||||
|
|
@ -339,8 +340,9 @@ class TestListener(base.BaseAPITest):
|
|||
self.put(listener_path, new_listener, status=400)
|
||||
|
||||
def test_update_pending_create(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb_listener = {'name': 'listener1', 'description': 'desc1',
|
||||
'enabled': False, 'protocol': constants.PROTOCOL_HTTP,
|
||||
'protocol_port': 80, 'connection_limit': 10,
|
||||
|
|
@ -349,8 +351,9 @@ class TestListener(base.BaseAPITest):
|
|||
lb_listener, status=409)
|
||||
|
||||
def test_delete_pending_update(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
self.set_lb_status(lb.get('id'))
|
||||
lb_listener = {'name': 'listener1', 'description': 'desc1',
|
||||
'enabled': False, 'protocol': constants.PROTOCOL_HTTP,
|
||||
|
|
@ -363,8 +366,9 @@ class TestListener(base.BaseAPITest):
|
|||
status=409)
|
||||
|
||||
def test_update_pending_update(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
self.set_lb_status(lb.get('id'))
|
||||
lb_listener = {'name': 'listener1', 'description': 'desc1',
|
||||
'enabled': False, 'protocol': constants.PROTOCOL_HTTP,
|
||||
|
|
@ -379,8 +383,9 @@ class TestListener(base.BaseAPITest):
|
|||
{}, status=409)
|
||||
|
||||
def test_update_pending_delete(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
self.set_lb_status(lb.get('id'))
|
||||
lb_listener = {'name': 'listener1', 'description': 'desc1',
|
||||
'enabled': False, 'protocol': constants.PROTOCOL_HTTP,
|
||||
|
|
@ -395,8 +400,9 @@ class TestListener(base.BaseAPITest):
|
|||
{}, status=409)
|
||||
|
||||
def test_delete_pending_delete(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
self.set_lb_status(lb.get('id'))
|
||||
lb_listener = {'name': 'listener1', 'description': 'desc1',
|
||||
'enabled': False, 'protocol': constants.PROTOCOL_HTTP,
|
||||
|
|
|
|||
|
|
@ -23,7 +23,8 @@ class TestListenerStatistics(base.BaseAPITest):
|
|||
|
||||
def setUp(self):
|
||||
super(TestListenerStatistics, self).setUp()
|
||||
self.lb = self.create_load_balancer({})
|
||||
self.lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.set_lb_status(self.lb.get('id'))
|
||||
self.listener = self.create_listener(self.lb.get('id'),
|
||||
constants.PROTOCOL_HTTP, 80)
|
||||
|
|
|
|||
|
|
@ -19,59 +19,230 @@ from oslo_utils import uuidutils
|
|||
|
||||
from octavia.common import constants
|
||||
from octavia.network import base as network_base
|
||||
from octavia.network import data_models as network_models
|
||||
from octavia.tests.functional.api.v1 import base
|
||||
|
||||
|
||||
class TestLoadBalancer(base.BaseAPITest):
|
||||
|
||||
def _assert_request_matches_response(self, req, resp, **optionals):
|
||||
self.assertTrue(uuidutils.is_uuid_like(resp.get('id')))
|
||||
self.assertEqual(req.get('name'), resp.get('name'))
|
||||
self.assertEqual(req.get('description'), resp.get('description'))
|
||||
self.assertEqual(constants.PENDING_CREATE,
|
||||
resp.get('provisioning_status'))
|
||||
self.assertEqual(constants.OFFLINE, resp.get('operating_status'))
|
||||
self.assertEqual(req.get('enabled', True), resp.get('enabled'))
|
||||
self.assertIsNotNone(resp.get('created_at'))
|
||||
self.assertIsNone(resp.get('updated_at'))
|
||||
for key, value in optionals.items():
|
||||
self.assertEqual(value, req.get(key))
|
||||
self.assert_final_lb_statuses(resp.get('id'))
|
||||
|
||||
def test_empty_list(self):
|
||||
response = self.get(self.LBS_PATH)
|
||||
api_list = response.json
|
||||
self.assertEqual([], api_list)
|
||||
|
||||
def test_create(self, **optionals):
|
||||
lb_json = {'name': 'test1', 'vip': {}, 'project_id': self.project_id}
|
||||
lb_json = {'name': 'test1',
|
||||
'vip': {'subnet_id': uuidutils.generate_uuid()},
|
||||
'project_id': self.project_id}
|
||||
lb_json.update(optionals)
|
||||
response = self.post(self.LBS_PATH, lb_json)
|
||||
api_lb = response.json
|
||||
self.assertTrue(uuidutils.is_uuid_like(api_lb.get('id')))
|
||||
self.assertEqual(lb_json.get('name'), api_lb.get('name'))
|
||||
self.assertEqual(constants.PENDING_CREATE,
|
||||
api_lb.get('provisioning_status'))
|
||||
self.assertEqual(constants.OFFLINE,
|
||||
api_lb.get('operating_status'))
|
||||
self.assertTrue(api_lb.get('enabled'))
|
||||
self.assertIsNotNone(api_lb.get('created_at'))
|
||||
self.assertIsNone(api_lb.get('updated_at'))
|
||||
for key, value in optionals.items():
|
||||
self.assertEqual(value, lb_json.get(key))
|
||||
self.assert_final_lb_statuses(api_lb.get('id'))
|
||||
self._assert_request_matches_response(lb_json, api_lb)
|
||||
|
||||
def test_create_with_id(self):
|
||||
self.test_create(id=uuidutils.generate_uuid())
|
||||
|
||||
def test_create_with_duplicate_id(self):
|
||||
lb = self.create_load_balancer({})
|
||||
self.post(self.LBS_PATH, {'id': lb.get('id'), 'vip': {}},
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.post(self.LBS_PATH,
|
||||
{'id': lb.get('id'),
|
||||
'vip': {'subnet_id': uuidutils.generate_uuid()}},
|
||||
status=409, expect_errors=True)
|
||||
|
||||
def test_create_without_vip(self):
|
||||
lb_json = {'name': 'test1'}
|
||||
self.post(self.LB_PATH, lb_json, status=400)
|
||||
|
||||
def test_create_with_project_id(self):
|
||||
self.test_create(project_id=uuidutils.generate_uuid())
|
||||
|
||||
def test_create_over_quota(self):
|
||||
lb_json = {'name': 'test1', 'vip': {}, 'project_id': self.project_id}
|
||||
lb_json = {'name': 'test1',
|
||||
'vip': {'subnet_id': uuidutils.generate_uuid()},
|
||||
'project_id': self.project_id}
|
||||
self.check_quota_met_true_mock.start()
|
||||
self.addCleanup(self.check_quota_met_true_mock.stop)
|
||||
self.post(self.LBS_PATH, lb_json, status=403)
|
||||
|
||||
def test_create_without_vip(self):
|
||||
lb_json = {}
|
||||
response = self.post(self.LBS_PATH, lb_json, status=400)
|
||||
err_msg = ("Invalid input for field/attribute vip. Value: 'None'. "
|
||||
"Mandatory field missing.")
|
||||
self.assertEqual(response.json.get('faultstring'), err_msg)
|
||||
|
||||
def test_create_with_empty_vip(self):
|
||||
lb_json = {'vip': {},
|
||||
'project_id': self.project_id}
|
||||
response = self.post(self.LBS_PATH, lb_json, status=400)
|
||||
err_msg = ('Validation failure: '
|
||||
'VIP must contain one of: port_id, network_id, subnet_id.')
|
||||
self.assertEqual(response.json.get('faultstring'), err_msg)
|
||||
|
||||
def test_create_with_invalid_vip_subnet(self):
|
||||
subnet_id = uuidutils.generate_uuid()
|
||||
lb_json = {'vip': {'subnet_id': subnet_id},
|
||||
'project_id': self.project_id}
|
||||
with mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_subnet") as mock_get_subnet:
|
||||
mock_get_subnet.side_effect = network_base.SubnetNotFound
|
||||
response = self.post(self.LBS_PATH, lb_json, status=400)
|
||||
err_msg = 'Subnet {} not found.'.format(subnet_id)
|
||||
self.assertEqual(response.json.get('faultstring'), err_msg)
|
||||
|
||||
def test_create_with_invalid_vip_network_subnet(self):
|
||||
network = network_models.Network(id=uuidutils.generate_uuid(),
|
||||
subnets=[])
|
||||
subnet_id = uuidutils.generate_uuid()
|
||||
lb_json = {
|
||||
'vip': {
|
||||
'subnet_id': subnet_id,
|
||||
'network_id': network.id
|
||||
},
|
||||
'project_id': self.project_id}
|
||||
with mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_network") as mock_get_network:
|
||||
mock_get_network.return_value = network
|
||||
response = self.post(self.LBS_PATH, lb_json, status=400)
|
||||
err_msg = 'Subnet {} not found.'.format(subnet_id)
|
||||
self.assertEqual(response.json.get('faultstring'), err_msg)
|
||||
|
||||
def test_create_with_vip_subnet_fills_network(self):
|
||||
subnet = network_models.Subnet(id=uuidutils.generate_uuid(),
|
||||
network_id=uuidutils.generate_uuid())
|
||||
vip = {'subnet_id': subnet.id}
|
||||
lb_json = {'vip': vip,
|
||||
'project_id': self.project_id}
|
||||
with mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_subnet") as mock_get_subnet:
|
||||
mock_get_subnet.return_value = subnet
|
||||
response = self.post(self.LBS_PATH, lb_json)
|
||||
api_lb = response.json
|
||||
self._assert_request_matches_response(lb_json, api_lb)
|
||||
self.assertEqual(subnet.id,
|
||||
api_lb.get('vip', {}).get('subnet_id'))
|
||||
self.assertEqual(subnet.network_id,
|
||||
api_lb.get('vip', {}).get('network_id'))
|
||||
|
||||
def test_create_with_vip_network_has_no_subnet(self):
|
||||
network = network_models.Network(id=uuidutils.generate_uuid(),
|
||||
subnets=[])
|
||||
lb_json = {
|
||||
'vip': {'network_id': network.id},
|
||||
'project_id': self.project_id}
|
||||
with mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_network") as mock_get_network:
|
||||
mock_get_network.return_value = network
|
||||
response = self.post(self.LBS_PATH, lb_json, status=400)
|
||||
err_msg = ("Validation failure: "
|
||||
"Supplied network does not contain a subnet.")
|
||||
self.assertEqual(response.json.get('faultstring'), err_msg)
|
||||
|
||||
def test_create_with_vip_network_picks_subnet_ipv4(self):
|
||||
network_id = uuidutils.generate_uuid()
|
||||
subnet1 = network_models.Subnet(id=uuidutils.generate_uuid(),
|
||||
network_id=network_id,
|
||||
ip_version=6)
|
||||
subnet2 = network_models.Subnet(id=uuidutils.generate_uuid(),
|
||||
network_id=network_id,
|
||||
ip_version=4)
|
||||
network = network_models.Network(id=network_id,
|
||||
subnets=[subnet1.id, subnet2.id])
|
||||
vip = {'network_id': network.id}
|
||||
lb_json = {'vip': vip,
|
||||
'project_id': self.project_id}
|
||||
with mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_network") as mock_get_network, \
|
||||
mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_subnet") as mock_get_subnet:
|
||||
mock_get_network.return_value = network
|
||||
mock_get_subnet.side_effect = [subnet1, subnet2]
|
||||
response = self.post(self.LBS_PATH, lb_json)
|
||||
api_lb = response.json
|
||||
self._assert_request_matches_response(lb_json, api_lb)
|
||||
self.assertEqual(subnet2.id,
|
||||
api_lb.get('vip', {}).get('subnet_id'))
|
||||
self.assertEqual(network_id,
|
||||
api_lb.get('vip', {}).get('network_id'))
|
||||
|
||||
def test_create_with_vip_network_picks_subnet_ipv6(self):
|
||||
network_id = uuidutils.generate_uuid()
|
||||
subnet = network_models.Subnet(id=uuidutils.generate_uuid(),
|
||||
network_id=network_id,
|
||||
ip_version=6)
|
||||
network = network_models.Network(id=network_id,
|
||||
subnets=[subnet.id])
|
||||
vip = {'network_id': network.id}
|
||||
lb_json = {'vip': vip,
|
||||
'project_id': self.project_id}
|
||||
with mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_network") as mock_get_network, \
|
||||
mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_subnet") as mock_get_subnet:
|
||||
mock_get_network.return_value = network
|
||||
mock_get_subnet.return_value = subnet
|
||||
response = self.post(self.LBS_PATH, lb_json)
|
||||
api_lb = response.json
|
||||
self._assert_request_matches_response(lb_json, api_lb)
|
||||
self.assertEqual(subnet.id,
|
||||
api_lb.get('vip', {}).get('subnet_id'))
|
||||
self.assertEqual(network_id,
|
||||
api_lb.get('vip', {}).get('network_id'))
|
||||
|
||||
def test_create_with_vip_full(self):
|
||||
subnet = network_models.Subnet(id=uuidutils.generate_uuid())
|
||||
network = network_models.Network(id=uuidutils.generate_uuid(),
|
||||
subnets=[subnet])
|
||||
port = network_models.Port(id=uuidutils.generate_uuid(),
|
||||
network_id=network.id)
|
||||
vip = {'ip_address': '10.0.0.1',
|
||||
'subnet_id': subnet.id,
|
||||
'network_id': network.id,
|
||||
'port_id': port.id}
|
||||
lb_json = {'name': 'test1', 'description': 'test1_desc',
|
||||
'vip': vip, 'enabled': False,
|
||||
'project_id': self.project_id}
|
||||
with mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_network") as mock_get_network, \
|
||||
mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_port") as mock_get_port:
|
||||
mock_get_network.return_value = network
|
||||
mock_get_port.return_value = port
|
||||
response = self.post(self.LBS_PATH, lb_json)
|
||||
api_lb = response.json
|
||||
self._assert_request_matches_response(lb_json, api_lb)
|
||||
self.assertEqual(vip, api_lb.get('vip'))
|
||||
|
||||
def test_create_with_long_name(self):
|
||||
lb_json = {'name': 'n' * 256, 'vip': {}}
|
||||
self.post(self.LBS_PATH, lb_json, status=400)
|
||||
|
||||
def test_create_with_long_description(self):
|
||||
lb_json = {'description': 'n' * 256, 'vip': {}}
|
||||
self.post(self.LBS_PATH, lb_json, status=400)
|
||||
|
||||
def test_create_with_nonuuid_vip_attributes(self):
|
||||
lb_json = {'vip': {'subnet_id': 'HI'}}
|
||||
self.post(self.LBS_PATH, lb_json, status=400)
|
||||
|
||||
def test_get_all(self):
|
||||
lb1 = self.create_load_balancer({}, name='lb1')
|
||||
lb2 = self.create_load_balancer({}, name='lb2')
|
||||
lb3 = self.create_load_balancer({}, name='lb3')
|
||||
lb1 = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()}, name='lb1')
|
||||
lb2 = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()}, name='lb2')
|
||||
lb3 = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()}, name='lb3')
|
||||
response = self.get(self.LBS_PATH,
|
||||
params={'project_id': self.project_id})
|
||||
lbs = response.json
|
||||
|
|
@ -84,9 +255,15 @@ class TestLoadBalancer(base.BaseAPITest):
|
|||
def test_get_all_by_project_id(self):
|
||||
project1_id = uuidutils.generate_uuid()
|
||||
project2_id = uuidutils.generate_uuid()
|
||||
lb1 = self.create_load_balancer({}, name='lb1', project_id=project1_id)
|
||||
lb2 = self.create_load_balancer({}, name='lb2', project_id=project1_id)
|
||||
lb3 = self.create_load_balancer({}, name='lb3', project_id=project2_id)
|
||||
lb1 = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', project_id=project1_id)
|
||||
lb2 = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb2', project_id=project1_id)
|
||||
lb3 = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb3', project_id=project2_id)
|
||||
project1_path = "{0}?project_id={1}".format(self.LBS_PATH, project1_id)
|
||||
response = self.get(project1_path)
|
||||
lbs = response.json
|
||||
|
|
@ -102,12 +279,24 @@ class TestLoadBalancer(base.BaseAPITest):
|
|||
self.assertIn((lb3.get('id'), lb3.get('name')), lb_id_names)
|
||||
|
||||
def test_get(self):
|
||||
subnet = network_models.Subnet(id=uuidutils.generate_uuid())
|
||||
network = network_models.Network(id=uuidutils.generate_uuid(),
|
||||
subnets=[subnet])
|
||||
port = network_models.Port(id=uuidutils.generate_uuid(),
|
||||
network_id=network.id)
|
||||
vip = {'ip_address': '10.0.0.1',
|
||||
'port_id': uuidutils.generate_uuid(),
|
||||
'subnet_id': uuidutils.generate_uuid()}
|
||||
lb = self.create_load_balancer(vip, name='lb1',
|
||||
description='test1_desc',
|
||||
enabled=False)
|
||||
'subnet_id': subnet.id,
|
||||
'network_id': network.id,
|
||||
'port_id': port.id}
|
||||
with mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_network") as mock_get_network, \
|
||||
mock.patch("octavia.network.drivers.noop_driver.driver"
|
||||
".NoopManager.get_port") as mock_get_port:
|
||||
mock_get_network.return_value = network
|
||||
mock_get_port.return_value = port
|
||||
lb = self.create_load_balancer(vip, name='lb1',
|
||||
description='test1_desc',
|
||||
enabled=False)
|
||||
response = self.get(self.LB_PATH.format(lb_id=lb.get('id')))
|
||||
self.assertEqual('lb1', response.json.get('name'))
|
||||
self.assertEqual('test1_desc', response.json.get('description'))
|
||||
|
|
@ -118,41 +307,10 @@ class TestLoadBalancer(base.BaseAPITest):
|
|||
path = self.LB_PATH.format(lb_id='SEAN-CONNERY')
|
||||
self.get(path, status=404)
|
||||
|
||||
def test_create_with_vip(self):
|
||||
vip = {'ip_address': '10.0.0.1',
|
||||
'subnet_id': uuidutils.generate_uuid(),
|
||||
'port_id': uuidutils.generate_uuid()}
|
||||
lb_json = {'name': 'test1', 'description': 'test1_desc',
|
||||
'vip': vip, 'enabled': False,
|
||||
'project_id': self.project_id}
|
||||
response = self.post(self.LBS_PATH, lb_json)
|
||||
api_lb = response.json
|
||||
self.assertTrue(uuidutils.is_uuid_like(api_lb.get('id')))
|
||||
self.assertEqual(lb_json.get('name'), api_lb.get('name'))
|
||||
self.assertEqual(lb_json.get('description'), api_lb.get('description'))
|
||||
self.assertEqual(constants.PENDING_CREATE,
|
||||
api_lb['provisioning_status'])
|
||||
self.assertEqual(constants.OFFLINE,
|
||||
api_lb['operating_status'])
|
||||
self.assertEqual(vip, api_lb.get('vip'))
|
||||
self.assertEqual(lb_json.get('enabled'), api_lb.get('enabled'))
|
||||
self.assert_final_lb_statuses(api_lb.get('id'))
|
||||
|
||||
def test_create_with_long_name(self):
|
||||
lb_json = {'name': 'n' * 256, 'vip': {}}
|
||||
self.post(self.LBS_PATH, lb_json, status=400)
|
||||
|
||||
def test_create_with_long_description(self):
|
||||
lb_json = {'description': 'n' * 256, 'vip': {}}
|
||||
self.post(self.LBS_PATH, lb_json, status=400)
|
||||
|
||||
def test_create_with_nonuuid_vip_attributes(self):
|
||||
lb_json = {'vip': {'subnet_id': 'HI'}}
|
||||
self.post(self.LBS_PATH, lb_json, status=400)
|
||||
|
||||
def test_update(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb_json = {'name': 'lb2'}
|
||||
lb = self.set_lb_status(lb.get('id'))
|
||||
response = self.put(self.LB_PATH.format(lb_id=lb.get('id')), lb_json)
|
||||
|
|
@ -171,8 +329,9 @@ class TestLoadBalancer(base.BaseAPITest):
|
|||
self.assert_final_lb_statuses(api_lb.get('id'))
|
||||
|
||||
def test_update_with_vip(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb_json = {'vip': {'subnet_id': '1234'}}
|
||||
lb = self.set_lb_status(lb.get('id'))
|
||||
self.put(self.LB_PATH.format(lb_id=lb.get('id')), lb_json, status=400)
|
||||
|
|
@ -182,56 +341,64 @@ class TestLoadBalancer(base.BaseAPITest):
|
|||
self.put(path, body={}, status=404)
|
||||
|
||||
def test_update_pending_create(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb_json = {'name': 'Roberto'}
|
||||
self.put(self.LB_PATH.format(lb_id=lb.get('id')), lb_json, status=409)
|
||||
|
||||
def test_delete_pending_create(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
self.delete(self.LB_PATH.format(lb_id=lb.get('id')), status=409)
|
||||
|
||||
def test_update_pending_update(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb_json = {'name': 'Bob'}
|
||||
lb = self.set_lb_status(lb.get('id'))
|
||||
self.put(self.LB_PATH.format(lb_id=lb.get('id')), lb_json)
|
||||
self.put(self.LB_PATH.format(lb_id=lb.get('id')), lb_json, status=409)
|
||||
|
||||
def test_delete_pending_update(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb_json = {'name': 'Steve'}
|
||||
lb = self.set_lb_status(lb.get('id'))
|
||||
self.put(self.LB_PATH.format(lb_id=lb.get('id')), lb_json)
|
||||
self.delete(self.LB_PATH.format(lb_id=lb.get('id')), status=409)
|
||||
|
||||
def test_delete_with_error_status(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb = self.set_lb_status(lb.get('id'), status=constants.ERROR)
|
||||
self.delete(self.LB_PATH.format(lb_id=lb.get('id')), status=202)
|
||||
|
||||
def test_update_pending_delete(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb = self.set_lb_status(lb.get('id'))
|
||||
self.delete(self.LB_PATH.format(lb_id=lb.get('id')))
|
||||
lb_json = {'name': 'John'}
|
||||
self.put(self.LB_PATH.format(lb_id=lb.get('id')), lb_json, status=409)
|
||||
|
||||
def test_delete_pending_delete(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb = self.set_lb_status(lb.get('id'))
|
||||
self.delete(self.LB_PATH.format(lb_id=lb.get('id')))
|
||||
self.delete(self.LB_PATH.format(lb_id=lb.get('id')), status=409)
|
||||
|
||||
def test_delete(self):
|
||||
lb = self.create_load_balancer({}, name='lb1', description='desc1',
|
||||
enabled=False)
|
||||
lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()},
|
||||
name='lb1', description='desc1', enabled=False)
|
||||
lb = self.set_lb_status(lb.get('id'))
|
||||
self.delete(self.LB_PATH.format(lb_id=lb.get('id')))
|
||||
response = self.get(self.LB_PATH.format(lb_id=lb.get('id')))
|
||||
|
|
@ -249,36 +416,6 @@ class TestLoadBalancer(base.BaseAPITest):
|
|||
path = self.LB_PATH.format(lb_id='bad_uuid')
|
||||
self.delete(path, status=404)
|
||||
|
||||
def test_create_with_bad_subnet(self, **optionals):
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_subnet = mock.Mock(
|
||||
side_effect=network_base.SubnetNotFound('Subnet not found'))
|
||||
subnet_id = uuidutils.generate_uuid()
|
||||
lb_json = {'name': 'test1',
|
||||
'vip': {'subnet_id': subnet_id,
|
||||
'ip_address': '10.0.0.1'},
|
||||
'project_id': self.project_id}
|
||||
lb_json.update(optionals)
|
||||
response = self.post(self.LBS_PATH, lb_json, expect_errors=True)
|
||||
err_msg = 'Subnet ' + subnet_id + ' not found.'
|
||||
self.assertEqual(response.json.get('faultstring'), err_msg)
|
||||
|
||||
def test_create_with_valid_subnet(self, **optionals):
|
||||
subnet_id = uuidutils.generate_uuid()
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_subnet.return_value = subnet_id
|
||||
lb_json = {'name': 'test1',
|
||||
'vip': {'subnet_id': subnet_id,
|
||||
'ip_address': '10.0.0.1'},
|
||||
'project_id': self.project_id}
|
||||
lb_json.update(optionals)
|
||||
response = self.post(self.LBS_PATH, lb_json)
|
||||
api_lb = response.json
|
||||
self.assertEqual(lb_json.get('vip')['subnet_id'],
|
||||
api_lb.get('vip')['subnet_id'])
|
||||
|
||||
|
||||
class TestLoadBalancerGraph(base.BaseAPITest):
|
||||
|
||||
|
|
@ -346,22 +483,23 @@ class TestLoadBalancerGraph(base.BaseAPITest):
|
|||
self.assertIn(observed_listener, expected_listeners)
|
||||
|
||||
def _get_lb_bodies(self, create_listeners, expected_listeners):
|
||||
subnet_id = uuidutils.generate_uuid()
|
||||
create_lb = {
|
||||
'name': 'lb1',
|
||||
'project_id': self._project_id,
|
||||
'vip': {},
|
||||
'vip': {'subnet_id': subnet_id},
|
||||
'listeners': create_listeners
|
||||
}
|
||||
expected_lb = {
|
||||
'description': None,
|
||||
'enabled': True,
|
||||
'provisioning_status': constants.PENDING_CREATE,
|
||||
'operating_status': constants.OFFLINE
|
||||
'operating_status': constants.OFFLINE,
|
||||
}
|
||||
expected_lb.update(create_lb)
|
||||
expected_lb['listeners'] = expected_listeners
|
||||
expected_lb['vip'] = {'ip_address': None, 'port_id': None,
|
||||
'subnet_id': None}
|
||||
'subnet_id': subnet_id, 'network_id': None}
|
||||
return create_lb, expected_lb
|
||||
|
||||
def _get_listener_bodies(self, name='listener1', protocol_port=80,
|
||||
|
|
|
|||
|
|
@ -23,7 +23,8 @@ class TestLoadBlancerStatistics(base.BaseAPITest):
|
|||
|
||||
def setUp(self):
|
||||
super(TestLoadBlancerStatistics, self).setUp()
|
||||
self.lb = self.create_load_balancer({})
|
||||
self.lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.set_lb_status(self.lb.get('id'))
|
||||
self.listener = self.create_listener(self.lb.get('id'),
|
||||
constants.PROTOCOL_HTTP, 80)
|
||||
|
|
|
|||
|
|
@ -24,7 +24,8 @@ class TestMember(base.BaseAPITest):
|
|||
|
||||
def setUp(self):
|
||||
super(TestMember, self).setUp()
|
||||
self.lb = self.create_load_balancer({})
|
||||
self.lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.set_lb_status(self.lb.get('id'))
|
||||
self.listener = self.create_listener(self.lb.get('id'),
|
||||
constants.PROTOCOL_HTTP, 80)
|
||||
|
|
|
|||
|
|
@ -22,7 +22,8 @@ class TestPool(base.BaseAPITest):
|
|||
|
||||
def setUp(self):
|
||||
super(TestPool, self).setUp()
|
||||
self.lb = self.create_load_balancer({})
|
||||
self.lb = self.create_load_balancer(
|
||||
{'subnet_id': uuidutils.generate_uuid()})
|
||||
self.lb = self.set_lb_status(self.lb.get('id'))
|
||||
self.listener = self.create_listener(self.lb.get('id'),
|
||||
constants.PROTOCOL_HTTP, 80)
|
||||
|
|
|
|||
|
|
@ -12,12 +12,10 @@
|
|||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
from oslo_config import cfg
|
||||
from oslo_config import fixture as oslo_fixture
|
||||
from oslo_db.sqlalchemy import test_base
|
||||
|
||||
# needed for tests to function when run independently:
|
||||
from octavia.common import config # noqa: F401
|
||||
from octavia.common import config
|
||||
from octavia.common import constants
|
||||
from octavia.db import api as db_api
|
||||
from octavia.db import base_models
|
||||
|
|
@ -32,7 +30,7 @@ class OctaviaDBTestBase(test_base.DbTestCase):
|
|||
# session set up in the fixture for test_base.DbTestCase does not work
|
||||
# with the API functional tests. Need to investigate more if this
|
||||
# becomes a problem
|
||||
conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
|
||||
conf = self.useFixture(oslo_fixture.Config(config.cfg.CONF))
|
||||
conf.config(group="database", connection='sqlite://')
|
||||
|
||||
# needed for closure
|
||||
|
|
|
|||
|
|
@ -130,7 +130,8 @@ class AllRepositoriesTest(base.OctaviaDBTestBase):
|
|||
'id': uuidutils.generate_uuid()}
|
||||
vip = {'ip_address': '10.0.0.1',
|
||||
'port_id': uuidutils.generate_uuid(),
|
||||
'subnet_id': uuidutils.generate_uuid()}
|
||||
'subnet_id': uuidutils.generate_uuid(),
|
||||
'network_id': uuidutils.generate_uuid()}
|
||||
lb_dm = self.repos.create_load_balancer_and_vip(self.session, lb, vip)
|
||||
lb_dm_dict = lb_dm.to_dict()
|
||||
del lb_dm_dict['vip']
|
||||
|
|
|
|||
|
|
@ -15,10 +15,12 @@
|
|||
import mock
|
||||
from oslo_utils import uuidutils
|
||||
|
||||
from octavia.api.v1.types import load_balancer as lb_types
|
||||
import octavia.common.constants as constants
|
||||
import octavia.common.exceptions as exceptions
|
||||
import octavia.common.validate as validate
|
||||
from octavia.network import base as network_base
|
||||
from octavia.network import data_models as network_models
|
||||
import octavia.tests.unit.base as base
|
||||
|
||||
|
||||
|
|
@ -243,17 +245,87 @@ class TestValidations(base.TestCase):
|
|||
self.assertRaises(exceptions.InvalidL7PolicyArgs,
|
||||
validate.sanitize_l7policy_api_args, l7p)
|
||||
|
||||
def test_port_exists_with_bad_port(self):
|
||||
port_id = uuidutils.generate_uuid()
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_port = mock.Mock(
|
||||
side_effect=network_base.PortNotFound('Port not found'))
|
||||
self.assertRaises(
|
||||
exceptions.InvalidSubresource,
|
||||
validate.port_exists, port_id)
|
||||
|
||||
def test_port_exists_with_valid_port(self):
|
||||
port_id = uuidutils.generate_uuid()
|
||||
port = network_models.Port(id=port_id)
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_port.return_value = port
|
||||
self.assertEqual(validate.port_exists(port_id), port)
|
||||
|
||||
def test_subnet_exists_with_bad_subnet(self):
|
||||
subnet_id = uuidutils.generate_uuid()
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_subnet = mock.Mock(
|
||||
side_effect=network_base.SubnetNotFound('Subnet not found'))
|
||||
subnet_id = uuidutils.generate_uuid()
|
||||
self.assertEqual(validate.subnet_exists(subnet_id), False)
|
||||
self.assertRaises(
|
||||
exceptions.InvalidSubresource,
|
||||
validate.subnet_exists, subnet_id)
|
||||
|
||||
def test_subnet_exists_with_valid_subnet(self):
|
||||
subnet_id = uuidutils.generate_uuid()
|
||||
subnet = network_models.Subnet(id=subnet_id)
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_subnet.return_value = subnet_id
|
||||
self.assertEqual(validate.subnet_exists(subnet_id), True)
|
||||
net_mock.return_value.get_subnet.return_value = subnet
|
||||
self.assertEqual(validate.subnet_exists(subnet_id), subnet)
|
||||
|
||||
def test_network_exists_with_bad_network(self):
|
||||
vip = lb_types.VIP()
|
||||
vip.network_id = uuidutils.generate_uuid()
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_network = mock.Mock(
|
||||
side_effect=network_base.NetworkNotFound('Network not found'))
|
||||
self.assertRaises(
|
||||
exceptions.InvalidSubresource,
|
||||
validate.network_exists_optionally_contains_subnet, vip)
|
||||
|
||||
def test_network_exists_with_valid_network(self):
|
||||
vip = lb_types.VIP()
|
||||
vip.network_id = uuidutils.generate_uuid()
|
||||
network = network_models.Network(id=vip.network_id)
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_network.return_value = network
|
||||
self.assertEqual(
|
||||
validate.network_exists_optionally_contains_subnet(vip),
|
||||
network)
|
||||
|
||||
def test_network_exists_with_valid_subnet(self):
|
||||
vip = lb_types.VIP()
|
||||
vip.network_id = uuidutils.generate_uuid()
|
||||
vip.subnet_id = uuidutils.generate_uuid()
|
||||
network = network_models.Network(
|
||||
id=vip.network_id,
|
||||
subnets=[vip.subnet_id])
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_network.return_value = network
|
||||
self.assertEqual(
|
||||
validate.network_exists_optionally_contains_subnet(vip),
|
||||
network)
|
||||
|
||||
def test_network_exists_with_bad_subnet(self):
|
||||
vip = lb_types.VIP()
|
||||
vip.network_id = uuidutils.generate_uuid()
|
||||
vip.subnet_id = uuidutils.generate_uuid()
|
||||
network = network_models.Network(id=vip.network_id)
|
||||
with mock.patch(
|
||||
'octavia.common.utils.get_network_driver') as net_mock:
|
||||
net_mock.return_value.get_network.return_value = network
|
||||
self.assertRaises(
|
||||
exceptions.InvalidSubresource,
|
||||
validate.network_exists_optionally_contains_subnet,
|
||||
vip.network_id, vip.subnet_id)
|
||||
|
|
|
|||
|
|
@ -28,9 +28,9 @@ from octavia.network import base as network_base
|
|||
from octavia.network import data_models as network_models
|
||||
from octavia.network.drivers.neutron import allowed_address_pairs
|
||||
from octavia.network.drivers.neutron import base as neutron_base
|
||||
from octavia.tests.common import constants as t_constants
|
||||
from octavia.tests.common import data_model_helpers as dmh
|
||||
from octavia.tests.unit import base
|
||||
from octavia.tests.unit.network.drivers.neutron import constants as n_constants
|
||||
|
||||
|
||||
class TestAllowedAddressPairsDriver(base.TestCase):
|
||||
|
|
@ -240,7 +240,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
]
|
||||
list_security_groups.side_effect = lsc_side_effect
|
||||
interface_attach = self.driver.nova_client.servers.interface_attach
|
||||
interface_attach.return_value = n_constants.MOCK_NOVA_INTERFACE
|
||||
interface_attach.return_value = t_constants.MOCK_NOVA_INTERFACE
|
||||
|
||||
update_port = self.driver.neutron_client.update_port
|
||||
update_port.side_effect = neutron_exceptions.PortNotFoundClient
|
||||
|
|
@ -256,7 +256,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
}
|
||||
}
|
||||
interface_attach = self.driver.nova_client.servers.interface_attach
|
||||
interface_attach.return_value = n_constants.MOCK_NOVA_INTERFACE
|
||||
interface_attach.return_value = t_constants.MOCK_NOVA_INTERFACE
|
||||
list_security_groups = self.driver.neutron_client.list_security_groups
|
||||
list_security_groups.return_value = {
|
||||
'security_groups': [
|
||||
|
|
@ -267,42 +267,47 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
expected_aap = {'port': {'allowed_address_pairs':
|
||||
[{'ip_address': lb.vip.ip_address}]}}
|
||||
interface_list = self.driver.nova_client.servers.interface_list
|
||||
if1 = n_constants.MOCK_NOVA_INTERFACE
|
||||
if2 = n_constants.MockNovaInterface()
|
||||
if1 = t_constants.MOCK_NOVA_INTERFACE
|
||||
if2 = t_constants.MockNovaInterface()
|
||||
if2.net_id = '3'
|
||||
if2.port_id = '4'
|
||||
if2.fixed_ips = [{'ip_address': '10.0.0.2'}]
|
||||
if1.fixed_ips = [{'ip_address': n_constants.MOCK_IP_ADDRESS,
|
||||
if1.fixed_ips = [{'ip_address': t_constants.MOCK_IP_ADDRESS,
|
||||
'subnet_id': lb.vip.subnet_id}]
|
||||
interface_list.return_value = [if1, if2]
|
||||
amps = self.driver.plug_vip(lb, lb.vip)
|
||||
self.assertEqual(5, update_port.call_count)
|
||||
update_port.assert_any_call(if1.port_id, expected_aap)
|
||||
for amp in amps:
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS, amp.vrrp_ip)
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS, amp.vrrp_ip)
|
||||
self.assertEqual(lb.vip.ip_address, amp.ha_ip)
|
||||
self.assertIn(amp.id, [lb.amphorae[0].id, lb.amphorae[1].id])
|
||||
|
||||
def test_allocate_vip_when_port_already_provided(self):
|
||||
fake_lb_vip = data_models.Vip()
|
||||
fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip)
|
||||
self.assertRaises(network_base.AllocateVIPException,
|
||||
self.driver.allocate_vip, fake_lb)
|
||||
show_port = self.driver.neutron_client.show_port
|
||||
show_port.return_value = n_constants.MOCK_NEUTRON_PORT
|
||||
show_port.return_value = t_constants.MOCK_NEUTRON_PORT
|
||||
fake_lb_vip = data_models.Vip(
|
||||
port_id=n_constants.MOCK_PORT_ID,
|
||||
subnet_id=n_constants.MOCK_SUBNET_ID)
|
||||
port_id=t_constants.MOCK_PORT_ID,
|
||||
subnet_id=t_constants.MOCK_SUBNET_ID)
|
||||
fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip)
|
||||
vip = self.driver.allocate_vip(fake_lb)
|
||||
self.assertIsInstance(vip, data_models.Vip)
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS, vip.ip_address)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID, vip.subnet_id)
|
||||
self.assertEqual(n_constants.MOCK_PORT_ID, vip.port_id)
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
|
||||
self.assertEqual(t_constants.MOCK_PORT_ID, vip.port_id)
|
||||
self.assertEqual(fake_lb.id, vip.load_balancer_id)
|
||||
|
||||
def test_allocate_vip_when_port_creation_fails(self):
|
||||
fake_lb_vip = data_models.Vip(
|
||||
subnet_id=t_constants.MOCK_SUBNET_ID)
|
||||
fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip)
|
||||
create_port = self.driver.neutron_client.create_port
|
||||
create_port.side_effect = Exception
|
||||
self.assertRaises(network_base.AllocateVIPException,
|
||||
self.driver.allocate_vip, fake_lb)
|
||||
|
||||
def test_allocate_vip_when_only_subnet_provided(self):
|
||||
port_create_dict = copy.copy(n_constants.MOCK_NEUTRON_PORT)
|
||||
port_create_dict = copy.copy(t_constants.MOCK_NEUTRON_PORT)
|
||||
port_create_dict['port']['device_owner'] = (
|
||||
allowed_address_pairs.OCTAVIA_OWNER)
|
||||
port_create_dict['port']['device_id'] = 'lb-1'
|
||||
|
|
@ -310,16 +315,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
create_port.return_value = port_create_dict
|
||||
show_subnet = self.driver.neutron_client.show_subnet
|
||||
show_subnet.return_value = {'subnet': {
|
||||
'id': n_constants.MOCK_SUBNET_ID,
|
||||
'network_id': n_constants.MOCK_NETWORK_ID
|
||||
'id': t_constants.MOCK_SUBNET_ID,
|
||||
'network_id': t_constants.MOCK_NETWORK_ID
|
||||
}}
|
||||
fake_lb_vip = data_models.Vip(subnet_id=n_constants.MOCK_SUBNET_ID)
|
||||
fake_lb_vip = data_models.Vip(subnet_id=t_constants.MOCK_SUBNET_ID,
|
||||
network_id=t_constants.MOCK_NETWORK_ID)
|
||||
fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip)
|
||||
vip = self.driver.allocate_vip(fake_lb)
|
||||
exp_create_port_call = {
|
||||
'port': {
|
||||
'name': 'octavia-lb-1',
|
||||
'network_id': n_constants.MOCK_NETWORK_ID,
|
||||
'network_id': t_constants.MOCK_NETWORK_ID,
|
||||
'device_id': 'lb-1',
|
||||
'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
|
||||
'admin_state_up': False
|
||||
|
|
@ -327,17 +333,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
}
|
||||
create_port.assert_called_once_with(exp_create_port_call)
|
||||
self.assertIsInstance(vip, data_models.Vip)
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS, vip.ip_address)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID, vip.subnet_id)
|
||||
self.assertEqual(n_constants.MOCK_PORT_ID, vip.port_id)
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
|
||||
self.assertEqual(t_constants.MOCK_PORT_ID, vip.port_id)
|
||||
self.assertEqual(fake_lb.id, vip.load_balancer_id)
|
||||
|
||||
def test_unplug_vip_errors_when_update_port_cant_find_port(self):
|
||||
lb = dmh.generate_load_balancer_tree()
|
||||
list_ports = self.driver.neutron_client.list_ports
|
||||
show_subnet = self.driver.neutron_client.show_subnet
|
||||
show_subnet.return_value = n_constants.MOCK_SUBNET
|
||||
port1 = n_constants.MOCK_NEUTRON_PORT['port']
|
||||
show_subnet.return_value = t_constants.MOCK_SUBNET
|
||||
port1 = t_constants.MOCK_NEUTRON_PORT['port']
|
||||
port2 = {
|
||||
'id': '4', 'network_id': '3', 'fixed_ips':
|
||||
[{'ip_address': '10.0.0.2'}]
|
||||
|
|
@ -351,8 +357,8 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
def test_unplug_vip_errors_when_update_port_fails(self):
|
||||
lb = dmh.generate_load_balancer_tree()
|
||||
show_subnet = self.driver.neutron_client.show_subnet
|
||||
show_subnet.return_value = n_constants.MOCK_SUBNET
|
||||
port1 = n_constants.MOCK_NEUTRON_PORT['port']
|
||||
show_subnet.return_value = t_constants.MOCK_SUBNET
|
||||
port1 = t_constants.MOCK_NEUTRON_PORT['port']
|
||||
port2 = {
|
||||
'id': '4', 'network_id': '3', 'fixed_ips':
|
||||
[{'ip_address': '10.0.0.2'}]
|
||||
|
|
@ -375,9 +381,9 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
def test_unplug_vip(self):
|
||||
lb = dmh.generate_load_balancer_tree()
|
||||
show_subnet = self.driver.neutron_client.show_subnet
|
||||
show_subnet.return_value = n_constants.MOCK_SUBNET
|
||||
show_subnet.return_value = t_constants.MOCK_SUBNET
|
||||
update_port = self.driver.neutron_client.update_port
|
||||
port1 = n_constants.MOCK_NEUTRON_PORT['port']
|
||||
port1 = t_constants.MOCK_NEUTRON_PORT['port']
|
||||
port2 = {
|
||||
'id': '4', 'network_id': '3', 'fixed_ips':
|
||||
[{'ip_address': '10.0.0.2'}]
|
||||
|
|
@ -391,64 +397,64 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
mock.call(port1.get('id'), clear_aap)])
|
||||
|
||||
def test_plug_network_when_compute_instance_cant_be_found(self):
|
||||
net_id = n_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
net_id = t_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
interface_attach = self.driver.nova_client.servers.interface_attach
|
||||
interface_attach.side_effect = nova_exceptions.NotFound(
|
||||
404, message='Instance not found')
|
||||
self.assertRaises(network_base.AmphoraNotFound,
|
||||
self.driver.plug_network,
|
||||
n_constants.MOCK_COMPUTE_ID, net_id)
|
||||
t_constants.MOCK_COMPUTE_ID, net_id)
|
||||
|
||||
def test_plug_network_when_network_cant_be_found(self):
|
||||
net_id = n_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
net_id = t_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
interface_attach = self.driver.nova_client.servers.interface_attach
|
||||
interface_attach.side_effect = nova_exceptions.NotFound(
|
||||
404, message='Network not found')
|
||||
self.assertRaises(network_base.NetworkException,
|
||||
self.driver.plug_network,
|
||||
n_constants.MOCK_COMPUTE_ID, net_id)
|
||||
t_constants.MOCK_COMPUTE_ID, net_id)
|
||||
|
||||
def test_plug_network_when_interface_attach_fails(self):
|
||||
net_id = n_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
net_id = t_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
interface_attach = self.driver.nova_client.servers.interface_attach
|
||||
interface_attach.side_effect = TypeError
|
||||
self.assertRaises(network_base.PlugNetworkException,
|
||||
self.driver.plug_network,
|
||||
n_constants.MOCK_COMPUTE_ID, net_id)
|
||||
t_constants.MOCK_COMPUTE_ID, net_id)
|
||||
|
||||
def test_plug_network(self):
|
||||
net_id = n_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
net_id = t_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
interface_attach = self.driver.nova_client.servers.interface_attach
|
||||
interface_attach.return_value = n_constants.MOCK_NOVA_INTERFACE
|
||||
interface_attach.return_value = t_constants.MOCK_NOVA_INTERFACE
|
||||
oct_interface = self.driver.plug_network(
|
||||
n_constants.MOCK_COMPUTE_ID, net_id)
|
||||
t_constants.MOCK_COMPUTE_ID, net_id)
|
||||
exp_ips = [fixed_ip.get('ip_address')
|
||||
for fixed_ip in n_constants.MOCK_NOVA_INTERFACE.fixed_ips]
|
||||
for fixed_ip in t_constants.MOCK_NOVA_INTERFACE.fixed_ips]
|
||||
actual_ips = [fixed_ip.ip_address
|
||||
for fixed_ip in oct_interface.fixed_ips]
|
||||
self.assertEqual(exp_ips, actual_ips)
|
||||
self.assertEqual(n_constants.MOCK_COMPUTE_ID, oct_interface.compute_id)
|
||||
self.assertEqual(t_constants.MOCK_COMPUTE_ID, oct_interface.compute_id)
|
||||
self.assertEqual(net_id, oct_interface.network_id)
|
||||
|
||||
def test_unplug_network_when_compute_port_cant_be_found(self):
|
||||
net_id = n_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
net_id = t_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
list_ports = self.driver.neutron_client.list_ports
|
||||
list_ports.return_value = {'ports': []}
|
||||
self.assertRaises(network_base.AmphoraNotFound,
|
||||
self.driver.unplug_network,
|
||||
n_constants.MOCK_COMPUTE_ID, net_id)
|
||||
t_constants.MOCK_COMPUTE_ID, net_id)
|
||||
|
||||
def test_unplug_network_when_list_ports_fails(self):
|
||||
net_id = n_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
net_id = t_constants.MOCK_NOVA_INTERFACE.net_id
|
||||
list_ports = self.driver.neutron_client.list_ports
|
||||
list_ports.side_effect = Exception
|
||||
self.assertRaises(network_base.NetworkException,
|
||||
self.driver.unplug_network,
|
||||
n_constants.MOCK_COMPUTE_ID, net_id)
|
||||
t_constants.MOCK_COMPUTE_ID, net_id)
|
||||
|
||||
def test_unplug_network_when_interface_detach_fails(self):
|
||||
list_ports = self.driver.neutron_client.list_ports
|
||||
port1 = n_constants.MOCK_NEUTRON_PORT['port']
|
||||
port1 = t_constants.MOCK_NEUTRON_PORT['port']
|
||||
port2 = {
|
||||
'id': '4', 'network_id': '3', 'fixed_ips':
|
||||
[{'ip_address': '10.0.0.2'}]
|
||||
|
|
@ -458,22 +464,22 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
interface_detach.side_effect = Exception
|
||||
self.assertRaises(network_base.UnplugNetworkException,
|
||||
self.driver.unplug_network,
|
||||
n_constants.MOCK_COMPUTE_ID,
|
||||
t_constants.MOCK_COMPUTE_ID,
|
||||
port2.get('network_id'))
|
||||
|
||||
def test_unplug_network(self):
|
||||
list_ports = self.driver.neutron_client.list_ports
|
||||
port1 = n_constants.MOCK_NEUTRON_PORT['port']
|
||||
port1 = t_constants.MOCK_NEUTRON_PORT['port']
|
||||
port2 = {
|
||||
'id': '4', 'network_id': '3', 'fixed_ips':
|
||||
[{'ip_address': '10.0.0.2'}]
|
||||
}
|
||||
list_ports.return_value = {'ports': [port1, port2]}
|
||||
interface_detach = self.driver.nova_client.servers.interface_detach
|
||||
self.driver.unplug_network(n_constants.MOCK_COMPUTE_ID,
|
||||
self.driver.unplug_network(t_constants.MOCK_COMPUTE_ID,
|
||||
port2.get('network_id'))
|
||||
interface_detach.assert_called_once_with(
|
||||
server=n_constants.MOCK_COMPUTE_ID, port_id=port2.get('id'))
|
||||
server=t_constants.MOCK_COMPUTE_ID, port_id=port2.get('id'))
|
||||
|
||||
def test_update_vip(self):
|
||||
listeners = [data_models.Listener(protocol_port=80, peer_port=1024),
|
||||
|
|
@ -680,11 +686,11 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
amphora_mock.status = constants.DELETED
|
||||
load_balancer_mock.amphorae = [amphora_mock]
|
||||
show_port = self.driver.neutron_client.show_port
|
||||
show_port.return_value = n_constants.MOCK_NEUTRON_PORT
|
||||
show_port.return_value = t_constants.MOCK_NEUTRON_PORT
|
||||
fake_subnet = {'subnet': {
|
||||
'id': n_constants.MOCK_SUBNET_ID,
|
||||
'gateway_ip': n_constants.MOCK_IP_ADDRESS,
|
||||
'cidr': n_constants.MOCK_CIDR}}
|
||||
'id': t_constants.MOCK_SUBNET_ID,
|
||||
'gateway_ip': t_constants.MOCK_IP_ADDRESS,
|
||||
'cidr': t_constants.MOCK_CIDR}}
|
||||
show_subnet = self.driver.neutron_client.show_subnet
|
||||
show_subnet.return_value = fake_subnet
|
||||
configs = self.driver.get_network_configs(load_balancer_mock)
|
||||
|
|
@ -707,7 +713,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
|
|||
# will return the same values if a method happens to call it
|
||||
# multiple times for different subnets. We should be able to verify
|
||||
# different requests get different expected data.
|
||||
expected_port_id = n_constants.MOCK_NEUTRON_PORT['port']['id']
|
||||
expected_port_id = t_constants.MOCK_NEUTRON_PORT['port']['id']
|
||||
self.assertEqual(expected_port_id, config.ha_port.id)
|
||||
self.assertEqual(expected_port_id, config.vrrp_port.id)
|
||||
expected_subnet_id = fake_subnet['subnet']['id']
|
||||
|
|
|
|||
|
|
@ -21,9 +21,9 @@ from octavia.network import base as network_base
|
|||
from octavia.network import data_models as network_models
|
||||
from octavia.network.drivers.neutron import base as neutron_base
|
||||
from octavia.network.drivers.neutron import utils
|
||||
from octavia.tests.common import constants as t_constants
|
||||
from octavia.tests.common import data_model_helpers as dmh
|
||||
from octavia.tests.unit import base
|
||||
from octavia.tests.unit.network.drivers.neutron import constants as n_constants
|
||||
|
||||
|
||||
class TestBaseNeutronNetworkDriver(base.TestCase):
|
||||
|
|
@ -62,17 +62,17 @@ class TestBaseNeutronNetworkDriver(base.TestCase):
|
|||
|
||||
def test__port_to_vip(self):
|
||||
lb = dmh.generate_load_balancer_tree()
|
||||
lb.vip.subnet_id = n_constants.MOCK_SUBNET_ID
|
||||
port = utils.convert_port_dict_to_model(n_constants.MOCK_NEUTRON_PORT)
|
||||
lb.vip.subnet_id = t_constants.MOCK_SUBNET_ID
|
||||
port = utils.convert_port_dict_to_model(t_constants.MOCK_NEUTRON_PORT)
|
||||
vip = self.driver._port_to_vip(port, lb)
|
||||
self.assertIsInstance(vip, data_models.Vip)
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS, vip.ip_address)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID, vip.subnet_id)
|
||||
self.assertEqual(n_constants.MOCK_PORT_ID, vip.port_id)
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
|
||||
self.assertEqual(t_constants.MOCK_PORT_ID, vip.port_id)
|
||||
self.assertEqual(lb.id, vip.load_balancer_id)
|
||||
|
||||
def test__nova_interface_to_octavia_interface(self):
|
||||
nova_interface = n_constants.MockNovaInterface()
|
||||
nova_interface = t_constants.MockNovaInterface()
|
||||
nova_interface.net_id = '1'
|
||||
nova_interface.port_id = '2'
|
||||
nova_interface.fixed_ips = [{'ip_address': '10.0.0.1'}]
|
||||
|
|
@ -87,18 +87,18 @@ class TestBaseNeutronNetworkDriver(base.TestCase):
|
|||
list_ports = self.driver.neutron_client.list_ports
|
||||
list_ports.side_effect = TypeError
|
||||
o_ifaces = self.driver.get_plugged_networks(
|
||||
n_constants.MOCK_COMPUTE_ID)
|
||||
t_constants.MOCK_COMPUTE_ID)
|
||||
self.assertEqual(0, len(o_ifaces))
|
||||
list_ports.side_effect = None
|
||||
list_ports.reset_mock()
|
||||
port1 = n_constants.MOCK_NEUTRON_PORT['port']
|
||||
port1 = t_constants.MOCK_NEUTRON_PORT['port']
|
||||
port2 = {
|
||||
'id': '4', 'network_id': '3', 'fixed_ips':
|
||||
[{'ip_address': '10.0.0.2'}]
|
||||
}
|
||||
list_ports.return_value = {'ports': [port1, port2]}
|
||||
plugged_networks = self.driver.get_plugged_networks(
|
||||
n_constants.MOCK_COMPUTE_ID)
|
||||
t_constants.MOCK_COMPUTE_ID)
|
||||
for pn in plugged_networks:
|
||||
self.assertIn(pn.port_id, [port1.get('id'), port2.get('id')])
|
||||
self.assertIn(pn.network_id, [port1.get('network_id'),
|
||||
|
|
@ -111,161 +111,161 @@ class TestBaseNeutronNetworkDriver(base.TestCase):
|
|||
def test_get_network(self):
|
||||
show_network = self.driver.neutron_client.show_network
|
||||
show_network.return_value = {'network': {
|
||||
'id': n_constants.MOCK_NETWORK_ID,
|
||||
'subnets': [n_constants.MOCK_SUBNET_ID]}}
|
||||
network = self.driver.get_network(n_constants.MOCK_NETWORK_ID)
|
||||
'id': t_constants.MOCK_NETWORK_ID,
|
||||
'subnets': [t_constants.MOCK_SUBNET_ID]}}
|
||||
network = self.driver.get_network(t_constants.MOCK_NETWORK_ID)
|
||||
self.assertIsInstance(network, network_models.Network)
|
||||
self.assertEqual(n_constants.MOCK_NETWORK_ID, network.id)
|
||||
self.assertEqual(t_constants.MOCK_NETWORK_ID, network.id)
|
||||
self.assertEqual(1, len(network.subnets))
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID, network.subnets[0])
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID, network.subnets[0])
|
||||
|
||||
def test_get_subnet(self):
|
||||
show_subnet = self.driver.neutron_client.show_subnet
|
||||
show_subnet.return_value = {'subnet': {
|
||||
'id': n_constants.MOCK_SUBNET_ID,
|
||||
'gateway_ip': n_constants.MOCK_IP_ADDRESS,
|
||||
'cidr': n_constants.MOCK_CIDR}}
|
||||
subnet = self.driver.get_subnet(n_constants.MOCK_SUBNET_ID)
|
||||
'id': t_constants.MOCK_SUBNET_ID,
|
||||
'gateway_ip': t_constants.MOCK_IP_ADDRESS,
|
||||
'cidr': t_constants.MOCK_CIDR}}
|
||||
subnet = self.driver.get_subnet(t_constants.MOCK_SUBNET_ID)
|
||||
self.assertIsInstance(subnet, network_models.Subnet)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID, subnet.id)
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS, subnet.gateway_ip)
|
||||
self.assertEqual(n_constants.MOCK_CIDR, subnet.cidr)
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID, subnet.id)
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS, subnet.gateway_ip)
|
||||
self.assertEqual(t_constants.MOCK_CIDR, subnet.cidr)
|
||||
|
||||
def test_get_port(self):
|
||||
show_port = self.driver.neutron_client.show_port
|
||||
show_port.return_value = {'port': {
|
||||
'id': n_constants.MOCK_PORT_ID,
|
||||
'mac_address': n_constants.MOCK_MAC_ADDR,
|
||||
'network_id': n_constants.MOCK_NETWORK_ID,
|
||||
'id': t_constants.MOCK_PORT_ID,
|
||||
'mac_address': t_constants.MOCK_MAC_ADDR,
|
||||
'network_id': t_constants.MOCK_NETWORK_ID,
|
||||
'fixed_ips': [{
|
||||
'subnet_id': n_constants.MOCK_SUBNET_ID,
|
||||
'ip_address': n_constants.MOCK_IP_ADDRESS
|
||||
'subnet_id': t_constants.MOCK_SUBNET_ID,
|
||||
'ip_address': t_constants.MOCK_IP_ADDRESS
|
||||
}]}}
|
||||
port = self.driver.get_port(n_constants.MOCK_PORT_ID)
|
||||
port = self.driver.get_port(t_constants.MOCK_PORT_ID)
|
||||
self.assertIsInstance(port, network_models.Port)
|
||||
self.assertEqual(n_constants.MOCK_PORT_ID, port.id)
|
||||
self.assertEqual(n_constants.MOCK_MAC_ADDR, port.mac_address)
|
||||
self.assertEqual(n_constants.MOCK_NETWORK_ID, port.network_id)
|
||||
self.assertEqual(t_constants.MOCK_PORT_ID, port.id)
|
||||
self.assertEqual(t_constants.MOCK_MAC_ADDR, port.mac_address)
|
||||
self.assertEqual(t_constants.MOCK_NETWORK_ID, port.network_id)
|
||||
self.assertEqual(1, len(port.fixed_ips))
|
||||
self.assertIsInstance(port.fixed_ips[0], network_models.FixedIP)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID,
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID,
|
||||
port.fixed_ips[0].subnet_id)
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS,
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS,
|
||||
port.fixed_ips[0].ip_address)
|
||||
|
||||
def test_get_network_by_name(self):
|
||||
list_network = self.driver.neutron_client.list_networks
|
||||
list_network.return_value = {'networks': [{'network': {
|
||||
'id': n_constants.MOCK_NETWORK_ID,
|
||||
'name': n_constants.MOCK_NETWORK_NAME,
|
||||
'subnets': [n_constants.MOCK_SUBNET_ID]}}]}
|
||||
'id': t_constants.MOCK_NETWORK_ID,
|
||||
'name': t_constants.MOCK_NETWORK_NAME,
|
||||
'subnets': [t_constants.MOCK_SUBNET_ID]}}]}
|
||||
network = self.driver.get_network_by_name(
|
||||
n_constants.MOCK_NETWORK_NAME)
|
||||
t_constants.MOCK_NETWORK_NAME)
|
||||
self.assertIsInstance(network, network_models.Network)
|
||||
self.assertEqual(n_constants.MOCK_NETWORK_ID, network.id)
|
||||
self.assertEqual(n_constants.MOCK_NETWORK_NAME, network.name)
|
||||
self.assertEqual(t_constants.MOCK_NETWORK_ID, network.id)
|
||||
self.assertEqual(t_constants.MOCK_NETWORK_NAME, network.name)
|
||||
self.assertEqual(1, len(network.subnets))
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID, network.subnets[0])
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID, network.subnets[0])
|
||||
# Negative
|
||||
list_network.side_effect = neutron_client_exceptions.NotFound
|
||||
self.assertRaises(network_base.NetworkNotFound,
|
||||
self.driver.get_network_by_name,
|
||||
n_constants.MOCK_NETWORK_NAME)
|
||||
t_constants.MOCK_NETWORK_NAME)
|
||||
list_network.side_effect = Exception
|
||||
self.assertRaises(network_base.NetworkException,
|
||||
self.driver.get_network_by_name,
|
||||
n_constants.MOCK_NETWORK_NAME)
|
||||
t_constants.MOCK_NETWORK_NAME)
|
||||
|
||||
def test_get_subnet_by_name(self):
|
||||
list_subnet = self.driver.neutron_client.list_subnets
|
||||
list_subnet.return_value = {'subnets': [{'subnet': {
|
||||
'id': n_constants.MOCK_SUBNET_ID,
|
||||
'name': n_constants.MOCK_SUBNET_NAME,
|
||||
'gateway_ip': n_constants.MOCK_IP_ADDRESS,
|
||||
'cidr': n_constants.MOCK_CIDR}}]}
|
||||
subnet = self.driver.get_subnet_by_name(n_constants.MOCK_SUBNET_NAME)
|
||||
'id': t_constants.MOCK_SUBNET_ID,
|
||||
'name': t_constants.MOCK_SUBNET_NAME,
|
||||
'gateway_ip': t_constants.MOCK_IP_ADDRESS,
|
||||
'cidr': t_constants.MOCK_CIDR}}]}
|
||||
subnet = self.driver.get_subnet_by_name(t_constants.MOCK_SUBNET_NAME)
|
||||
self.assertIsInstance(subnet, network_models.Subnet)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID, subnet.id)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_NAME, subnet.name)
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS, subnet.gateway_ip)
|
||||
self.assertEqual(n_constants.MOCK_CIDR, subnet.cidr)
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID, subnet.id)
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_NAME, subnet.name)
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS, subnet.gateway_ip)
|
||||
self.assertEqual(t_constants.MOCK_CIDR, subnet.cidr)
|
||||
# Negative
|
||||
list_subnet.side_effect = neutron_client_exceptions.NotFound
|
||||
self.assertRaises(network_base.SubnetNotFound,
|
||||
self.driver.get_subnet_by_name,
|
||||
n_constants.MOCK_SUBNET_NAME)
|
||||
t_constants.MOCK_SUBNET_NAME)
|
||||
list_subnet.side_effect = Exception
|
||||
self.assertRaises(network_base.NetworkException,
|
||||
self.driver.get_subnet_by_name,
|
||||
n_constants.MOCK_SUBNET_NAME)
|
||||
t_constants.MOCK_SUBNET_NAME)
|
||||
|
||||
def test_get_port_by_name(self):
|
||||
list_port = self.driver.neutron_client.list_ports
|
||||
list_port.return_value = {'ports': [{'port': {
|
||||
'id': n_constants.MOCK_PORT_ID,
|
||||
'name': n_constants.MOCK_PORT_NAME,
|
||||
'mac_address': n_constants.MOCK_MAC_ADDR,
|
||||
'network_id': n_constants.MOCK_NETWORK_ID,
|
||||
'id': t_constants.MOCK_PORT_ID,
|
||||
'name': t_constants.MOCK_PORT_NAME,
|
||||
'mac_address': t_constants.MOCK_MAC_ADDR,
|
||||
'network_id': t_constants.MOCK_NETWORK_ID,
|
||||
'fixed_ips': [{
|
||||
'subnet_id': n_constants.MOCK_SUBNET_ID,
|
||||
'ip_address': n_constants.MOCK_IP_ADDRESS
|
||||
'subnet_id': t_constants.MOCK_SUBNET_ID,
|
||||
'ip_address': t_constants.MOCK_IP_ADDRESS
|
||||
}]}}]}
|
||||
port = self.driver.get_port_by_name(n_constants.MOCK_PORT_NAME)
|
||||
port = self.driver.get_port_by_name(t_constants.MOCK_PORT_NAME)
|
||||
self.assertIsInstance(port, network_models.Port)
|
||||
self.assertEqual(n_constants.MOCK_PORT_ID, port.id)
|
||||
self.assertEqual(n_constants.MOCK_PORT_NAME, port.name)
|
||||
self.assertEqual(n_constants.MOCK_MAC_ADDR, port.mac_address)
|
||||
self.assertEqual(n_constants.MOCK_NETWORK_ID, port.network_id)
|
||||
self.assertEqual(t_constants.MOCK_PORT_ID, port.id)
|
||||
self.assertEqual(t_constants.MOCK_PORT_NAME, port.name)
|
||||
self.assertEqual(t_constants.MOCK_MAC_ADDR, port.mac_address)
|
||||
self.assertEqual(t_constants.MOCK_NETWORK_ID, port.network_id)
|
||||
self.assertEqual(1, len(port.fixed_ips))
|
||||
self.assertIsInstance(port.fixed_ips[0], network_models.FixedIP)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID,
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID,
|
||||
port.fixed_ips[0].subnet_id)
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS,
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS,
|
||||
port.fixed_ips[0].ip_address)
|
||||
# Negative
|
||||
list_port.side_effect = neutron_client_exceptions.NotFound
|
||||
self.assertRaises(network_base.PortNotFound,
|
||||
self.driver.get_port_by_name,
|
||||
n_constants.MOCK_PORT_NAME)
|
||||
t_constants.MOCK_PORT_NAME)
|
||||
list_port.side_effect = Exception
|
||||
self.assertRaises(network_base.NetworkException,
|
||||
self.driver.get_port_by_name,
|
||||
n_constants.MOCK_PORT_NAME)
|
||||
t_constants.MOCK_PORT_NAME)
|
||||
|
||||
def test_get_port_by_net_id_device_id(self):
|
||||
list_port = self.driver.neutron_client.list_ports
|
||||
list_port.return_value = {'ports': [{'port': {
|
||||
'id': n_constants.MOCK_PORT_ID,
|
||||
'name': n_constants.MOCK_PORT_NAME,
|
||||
'mac_address': n_constants.MOCK_MAC_ADDR,
|
||||
'network_id': n_constants.MOCK_NETWORK_ID,
|
||||
'device_id': n_constants.MOCK_DEVICE_ID,
|
||||
'id': t_constants.MOCK_PORT_ID,
|
||||
'name': t_constants.MOCK_PORT_NAME,
|
||||
'mac_address': t_constants.MOCK_MAC_ADDR,
|
||||
'network_id': t_constants.MOCK_NETWORK_ID,
|
||||
'device_id': t_constants.MOCK_DEVICE_ID,
|
||||
'fixed_ips': [{
|
||||
'subnet_id': n_constants.MOCK_SUBNET_ID,
|
||||
'ip_address': n_constants.MOCK_IP_ADDRESS
|
||||
'subnet_id': t_constants.MOCK_SUBNET_ID,
|
||||
'ip_address': t_constants.MOCK_IP_ADDRESS
|
||||
}]}}]}
|
||||
port = self.driver.get_port_by_net_id_device_id(
|
||||
n_constants.MOCK_NETWORK_ID, n_constants.MOCK_DEVICE_ID)
|
||||
t_constants.MOCK_NETWORK_ID, t_constants.MOCK_DEVICE_ID)
|
||||
self.assertIsInstance(port, network_models.Port)
|
||||
self.assertEqual(n_constants.MOCK_PORT_ID, port.id)
|
||||
self.assertEqual(n_constants.MOCK_DEVICE_ID, port.device_id)
|
||||
self.assertEqual(n_constants.MOCK_PORT_NAME, port.name)
|
||||
self.assertEqual(n_constants.MOCK_MAC_ADDR, port.mac_address)
|
||||
self.assertEqual(n_constants.MOCK_NETWORK_ID, port.network_id)
|
||||
self.assertEqual(t_constants.MOCK_PORT_ID, port.id)
|
||||
self.assertEqual(t_constants.MOCK_DEVICE_ID, port.device_id)
|
||||
self.assertEqual(t_constants.MOCK_PORT_NAME, port.name)
|
||||
self.assertEqual(t_constants.MOCK_MAC_ADDR, port.mac_address)
|
||||
self.assertEqual(t_constants.MOCK_NETWORK_ID, port.network_id)
|
||||
self.assertEqual(1, len(port.fixed_ips))
|
||||
self.assertIsInstance(port.fixed_ips[0], network_models.FixedIP)
|
||||
self.assertEqual(n_constants.MOCK_SUBNET_ID,
|
||||
self.assertEqual(t_constants.MOCK_SUBNET_ID,
|
||||
port.fixed_ips[0].subnet_id)
|
||||
self.assertEqual(n_constants.MOCK_IP_ADDRESS,
|
||||
self.assertEqual(t_constants.MOCK_IP_ADDRESS,
|
||||
port.fixed_ips[0].ip_address)
|
||||
# Negative
|
||||
list_port.side_effect = neutron_client_exceptions.NotFound
|
||||
self.assertRaises(network_base.PortNotFound,
|
||||
self.driver.get_port_by_net_id_device_id,
|
||||
n_constants.MOCK_PORT_NAME,
|
||||
n_constants.MOCK_DEVICE_ID)
|
||||
t_constants.MOCK_PORT_NAME,
|
||||
t_constants.MOCK_DEVICE_ID)
|
||||
list_port.side_effect = Exception
|
||||
self.assertRaises(network_base.NetworkException,
|
||||
self.driver.get_port_by_net_id_device_id,
|
||||
n_constants.MOCK_NETWORK_ID,
|
||||
n_constants.MOCK_DEVICE_ID)
|
||||
t_constants.MOCK_NETWORK_ID,
|
||||
t_constants.MOCK_DEVICE_ID)
|
||||
|
|
|
|||
Loading…
Reference in New Issue