649 lines
30 KiB
Python
649 lines
30 KiB
Python
# Copyright 2017 VMware, 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.
|
|
#
|
|
|
|
from unittest import mock
|
|
|
|
from vmware_nsxlib.tests.unit.v3 import nsxlib_testcase
|
|
from vmware_nsxlib.tests.unit.v3 import test_constants as consts
|
|
from vmware_nsxlib.v3 import exceptions as nsxlib_exc
|
|
from vmware_nsxlib.v3 import load_balancer
|
|
|
|
|
|
app_profile_types = load_balancer.ApplicationProfileTypes
|
|
app_profiles = [app_profile_types.HTTP,
|
|
app_profile_types.FAST_TCP,
|
|
app_profile_types.FAST_UDP]
|
|
per_profile_types = load_balancer.PersistenceProfileTypes
|
|
per_profiles = [per_profile_types.COOKIE, per_profile_types.SOURCE_IP]
|
|
monitor_types = load_balancer.MonitorTypes
|
|
monitors = [monitor_types.HTTP, monitor_types.HTTPS, monitor_types.ICMP,
|
|
monitor_types.PASSIVE, monitor_types.TCP, monitor_types.UDP]
|
|
|
|
|
|
class TestApplicationProfile(nsxlib_testcase.NsxClientTestCase):
|
|
|
|
def test_create_application_profiles(self):
|
|
fake_profile = consts.FAKE_APPLICATION_PROFILE.copy()
|
|
for profile_type in app_profiles:
|
|
body = {
|
|
'display_name': fake_profile['display_name'],
|
|
'description': fake_profile['description'],
|
|
'resource_type': profile_type,
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.application_profile.create(
|
|
display_name=body['display_name'],
|
|
description=body['description'],
|
|
resource_type=body['resource_type'],
|
|
tags=consts.FAKE_TAGS)
|
|
create.assert_called_with('loadbalancer/application-profiles',
|
|
body)
|
|
|
|
def test_create_fast_tcp_profiles(self):
|
|
fake_profile = consts.FAKE_APPLICATION_PROFILE.copy()
|
|
body = {
|
|
'display_name': fake_profile['display_name'],
|
|
'description': fake_profile['description'],
|
|
'resource_type': app_profile_types.FAST_TCP,
|
|
'close_timeout': 8,
|
|
'ha_flow_mirroring_enabled': True,
|
|
'idle_timeout': 1800,
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.application_profile.create(
|
|
display_name=body['display_name'],
|
|
description=body['description'],
|
|
resource_type=body['resource_type'],
|
|
close_timeout=body['close_timeout'],
|
|
ha_flow_mirroring_enabled=body['ha_flow_mirroring_enabled'],
|
|
idle_timeout=body['idle_timeout'],
|
|
tags=consts.FAKE_TAGS)
|
|
create.assert_called_with('loadbalancer/application-profiles',
|
|
body)
|
|
|
|
def test_create_fast_udp_profiles(self):
|
|
fake_profile = consts.FAKE_APPLICATION_PROFILE.copy()
|
|
body = {
|
|
'display_name': fake_profile['display_name'],
|
|
'description': fake_profile['description'],
|
|
'resource_type': app_profile_types.FAST_UDP,
|
|
'flow_mirroring_enabled': True,
|
|
'idle_timeout': 1800,
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.application_profile.create(
|
|
display_name=body['display_name'],
|
|
description=body['description'],
|
|
resource_type=body['resource_type'],
|
|
flow_mirroring_enabled=body['flow_mirroring_enabled'],
|
|
idle_timeout=body['idle_timeout'],
|
|
tags=consts.FAKE_TAGS)
|
|
create.assert_called_with('loadbalancer/application-profiles',
|
|
body)
|
|
|
|
def test_create_http_profiles(self):
|
|
fake_profile = consts.FAKE_APPLICATION_PROFILE.copy()
|
|
body = {
|
|
'display_name': fake_profile['display_name'],
|
|
'description': fake_profile['description'],
|
|
'resource_type': app_profile_types.HTTP,
|
|
'http_redirect_to': fake_profile['http_redirect_to'],
|
|
'http_redirect_to_https': fake_profile['http_redirect_to_https'],
|
|
'ntlm': fake_profile['ntlm'],
|
|
'request_body_size': fake_profile['request_body_size'],
|
|
'request_header_size': fake_profile['request_header_size'],
|
|
'response_header_size': fake_profile['response_header_size'],
|
|
'response_timeout': fake_profile['response_timeout'],
|
|
'x_forwarded_for': fake_profile['x_forwarded_for'],
|
|
'idle_timeout': fake_profile['idle_timeout'],
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.application_profile.create(
|
|
display_name=body['display_name'],
|
|
description=body['description'],
|
|
resource_type=body['resource_type'],
|
|
http_redirect_to=body['http_redirect_to'],
|
|
http_redirect_to_https=body['http_redirect_to_https'],
|
|
ntlm=body['ntlm'],
|
|
request_body_size=body['request_body_size'],
|
|
request_header_size=body['request_header_size'],
|
|
response_header_size=body['response_header_size'],
|
|
response_timeout=body['response_timeout'],
|
|
x_forwarded_for=body['x_forwarded_for'],
|
|
idle_timeout=body['idle_timeout'],
|
|
tags=consts.FAKE_TAGS)
|
|
create.assert_called_with('loadbalancer/application-profiles',
|
|
body)
|
|
|
|
def test_list_application_profiles(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.application_profile.list()
|
|
list_call.assert_called_with(
|
|
resource='loadbalancer/application-profiles')
|
|
|
|
def test_get_application_profile(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_profile = consts.FAKE_APPLICATION_PROFILE.copy()
|
|
self.nsxlib.load_balancer.application_profile.get(
|
|
fake_profile['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/application-profiles/%s' % fake_profile['id'])
|
|
|
|
def test_delete_application_profile(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_profile = consts.FAKE_APPLICATION_PROFILE.copy()
|
|
self.nsxlib.load_balancer.application_profile.delete(
|
|
fake_profile['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/application-profiles/%s' % fake_profile['id'],
|
|
headers=None)
|
|
|
|
|
|
class TestPersistenceProfile(nsxlib_testcase.NsxClientTestCase):
|
|
|
|
def test_create_persistence_profiles(self):
|
|
fake_profile = consts.FAKE_PERSISTENCE_PROFILE.copy()
|
|
for profile_type in per_profiles:
|
|
body = {
|
|
'display_name': fake_profile['display_name'],
|
|
'description': fake_profile['description'],
|
|
'resource_type': profile_type,
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.persistence_profile.create(
|
|
body['display_name'], body['description'],
|
|
consts.FAKE_TAGS, body['resource_type'])
|
|
create.assert_called_with('loadbalancer/persistence-profiles',
|
|
body)
|
|
|
|
def test_list_persistence_profiles(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.persistence_profile.list()
|
|
list_call.assert_called_with(
|
|
resource='loadbalancer/persistence-profiles')
|
|
|
|
def test_get_persistence_profile(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_profile = consts.FAKE_APPLICATION_PROFILE.copy()
|
|
self.nsxlib.load_balancer.persistence_profile.get(
|
|
fake_profile['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/persistence-profiles/%s' % fake_profile['id'])
|
|
|
|
def test_delete_persistence_profile(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_profile = consts.FAKE_PERSISTENCE_PROFILE.copy()
|
|
self.nsxlib.load_balancer.persistence_profile.delete(
|
|
fake_profile['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/persistence-profiles/%s' % fake_profile['id'],
|
|
headers=None)
|
|
|
|
|
|
class TestRule(nsxlib_testcase.NsxClientTestCase):
|
|
def test_create_rule(self):
|
|
fake_rule = consts.FAKE_RULE.copy()
|
|
body = {
|
|
'display_name': fake_rule['display_name'],
|
|
'description': fake_rule['description'],
|
|
'resource_type': fake_rule['resource_type'],
|
|
'phase': fake_rule['phase'],
|
|
'match_strategy': fake_rule['match_strategy'],
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.rule.create(**body)
|
|
create.assert_called_with('loadbalancer/rules', body)
|
|
|
|
def test_list_rules(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.rule.list()
|
|
list_call.assert_called_with(resource='loadbalancer/rules')
|
|
|
|
def test_get_rule(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_rule = consts.FAKE_RULE.copy()
|
|
self.nsxlib.load_balancer.rule.get(fake_rule['id'])
|
|
get.assert_called_with('loadbalancer/rules/%s' % fake_rule['id'])
|
|
|
|
def test_delete_rule(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_rule = consts.FAKE_RULE.copy()
|
|
self.nsxlib.load_balancer.rule.delete(fake_rule['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/rules/%s' % fake_rule['id'], headers=None)
|
|
|
|
|
|
class TestClientSslProfile(nsxlib_testcase.NsxClientTestCase):
|
|
|
|
def test_create_client_ssl_profiles(self):
|
|
fake_profile = consts.FAKE_CLIENT_SSL_PROFILE.copy()
|
|
body = {
|
|
'display_name': fake_profile['display_name'],
|
|
'description': fake_profile['description'],
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.client_ssl_profile.create(
|
|
body['display_name'], body['description'],
|
|
consts.FAKE_TAGS)
|
|
create.assert_called_with('loadbalancer/client-ssl-profiles', body)
|
|
|
|
def test_list_client_ssl_profiles(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.client_ssl_profile.list()
|
|
list_call.assert_called_with(
|
|
resource='loadbalancer/client-ssl-profiles')
|
|
|
|
def test_get_client_ssl_profile(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_profile = consts.FAKE_CLIENT_SSL_PROFILE.copy()
|
|
self.nsxlib.load_balancer.client_ssl_profile.get(
|
|
fake_profile['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/client-ssl-profiles/%s' % fake_profile['id'])
|
|
|
|
def test_delete_client_ssl_profile(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_profile = consts.FAKE_CLIENT_SSL_PROFILE.copy()
|
|
self.nsxlib.load_balancer.client_ssl_profile.delete(
|
|
fake_profile['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/client-ssl-profiles/%s' % fake_profile['id'],
|
|
headers=None)
|
|
|
|
|
|
class TestServerSslProfile(nsxlib_testcase.NsxClientTestCase):
|
|
|
|
def test_create_server_client_ssl_profiles(self):
|
|
fake_profile = consts.FAKE_SERVER_SSL_PROFILE.copy()
|
|
body = {
|
|
'display_name': fake_profile['display_name'],
|
|
'description': fake_profile['description'],
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.server_ssl_profile.create(
|
|
body['display_name'], body['description'],
|
|
consts.FAKE_TAGS)
|
|
create.assert_called_with('loadbalancer/server-ssl-profiles', body)
|
|
|
|
def test_list_server_ssl_profiles(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.server_ssl_profile.list()
|
|
list_call.assert_called_with(
|
|
resource='loadbalancer/server-ssl-profiles')
|
|
|
|
def test_get_server_ssl_profile(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_profile = consts.FAKE_SERVER_SSL_PROFILE.copy()
|
|
self.nsxlib.load_balancer.server_ssl_profile.get(
|
|
fake_profile['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/server-ssl-profiles/%s' % fake_profile['id'])
|
|
|
|
def test_delete_server_ssl_profile(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_profile = consts.FAKE_SERVER_SSL_PROFILE.copy()
|
|
self.nsxlib.load_balancer.server_ssl_profile.delete(
|
|
fake_profile['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/server-ssl-profiles/%s' % fake_profile['id'],
|
|
headers=None)
|
|
|
|
|
|
class TestMonitor(nsxlib_testcase.NsxClientTestCase):
|
|
|
|
def test_create_monitors(self):
|
|
fake_monitor = consts.FAKE_MONITOR.copy()
|
|
for monitor_type in monitors:
|
|
body = {
|
|
'display_name': fake_monitor['display_name'],
|
|
'description': fake_monitor['description'],
|
|
'resource_type': monitor_type,
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.monitor.create(
|
|
body['display_name'], body['description'],
|
|
consts.FAKE_TAGS, body['resource_type'])
|
|
create.assert_called_with('loadbalancer/monitors',
|
|
body)
|
|
|
|
def test_list_monitors(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.monitor.list()
|
|
list_call.assert_called_with(resource='loadbalancer/monitors')
|
|
|
|
def test_get_monitor(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_monitor = consts.FAKE_MONITOR.copy()
|
|
self.nsxlib.load_balancer.monitor.get(fake_monitor['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/monitors/%s' % fake_monitor['id'])
|
|
|
|
def test_delete_monitor(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_monitor = consts.FAKE_MONITOR.copy()
|
|
self.nsxlib.load_balancer.monitor.delete(fake_monitor['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/monitors/%s' % fake_monitor['id'], headers=None)
|
|
|
|
|
|
class TestPool(nsxlib_testcase.NsxClientTestCase):
|
|
|
|
def test_create_pool(self):
|
|
fake_pool = consts.FAKE_POOL.copy()
|
|
body = {
|
|
'display_name': fake_pool['display_name'],
|
|
'description': fake_pool['description'],
|
|
'algorithm': fake_pool['algorithm'],
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.pool.create(
|
|
body['display_name'], body['description'],
|
|
consts.FAKE_TAGS, algorithm=body['algorithm'])
|
|
create.assert_called_with('loadbalancer/pools',
|
|
body)
|
|
|
|
def test_list_pools(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.pool.list()
|
|
list_call.assert_called_with(resource='loadbalancer/pools')
|
|
|
|
def test_get_pool(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_profile = consts.FAKE_POOL.copy()
|
|
self.nsxlib.load_balancer.pool.get(fake_profile['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/pools/%s' % fake_profile['id'])
|
|
|
|
def test_delete_pool(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_profile = consts.FAKE_POOL.copy()
|
|
self.nsxlib.load_balancer.pool.delete(fake_profile['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/pools/%s' % fake_profile['id'], headers=None)
|
|
|
|
def test_remove_monitor_from_pool(self):
|
|
fake_pool = consts.FAKE_POOL.copy()
|
|
fake_pool['active_monitor_ids'] = [consts.FAKE_MONITOR_UUID]
|
|
body = {'display_name': fake_pool['display_name'],
|
|
'description': fake_pool['description'],
|
|
'id': fake_pool['id'],
|
|
'algorithm': fake_pool['algorithm'],
|
|
'active_monitor_ids': []}
|
|
with mock.patch.object(self.nsxlib.client, 'get',
|
|
return_value=fake_pool):
|
|
with mock.patch.object(self.nsxlib.client, 'update') as update:
|
|
self.nsxlib.load_balancer.pool.remove_monitor_from_pool(
|
|
fake_pool['id'], consts.FAKE_MONITOR_UUID)
|
|
resource = 'loadbalancer/pools/%s' % fake_pool['id']
|
|
update.assert_called_with(resource, body)
|
|
|
|
def test_remove_non_exist_monitor_from_pool(self):
|
|
fake_pool = consts.FAKE_POOL.copy()
|
|
fake_pool['active_monitor_ids'] = [consts.FAKE_MONITOR_UUID]
|
|
with mock.patch.object(self.nsxlib.client, 'get',
|
|
return_value=fake_pool):
|
|
self.assertRaises(
|
|
nsxlib_exc.ResourceNotFound,
|
|
self.nsxlib.load_balancer.pool.remove_monitor_from_pool,
|
|
fake_pool['id'],
|
|
'xxx-yyy')
|
|
|
|
def test_add_monitor_to_pool(self):
|
|
fake_pool = consts.FAKE_POOL.copy()
|
|
body = {'display_name': fake_pool['display_name'],
|
|
'description': fake_pool['description'],
|
|
'id': fake_pool['id'],
|
|
'algorithm': fake_pool['algorithm'],
|
|
'active_monitor_ids': [consts.FAKE_MONITOR_UUID]}
|
|
with mock.patch.object(self.nsxlib.client, 'get',
|
|
return_value=fake_pool):
|
|
with mock.patch.object(self.nsxlib.client, 'update') as update:
|
|
self.nsxlib.load_balancer.pool.add_monitor_to_pool(
|
|
fake_pool['id'], consts.FAKE_MONITOR_UUID)
|
|
resource = 'loadbalancer/pools/%s' % fake_pool['id']
|
|
update.assert_called_with(resource, body)
|
|
|
|
|
|
class TestVirtualServer(nsxlib_testcase.NsxClientTestCase):
|
|
|
|
def test_create_virtual_server(self):
|
|
fake_virtual_server = consts.FAKE_VIRTUAL_SERVER.copy()
|
|
body = {
|
|
'display_name': fake_virtual_server['display_name'],
|
|
'description': fake_virtual_server['description'],
|
|
'ip_protocol': fake_virtual_server['ip_protocol'],
|
|
'port': fake_virtual_server['port'],
|
|
'enabled': fake_virtual_server['enabled'],
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create:
|
|
self.nsxlib.load_balancer.virtual_server.create(
|
|
body['display_name'], body['description'],
|
|
consts.FAKE_TAGS, ip_protocol=body['ip_protocol'],
|
|
port=body['port'], enabled=body['enabled'])
|
|
create.assert_called_with('loadbalancer/virtual-servers',
|
|
body)
|
|
|
|
def test_list_virtual_servers(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.virtual_server.list()
|
|
list_call.assert_called_with(
|
|
resource='loadbalancer/virtual-servers')
|
|
|
|
def test_get_virtual_server(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_virtual_server = consts.FAKE_VIRTUAL_SERVER.copy()
|
|
self.nsxlib.load_balancer.virtual_server.get(
|
|
fake_virtual_server['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/virtual-servers/%s' % fake_virtual_server['id'])
|
|
|
|
def test_delete_virtual_server(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_virtual_server = consts.FAKE_VIRTUAL_SERVER.copy()
|
|
self.nsxlib.load_balancer.virtual_server.delete(
|
|
fake_virtual_server['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/virtual-servers/%s' % fake_virtual_server['id'],
|
|
headers=None)
|
|
|
|
def test_add_rule(self):
|
|
fake_virtual_server = consts.FAKE_VIRTUAL_SERVER.copy()
|
|
body = {
|
|
'display_name': fake_virtual_server['display_name'],
|
|
'description': fake_virtual_server['description'],
|
|
'id': fake_virtual_server['id'],
|
|
'enabled': fake_virtual_server['enabled'],
|
|
'port': fake_virtual_server['port'],
|
|
'ip_protocol': fake_virtual_server['ip_protocol'],
|
|
'rule_ids': [consts.FAKE_RULE_UUID]
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'get') as mock_get, \
|
|
mock.patch.object(self.nsxlib.client, 'update') as mock_update:
|
|
mock_get.return_value = fake_virtual_server
|
|
self.nsxlib.load_balancer.virtual_server.add_rule(
|
|
fake_virtual_server['id'], consts.FAKE_RULE_UUID)
|
|
mock_update.assert_called_with(
|
|
'loadbalancer/virtual-servers/%s' % fake_virtual_server['id'],
|
|
body)
|
|
|
|
def test_remove_rule(self):
|
|
fake_virtual_server = consts.FAKE_VIRTUAL_SERVER.copy()
|
|
fake_virtual_server['rule_ids'] = [consts.FAKE_RULE_UUID]
|
|
body = {
|
|
'display_name': fake_virtual_server['display_name'],
|
|
'description': fake_virtual_server['description'],
|
|
'id': fake_virtual_server['id'],
|
|
'enabled': fake_virtual_server['enabled'],
|
|
'port': fake_virtual_server['port'],
|
|
'ip_protocol': fake_virtual_server['ip_protocol'],
|
|
'rule_ids': []
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'get') as mock_get, \
|
|
mock.patch.object(self.nsxlib.client, 'update') as mock_update:
|
|
mock_get.return_value = fake_virtual_server
|
|
self.nsxlib.load_balancer.virtual_server.remove_rule(
|
|
fake_virtual_server['id'], consts.FAKE_RULE_UUID)
|
|
mock_update.assert_called_with(
|
|
'loadbalancer/virtual-servers/%s' % fake_virtual_server['id'],
|
|
body)
|
|
|
|
def test_add_client_ssl_profile_binding(self):
|
|
fake_virtual_server = consts.FAKE_VIRTUAL_SERVER.copy()
|
|
body = {
|
|
'display_name': fake_virtual_server['display_name'],
|
|
'description': fake_virtual_server['description'],
|
|
'id': fake_virtual_server['id'],
|
|
'enabled': fake_virtual_server['enabled'],
|
|
'port': fake_virtual_server['port'],
|
|
'ip_protocol': fake_virtual_server['ip_protocol'],
|
|
'client_ssl_profile_binding': {
|
|
'ssl_profile_id': consts.FAKE_CLIENT_SSL_PROFILE_UUID,
|
|
'default_certificate_id': consts.FAKE_DEFAULT_CERTIFICATE_ID,
|
|
'client_auth': 'IGNORE',
|
|
'certificate_chain_depth': 3
|
|
}
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'get') as mock_get, \
|
|
mock.patch.object(self.nsxlib.client, 'update') as mock_update:
|
|
mock_get.return_value = fake_virtual_server
|
|
vs_client = self.nsxlib.load_balancer.virtual_server
|
|
vs_client.add_client_ssl_profile_binding(
|
|
fake_virtual_server['id'],
|
|
consts.FAKE_CLIENT_SSL_PROFILE_UUID,
|
|
consts.FAKE_DEFAULT_CERTIFICATE_ID,
|
|
client_auth='IGNORE',
|
|
certificate_chain_depth=3,
|
|
xyz='xyz'
|
|
)
|
|
mock_update.assert_called_with(
|
|
'loadbalancer/virtual-servers/%s' % fake_virtual_server['id'],
|
|
body)
|
|
|
|
def test_add_server_ssl_profile_binding(self):
|
|
fake_virtual_server = consts.FAKE_VIRTUAL_SERVER.copy()
|
|
body = {
|
|
'display_name': fake_virtual_server['display_name'],
|
|
'description': fake_virtual_server['description'],
|
|
'id': fake_virtual_server['id'],
|
|
'enabled': fake_virtual_server['enabled'],
|
|
'port': fake_virtual_server['port'],
|
|
'ip_protocol': fake_virtual_server['ip_protocol'],
|
|
'server_ssl_profile_binding': {
|
|
'ssl_profile_id': consts.FAKE_SERVER_SSL_PROFILE_UUID,
|
|
'server_auth': 'IGNORE',
|
|
'certificate_chain_depth': 3
|
|
}
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'get') as mock_get, \
|
|
mock.patch.object(self.nsxlib.client, 'update') as mock_update:
|
|
mock_get.return_value = fake_virtual_server
|
|
vs_client = self.nsxlib.load_balancer.virtual_server
|
|
vs_client.add_server_ssl_profile_binding(
|
|
fake_virtual_server['id'],
|
|
consts.FAKE_SERVER_SSL_PROFILE_UUID,
|
|
server_auth='IGNORE',
|
|
certificate_chain_depth=3,
|
|
xyz='xyz')
|
|
mock_update.assert_called_with(
|
|
'loadbalancer/virtual-servers/%s' % fake_virtual_server['id'],
|
|
body)
|
|
|
|
|
|
class TestService(nsxlib_testcase.NsxClientTestCase):
|
|
|
|
def test_create_service(self):
|
|
fake_service = consts.FAKE_SERVICE.copy()
|
|
body = {
|
|
'display_name': fake_service['display_name'],
|
|
'description': fake_service['description'],
|
|
'enabled': fake_service['enabled'],
|
|
'attachment': fake_service['attachment'],
|
|
'relax_scale_validation': fake_service['relax_scale_validation'],
|
|
'tags': consts.FAKE_TAGS
|
|
}
|
|
with mock.patch.object(self.nsxlib.client, 'create') as create, \
|
|
mock.patch.object(self.nsxlib, 'feature_supported') as support:
|
|
support.return_value = True
|
|
self.nsxlib.load_balancer.service.create(
|
|
body['display_name'], body['description'],
|
|
consts.FAKE_TAGS, enabled=body['enabled'],
|
|
attachment=body['attachment'],
|
|
relax_scale_validation=body['relax_scale_validation'])
|
|
create.assert_called_with('loadbalancer/services',
|
|
body)
|
|
|
|
def test_list_services(self):
|
|
with mock.patch.object(self.nsxlib.client, 'list') as list_call:
|
|
self.nsxlib.load_balancer.service.list()
|
|
list_call.assert_called_with(resource='loadbalancer/services')
|
|
|
|
def test_get_service(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_service = consts.FAKE_SERVICE.copy()
|
|
self.nsxlib.load_balancer.service.get(fake_service['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/services/%s' % fake_service['id'])
|
|
|
|
def test_get_stats(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_service = consts.FAKE_SERVICE.copy()
|
|
self.nsxlib.load_balancer.service.get_stats(fake_service['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/services/%s/statistics?source=realtime' %
|
|
fake_service['id'],
|
|
silent=False)
|
|
|
|
def test_get_status(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_service = consts.FAKE_SERVICE.copy()
|
|
self.nsxlib.load_balancer.service.get_status(fake_service['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/services/%s/status' % fake_service['id'])
|
|
|
|
def test_get_virtual_servers_status(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_service = consts.FAKE_SERVICE.copy()
|
|
self.nsxlib.load_balancer.service.get_virtual_servers_status(
|
|
fake_service['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/services/%s/virtual-servers/status' %
|
|
fake_service['id'])
|
|
|
|
def test_delete_service(self):
|
|
with mock.patch.object(self.nsxlib.client, 'delete') as delete:
|
|
fake_service = consts.FAKE_SERVICE.copy()
|
|
self.nsxlib.load_balancer.service.delete(fake_service['id'])
|
|
delete.assert_called_with(
|
|
'loadbalancer/services/%s' % fake_service['id'], headers=None)
|
|
|
|
def test_get_usage(self):
|
|
with mock.patch.object(self.nsxlib.client, 'get') as get:
|
|
fake_service = consts.FAKE_SERVICE.copy()
|
|
self.nsxlib.load_balancer.service.get_usage(fake_service['id'])
|
|
get.assert_called_with(
|
|
'loadbalancer/services/%s/usage' % fake_service['id'])
|