def _test_cast(self, fanout, server_params=None): self.mock_connection = self.mox.CreateMock(self.orig_connection) self.mock_session = self.mox.CreateMock(self.orig_session) self.mock_sender = self.mox.CreateMock(self.orig_sender) self.mock_connection.opened().AndReturn(False) self.mock_connection.open() self.mock_connection.session().AndReturn(self.mock_session) if fanout: expected_address = ('impl_qpid_test_fanout ; ' '{"node": {"x-declare": {"auto-delete": true, ' '"durable": false, "type": "fanout"}, ' '"type": "topic"}, "create": "always"}') else: expected_address = ( 'openstack/impl_qpid_test ; {"node": {"x-declare": ' '{"auto-delete": true, "durable": false}, "type": "topic"}, ' '"create": "always"}') self.mock_session.sender(expected_address).AndReturn(self.mock_sender) self.mock_sender.send(mox.IgnoreArg()) if not server_params: # This is a pooled connection, so instead of closing it, it # gets reset, which is just creating a new session on the # connection. self.mock_session.close() self.mock_connection.session().AndReturn(self.mock_session) self.mox.ReplayAll() try: ctx = context.RequestContext("user", "project") args = [ FLAGS, ctx, "impl_qpid_test", { "method": "test_method", "args": {} } ] if server_params: args.insert(2, server_params) if fanout: method = impl_qpid.fanout_cast_to_server else: method = impl_qpid.cast_to_server else: if fanout: method = impl_qpid.fanout_cast else: method = impl_qpid.cast method(*args) finally: while impl_qpid.Connection.pool.free_items: # Pull the mock connection object out of the connection pool so # that it doesn't mess up other test cases. impl_qpid.Connection.pool.get()
def _make_zone_request(zone, is_admin=False): ctxt = context.RequestContext('fake', 'fake', is_admin=is_admin) return { 'context': ctxt, 'request_spec': { 'resource_properties': { 'availability_zone': zone } } }
def _test_call_with_timeout(self, timeout, expect_failure): self._test_call_mock_common() if not expect_failure: self.mock_session.next_receiver(timeout=None).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "_msg_id": self.uuid4.hex, "result": "foo", "failure": False, "ending": False })) self.mock_session.acknowledge(mox.IgnoreArg()) self.mock_session.next_receiver(timeout=None).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "_msg_id": self.uuid4.hex, "failure": False, "ending": True })) self.mock_session.acknowledge(mox.IgnoreArg()) # Normally the iterconsume() runs indefinitely, but we have to stop it # here otherwise, the test won't end self.mock_session.next_receiver(timeout=None).AndRaise(StopIteration) self.mock_connection.close() self.mox.ReplayAll() try: ctx = context.RequestContext("user", "project") method = impl_qpid.call if expect_failure: try: res = method(self.FLAGS, ctx, "impl_qpid_test", { "method": "test_method", "args": {} }, timeout) self.fail('Expected a timeout exception') except rpc_common.Timeout: # Good, this is expected! pass else: res = method(self.FLAGS, ctx, "impl_qpid_test", { "method": "test_method", "args": {} }, timeout) self.assertEqual(res, "foo") finally: impl_qpid.cleanup() self.uuid4 = uuid.uuid4()
def setUp(self): super(HostFiltersTestCase, self).setUp() self.context = context.RequestContext('fake', 'fake') self.json_query = jsonutils.dumps([ 'and', ['>=', '$free_ram_mb', 1024], ['>=', '$free_disk_mb', 200 * 1024] ]) namespace = 'openstack.common.scheduler.filters' filter_handler = filters.HostFilterHandler(namespace) classes = filter_handler.get_all_classes() self.class_map = {} for cls in classes: self.class_map[cls.__name__] = cls
def test_serializer(self): ctxt = context.RequestContext('fake', 'fake') serializer = rpc_serializer.NoOpSerializer() self.mox.StubOutWithMock(serializer, 'serialize_entity') self.mox.StubOutWithMock(serializer, 'deserialize_entity') self.mox.StubOutWithMock(rpc, 'call') serializer.serialize_entity(ctxt, 1).AndReturn(1) serializer.serialize_entity(ctxt, 2).AndReturn(2) rpc.call(ctxt, 'fake', {'args': {'a': 1, 'b': 2}, 'namespace': None, 'method': 'foo', 'version': '1.0'}, None).AndReturn('foo') serializer.deserialize_entity(ctxt, 'foo').AndReturn('worked!') self.mox.ReplayAll() rpc_proxy = proxy.RpcProxy('fake', '1.0', serializer=serializer) msg = rpc_proxy.make_msg('foo', a=1, b=2) result = rpc_proxy.call(ctxt, msg) self.assertEqual(result, 'worked!')
def setUp(self): super(RpcDispatcherTestCase, self).setUp() self.ctxt = context.RequestContext('fake_user', 'fake_project') self.mox = self.useFixture(moxstubout.MoxStubout()).mox
def _test_call(self, multi): self.mock_connection = self.mox.CreateMock(self.orig_connection) self.mock_session = self.mox.CreateMock(self.orig_session) self.mock_sender = self.mox.CreateMock(self.orig_sender) self.mock_receiver = self.mox.CreateMock(self.orig_receiver) self.mock_connection.opened().AndReturn(False) self.mock_connection.open() self.mock_connection.session().AndReturn(self.mock_session) rcv_addr = mox.Regex( r'^.*/.* ; {"node": {"x-declare": {"auto-delete":' ' true, "durable": true, "type": "direct"}, "type": ' '"topic"}, "create": "always", "link": {"x-declare": ' '{"auto-delete": true, "exclusive": true, "durable": ' 'false}, "durable": true, "name": ".*"}}') self.mock_session.receiver(rcv_addr).AndReturn(self.mock_receiver) self.mock_receiver.capacity = 1 send_addr = ( 'openstack/impl_qpid_test ; {"node": {"x-declare": ' '{"auto-delete": true, "durable": false}, "type": "topic"}, ' '"create": "always"}') self.mock_session.sender(send_addr).AndReturn(self.mock_sender) self.mock_sender.send(mox.IgnoreArg()) self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "result": "foo", "failure": False, "ending": False })) self.mock_session.acknowledge(mox.IgnoreArg()) if multi: self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "result": "bar", "failure": False, "ending": False })) self.mock_session.acknowledge(mox.IgnoreArg()) self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "result": "baz", "failure": False, "ending": False })) self.mock_session.acknowledge(mox.IgnoreArg()) self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "failure": False, "ending": True })) self.mock_session.acknowledge(mox.IgnoreArg()) self.mock_session.close() self.mock_connection.session().AndReturn(self.mock_session) self.mox.ReplayAll() try: ctx = context.RequestContext("user", "project") if multi: method = impl_qpid.multicall else: method = impl_qpid.call res = method(FLAGS, ctx, "impl_qpid_test", { "method": "test_method", "args": {} }) if multi: self.assertEquals(list(res), ["foo", "bar", "baz"]) else: self.assertEquals(res, "foo") finally: while impl_qpid.Connection.pool.free_items: # Pull the mock connection object out of the connection pool so # that it doesn't mess up other test cases. impl_qpid.Connection.pool.get()
def _test_rpc_method(self, rpc_method, has_timeout=False, has_retval=False, server_params=None, supports_topic_override=True): topic = 'fake_topic' rpc_proxy = proxy.RpcProxy(topic, '1.0') ctxt = context.RequestContext('fake_user', 'fake_project') msg = {'method': 'fake_method', 'args': {'x': 'y'}} expected_msg = {'method': 'fake_method', 'args': {'x': 'y'}, 'version': '1.0'} expected_retval = 'hi' if has_retval else None self.fake_args = None self.fake_kwargs = None def _fake_rpc_method(*args, **kwargs): rpc._check_for_lock() self.fake_args = args self.fake_kwargs = kwargs if has_retval: return expected_retval def _fake_rpc_method_timeout(*args, **kwargs): rpc._check_for_lock() self.fake_args = args self.fake_kwargs = kwargs raise rpc_common.Timeout("The spider got you") def _check_args(context, topic, msg, timeout=None): expected_args = [context, topic, msg] if server_params: expected_args.insert(1, server_params) if has_timeout: expected_args.append(timeout) self.assertEqual(tuple(expected_args), self.fake_args) self.stubs.Set(rpc, rpc_method, _fake_rpc_method) args = [ctxt, msg] if server_params: args.insert(1, server_params) # Base method usage retval = getattr(rpc_proxy, rpc_method)(*args) self.assertEqual(retval, expected_retval) _check_args(ctxt, topic, expected_msg) # overriding the version retval = getattr(rpc_proxy, rpc_method)(*args, version='1.1') self.assertEqual(retval, expected_retval) new_msg = copy.deepcopy(expected_msg) new_msg['version'] = '1.1' _check_args(ctxt, topic, new_msg) # override the version to be above a specified cap rpc_proxy.version_cap = '1.0' self.assertRaises(rpc_common.RpcVersionCapError, getattr(rpc_proxy, rpc_method), *args, version='1.1') rpc_proxy.version_cap = None if has_timeout: # Set a timeout retval = getattr(rpc_proxy, rpc_method)(ctxt, msg, timeout=42) self.assertEqual(retval, expected_retval) _check_args(ctxt, topic, expected_msg, timeout=42) # Make it timeout and check that the exception is written as # expected self.stubs.Set(rpc, rpc_method, _fake_rpc_method_timeout) try: getattr(rpc_proxy, rpc_method)(*args, timeout=42) self.fail("This should have raised a Timeout exception") except rpc_common.Timeout as exc: self.assertEqual(exc.info, 'The spider got you') self.assertEqual(exc.topic, 'fake_topic') self.assertEqual(exc.method, 'fake_method') self.assertEqual( u'Timeout while waiting on RPC response - ' 'topic: "fake_topic", RPC method: "fake_method" ' 'info: "The spider got you"', six.text_type(exc)) _check_args(ctxt, topic, expected_msg, timeout=42) self.stubs.Set(rpc, rpc_method, _fake_rpc_method) if supports_topic_override: # set a topic new_topic = 'foo.bar' retval = getattr(rpc_proxy, rpc_method)(*args, topic=new_topic) self.assertEqual(retval, expected_retval) _check_args(ctxt, new_topic, expected_msg)
def _test_call_with_timeout(self, timeout, expect_failure): # TODO(beagles): should be possible to refactor this method and # _test_call to share common code. Maybe making the messages # and test checks parameters, etc. self.mock_connection = self.mox.CreateMock(self.orig_connection) self.mock_session = self.mox.CreateMock(self.orig_session) self.mock_sender = self.mox.CreateMock(self.orig_sender) self.mock_receiver = self.mox.CreateMock(self.orig_receiver) self.mock_connection.opened().AndReturn(False) self.mock_connection.open() self.mock_connection.session().AndReturn(self.mock_session) rcv_addr = mox.Regex( r'^.*/.* ; {"node": {"x-declare": {"auto-delete":' ' true, "durable": true, "type": "direct"}, "type": ' '"topic"}, "create": "always", "link": {"x-declare": ' '{"auto-delete": true, "exclusive": true, "durable": ' 'false}, "durable": true, "name": ".*"}}') self.mock_session.receiver(rcv_addr).AndReturn(self.mock_receiver) self.mock_receiver.capacity = 1 send_addr = ( 'openstack/impl_qpid_test ; {"node": {"x-declare": ' '{"auto-delete": true, "durable": false}, "type": "topic"}, ' '"create": "always"}') self.mock_session.sender(send_addr).AndReturn(self.mock_sender) self.mock_sender.send(mox.IgnoreArg()) if expect_failure: self.mock_session.next_receiver(timeout=mox.IsA(int)).AndRaise( qpid.messaging.exceptions.Empty()) self.mock_receiver.fetch() self.mock_session.close() self.mock_connection.session().AndReturn(self.mock_session) else: self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn(qpid.messaging.Message( {"result": "foo", "failure": False, "ending": False})) self.mock_session.acknowledge(mox.IgnoreArg()) self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn(qpid.messaging.Message( {"failure": False, "ending": True})) self.mock_session.acknowledge(mox.IgnoreArg()) self.mock_session.close() self.mock_connection.session().AndReturn(self.mock_session) self.mox.ReplayAll() try: ctx = context.RequestContext("user", "project") method = impl_qpid.call if expect_failure: try: res = method(FLAGS, ctx, "impl_qpid_test", {"method": "test_method", "args": {}}, timeout) self.fail('Expected a timeout exception') except rpc_common.Timeout: # Good, this is expected! pass else: res = method(FLAGS, ctx, "impl_qpid_test", {"method": "test_method", "args": {}}, timeout) self.assertEquals(res, "foo") finally: while impl_qpid.Connection.pool.free_items: # Pull the mock connection object out of the connection pool so # that it doesn't mess up other test cases. impl_qpid.Connection.pool.get()
def test_context(self): ctx = context.RequestContext() self.assertTrue(ctx)
def _test_rpc_method(self, rpc_method, has_timeout=False, has_retval=False, server_params=None, supports_topic_override=True): topic = 'fake_topic' timeout = 123 rpc_proxy = proxy.RpcProxy(topic, '1.0') ctxt = context.RequestContext('fake_user', 'fake_project') msg = {'method': 'fake_method', 'args': {'x': 'y'}} expected_msg = { 'method': 'fake_method', 'args': { 'x': 'y' }, 'version': '1.0' } expected_retval = 'hi' if has_retval else None self.fake_args = None self.fake_kwargs = None def _fake_rpc_method(*args, **kwargs): self.fake_args = args self.fake_kwargs = kwargs if has_retval: return expected_retval self.stubs.Set(rpc, rpc_method, _fake_rpc_method) args = [ctxt, msg] if server_params: args.insert(1, server_params) # Base method usage retval = getattr(rpc_proxy, rpc_method)(*args) self.assertEqual(retval, expected_retval) expected_args = [ctxt, topic, expected_msg] if server_params: expected_args.insert(1, server_params) for arg, expected_arg in zip(self.fake_args, expected_args): self.assertEqual(arg, expected_arg) # overriding the version retval = getattr(rpc_proxy, rpc_method)(*args, version='1.1') self.assertEqual(retval, expected_retval) new_msg = copy.deepcopy(expected_msg) new_msg['version'] = '1.1' expected_args = [ctxt, topic, new_msg] if server_params: expected_args.insert(1, server_params) for arg, expected_arg in zip(self.fake_args, expected_args): self.assertEqual(arg, expected_arg) if has_timeout: # set a timeout retval = getattr(rpc_proxy, rpc_method)(ctxt, msg, timeout=timeout) self.assertEqual(retval, expected_retval) expected_args = [ctxt, topic, expected_msg, timeout] for arg, expected_arg in zip(self.fake_args, expected_args): self.assertEqual(arg, expected_arg) if supports_topic_override: # set a topic new_topic = 'foo.bar' retval = getattr(rpc_proxy, rpc_method)(*args, topic=new_topic) self.assertEqual(retval, expected_retval) expected_args = [ctxt, new_topic, expected_msg] if server_params: expected_args.insert(1, server_params) for arg, expected_arg in zip(self.fake_args, expected_args): self.assertEqual(arg, expected_arg)
def setUp(self): super(RpcDispatcherTestCase, self).setUp() self.ctxt = context.RequestContext('fake_user', 'fake_project')
def _fake_context(): return context.RequestContext(1, 1)
def _test_call(self, multi, reply_proxy_exc): self._test_call_mock_common() if reply_proxy_exc: self.mock_session.next_receiver(timeout=None).AndRaise( Exception('unexpected exception')) self.mock_session.next_receiver(timeout=None).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "_msg_id": self.uuid4.hex, "result": "foo", "failure": False, "ending": False })) self.mock_session.acknowledge(mox.IgnoreArg()) if multi: self.mock_session.next_receiver(timeout=None).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "_msg_id": self.uuid4.hex, "result": "bar", "failure": False, "ending": False })) self.mock_session.acknowledge(mox.IgnoreArg()) self.mock_session.next_receiver(timeout=None).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "_msg_id": self.uuid4.hex, "result": "baz", "failure": False, "ending": False })) self.mock_session.acknowledge(mox.IgnoreArg()) if reply_proxy_exc: self.mock_session.next_receiver(timeout=None).AndRaise( Exception('unexpected exception')) self.mock_session.next_receiver(timeout=None).AndReturn( self.mock_receiver) self.mock_receiver.fetch().AndReturn( qpid.messaging.Message({ "_msg_id": self.uuid4.hex, "failure": False, "ending": True })) self.mock_session.acknowledge(mox.IgnoreArg()) # Normally the iterconsume() runs indefinitely, but we have to stop it # here otherwise, the test won't end self.mock_session.next_receiver(timeout=None).AndRaise(StopIteration) self.mock_connection.close() self.mox.ReplayAll() try: ctx = context.RequestContext("user", "project") if multi: method = impl_qpid.multicall else: method = impl_qpid.call res = method(self.FLAGS, ctx, "impl_qpid_test", { "method": "test_method", "args": {} }) if multi: self.assertEqual(list(res), ["foo", "bar", "baz"]) else: self.assertEqual(res, "foo") finally: impl_qpid.cleanup() self.uuid4 = uuid.uuid4()
def _test_cast(self, fanout, server_params=None, topology_version=1): self.config(qpid_topology_version=topology_version) self.mock_connection = self.mox.CreateMock(self.orig_connection) self.mock_session = self.mox.CreateMock(self.orig_session) self.mock_sender = self.mox.CreateMock(self.orig_sender) self.mock_connection.opened().AndReturn(False) self.mock_connection.open() self.mock_connection.session().AndReturn(self.mock_session) if fanout: if topology_version == 1: expected_address = ( 'impl_qpid_test_fanout ; ' '{"node": {"x-declare": {"auto-delete": true, ' '"durable": false, "type": "fanout"}, ' '"type": "topic"}, "create": "always"}') elif topology_version == 2: expected_address = 'amq.topic/fanout/impl_qpid_test' else: if topology_version == 1: expected_address = ( 'openstack/impl_qpid_test ; {"node": {"x-declare": ' '{"auto-delete": true, "durable": false}, ' '"type": "topic"}, "create": "always"}') elif topology_version == 2: expected_address = 'amq.topic/topic/openstack/impl_qpid_test' self.mock_session.sender(expected_address).AndReturn(self.mock_sender) self.mock_sender.send(mox.IgnoreArg()) if not server_params: # This is a pooled connection, so instead of closing it, it # gets reset, which is just creating a new session on the # connection. self.mock_session.close() self.mock_connection.session().AndReturn(self.mock_session) self.mock_connection.close() self.mox.ReplayAll() try: ctx = context.RequestContext("user", "project") args = [ self.FLAGS, ctx, "impl_qpid_test", { "method": "test_method", "args": {} } ] if server_params: args.insert(2, server_params) if fanout: method = impl_qpid.fanout_cast_to_server else: method = impl_qpid.cast_to_server else: if fanout: method = impl_qpid.fanout_cast else: method = impl_qpid.cast method(*args) finally: impl_qpid.cleanup() self.uuid4 = uuid.uuid4()