class TestRequest(unittest.TestCase):
def setUp(self):
self.callback = MagicMock()
self.o = Request(32)
self.o.set_callback(self.callback)
def test_init(self):
assert self.o.id == 32
assert self.o.callback == self.callback
def test_respond_with_return(self):
cb, response = self.o.return_response(value=5)
assert cb == self.callback
assert response.to_dict() == Return(id=32, value=5).to_dict()
def test_respond_with_error(self):
cb, response = self.o.error_response(
exception=ValueError("Test Error"))
assert cb == self.callback
assert response.to_dict() == Error(id=32, message=ANY).to_dict()
assert str(response.message) == "Test Error"
def test_setters(self):
self.o.set_callback(MagicMock())
self.o.callback(888)
self.callback.assert_not_called()
class TestRequest(unittest.TestCase):
def setUp(self):
self.callback = MagicMock()
self.o = Request(32, self.callback)
def test_init(self):
assert self.o.id == 32
assert self.o.callback == self.callback
def test_respond_with_return(self):
cb, response = self.o.return_response(value=5)
assert cb == self.callback
assert response == Return(id=32, value=5)
def test_respond_with_error(self):
cb, response = self.o.error_response(
exception=ValueError("Test Error"))
assert cb == self.callback
assert response == Error(id=32, message="ValueError: Test Error")
def test_setters(self):
self.o.set_id(123)
assert 123 == self.o.id
self.o.set_callback(None)
self.o.callback(888)
self.callback.assert_not_called()
def test_Post(self, request_mock):
endpoint = ["BL18I:XSPRESS3", "configure"]
post = Request.Post(self.context, self.response_queue, endpoint)
request_mock.assert_called_once_with(self.context,
self.response_queue,
type_="Post")
def test_Get(self, request_mock):
endpoint = ["BL18I:XSPRESS3", "state", "value"]
get = Request.Get(self.context, self.response_queue, endpoint)
request_mock.assert_called_once_with(self.context,
self.response_queue,
type_="Get")
def test_given_valid_attr_then_return(self):
param_dict = dict(one=7, two=23)
post = Request.Post(self.context,
self.response_queue, [""],
parameters=param_dict)
self.assertEqual(param_dict, post.parameters)
def test_given_invalid_attr_then_raise_error(self):
param_dict = dict(one=7, two=23)
post = Request.Post(self.context,
self.response_queue, [""],
parameters=param_dict)
with self.assertRaises(KeyError):
post.null
def test_from_dict(self):
serialized = {"id": 1, "type": "Put", "extra_1": "abc",
"extra_2": {"field": "data"}}
request = Request.from_dict(serialized)
self.assertEquals(1, request.id_)
self.assertEquals("Put", request.type_)
self.assertEquals("abc", request.fields["extra_1"])
self.assertEquals({"field": "data"}, request.fields["extra_2"])
self.assertIsNone(request.context)
self.assertIsNone(request.response_queue)
def create_methods(self):
"""Get methods from remote block and mirror them internally"""
request = Request.Get(None, self.q, [self.block.name])
self.client_comms.q.put(request)
self.log_debug("Waiting for response to Get %s", self.block.name)
response = self.q.get()
# Find all the methods
for aname, amap in response.value.items():
# TODO: If it has "takes" it's a method, flaky...
if "takes" in amap:
yield self.wrap_method(aname, amap)
def on_message(self, message):
"""
Pass on received message to Process
Args:
message(str): Received message
"""
d = json.loads(message, object_pairs_hook=OrderedDict)
request = Request.from_dict(d)
request.context = self
self.servercomms.on_request(request)
def on_message(self, message):
"""
Pass on received message to Process
Args:
message(str): Received message
"""
d = json.loads(message, object_pairs_hook=OrderedDict)
request = Request.from_dict(d)
request.context = self
self.servercomms.on_request(request)
def call_server_method(self, method_name, args):
"""Call method_name on the server
Args:
method_name (str): Name of the method
args (dict): Map of arguments to be called with
"""
request = Request.Post(None, self.q, [self.block.name, method_name],
args)
self.client_comms.q.put(request)
response = self.q.get()
assert response.type_ == response.RETURN, \
"Expected Return, got %s" % response.type_
return response.value
def test_from_dict(self):
serialized = {
"id": 1,
"type": "Put",
"extra_1": "abc",
"extra_2": {
"field": "data"
}
}
request = Request.from_dict(serialized)
self.assertEquals(1, request.id_)
self.assertEquals("Put", request.type_)
self.assertEquals("abc", request.fields["extra_1"])
self.assertEquals({"field": "data"}, request.fields["extra_2"])
self.assertIsNone(request.context)
self.assertIsNone(request.response_queue)
def test_hello_controller_with_process(self):
sync_factory = SyncFactory("sched")
process = Process("proc", sync_factory)
block = Block("hello")
HelloController(block)
process.add_block(block)
process.start()
q = sync_factory.create_queue()
req = Request.Post(response_queue=q, context="ClientConnection",
endpoint=["hello", "say_hello"],
parameters=dict(name="thing"))
req.set_id(44)
process.q.put(req)
resp = q.get(timeout=1)
self.assertEqual(resp.id_, 44)
self.assertEqual(resp.context, "ClientConnection")
self.assertEqual(resp.type_, "Return")
self.assertEqual(resp.value, dict(greeting="Hello thing"))
class TestRequest(unittest.TestCase):
def setUp(self):
self.context = MagicMock()
self.response_queue = MagicMock()
self.request = Request(self.context, self.response_queue)
def test_init(self):
self.assertEqual(self.context, self.request.context)
self.assertEqual(self.response_queue, self.request.response_queue)
def test_repr(self):
r = Request(MagicMock(), MagicMock())
s = r.__repr__()
self.assertTrue(isinstance(s, str))
self.assertIn('id', s)
def test_respond_with_return(self):
self.request.respond_with_return(value=5)
call_arg = self.response_queue.put.call_args_list[0][0][0].to_dict()
expected_response = Return(self.request.id,
self.request.context,
value=5).to_dict()
self.assertEqual(call_arg, expected_response)
def test_respond_with_error(self):
self.request.respond_with_error(message="Test Error")
call_arg = self.response_queue.put.call_args_list[0][0][0].to_dict()
expected_response = Error(self.request.id,
self.request.context,
message="Test Error").to_dict()
self.assertEqual(call_arg, expected_response)
def test_setters(self):
self.request.set_id(123)
self.assertEquals(123, self.request.id)
class TestRequest(unittest.TestCase):
def setUp(self):
self.context = MagicMock()
self.response_queue = MagicMock()
self.response_queue.qsize.return_value = 0
self.request = Request(self.context, self.response_queue)
def test_init(self):
self.assertEqual(self.context, self.request.context)
self.assertEqual(self.response_queue, self.request.response_queue)
def test_repr(self):
r = Request(MagicMock(), MagicMock())
s = r.__repr__()
self.assertTrue(isinstance(s, str))
self.assertIn('id', s)
def test_respond_with_return(self):
self.request.respond_with_return(value=5)
call_arg = self.response_queue.put.call_args_list[0][0][0].to_dict()
expected_response = Return(self.request.id, self.request.context, value=5).to_dict()
self.assertEqual(call_arg, expected_response)
def test_respond_with_error(self):
self.request.respond_with_error(message="Test Error")
call_arg = self.response_queue.put.call_args_list[0][0][0].to_dict()
expected_response = Error(self.request.id, self.request.context,
message="Test Error").to_dict()
self.assertEqual(call_arg, expected_response)
def test_setters(self):
self.request.set_id(123)
self.assertEquals(123, self.request.id)
class TestRequest(unittest.TestCase):
def setUp(self):
self.context = MagicMock()
self.response_queue = MagicMock()
self.request = Request(self.context, self.response_queue, "Put")
def test_init(self):
self.assertEqual(self.context, self.request.context)
self.assertEqual(self.response_queue, self.request.response_queue)
self.assertEqual("Put", self.request.type_)
def test_to_dict(self):
expected_dict = OrderedDict()
expected_dict['id'] = 1
expected_dict['type'] = "Put"
parameters = OrderedDict(x=2, y=10)
expected_dict['parameters'] = parameters
self.request.id_ = 1
self.request.fields['parameters'] = parameters
return_dict = self.request.to_dict()
self.assertEqual(expected_dict, return_dict)
def test_from_dict(self):
serialized = {"id": 1, "type": "Put", "extra_1": "abc",
"extra_2": {"field": "data"}}
request = Request.from_dict(serialized)
self.assertEquals(1, request.id_)
self.assertEquals("Put", request.type_)
self.assertEquals("abc", request.fields["extra_1"])
self.assertEquals({"field": "data"}, request.fields["extra_2"])
self.assertIsNone(request.context)
self.assertIsNone(request.response_queue)
@patch("malcolm.core.response.Response.Return")
def test_respond_with_return(self, return_mock):
response = MagicMock()
return_mock.return_value = response
self.request.respond_with_return(value=5)
return_mock.assert_called_once_with(self.request.id_, self.request.context, value=5)
self.response_queue.put.assert_called_once_with(response)
@patch("malcolm.core.response.Response.Error")
def test_respond_with_error(self, return_mock):
response = MagicMock()
return_mock.return_value = response
self.request.respond_with_error(message="Test Error")
return_mock.assert_called_once_with(self.request.id_, self.request.context,
message="Test Error")
self.response_queue.put.assert_called_once_with(response)
@patch("malcolm.core.request.Request")
def test_Get(self, request_mock):
endpoint = ["BL18I:XSPRESS3", "state", "value"]
get = Request.Get(self.context, self.response_queue, endpoint)
request_mock.assert_called_once_with(self.context, self.response_queue, type_="Get")
@patch("malcolm.core.request.Request")
def test_Post(self, request_mock):
endpoint = ["BL18I:XSPRESS3", "configure"]
post = Request.Post(self.context, self.response_queue, endpoint)
request_mock.assert_called_once_with(self.context, self.response_queue, type_="Post")
def test_given_valid_attr_then_return(self):
param_dict = dict(one=7, two=23)
post = Request.Post(self.context, self.response_queue, [""], parameters=param_dict)
self.assertEqual(param_dict, post.parameters)
def test_given_invalid_attr_then_raise_error(self):
param_dict = dict(one=7, two=23)
post = Request.Post(self.context, self.response_queue, [""], parameters=param_dict)
with self.assertRaises(KeyError):
post.null
def setUp(self):
self.context = MagicMock()
self.response_queue = MagicMock()
self.request = Request(self.context, self.response_queue, "Put")
def setUp(self):
self.context = MagicMock()
self.response_queue = MagicMock()
self.response_queue.qsize.return_value = 0
self.request = Request(self.context, self.response_queue)
def test_repr(self):
r = Request(MagicMock(), MagicMock())
s = r.__repr__()
self.assertTrue(isinstance(s, str))
self.assertIn('id', s)
def setUp(self):
self.context = MagicMock()
self.response_queue = MagicMock()
self.request = Request(self.context, self.response_queue, "Put")
class TestRequest(unittest.TestCase):
def setUp(self):
self.context = MagicMock()
self.response_queue = MagicMock()
self.request = Request(self.context, self.response_queue, "Put")
def test_init(self):
self.assertEqual(self.context, self.request.context)
self.assertEqual(self.response_queue, self.request.response_queue)
self.assertEqual("Put", self.request.type_)
def test_to_dict(self):
expected_dict = OrderedDict()
expected_dict['id'] = 1
expected_dict['type'] = "Put"
parameters = OrderedDict(x=2, y=10)
expected_dict['parameters'] = parameters
self.request.id_ = 1
self.request.fields['parameters'] = parameters
return_dict = self.request.to_dict()
self.assertEqual(expected_dict, return_dict)
def test_from_dict(self):
serialized = {
"id": 1,
"type": "Put",
"extra_1": "abc",
"extra_2": {
"field": "data"
}
}
request = Request.from_dict(serialized)
self.assertEquals(1, request.id_)
self.assertEquals("Put", request.type_)
self.assertEquals("abc", request.fields["extra_1"])
self.assertEquals({"field": "data"}, request.fields["extra_2"])
self.assertIsNone(request.context)
self.assertIsNone(request.response_queue)
@patch("malcolm.core.response.Response.Return")
def test_respond_with_return(self, return_mock):
response = MagicMock()
return_mock.return_value = response
self.request.respond_with_return(value=5)
return_mock.assert_called_once_with(self.request.id_,
self.request.context,
value=5)
self.response_queue.put.assert_called_once_with(response)
@patch("malcolm.core.response.Response.Error")
def test_respond_with_error(self, return_mock):
response = MagicMock()
return_mock.return_value = response
self.request.respond_with_error(message="Test Error")
return_mock.assert_called_once_with(self.request.id_,
self.request.context,
message="Test Error")
self.response_queue.put.assert_called_once_with(response)
@patch("malcolm.core.request.Request")
def test_Get(self, request_mock):
endpoint = ["BL18I:XSPRESS3", "state", "value"]
get = Request.Get(self.context, self.response_queue, endpoint)
request_mock.assert_called_once_with(self.context,
self.response_queue,
type_="Get")
@patch("malcolm.core.request.Request")
def test_Post(self, request_mock):
endpoint = ["BL18I:XSPRESS3", "configure"]
post = Request.Post(self.context, self.response_queue, endpoint)
request_mock.assert_called_once_with(self.context,
self.response_queue,
type_="Post")
def test_given_valid_attr_then_return(self):
param_dict = dict(one=7, two=23)
post = Request.Post(self.context,
self.response_queue, [""],
parameters=param_dict)
self.assertEqual(param_dict, post.parameters)
def test_given_invalid_attr_then_raise_error(self):
param_dict = dict(one=7, two=23)
post = Request.Post(self.context,
self.response_queue, [""],
parameters=param_dict)
with self.assertRaises(KeyError):
post.null
def test_repr(self):
r = Request(MagicMock(), MagicMock())
s = r.__repr__()
self.assertTrue(isinstance(s, str))
self.assertIn('id', s)
def setUp(self):
self.callback = MagicMock()
self.o = Request(32)
self.o.set_callback(self.callback)
