348 lines
14 KiB
Python
348 lines
14 KiB
Python
# Copyright (c) 2015 Mellanox Technologies, Ltd
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import mock
|
|
from neutron_lib import context
|
|
from oslo_utils import uuidutils
|
|
from oslo_versionedobjects import fields as obj_fields
|
|
from oslo_versionedobjects import fixture
|
|
import testtools
|
|
|
|
from neutron.api.rpc.callbacks import resources
|
|
from neutron.api.rpc.callbacks import version_manager
|
|
from neutron.api.rpc.handlers import resources_rpc
|
|
from neutron.common import topics
|
|
from neutron.objects import base as objects_base
|
|
from neutron.objects import common_types
|
|
from neutron.tests import base
|
|
|
|
|
|
TEST_EVENT = 'test_event'
|
|
TEST_VERSION = '1.0'
|
|
|
|
|
|
def _create_test_dict(uuid=None):
|
|
return {'id': uuid or uuidutils.generate_uuid(),
|
|
'field': 'foo'}
|
|
|
|
|
|
def _create_test_resource(context=None, resource_cls=None):
|
|
resource_cls = resource_cls or FakeResource
|
|
resource_dict = _create_test_dict()
|
|
resource = resource_cls(context, **resource_dict)
|
|
resource.obj_reset_changes()
|
|
return resource
|
|
|
|
|
|
class BaseFakeResource(objects_base.NeutronObject):
|
|
@classmethod
|
|
def get_objects(cls, context, **kwargs):
|
|
return list()
|
|
|
|
|
|
class FakeResource(BaseFakeResource):
|
|
VERSION = TEST_VERSION
|
|
|
|
fields = {
|
|
'id': common_types.UUIDField(),
|
|
'field': obj_fields.StringField()
|
|
}
|
|
|
|
|
|
class FakeResource2(BaseFakeResource):
|
|
VERSION = TEST_VERSION
|
|
|
|
fields = {
|
|
'id': common_types.UUIDField(),
|
|
'field': obj_fields.StringField()
|
|
}
|
|
|
|
|
|
class ResourcesRpcBaseTestCase(base.BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(ResourcesRpcBaseTestCase, self).setUp()
|
|
|
|
self.obj_registry = self.useFixture(
|
|
fixture.VersionedObjectRegistryFixture())
|
|
|
|
self.context = context.get_admin_context()
|
|
mock.patch.object(resources_rpc.resources,
|
|
'is_valid_resource_type').start()
|
|
mock.patch.object(resources_rpc.resources, 'get_resource_cls',
|
|
side_effect=self._get_resource_cls).start()
|
|
|
|
self.resource_objs = [_create_test_resource(self.context)
|
|
for _ in range(2)]
|
|
self.resource_objs2 = [_create_test_resource(self.context,
|
|
FakeResource2)
|
|
for _ in range(2)]
|
|
|
|
@staticmethod
|
|
def _get_resource_cls(resource_type):
|
|
return {FakeResource.obj_name(): FakeResource,
|
|
FakeResource2.obj_name(): FakeResource2}.get(resource_type)
|
|
|
|
|
|
class _ValidateResourceTypeTestCase(base.BaseTestCase):
|
|
def setUp(self):
|
|
super(_ValidateResourceTypeTestCase, self).setUp()
|
|
self.is_valid_mock = mock.patch.object(
|
|
resources_rpc.resources, 'is_valid_resource_type').start()
|
|
|
|
def test_valid_type(self):
|
|
self.is_valid_mock.return_value = True
|
|
resources_rpc._validate_resource_type('foo')
|
|
|
|
def test_invalid_type(self):
|
|
self.is_valid_mock.return_value = False
|
|
with testtools.ExpectedException(
|
|
resources_rpc.InvalidResourceTypeClass):
|
|
resources_rpc._validate_resource_type('foo')
|
|
|
|
|
|
class _ResourceTypeVersionedTopicTestCase(base.BaseTestCase):
|
|
|
|
@mock.patch.object(resources_rpc, '_validate_resource_type')
|
|
def test_resource_type_versioned_topic(self, validate_mock):
|
|
obj_name = FakeResource.obj_name()
|
|
expected = topics.RESOURCE_TOPIC_PATTERN % {
|
|
'resource_type': 'FakeResource', 'version': '1.0'}
|
|
with mock.patch.object(resources_rpc.resources, 'get_resource_cls',
|
|
return_value=FakeResource):
|
|
observed = resources_rpc.resource_type_versioned_topic(obj_name)
|
|
self.assertEqual(expected, observed)
|
|
|
|
|
|
class ResourcesPullRpcApiTestCase(ResourcesRpcBaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(ResourcesPullRpcApiTestCase, self).setUp()
|
|
self.rpc = resources_rpc.ResourcesPullRpcApi()
|
|
mock.patch.object(self.rpc, 'client').start()
|
|
self.cctxt_mock = self.rpc.client.prepare.return_value
|
|
|
|
def test_is_singleton(self):
|
|
self.assertIs(self.rpc, resources_rpc.ResourcesPullRpcApi())
|
|
|
|
def test_pull(self):
|
|
self.obj_registry.register(FakeResource)
|
|
expected_obj = _create_test_resource(self.context)
|
|
resource_id = expected_obj.id
|
|
self.cctxt_mock.call.return_value = expected_obj.obj_to_primitive()
|
|
|
|
result = self.rpc.pull(
|
|
self.context, FakeResource.obj_name(), resource_id)
|
|
|
|
self.cctxt_mock.call.assert_called_once_with(
|
|
self.context, 'pull', resource_type='FakeResource',
|
|
version=TEST_VERSION, resource_id=resource_id)
|
|
self.assertEqual(expected_obj, result)
|
|
|
|
def test_bulk_pull(self):
|
|
self.obj_registry.register(FakeResource)
|
|
expected_objs = [_create_test_resource(self.context),
|
|
_create_test_resource(self.context)]
|
|
self.cctxt_mock.call.return_value = [
|
|
e.obj_to_primitive() for e in expected_objs]
|
|
|
|
filter_kwargs = {'a': 'b', 'c': 'd'}
|
|
result = self.rpc.bulk_pull(
|
|
self.context, FakeResource.obj_name(),
|
|
filter_kwargs=filter_kwargs)
|
|
|
|
self.cctxt_mock.call.assert_called_once_with(
|
|
self.context, 'bulk_pull', resource_type='FakeResource',
|
|
version=TEST_VERSION, filter_kwargs=filter_kwargs)
|
|
self.assertEqual(expected_objs, result)
|
|
|
|
def test_pull_resource_not_found(self):
|
|
resource_dict = _create_test_dict()
|
|
resource_id = resource_dict['id']
|
|
self.cctxt_mock.call.return_value = None
|
|
with testtools.ExpectedException(resources_rpc.ResourceNotFound):
|
|
self.rpc.pull(self.context, FakeResource.obj_name(),
|
|
resource_id)
|
|
|
|
|
|
class ResourcesPushToServerRpcCallbackTestCase(ResourcesRpcBaseTestCase):
|
|
|
|
def test_report_versions(self):
|
|
callbacks = resources_rpc.ResourcesPushToServerRpcCallback()
|
|
with mock.patch('neutron.api.rpc.callbacks.version_manager'
|
|
'.update_versions') as update_versions:
|
|
version_map = {'A': '1.0'}
|
|
callbacks.report_agent_resource_versions(context=mock.ANY,
|
|
agent_type='DHCP Agent',
|
|
agent_host='fake-host',
|
|
version_map=version_map)
|
|
update_versions.assert_called_once_with(mock.ANY,
|
|
version_map)
|
|
|
|
|
|
class ResourcesPullRpcCallbackTestCase(ResourcesRpcBaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(ResourcesPullRpcCallbackTestCase, self).setUp()
|
|
self.obj_registry.register(FakeResource)
|
|
self.callbacks = resources_rpc.ResourcesPullRpcCallback()
|
|
self.resource_obj = _create_test_resource(self.context)
|
|
|
|
def test_pull(self):
|
|
resource_dict = _create_test_dict(uuid=self.resource_obj.id)
|
|
with mock.patch.object(
|
|
resources_rpc.prod_registry, 'pull',
|
|
return_value=self.resource_obj) as registry_mock:
|
|
primitive = self.callbacks.pull(
|
|
self.context, resource_type=FakeResource.obj_name(),
|
|
version=TEST_VERSION,
|
|
resource_id=self.resource_obj.id)
|
|
registry_mock.assert_called_once_with(
|
|
'FakeResource', self.resource_obj.id, context=self.context)
|
|
self.assertEqual(resource_dict,
|
|
primitive['versioned_object.data'])
|
|
self.assertEqual(self.resource_obj.obj_to_primitive(), primitive)
|
|
|
|
def test_bulk_pull(self):
|
|
r1 = self.resource_obj
|
|
r2 = _create_test_resource(self.context)
|
|
|
|
@classmethod
|
|
def get_objs(*args, **kwargs):
|
|
if 'id' not in kwargs:
|
|
return [r1, r2]
|
|
return [r for r in [r1, r2] if r.id == kwargs['id']]
|
|
|
|
# the bulk interface currently retrieves directly from the registry
|
|
with mock.patch.object(FakeResource, 'get_objects', new=get_objs):
|
|
objs = self.callbacks.bulk_pull(
|
|
self.context, resource_type=FakeResource.obj_name(),
|
|
version=TEST_VERSION)
|
|
self.assertItemsEqual([r1.obj_to_primitive(),
|
|
r2.obj_to_primitive()],
|
|
objs)
|
|
objs = self.callbacks.bulk_pull(
|
|
self.context, resource_type=FakeResource.obj_name(),
|
|
version=TEST_VERSION, filter_kwargs={'id': r1.id})
|
|
self.assertEqual([r1.obj_to_primitive()], objs)
|
|
|
|
@mock.patch.object(FakeResource, 'obj_to_primitive')
|
|
def test_pull_backports_to_older_version(self, to_prim_mock):
|
|
with mock.patch.object(resources_rpc.prod_registry, 'pull',
|
|
return_value=self.resource_obj):
|
|
self.callbacks.pull(
|
|
self.context, resource_type=FakeResource.obj_name(),
|
|
version='0.9', # less than initial version 1.0
|
|
resource_id=self.resource_obj.id)
|
|
to_prim_mock.assert_called_with(target_version='0.9')
|
|
|
|
|
|
class ResourcesPushRpcApiTestCase(ResourcesRpcBaseTestCase):
|
|
"""Tests the neutron server side of the RPC interface."""
|
|
|
|
def setUp(self):
|
|
super(ResourcesPushRpcApiTestCase, self).setUp()
|
|
mock.patch.object(resources_rpc.n_rpc, 'get_client').start()
|
|
self.rpc = resources_rpc.ResourcesPushRpcApi()
|
|
self.cctxt_mock = self.rpc.client.prepare.return_value
|
|
mock.patch.object(version_manager, 'get_resource_versions',
|
|
return_value=set([TEST_VERSION])).start()
|
|
|
|
def test__prepare_object_fanout_context(self):
|
|
expected_topic = topics.RESOURCE_TOPIC_PATTERN % {
|
|
'resource_type': resources.get_resource_type(
|
|
self.resource_objs[0]),
|
|
'version': TEST_VERSION}
|
|
|
|
observed = self.rpc._prepare_object_fanout_context(
|
|
self.resource_objs[0], self.resource_objs[0].VERSION, '1.0')
|
|
|
|
self.rpc.client.prepare.assert_called_once_with(
|
|
fanout=True, topic=expected_topic, version='1.0')
|
|
self.assertEqual(self.cctxt_mock, observed)
|
|
|
|
def test_push_single_type(self):
|
|
self.rpc.push(
|
|
self.context, self.resource_objs, TEST_EVENT)
|
|
|
|
self.cctxt_mock.cast.assert_called_once_with(
|
|
self.context, 'push',
|
|
resource_list=[resource.obj_to_primitive()
|
|
for resource in self.resource_objs],
|
|
event_type=TEST_EVENT)
|
|
|
|
def test_push_mixed(self):
|
|
self.rpc.push(
|
|
self.context, self.resource_objs + self.resource_objs2,
|
|
event_type=TEST_EVENT)
|
|
|
|
self.cctxt_mock.cast.assert_any_call(
|
|
self.context, 'push',
|
|
resource_list=[resource.obj_to_primitive()
|
|
for resource in self.resource_objs],
|
|
event_type=TEST_EVENT)
|
|
|
|
self.cctxt_mock.cast.assert_any_call(
|
|
self.context, 'push',
|
|
resource_list=[resource.obj_to_primitive()
|
|
for resource in self.resource_objs2],
|
|
event_type=TEST_EVENT)
|
|
|
|
def test_push_mitaka_backwardscompat(self):
|
|
#TODO(mangelajo) remove in Ocata, since the 'resource' parameter
|
|
# is just for backwards compatibility with Mitaka
|
|
# agents.
|
|
self.rpc.push(
|
|
self.context, [self.resource_objs[0]], TEST_EVENT)
|
|
|
|
self.cctxt_mock.cast.assert_called_once_with(
|
|
self.context, 'push',
|
|
resource=self.resource_objs[0].obj_to_primitive(),
|
|
event_type=TEST_EVENT)
|
|
|
|
|
|
class ResourcesPushRpcCallbackTestCase(ResourcesRpcBaseTestCase):
|
|
"""Tests the agent-side of the RPC interface."""
|
|
|
|
def setUp(self):
|
|
super(ResourcesPushRpcCallbackTestCase, self).setUp()
|
|
self.callbacks = resources_rpc.ResourcesPushRpcCallback()
|
|
|
|
@mock.patch.object(resources_rpc.cons_registry, 'push')
|
|
def test_push(self, reg_push_mock):
|
|
self.obj_registry.register(FakeResource)
|
|
self.callbacks.push(self.context,
|
|
resource_list=[resource.obj_to_primitive()
|
|
for resource in self.resource_objs],
|
|
event_type=TEST_EVENT)
|
|
reg_push_mock.assert_called_once_with(self.context,
|
|
self.resource_objs[0].obj_name(),
|
|
self.resource_objs,
|
|
TEST_EVENT)
|
|
|
|
@mock.patch.object(resources_rpc.cons_registry, 'push')
|
|
def test_push_mitaka_backwardscompat(self, reg_push_mock):
|
|
#TODO(mangelajo) remove in Ocata, since the 'resource' parameter
|
|
# is just for backwards compatibility with Mitaka
|
|
# agents.
|
|
self.obj_registry.register(FakeResource)
|
|
self.callbacks.push(self.context,
|
|
resource=self.resource_objs[0].obj_to_primitive(),
|
|
event_type=TEST_EVENT)
|
|
reg_push_mock.assert_called_once_with(self.context,
|
|
self.resource_objs[0].obj_name(),
|
|
[self.resource_objs[0]],
|
|
TEST_EVENT)
|