neutron/tests/unit/api/rpc/handlers/test_resources_rpc.py

   1 # Copyright (c) 2015 Mellanox Technologies, Ltd
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #    http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  12 # implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 import copy
  17
  18 import mock
  19 from oslo_versionedobjects import base as obj_base
  20 from oslo_versionedobjects import fields as obj_fields
  21 import testtools
  22
  23 from neutron.api.rpc.callbacks import resources
  24 from neutron.api.rpc.handlers import resources_rpc
  25 from neutron.common import topics
  26 from neutron import context
  27 from neutron.objects import base as objects_base
  28 from neutron.tests import base
  29
  30
  31 def _create_test_dict():
  32     return {'id': 'uuid',
  33             'field': 'foo'}
  34
  35
  36 def _create_test_resource(context=None):
  37     resource_dict = _create_test_dict()
  38     resource = FakeResource(context, **resource_dict)
  39     resource.obj_reset_changes()
  40     return resource
  41
  42
  43 class FakeResource(objects_base.NeutronObject):
  44     # Version 1.0: Initial version
  45     VERSION = '1.0'
  46
  47     fields = {
  48         'id': obj_fields.UUIDField(),
  49         'field': obj_fields.StringField()
  50     }
  51
  52     @classmethod
  53     def get_objects(cls, context, **kwargs):
  54         return list()
  55
  56
  57 class ResourcesRpcBaseTestCase(base.BaseTestCase):
  58
  59     def setUp(self):
  60         super(ResourcesRpcBaseTestCase, self).setUp()
  61
  62         # TODO(mhickey) This is using temp registry pattern. The
  63         # pattern solution is to backup the object registry, register
  64         # a class locally, and then restore the original registry.
  65         # Refer to https://review.openstack.org/#/c/263800/ for more
  66         # details. This code should be updated when the patch is merged.
  67         self._base_test_backup = copy.copy(
  68             obj_base.VersionedObjectRegistry._registry._obj_classes)
  69         self.addCleanup(self._restore_obj_registry)
  70
  71         self.context = context.get_admin_context()
  72
  73     def _restore_obj_registry(self):
  74         obj_base.VersionedObjectRegistry._registry._obj_classes = (
  75             self._base_test_backup)
  76
  77
  78 class _ValidateResourceTypeTestCase(base.BaseTestCase):
  79     def setUp(self):
  80         super(_ValidateResourceTypeTestCase, self).setUp()
  81         self.is_valid_mock = mock.patch.object(
  82             resources_rpc.resources, 'is_valid_resource_type').start()
  83
  84     def test_valid_type(self):
  85         self.is_valid_mock.return_value = True
  86         resources_rpc._validate_resource_type('foo')
  87
  88     def test_invalid_type(self):
  89         self.is_valid_mock.return_value = False
  90         with testtools.ExpectedException(
  91                 resources_rpc.InvalidResourceTypeClass):
  92             resources_rpc._validate_resource_type('foo')
  93
  94
  95 class _ResourceTypeVersionedTopicTestCase(base.BaseTestCase):
  96
  97     @mock.patch.object(resources_rpc, '_validate_resource_type')
  98     def test_resource_type_versioned_topic(self, validate_mock):
  99         obj_name = FakeResource.obj_name()
 100         expected = topics.RESOURCE_TOPIC_PATTERN % {
 101             'resource_type': 'FakeResource', 'version': '1.0'}
 102         with mock.patch.object(resources_rpc.resources, 'get_resource_cls',
 103                 return_value=FakeResource):
 104             observed = resources_rpc.resource_type_versioned_topic(obj_name)
 105         self.assertEqual(expected, observed)
 106
 107
 108 class ResourcesPullRpcApiTestCase(ResourcesRpcBaseTestCase):
 109
 110     def setUp(self):
 111         super(ResourcesPullRpcApiTestCase, self).setUp()
 112         mock.patch.object(resources_rpc, '_validate_resource_type').start()
 113         mock.patch('neutron.api.rpc.callbacks.resources.get_resource_cls',
 114                    return_value=FakeResource).start()
 115         self.rpc = resources_rpc.ResourcesPullRpcApi()
 116         mock.patch.object(self.rpc, 'client').start()
 117         self.cctxt_mock = self.rpc.client.prepare.return_value
 118
 119     def test_is_singleton(self):
 120         self.assertIs(self.rpc, resources_rpc.ResourcesPullRpcApi())
 121
 122     def test_pull(self):
 123         obj_base.VersionedObjectRegistry.register(FakeResource)
 124         expected_obj = _create_test_resource(self.context)
 125         resource_id = expected_obj.id
 126         self.cctxt_mock.call.return_value = expected_obj.obj_to_primitive()
 127
 128         result = self.rpc.pull(
 129             self.context, FakeResource.obj_name(), resource_id)
 130
 131         self.cctxt_mock.call.assert_called_once_with(
 132             self.context, 'pull', resource_type='FakeResource',
 133             version=FakeResource.VERSION, resource_id=resource_id)
 134         self.assertEqual(expected_obj, result)
 135
 136     def test_pull_resource_not_found(self):
 137         resource_dict = _create_test_dict()
 138         resource_id = resource_dict['id']
 139         self.cctxt_mock.call.return_value = None
 140         with testtools.ExpectedException(resources_rpc.ResourceNotFound):
 141             self.rpc.pull(self.context, FakeResource.obj_name(),
 142                           resource_id)
 143
 144
 145 class ResourcesPullRpcCallbackTestCase(ResourcesRpcBaseTestCase):
 146
 147     def setUp(self):
 148         super(ResourcesPullRpcCallbackTestCase, self).setUp()
 149         obj_base.VersionedObjectRegistry.register(FakeResource)
 150         self.callbacks = resources_rpc.ResourcesPullRpcCallback()
 151         self.resource_obj = _create_test_resource(self.context)
 152
 153     def test_pull(self):
 154         resource_dict = _create_test_dict()
 155         with mock.patch.object(
 156                 resources_rpc.prod_registry, 'pull',
 157                 return_value=self.resource_obj) as registry_mock:
 158             primitive = self.callbacks.pull(
 159                 self.context, resource_type=FakeResource.obj_name(),
 160                 version=FakeResource.VERSION,
 161                 resource_id=self.resource_obj.id)
 162         registry_mock.assert_called_once_with(
 163             'FakeResource', self.resource_obj.id, context=self.context)
 164         self.assertEqual(resource_dict,
 165                          primitive['versioned_object.data'])
 166         self.assertEqual(self.resource_obj.obj_to_primitive(), primitive)
 167
 168     @mock.patch.object(FakeResource, 'obj_to_primitive')
 169     def test_pull_backports_to_older_version(self, to_prim_mock):
 170         with mock.patch.object(resources_rpc.prod_registry, 'pull',
 171                                return_value=self.resource_obj):
 172             self.callbacks.pull(
 173                 self.context, resource_type=FakeResource.obj_name(),
 174                 version='0.9',  # less than initial version 1.0
 175                 resource_id=self.resource_obj.id)
 176             to_prim_mock.assert_called_with(target_version='0.9')
 177
 178
 179 class ResourcesPushRpcApiTestCase(ResourcesRpcBaseTestCase):
 180
 181     def setUp(self):
 182         super(ResourcesPushRpcApiTestCase, self).setUp()
 183         mock.patch.object(resources_rpc.n_rpc, 'get_client').start()
 184         mock.patch.object(resources_rpc, '_validate_resource_type').start()
 185         self.rpc = resources_rpc.ResourcesPushRpcApi()
 186         self.cctxt_mock = self.rpc.client.prepare.return_value
 187         self.resource_obj = _create_test_resource(self.context)
 188
 189     def test__prepare_object_fanout_context(self):
 190         expected_topic = topics.RESOURCE_TOPIC_PATTERN % {
 191             'resource_type': resources.get_resource_type(self.resource_obj),
 192             'version': self.resource_obj.VERSION}
 193
 194         with mock.patch.object(resources_rpc.resources, 'get_resource_cls',
 195                 return_value=FakeResource):
 196             observed = self.rpc._prepare_object_fanout_context(
 197                 self.resource_obj)
 198
 199         self.rpc.client.prepare.assert_called_once_with(
 200             fanout=True, topic=expected_topic)
 201         self.assertEqual(self.cctxt_mock, observed)
 202
 203     def test_pushy(self):
 204         with mock.patch.object(resources_rpc.resources, 'get_resource_cls',
 205                 return_value=FakeResource):
 206             self.rpc.push(
 207                 self.context, self.resource_obj, 'TYPE')
 208
 209         self.cctxt_mock.cast.assert_called_once_with(
 210             self.context, 'push',
 211             resource=self.resource_obj.obj_to_primitive(),
 212             event_type='TYPE')
 213
 214
 215 class ResourcesPushRpcCallbackTestCase(ResourcesRpcBaseTestCase):
 216
 217     def setUp(self):
 218         super(ResourcesPushRpcCallbackTestCase, self).setUp()
 219         mock.patch.object(resources_rpc, '_validate_resource_type').start()
 220         mock.patch.object(
 221             resources_rpc.resources,
 222             'get_resource_cls', return_value=FakeResource).start()
 223         self.resource_obj = _create_test_resource(self.context)
 224         self.resource_prim = self.resource_obj.obj_to_primitive()
 225         self.callbacks = resources_rpc.ResourcesPushRpcCallback()
 226
 227     @mock.patch.object(resources_rpc.cons_registry, 'push')
 228     def test_push(self, reg_push_mock):
 229         obj_base.VersionedObjectRegistry.register(FakeResource)
 230         self.callbacks.push(self.context, self.resource_prim, 'TYPE')
 231         reg_push_mock.assert_called_once_with(self.resource_obj.obj_name(),
 232                                               self.resource_obj, 'TYPE')