def test_remove_put(self):
self.PVA = PvaServerComms(self.p)
put1 = MagicMock()
put2 = MagicMock()
self.PVA._puts = {1: put1, 2: put2}
self.PVA.remove_put(1)
self.assertEqual(self.PVA._puts, {2: put2})
def test_remove_get(self):
self.PVA = PvaServerComms(self.p)
get1 = MagicMock()
get2 = MagicMock()
self.PVA._gets = {1: get1, 2: get2}
self.PVA.remove_get(1)
self.assertEqual(self.PVA._gets, {2: get2})
def test_unique_id(self):
self.PVA = PvaServerComms(self.p)
self.assertEqual(self.PVA._get_unique_id(), 2)
self.assertEqual(self.PVA._get_unique_id(), 3)
self.assertEqual(self.PVA._get_unique_id(), 4)
self.assertEqual(self.PVA._get_unique_id(), 5)
def test_unique_id(self):
self.PVA = PvaServerComms(self.p)
starting_id = self.PVA._current_id
self.assertEqual(self.PVA._get_unique_id(), starting_id + 1)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 2)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 3)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 4)
def test_strip_type_id(self):
self.PVA = PvaServerComms(self.p)
#val = self.PVA.dict_to_structure({"typeid": "type1", "level1": {"typeid": "type2", "level2": {"typeid": "type3", "item1": 1, "item2": "2", "item3": True}}})
val = self.PVA.strip_type_id(
OrderedDict({
"typeid": "type1",
"val1": "1"
}))
self.assertEquals(val, OrderedDict({"val1": "1"}))
def test_purge_rpcs(self):
self.PVA = PvaServerComms(self.p)
self.rpc1 = MagicMock()
self.rpc2 = MagicMock()
self.PVA.register_rpc(1, self.rpc1)
self.PVA.register_rpc(2, self.rpc2)
self.assertEqual(self.PVA._rpcs, {1: self.rpc1, 2: self.rpc2})
self.PVA.register_dead_rpc(1)
self.assertEqual(self.PVA._dead_rpcs, [1])
self.PVA.purge_rpcs()
self.assertEqual(self.PVA._rpcs, {2: self.rpc2})
self.assertEqual(self.PVA._dead_rpcs, [])
def test_update_block_list(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
self.PVA._cache = {"block1": 1, "block2": 2, "block3": 3}
self.PVA._update_block_list()
calls = [call("block3"), call("block2"), call("block1")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.PVA._add_new_pva_channel.reset_mock()
self.PVA._cache = {"block1": 1, "block2": 2, "block3": 3, "block4": 4}
self.PVA._update_block_list()
calls = [call("block4")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
def test_remove_put(self):
self.PVA = PvaServerComms(self.p)
put1 = MagicMock()
put2 = MagicMock()
self.PVA._puts = {1: put1, 2: put2}
self.PVA.remove_put(1)
self.assertEqual(self.PVA._puts, {2: put2})
def test_send_to_client(self):
self.PVA = PvaServerComms(self.p)
self.PVA._update_cache = MagicMock()
rpc_mock1 = MagicMock()
rpc_mock2 = MagicMock()
self.PVA._rpcs[1] = rpc_mock1
self.PVA._rpcs[2] = rpc_mock2
response1 = Return(id_=1)
self.PVA.send_to_client(response1)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=2)
self.PVA.send_to_client(response2)
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Delta(id_=3)
self.PVA.send_to_client(response3)
self.PVA._update_cache.assert_has_calls([call(response3)])
def test_remove_get(self):
self.PVA = PvaServerComms(self.p)
get1 = MagicMock()
get2 = MagicMock()
self.PVA._gets = {1: get1, 2: get2}
self.PVA.remove_get(1)
self.assertEqual(self.PVA._gets, {2: get2})
def test_cache_to_pvobject(self):
self.PVA = PvaServerComms(self.p)
self.PVA._cache["test.block"] = OrderedDict({
"p1":
OrderedDict({
"p2": "val2",
"typeid": "type2"
}),
"typeid":
"type1"
})
object = self.PVA.cache_to_pvobject("test.block", [["p1", "p2"]])
self.assertEqual(
object,
PvTempObject(OrderedDict({"p1": OrderedDict({"p2": "val2"})}),
"type1"))
self.PVA._cache["test.block"] = OrderedDict({
"p1": [
OrderedDict({
"p2": 2,
"typeid": "type2"
}),
OrderedDict({
"p3": "val3",
"typeid": "type3"
})
],
"typeid":
"type1"
})
object = self.PVA.cache_to_pvobject("test.block", [["p1"]])
self.assertEqual(
object,
PvTempObject(
OrderedDict({
"p1": [
OrderedDict({
"p2": 2,
"typeid": "type2"
}),
OrderedDict({
"p3": "val3",
"typeid": "type3"
})
]
}), "type1"))
def test_update_cache(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
request = Delta(id_=1,
changes=[[["block1"], 1], [["block2"], 2],
[["block3"], 3]])
self.PVA._update_cache(request)
calls = [call("block1"), call("block2"), call("block3")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.assertEqual(self.PVA._cache, {
"block1": 1,
"block2": 2,
"block3": 3
})
def test_unique_id(self):
self.PVA = PvaServerComms(self.p)
starting_id = self.PVA._current_id
self.assertEqual(self.PVA._get_unique_id(), starting_id + 1)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 2)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 3)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 4)
def test_dict_to_stucture(self):
self.PVA = PvaServerComms(self.p)
val_dict = OrderedDict()
val_dict["typeid"] = "type1"
val_dict["val1"] = "1"
val_dict["val2"] = np.int32(2)
val_dict["val3"] = True
val_dict["val4"] = np.int64(0)
val_dict["val5"] = np.float64(0.5)
val_dict["val6"] = StringArray('', '')
val_dict["val7"] = np.array([5, 1], dtype=np.int32)
val_dict["val8"] = [True, False]
val_dict["val9"] = np.array([0, 1], dtype=np.int64)
val_dict["val10"] = np.array([0.2, 0.6], dtype=np.float64)
val = self.PVA.pva_structure_from_value(val_dict)
test_dict = OrderedDict()
test_dict["val1"] = pvaccess.STRING
test_dict["val2"] = pvaccess.INT
test_dict["val3"] = pvaccess.BOOLEAN
test_dict["val4"] = pvaccess.LONG
test_dict["val5"] = pvaccess.DOUBLE
test_dict["val6"] = [pvaccess.STRING]
test_dict["val7"] = [pvaccess.INT]
test_dict["val8"] = [pvaccess.BOOLEAN]
test_dict["val9"] = [pvaccess.LONG]
test_dict["val10"] = [pvaccess.DOUBLE]
test_val = pvaccess.PvObject(test_dict, "type1")
self.assertEquals(val, test_val)
# Test the variant union array type
val = self.PVA.pva_structure_from_value(
{"union_array": [{
"val1": 1
}, {
"val2": "2"
}]})
test_dict = OrderedDict()
test_dict["union_array"] = [()]
test_val = pvaccess.PvObject(test_dict, "")
self.assertEquals(val, test_val)
val = self.PVA.pva_structure_from_value({"union_array": []})
test_dict = OrderedDict()
test_dict["union_array"] = [()]
test_val = pvaccess.PvObject(test_dict, "")
self.assertEquals(val, test_val)
def test_dict_to_pv(self):
self.PVA = PvaServerComms(self.p)
val_dict = OrderedDict()
val_dict["typeid"] = "type1"
val_dict["val1"] = StringArray('', '')
val_dict["val2"] = np.array((1, 2))
val_dict["val3"] = dict(a=43)
val_dict["val4"] = [True, False]
val_dict["val5"] = [dict(a=43), dict(b=44)]
val_dict["val6"] = "s"
actual = self.PVA.dict_to_pv_object(val_dict)
self.assertEqual(actual._type, "type1")
self.assertEqual(actual._dict["val1"], ["", ""])
self.assertEqual(actual._dict["val2"], [1, 2])
self.assertEqual(actual._dict["val3"], dict(a=43))
self.assertEqual(actual._dict["val4"], [True, False])
self.assertEqual(len(actual._dict["val5"]), 2)
self.assertEqual(actual._dict["val5"][0]._dict, dict(a=43))
self.assertEqual(actual._dict["val5"][1]._dict, dict(b=44))
self.assertEqual(actual._dict["val6"], "s")
def test_purge_rpcs(self):
self.PVA = PvaServerComms(self.p)
self.rpc1 = MagicMock()
self.rpc2 = MagicMock()
self.PVA.register_rpc(1, self.rpc1)
self.PVA.register_rpc(2, self.rpc2)
self.assertEqual(self.PVA._rpcs, {1: self.rpc1, 2: self.rpc2})
self.PVA.register_dead_rpc(1)
self.assertEqual(self.PVA._dead_rpcs, [1])
self.PVA.purge_rpcs()
self.assertEqual(self.PVA._rpcs, {2: self.rpc2})
self.assertEqual(self.PVA._dead_rpcs, [])
def test_update_remote_block_list(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
self.PVA._update_local_block_list({"block1": 1, "block2": 2, "block3": 3})
calls = [call("block3"), call("block2"), call("block1")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.PVA._add_new_pva_channel.reset_mock()
self.PVA._update_local_block_list({"block1": 1, "block2": 2, "block3": 3, "block4": 4})
calls = [call("block4")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
def test_dict_to_stucture(self):
self.PVA = PvaServerComms(self.p)
val_dict = OrderedDict()
val_dict["typeid"] = "type1"
val_dict["val1"] = "1"
val_dict["val2"] = np.int32(2)
val_dict["val3"] = True
val_dict["val4"] = np.int64(0)
val_dict["val5"] = np.float64(0.5)
val_dict["val6"] = ["", ""]
val_dict["val7"] = np.array([5, 1], dtype=np.int32)
val_dict["val8"] = [True, False]
val_dict["val9"] = np.array([0, 1], dtype=np.int64)
val_dict["val10"] = np.array([0.2, 0.6], dtype=np.float64)
val = self.PVA.dict_to_pv_object_structure(val_dict)
test_dict = OrderedDict()
test_dict["val1"] = pvaccess.STRING
test_dict["val2"] = pvaccess.INT
test_dict["val3"] = pvaccess.BOOLEAN
test_dict["val4"] = pvaccess.LONG
test_dict["val5"] = pvaccess.DOUBLE
test_dict["val6"] = [pvaccess.STRING]
test_dict["val7"] = [pvaccess.INT]
test_dict["val8"] = [pvaccess.BOOLEAN]
test_dict["val9"] = [pvaccess.LONG]
test_dict["val10"] = [pvaccess.DOUBLE]
test_val = pvaccess.PvObject(test_dict, "type1")
self.assertEquals(val, test_val)
# Test the variant union array type
val = self.PVA.dict_to_pv_object_structure(
OrderedDict({"union_array": [OrderedDict({"val1": 1}), OrderedDict({"val2": "2"})]})
)
test_dict = OrderedDict()
test_dict["union_array"] = [({},)]
test_val = pvaccess.PvObject(test_dict, "")
self.assertEquals(val, test_val)
def test_create_pva_server(self):
self.PVA = PvaServerComms(self.p)
pvaccess.PvaServer.reset_mock()
self.PVA.create_pva_server()
pvaccess.PvaServer.assert_called_once()
def test_create_pva_server(self):
self.PVA = PvaServerComms(self.p)
pvaccess.PvaServer.reset_mock()
self.PVA.create_pva_server()
pvaccess.PvaServer.assert_called_once()
def test_register_rpc(self):
self.PVA = PvaServerComms(self.p)
self.rpc = MagicMock()
self.PVA.register_rpc(1, self.rpc)
self.assertEqual(self.PVA._rpcs, {1: self.rpc})
def test_start_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.startListener = MagicMock()
self.PVA.start_pva_server()
self.PVA._server.startListener.assert_called_once()
def test_register_dead_rpc(self):
self.PVA = PvaServerComms(self.p)
self.PVA.register_dead_rpc(1)
self.PVA.register_dead_rpc(2)
self.assertEqual(self.PVA._dead_rpcs, [1, 2])
def test_send_to_client(self):
self.PVA = PvaServerComms(self.p)
self.PVA._update_cache = MagicMock()
rpc_mock1 = MagicMock()
rpc_mock2 = MagicMock()
self.PVA._rpcs[1] = rpc_mock1
self.PVA._rpcs[2] = rpc_mock2
response1 = Return(id_=1)
self.PVA.send_to_client(response1)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=2)
self.PVA.send_to_client(response2)
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=3)
self.PVA.send_to_client(response3)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
# Gets
get_mock1 = MagicMock()
get_mock2 = MagicMock()
self.PVA._gets[3] = get_mock1
self.PVA._gets[4] = get_mock2
response1 = Return(id_=3)
self.PVA.send_to_client(response1)
get_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=4)
self.PVA.send_to_client(response2)
get_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=5)
self.PVA.send_to_client(response3)
get_mock1.notify_reply.assert_has_calls([call(response1)])
get_mock2.notify_reply.assert_has_calls([call(response2)])
# Puts
put_mock1 = MagicMock()
put_mock2 = MagicMock()
self.PVA._puts[5] = put_mock1
self.PVA._puts[6] = put_mock2
response1 = Return(id_=5)
self.PVA.send_to_client(response1)
put_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=6)
self.PVA.send_to_client(response2)
put_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=7)
self.PVA.send_to_client(response3)
put_mock1.notify_reply.assert_has_calls([call(response1)])
put_mock2.notify_reply.assert_has_calls([call(response2)])
# Monitors
mon_mock1 = MagicMock()
mon_mock2 = MagicMock()
self.PVA._monitors[7] = mon_mock1
self.PVA._monitors[8] = mon_mock2
response1 = Return(id_=7)
self.PVA.send_to_client(response1)
mon_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=8)
self.PVA.send_to_client(response2)
mon_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=9)
self.PVA.send_to_client(response3)
mon_mock1.notify_reply.assert_has_calls([call(response1)])
mon_mock2.notify_reply.assert_has_calls([call(response2)])
# Delta
mon_mock3 = MagicMock()
self.PVA._monitors[9] = mon_mock3
response3 = Delta(id_=9)
self.PVA.send_to_client(response3)
mon_mock3.update.assert_has_calls([call(response3["changes"])])
# Updates
self.PVA._update_local_block_list = MagicMock()
self.PVA._update_remote_block_list = MagicMock()
response4 = Update(id_=self.PVA._local_block_id)
response5 = Update(id_=self.PVA._remote_block_id)
self.PVA.send_to_client(response4)
self.PVA._update_local_block_list.assert_called_once()
self.PVA.send_to_client(response5)
self.PVA._update_remote_block_list.assert_called_once()
def test_init(self):
self.PVA = PvaServerComms(self.p)
self.assertEqual("PvaServerComms", self.PVA.name)
self.assertEqual(self.p, self.PVA.process)
def test_add_new_pva_channel(self, mock_endpoint):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel("test.block")
mock_endpoint.assert_called_with("PvaServerComms", "test.block",
self.PVA._server, self.PVA)
def test_add_new_pva_channel(self, mock_endpoint):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel("test.block")
mock_endpoint.assert_called_with("PvaServerComms", "test.block", self.PVA._server, self.PVA)
def test_register_monitor(self):
self.PVA = PvaServerComms(self.p)
self.mon = MagicMock()
self.PVA.register_monitor(1, self.mon)
self.assertEqual(self.PVA._monitors, {1: self.mon})
def test_register_dead_rpc(self):
self.PVA = PvaServerComms(self.p)
self.PVA.register_dead_rpc(1)
self.PVA.register_dead_rpc(2)
self.assertEqual(self.PVA._dead_rpcs, [1, 2])
def test_send_to_client(self):
self.PVA = PvaServerComms(self.p)
self.PVA._update_cache = MagicMock()
rpc_mock1 = MagicMock()
rpc_mock2 = MagicMock()
self.PVA._rpcs[1] = rpc_mock1
self.PVA._rpcs[2] = rpc_mock2
response1 = Return(id_=1)
self.PVA.send_to_client(response1)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=2)
self.PVA.send_to_client(response2)
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=3)
self.PVA.send_to_client(response3)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
# Gets
get_mock1 = MagicMock()
get_mock2 = MagicMock()
self.PVA._gets[3] = get_mock1
self.PVA._gets[4] = get_mock2
response1 = Return(id_=3)
self.PVA.send_to_client(response1)
get_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=4)
self.PVA.send_to_client(response2)
get_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=5)
self.PVA.send_to_client(response3)
get_mock1.notify_reply.assert_has_calls([call(response1)])
get_mock2.notify_reply.assert_has_calls([call(response2)])
# Puts
put_mock1 = MagicMock()
put_mock2 = MagicMock()
self.PVA._puts[5] = put_mock1
self.PVA._puts[6] = put_mock2
response1 = Return(id_=5)
self.PVA.send_to_client(response1)
put_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=6)
self.PVA.send_to_client(response2)
put_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=7)
self.PVA.send_to_client(response3)
put_mock1.notify_reply.assert_has_calls([call(response1)])
put_mock2.notify_reply.assert_has_calls([call(response2)])
# Monitors
mon_mock1 = MagicMock()
mon_mock2 = MagicMock()
self.PVA._monitors[7] = mon_mock1
self.PVA._monitors[8] = mon_mock2
response1 = Return(id_=7)
self.PVA.send_to_client(response1)
mon_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=8)
self.PVA.send_to_client(response2)
mon_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=9)
self.PVA.send_to_client(response3)
mon_mock1.notify_reply.assert_has_calls([call(response1)])
mon_mock2.notify_reply.assert_has_calls([call(response2)])
# Delta
mon_mock3 = MagicMock()
self.PVA._monitors[9] = mon_mock3
response3 = Delta(id_=9)
self.PVA.send_to_client(response3)
mon_mock3.update.assert_has_calls([call(response3["changes"])])
# Updates
self.PVA._update_local_block_list = MagicMock()
self.PVA._update_remote_block_list = MagicMock()
response4 = Update(id_=self.PVA._local_block_id)
response5 = Update(id_=self.PVA._remote_block_id)
self.PVA.send_to_client(response4)
self.PVA._update_local_block_list.assert_called_once()
self.PVA.send_to_client(response5)
self.PVA._update_remote_block_list.assert_called_once()
def test_register_put(self):
self.PVA = PvaServerComms(self.p)
self.put = MagicMock()
self.PVA.register_put(1, self.put)
self.assertEqual(self.PVA._puts, {1: self.put})
def test_start_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.startListener = MagicMock()
self.PVA.start_pva_server()
self.PVA._server.startListener.assert_called_once()
class TestPVAServerComms(unittest.TestCase):
def setUp(self):
pvaccess.PvaServer = MagicMock()
pvaccess.Endpoint = MagicMock()
pvaccess.PvObject = PvTempObject
self.p = MagicMock()
self.p.name = "ProcessName"
@patch("malcolm.comms.pva.pvaservercomms.PvaRpcImplementation")
def test_pva_endpoint(self, mock_rpc):
pva_server_mock = MagicMock()
server_mock = MagicMock()
server_mock._get_unique_id = MagicMock(return_value=1)
pvaccess.Endpoint.registerEndpointGet = MagicMock()
pvaccess.Endpoint.registerEndpointPut = MagicMock()
pvaccess.Endpoint.registerEndpointRPC = MagicMock()
pvaccess.Endpoint.registerEndpointMonitor = MagicMock()
endpoint = PvaEndpoint("test.name", "test.block", pva_server_mock, server_mock)
# Test calling of get
request = MagicMock()
with patch("malcolm.comms.pva.pvaservercomms.PvaImplementation.wait_for_reply"):
request.toDict = MagicMock(return_value={"name1": "val1"})
endpoint.get_callback(request)
server_mock._get_unique_id.assert_called_once()
server_mock.register_get.assert_called_once()
server_mock.remove_get.assert_called_once()
server_mock.reset_mock()
# Test calling of put
request = MagicMock()
request.toDict = MagicMock(return_value={"name1": "val1"})
endpoint.put_callback(request)
server_mock._get_unique_id.assert_called_once()
server_mock.register_get.assert_called_once()
server_mock.remove_get.assert_called_once()
server_mock.reset_mock()
# Test calling of monitor
request = MagicMock()
request.toDict = MagicMock(return_value={"name1": "val1"})
endpoint.monitor_callback(request)
server_mock._get_unique_id.assert_called_once()
server_mock.register_get.assert_called_once()
server_mock.remove_get.assert_called_once()
server_mock.reset_mock()
# request = MagicMock()
# endpoint.rpc_callback(request)
# server_mock._get_unique_id.assert_called_once()
# server_mock.register_rpc.assert_called_once()
# server_mock.reset_mock()
# endpoint.put_callback(request)
# server_mock._get_unique_id.assert_called_once()
# server_mock.register_put.assert_called_once()
# server_mock.get_request.assert_has_calls([call("test.block", request)])
# server_mock.reset_mock()
# request = MagicMock()
# endpoint.monitor_callback(request)
# server_mock._get_unique_id.assert_called_once()
# server_mock.register_monitor.assert_called_once()
# server_mock.get_request.assert_has_calls([call("test.block", request)])
def test_pva_get_implementation(self):
server = MagicMock()
server.get_request = MagicMock(return_value="test_return_1")
request = MagicMock()
pva = PvaGetImplementation(1, request, "test.block", server)
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._request, request)
self.assertEqual(pva._server, server)
pva._pv_structure = "structure"
self.assertEqual(pva.getPVStructure(), "structure")
pva.get()
# server.get_request.assert_called_with("test.block", request)
# self.assertEqual(pva.getPVStructure(), "test_return_1")
# server.get_request = MagicMock(return_value="test_return_2")
# pva.get()
# server.get_request.assert_called_with("test.block", request)
# self.assertEqual(pva.getPVStructure(), "test_return_2")
# self.assertEqual(pva._name, "test.name")
def test_pva_put_implementation(self):
server = MagicMock()
server.get_request = MagicMock(return_value="test_return_1")
request = MagicMock()
pva = PvaPutImplementation(1, request, "test.block", server)
pva.wait_for_reply = MagicMock()
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._request, request)
self.assertEqual(pva._server, server)
pva._pv_structure = "structure"
self.assertEqual(pva.getPVStructure(), "structure")
pv = MagicMock()
pv.toDict = MagicMock(return_value={"item1": {"item2": {}}})
pva.put(pv)
server.register_put.assert_called_once()
pv.toDict.assert_called_once()
server.send_to_process.assert_called_once()
pva.wait_for_reply.assert_called_once()
# server.get_request.assert_called_with("test.block", request)
# self.assertEqual(pva.getPVStructure(), "test_return_1")
# path = pva.dict_to_path({'p1': {'p2': {'p3': 'v3'}}})
# self.assertEqual(path, ['p1', 'p2', 'p3'])
# value = pva.dict_to_value({'p1': {'p2': {'p3': 'v3'}}})
# self.assertEqual(value, 'v3')
# pva._lock = MagicMock()
# pva._event = MagicMock()
# pva.check_lock()
# pva._lock.acquire.assert_has_calls([call(False)])
# pva.wait_for_reply()
# pva._event.wait.assert_called_once()
# response = MagicMock()
# pva.notify_reply(response)
# pva._event.set.assert_called_once()
# self.assertEqual(pva._response, response)
# server.get_request = MagicMock(return_value="test_return_2")
# pva.get()
# server.get_request.assert_called_with("test.block", request)
# self.assertEqual(pva.getPVStructure(), "test_return_2")
# pva.dict_to_path = MagicMock()
# pva.dict_to_value = MagicMock()
# pv = MagicMock()
# pva.put(pv)
# pva.dict_to_path.assert_called_once()
# pva.dict_to_value.assert_called_once()
# server.send_to_process.assert_called_once()
# server.remove_put.assert_called_once()
def test_pva_rpc_implementation(self):
server = MagicMock()
request = {"method": "test_method"}
pva = PvaRpcImplementation(1, request, "test.block", server)
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._request, request)
self.assertEqual(pva._server, server)
self.assertEqual(pva._method, "test_method")
pre_parse = {"dict1": {"item1", 1}, "list1": [1, 2, 3], "tuple1": ({"item2": 2, "item3": 3}, 2)}
post_parse = {"dict1": {"item1", 1}, "list1": [1, 2, 3], "tuple1": {"item2": 2, "item3": 3}}
self.assertEqual(pva.parse_variants(pre_parse), post_parse)
response = Return(id_=2, value="test.value")
pva.notify_reply(response)
pv = MagicMock()
pva.execute(pv)
server.process.q.put.assert_called_once()
pv.toDict.assert_called_once()
pva._lock = MagicMock()
pva.check_lock()
pva._lock.acquire.assert_has_calls([call(False)])
pva._event = MagicMock()
pva.wait_for_reply()
pva._event.wait.assert_called_once()
def test_pva_monitor_implementation(self):
request = MagicMock()
request.toDict = MagicMock(return_value={"item1": {"item2": {}}})
server = MagicMock()
structure = MagicMock()
pva = PvaMonitorImplementation(1, request, "test.block", server)
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._request, request)
self.assertEqual(pva._server, server)
self.assertEqual(pva.get_block(), "test.block")
pva._pv_structure = structure
self.assertEqual(pva.getPVStructure(), structure)
pva.mu = MagicMock()
pva.mu.update = MagicMock()
self.assertEqual(pva.getUpdater(), pva.mu)
pva.send_subscription()
server.send_to_process.assert_called_once()
pva.update([[["a", "b", "c"], "val1"], [["d", "e", "f"], "val2"]])
# pva.notify_updates()
pva.mu.update.assert_not_called()
pva._pv_structure.hasField = MagicMock(return_value=True)
pva.update([[["a", "b", "c"], "val3"], [["d", "e", "f"], "val4"]])
pva.mu.update.assert_called_once()
def test_init(self):
self.PVA = PvaServerComms(self.p)
self.assertEqual("PvaServerComms", self.PVA.name)
self.assertEqual(self.p, self.PVA.process)
def test_unique_id(self):
self.PVA = PvaServerComms(self.p)
starting_id = self.PVA._current_id
self.assertEqual(self.PVA._get_unique_id(), starting_id + 1)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 2)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 3)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 4)
def test_update_local_block_list(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
self.PVA._update_local_block_list({"block1": 1, "block2": 2, "block3": 3})
calls = [call("block3"), call("block2"), call("block1")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.PVA._add_new_pva_channel.reset_mock()
self.PVA._update_local_block_list({"block1": 1, "block2": 2, "block3": 3, "block4": 4})
calls = [call("block4")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
def test_update_remote_block_list(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
self.PVA._update_local_block_list({"block1": 1, "block2": 2, "block3": 3})
calls = [call("block3"), call("block2"), call("block1")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.PVA._add_new_pva_channel.reset_mock()
self.PVA._update_local_block_list({"block1": 1, "block2": 2, "block3": 3, "block4": 4})
calls = [call("block4")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
def test_send_to_client(self):
self.PVA = PvaServerComms(self.p)
self.PVA._update_cache = MagicMock()
rpc_mock1 = MagicMock()
rpc_mock2 = MagicMock()
self.PVA._rpcs[1] = rpc_mock1
self.PVA._rpcs[2] = rpc_mock2
response1 = Return(id_=1)
self.PVA.send_to_client(response1)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=2)
self.PVA.send_to_client(response2)
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=3)
self.PVA.send_to_client(response3)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
# Gets
get_mock1 = MagicMock()
get_mock2 = MagicMock()
self.PVA._gets[3] = get_mock1
self.PVA._gets[4] = get_mock2
response1 = Return(id_=3)
self.PVA.send_to_client(response1)
get_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=4)
self.PVA.send_to_client(response2)
get_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=5)
self.PVA.send_to_client(response3)
get_mock1.notify_reply.assert_has_calls([call(response1)])
get_mock2.notify_reply.assert_has_calls([call(response2)])
# Puts
put_mock1 = MagicMock()
put_mock2 = MagicMock()
self.PVA._puts[5] = put_mock1
self.PVA._puts[6] = put_mock2
response1 = Return(id_=5)
self.PVA.send_to_client(response1)
put_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=6)
self.PVA.send_to_client(response2)
put_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=7)
self.PVA.send_to_client(response3)
put_mock1.notify_reply.assert_has_calls([call(response1)])
put_mock2.notify_reply.assert_has_calls([call(response2)])
# Monitors
mon_mock1 = MagicMock()
mon_mock2 = MagicMock()
self.PVA._monitors[7] = mon_mock1
self.PVA._monitors[8] = mon_mock2
response1 = Return(id_=7)
self.PVA.send_to_client(response1)
mon_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=8)
self.PVA.send_to_client(response2)
mon_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=9)
self.PVA.send_to_client(response3)
mon_mock1.notify_reply.assert_has_calls([call(response1)])
mon_mock2.notify_reply.assert_has_calls([call(response2)])
# Delta
mon_mock3 = MagicMock()
self.PVA._monitors[9] = mon_mock3
response3 = Delta(id_=9)
self.PVA.send_to_client(response3)
mon_mock3.update.assert_has_calls([call(response3["changes"])])
# Updates
self.PVA._update_local_block_list = MagicMock()
self.PVA._update_remote_block_list = MagicMock()
response4 = Update(id_=self.PVA._local_block_id)
response5 = Update(id_=self.PVA._remote_block_id)
self.PVA.send_to_client(response4)
self.PVA._update_local_block_list.assert_called_once()
self.PVA.send_to_client(response5)
self.PVA._update_remote_block_list.assert_called_once()
def test_create_pva_server(self):
self.PVA = PvaServerComms(self.p)
pvaccess.PvaServer.reset_mock()
self.PVA.create_pva_server()
pvaccess.PvaServer.assert_called_once()
def test_start_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.startListener = MagicMock()
self.PVA.start_pva_server()
self.PVA._server.startListener.assert_called_once()
def test_stop_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.stop = MagicMock()
self.PVA.stop_pva_server()
self.PVA._server.stop.assert_called_once()
@patch("malcolm.comms.pva.pvaservercomms.PvaEndpoint")
def test_add_new_pva_channel(self, mock_endpoint):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel("test.block")
mock_endpoint.assert_called_with("PvaServerComms", "test.block", self.PVA._server, self.PVA)
def test_register_rpc(self):
self.PVA = PvaServerComms(self.p)
self.rpc = MagicMock()
self.PVA.register_rpc(1, self.rpc)
self.assertEqual(self.PVA._rpcs, {1: self.rpc})
def test_register_monitor(self):
self.PVA = PvaServerComms(self.p)
self.mon = MagicMock()
self.PVA.register_monitor(1, self.mon)
self.assertEqual(self.PVA._monitors, {1: self.mon})
def test_register_get(self):
self.PVA = PvaServerComms(self.p)
self.get = MagicMock()
self.PVA.register_get(1, self.get)
self.assertEqual(self.PVA._gets, {1: self.get})
def test_remove_get(self):
self.PVA = PvaServerComms(self.p)
get1 = MagicMock()
get2 = MagicMock()
self.PVA._gets = {1: get1, 2: get2}
self.PVA.remove_get(1)
self.assertEqual(self.PVA._gets, {2: get2})
def test_register_put(self):
self.PVA = PvaServerComms(self.p)
self.put = MagicMock()
self.PVA.register_put(1, self.put)
self.assertEqual(self.PVA._puts, {1: self.put})
def test_remove_put(self):
self.PVA = PvaServerComms(self.p)
put1 = MagicMock()
put2 = MagicMock()
self.PVA._puts = {1: put1, 2: put2}
self.PVA.remove_put(1)
self.assertEqual(self.PVA._puts, {2: put2})
def test_register_dead_rpc(self):
self.PVA = PvaServerComms(self.p)
self.PVA.register_dead_rpc(1)
self.PVA.register_dead_rpc(2)
self.assertEqual(self.PVA._dead_rpcs, [1, 2])
def test_purge_rpcs(self):
self.PVA = PvaServerComms(self.p)
self.rpc1 = MagicMock()
self.rpc2 = MagicMock()
self.PVA.register_rpc(1, self.rpc1)
self.PVA.register_rpc(2, self.rpc2)
self.assertEqual(self.PVA._rpcs, {1: self.rpc1, 2: self.rpc2})
self.PVA.register_dead_rpc(1)
self.assertEqual(self.PVA._dead_rpcs, [1])
self.PVA.purge_rpcs()
self.assertEqual(self.PVA._rpcs, {2: self.rpc2})
self.assertEqual(self.PVA._dead_rpcs, [])
def test_dict_to_stucture(self):
self.PVA = PvaServerComms(self.p)
val_dict = OrderedDict()
val_dict["typeid"] = "type1"
val_dict["val1"] = "1"
val_dict["val2"] = np.int32(2)
val_dict["val3"] = True
val_dict["val4"] = np.int64(0)
val_dict["val5"] = np.float64(0.5)
val_dict["val6"] = ["", ""]
val_dict["val7"] = np.array([5, 1], dtype=np.int32)
val_dict["val8"] = [True, False]
val_dict["val9"] = np.array([0, 1], dtype=np.int64)
val_dict["val10"] = np.array([0.2, 0.6], dtype=np.float64)
val = self.PVA.dict_to_pv_object_structure(val_dict)
test_dict = OrderedDict()
test_dict["val1"] = pvaccess.STRING
test_dict["val2"] = pvaccess.INT
test_dict["val3"] = pvaccess.BOOLEAN
test_dict["val4"] = pvaccess.LONG
test_dict["val5"] = pvaccess.DOUBLE
test_dict["val6"] = [pvaccess.STRING]
test_dict["val7"] = [pvaccess.INT]
test_dict["val8"] = [pvaccess.BOOLEAN]
test_dict["val9"] = [pvaccess.LONG]
test_dict["val10"] = [pvaccess.DOUBLE]
test_val = pvaccess.PvObject(test_dict, "type1")
self.assertEquals(val, test_val)
# Test the variant union array type
val = self.PVA.dict_to_pv_object_structure(
OrderedDict({"union_array": [OrderedDict({"val1": 1}), OrderedDict({"val2": "2"})]})
)
test_dict = OrderedDict()
test_dict["union_array"] = [({},)]
test_val = pvaccess.PvObject(test_dict, "")
self.assertEquals(val, test_val)
def test_strip_type_id(self):
self.PVA = PvaServerComms(self.p)
# val = self.PVA.dict_to_structure({"typeid": "type1", "level1": {"typeid": "type2", "level2": {"typeid": "type3", "item1": 1, "item2": "2", "item3": True}}})
val = self.PVA.strip_type_id(OrderedDict({"typeid": "type1", "val1": "1"}))
self.assertEquals(val, OrderedDict({"val1": "1"}))
def test_stop_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.stop = MagicMock()
self.PVA.stop_pva_server()
self.PVA._server.stop.assert_called_once()
def test_init(self):
self.PVA = PvaServerComms(self.p)
self.assertEqual("PvaServerComms", self.PVA.name)
self.assertEqual(self.p, self.PVA.process)
def test_register_rpc(self):
self.PVA = PvaServerComms(self.p)
self.rpc = MagicMock()
self.PVA.register_rpc(1, self.rpc)
self.assertEqual(self.PVA._rpcs, {1: self.rpc})
class TestPVAServerComms(unittest.TestCase):
def setUp(self):
pvaccess.PvaServer = MagicMock()
pvaccess.Endpoint = MagicMock()
pvaccess.PvObject = PvTempObject
self.p = MagicMock()
self.p.name = "ProcessName"
@patch('malcolm.comms.pva.pvaservercomms.PvaRpcImplementation')
def test_pva_endpoint(self, mock_rpc):
pva_server_mock = MagicMock()
server_mock = MagicMock()
server_mock._get_unique_id = MagicMock(return_value=1)
pvaccess.Endpoint.registerEndpointGet = MagicMock()
pvaccess.Endpoint.registerEndpointPut = MagicMock()
pvaccess.Endpoint.registerEndpointRPC = MagicMock()
pvaccess.Endpoint.registerEndpointMonitor = MagicMock()
endpoint = PvaEndpoint("test.name", "test.block", pva_server_mock,
server_mock)
# Test calling of get
request = MagicMock()
with patch(
'malcolm.comms.pva.pvaservercomms.PvaImplementation.wait_for_reply'
):
request.toDict = MagicMock(return_value={"name1": "val1"})
endpoint.get_callback(request)
server_mock._get_unique_id.assert_called_once()
server_mock.register_get.assert_called_once()
server_mock.remove_get.assert_called_once()
server_mock.reset_mock()
# Test calling of put
request = MagicMock()
request.toDict = MagicMock(return_value={"name1": "val1"})
endpoint.put_callback(request)
server_mock._get_unique_id.assert_called_once()
server_mock.register_get.assert_called_once()
server_mock.remove_get.assert_called_once()
server_mock.reset_mock()
# Test calling of monitor
request = MagicMock()
request.toDict = MagicMock(return_value={"name1": "val1"})
endpoint.monitor_callback(request)
server_mock._get_unique_id.assert_called_once()
server_mock.register_get.assert_called_once()
server_mock.remove_get.assert_called_once()
server_mock.reset_mock()
# request = MagicMock()
# endpoint.rpc_callback(request)
# server_mock._get_unique_id.assert_called_once()
# server_mock.register_rpc.assert_called_once()
# server_mock.reset_mock()
# endpoint.put_callback(request)
# server_mock._get_unique_id.assert_called_once()
# server_mock.register_put.assert_called_once()
# server_mock.get_request.assert_has_calls([call("test.block", request)])
# server_mock.reset_mock()
# request = MagicMock()
# endpoint.monitor_callback(request)
# server_mock._get_unique_id.assert_called_once()
# server_mock.register_monitor.assert_called_once()
# server_mock.get_request.assert_has_calls([call("test.block", request)])
def test_pva_get_implementation(self):
server = MagicMock()
server.get_request = MagicMock(return_value="test_return_1")
request = MagicMock()
pva = PvaGetImplementation(1, request, "test.block", server)
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._request, request)
self.assertEqual(pva._server, server)
pva._pv_structure = "structure"
self.assertEqual(pva.getPVStructure(), "structure")
pva.get()
#server.get_request.assert_called_with("test.block", request)
#self.assertEqual(pva.getPVStructure(), "test_return_1")
#server.get_request = MagicMock(return_value="test_return_2")
#pva.get()
#server.get_request.assert_called_with("test.block", request)
#self.assertEqual(pva.getPVStructure(), "test_return_2")
#self.assertEqual(pva._name, "test.name")
def test_pva_put_implementation(self):
server = MagicMock()
server.get_request = MagicMock(return_value="test_return_1")
request = MagicMock()
pva = PvaPutImplementation(1, request, "test.block", server)
pva.wait_for_reply = MagicMock()
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._request, request)
self.assertEqual(pva._server, server)
pva._pv_structure = "structure"
self.assertEqual(pva.getPVStructure(), "structure")
pv = MagicMock()
pv.toDict = MagicMock(return_value={"item1": {"item2": {}}})
pva.put(pv)
server.register_put.assert_called_once()
pv.toDict.assert_called_once()
server.send_to_process.assert_called_once()
pva.wait_for_reply.assert_called_once()
#server.get_request.assert_called_with("test.block", request)
#self.assertEqual(pva.getPVStructure(), "test_return_1")
#path = pva.dict_to_path({'p1': {'p2': {'p3': 'v3'}}})
#self.assertEqual(path, ['p1', 'p2', 'p3'])
#value = pva.dict_to_value({'p1': {'p2': {'p3': 'v3'}}})
#self.assertEqual(value, 'v3')
#pva._lock = MagicMock()
#pva._event = MagicMock()
#pva.check_lock()
#pva._lock.acquire.assert_has_calls([call(False)])
#pva.wait_for_reply()
#pva._event.wait.assert_called_once()
#response = MagicMock()
#pva.notify_reply(response)
#pva._event.set.assert_called_once()
#self.assertEqual(pva._response, response)
#server.get_request = MagicMock(return_value="test_return_2")
#pva.get()
#server.get_request.assert_called_with("test.block", request)
#self.assertEqual(pva.getPVStructure(), "test_return_2")
#pva.dict_to_path = MagicMock()
#pva.dict_to_value = MagicMock()
#pv = MagicMock()
#pva.put(pv)
#pva.dict_to_path.assert_called_once()
#pva.dict_to_value.assert_called_once()
#server.send_to_process.assert_called_once()
#server.remove_put.assert_called_once()
def test_pva_rpc_implementation(self):
server = MagicMock()
request = {"method": "test_method"}
pva = PvaRpcImplementation(1, request, "test.block", server)
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._request, request)
self.assertEqual(pva._server, server)
self.assertEqual(pva._method, "test_method")
pre_parse = {
"dict1": {"item1", 1},
"list1": [1, 2, 3],
"tuple1": ({
"item2": 2,
"item3": 3
}, 2)
}
post_parse = {
"dict1": {"item1", 1},
"list1": [1, 2, 3],
"tuple1": {
"item2": 2,
"item3": 3
}
}
self.assertEqual(pva.parse_variants(pre_parse), post_parse)
response = Return(id_=2, value="test.value")
pva.notify_reply(response)
pv = MagicMock()
pva.execute(pv)
server.process.q.put.assert_called_once()
pv.toDict.assert_called_once()
pva._lock = MagicMock()
pva.check_lock()
pva._lock.acquire.assert_has_calls([call(False)])
pva._event = MagicMock()
pva.wait_for_reply()
pva._event.wait.assert_called_once()
def test_pva_monitor_implementation(self):
request = MagicMock()
request.toDict = MagicMock(return_value={"item1": {"item2": {}}})
server = MagicMock()
structure = MagicMock()
pva = PvaMonitorImplementation(1, request, "test.block", server)
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._request, request)
self.assertEqual(pva._server, server)
self.assertEqual(pva.get_block(), "test.block")
pva._pv_structure = structure
self.assertEqual(pva.getPVStructure(), structure)
pva.mu = MagicMock()
pva.mu.update = MagicMock()
self.assertEqual(pva.getUpdater(), pva.mu)
pva.send_subscription()
server.send_to_process.assert_called_once()
pva.update([[["a", "b", "c"], "val1"], [["d", "e", "f"], "val2"]])
#pva.notify_updates()
pva.mu.update.assert_not_called()
pva._pv_structure.hasField = MagicMock(return_value=True)
pva.update([[["a", "b", "c"], "val3"], [["d", "e", "f"], "val4"]])
pva.mu.update.assert_called_once()
def test_init(self):
self.PVA = PvaServerComms(self.p)
self.assertEqual("PvaServerComms", self.PVA.name)
self.assertEqual(self.p, self.PVA.process)
def test_unique_id(self):
self.PVA = PvaServerComms(self.p)
starting_id = self.PVA._current_id
self.assertEqual(self.PVA._get_unique_id(), starting_id + 1)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 2)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 3)
self.assertEqual(self.PVA._get_unique_id(), starting_id + 4)
def test_update_local_block_list(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
self.PVA._update_local_block_list({
"block1": 1,
"block2": 2,
"block3": 3
})
calls = [call("block3"), call("block2"), call("block1")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.PVA._add_new_pva_channel.reset_mock()
self.PVA._update_local_block_list({
"block1": 1,
"block2": 2,
"block3": 3,
"block4": 4
})
calls = [call("block4")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
def test_update_remote_block_list(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
self.PVA._update_local_block_list({
"block1": 1,
"block2": 2,
"block3": 3
})
calls = [call("block3"), call("block2"), call("block1")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.PVA._add_new_pva_channel.reset_mock()
self.PVA._update_local_block_list({
"block1": 1,
"block2": 2,
"block3": 3,
"block4": 4
})
calls = [call("block4")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
def test_send_to_client(self):
self.PVA = PvaServerComms(self.p)
self.PVA._update_cache = MagicMock()
rpc_mock1 = MagicMock()
rpc_mock2 = MagicMock()
self.PVA._rpcs[1] = rpc_mock1
self.PVA._rpcs[2] = rpc_mock2
response1 = Return(id_=1)
self.PVA.send_to_client(response1)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=2)
self.PVA.send_to_client(response2)
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=3)
self.PVA.send_to_client(response3)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
# Gets
get_mock1 = MagicMock()
get_mock2 = MagicMock()
self.PVA._gets[3] = get_mock1
self.PVA._gets[4] = get_mock2
response1 = Return(id_=3)
self.PVA.send_to_client(response1)
get_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=4)
self.PVA.send_to_client(response2)
get_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=5)
self.PVA.send_to_client(response3)
get_mock1.notify_reply.assert_has_calls([call(response1)])
get_mock2.notify_reply.assert_has_calls([call(response2)])
# Puts
put_mock1 = MagicMock()
put_mock2 = MagicMock()
self.PVA._puts[5] = put_mock1
self.PVA._puts[6] = put_mock2
response1 = Return(id_=5)
self.PVA.send_to_client(response1)
put_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=6)
self.PVA.send_to_client(response2)
put_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=7)
self.PVA.send_to_client(response3)
put_mock1.notify_reply.assert_has_calls([call(response1)])
put_mock2.notify_reply.assert_has_calls([call(response2)])
# Monitors
mon_mock1 = MagicMock()
mon_mock2 = MagicMock()
self.PVA._monitors[7] = mon_mock1
self.PVA._monitors[8] = mon_mock2
response1 = Return(id_=7)
self.PVA.send_to_client(response1)
mon_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=8)
self.PVA.send_to_client(response2)
mon_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Return(id_=9)
self.PVA.send_to_client(response3)
mon_mock1.notify_reply.assert_has_calls([call(response1)])
mon_mock2.notify_reply.assert_has_calls([call(response2)])
# Delta
mon_mock3 = MagicMock()
self.PVA._monitors[9] = mon_mock3
response3 = Delta(id_=9)
self.PVA.send_to_client(response3)
mon_mock3.update.assert_has_calls([call(response3["changes"])])
# Updates
self.PVA._update_local_block_list = MagicMock()
self.PVA._update_remote_block_list = MagicMock()
response4 = Update(id_=self.PVA._local_block_id)
response5 = Update(id_=self.PVA._remote_block_id)
self.PVA.send_to_client(response4)
self.PVA._update_local_block_list.assert_called_once()
self.PVA.send_to_client(response5)
self.PVA._update_remote_block_list.assert_called_once()
def test_create_pva_server(self):
self.PVA = PvaServerComms(self.p)
pvaccess.PvaServer.reset_mock()
self.PVA.create_pva_server()
pvaccess.PvaServer.assert_called_once()
def test_start_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.startListener = MagicMock()
self.PVA.start_pva_server()
self.PVA._server.startListener.assert_called_once()
def test_stop_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.stop = MagicMock()
self.PVA.stop_pva_server()
self.PVA._server.stop.assert_called_once()
@patch('malcolm.comms.pva.pvaservercomms.PvaEndpoint')
def test_add_new_pva_channel(self, mock_endpoint):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel("test.block")
mock_endpoint.assert_called_with("PvaServerComms", "test.block",
self.PVA._server, self.PVA)
def test_register_rpc(self):
self.PVA = PvaServerComms(self.p)
self.rpc = MagicMock()
self.PVA.register_rpc(1, self.rpc)
self.assertEqual(self.PVA._rpcs, {1: self.rpc})
def test_register_monitor(self):
self.PVA = PvaServerComms(self.p)
self.mon = MagicMock()
self.PVA.register_monitor(1, self.mon)
self.assertEqual(self.PVA._monitors, {1: self.mon})
def test_register_get(self):
self.PVA = PvaServerComms(self.p)
self.get = MagicMock()
self.PVA.register_get(1, self.get)
self.assertEqual(self.PVA._gets, {1: self.get})
def test_remove_get(self):
self.PVA = PvaServerComms(self.p)
get1 = MagicMock()
get2 = MagicMock()
self.PVA._gets = {1: get1, 2: get2}
self.PVA.remove_get(1)
self.assertEqual(self.PVA._gets, {2: get2})
def test_register_put(self):
self.PVA = PvaServerComms(self.p)
self.put = MagicMock()
self.PVA.register_put(1, self.put)
self.assertEqual(self.PVA._puts, {1: self.put})
def test_remove_put(self):
self.PVA = PvaServerComms(self.p)
put1 = MagicMock()
put2 = MagicMock()
self.PVA._puts = {1: put1, 2: put2}
self.PVA.remove_put(1)
self.assertEqual(self.PVA._puts, {2: put2})
def test_register_dead_rpc(self):
self.PVA = PvaServerComms(self.p)
self.PVA.register_dead_rpc(1)
self.PVA.register_dead_rpc(2)
self.assertEqual(self.PVA._dead_rpcs, [1, 2])
def test_purge_rpcs(self):
self.PVA = PvaServerComms(self.p)
self.rpc1 = MagicMock()
self.rpc2 = MagicMock()
self.PVA.register_rpc(1, self.rpc1)
self.PVA.register_rpc(2, self.rpc2)
self.assertEqual(self.PVA._rpcs, {1: self.rpc1, 2: self.rpc2})
self.PVA.register_dead_rpc(1)
self.assertEqual(self.PVA._dead_rpcs, [1])
self.PVA.purge_rpcs()
self.assertEqual(self.PVA._rpcs, {2: self.rpc2})
self.assertEqual(self.PVA._dead_rpcs, [])
def test_dict_to_stucture(self):
self.PVA = PvaServerComms(self.p)
val_dict = OrderedDict()
val_dict["typeid"] = "type1"
val_dict["val1"] = "1"
val_dict["val2"] = np.int32(2)
val_dict["val3"] = True
val_dict["val4"] = np.int64(0)
val_dict["val5"] = np.float64(0.5)
val_dict["val6"] = StringArray('', '')
val_dict["val7"] = np.array([5, 1], dtype=np.int32)
val_dict["val8"] = [True, False]
val_dict["val9"] = np.array([0, 1], dtype=np.int64)
val_dict["val10"] = np.array([0.2, 0.6], dtype=np.float64)
val = self.PVA.pva_structure_from_value(val_dict)
test_dict = OrderedDict()
test_dict["val1"] = pvaccess.STRING
test_dict["val2"] = pvaccess.INT
test_dict["val3"] = pvaccess.BOOLEAN
test_dict["val4"] = pvaccess.LONG
test_dict["val5"] = pvaccess.DOUBLE
test_dict["val6"] = [pvaccess.STRING]
test_dict["val7"] = [pvaccess.INT]
test_dict["val8"] = [pvaccess.BOOLEAN]
test_dict["val9"] = [pvaccess.LONG]
test_dict["val10"] = [pvaccess.DOUBLE]
test_val = pvaccess.PvObject(test_dict, "type1")
self.assertEquals(val, test_val)
# Test the variant union array type
val = self.PVA.pva_structure_from_value(
{"union_array": [{
"val1": 1
}, {
"val2": "2"
}]})
test_dict = OrderedDict()
test_dict["union_array"] = [()]
test_val = pvaccess.PvObject(test_dict, "")
self.assertEquals(val, test_val)
val = self.PVA.pva_structure_from_value({"union_array": []})
test_dict = OrderedDict()
test_dict["union_array"] = [()]
test_val = pvaccess.PvObject(test_dict, "")
self.assertEquals(val, test_val)
def test_dict_to_pv(self):
self.PVA = PvaServerComms(self.p)
val_dict = OrderedDict()
val_dict["typeid"] = "type1"
val_dict["val1"] = StringArray('', '')
val_dict["val2"] = np.array((1, 2))
val_dict["val3"] = dict(a=43)
val_dict["val4"] = [True, False]
val_dict["val5"] = [dict(a=43), dict(b=44)]
val_dict["val6"] = "s"
actual = self.PVA.dict_to_pv_object(val_dict)
self.assertEqual(actual._type, "type1")
self.assertEqual(actual._dict["val1"], ["", ""])
self.assertEqual(actual._dict["val2"], [1, 2])
self.assertEqual(actual._dict["val3"], dict(a=43))
self.assertEqual(actual._dict["val4"], [True, False])
self.assertEqual(len(actual._dict["val5"]), 2)
self.assertEqual(actual._dict["val5"][0]._dict, dict(a=43))
self.assertEqual(actual._dict["val5"][1]._dict, dict(b=44))
self.assertEqual(actual._dict["val6"], "s")
def test_register_put(self):
self.PVA = PvaServerComms(self.p)
self.put = MagicMock()
self.PVA.register_put(1, self.put)
self.assertEqual(self.PVA._puts, {1: self.put})
def test_stop_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.stop = MagicMock()
self.PVA.stop_pva_server()
self.PVA._server.stop.assert_called_once()
def test_dict_to_stucture(self):
self.PVA = PvaServerComms(self.p)
#val = self.PVA.dict_to_structure({"typeid": "type1", "level1": {"typeid": "type2", "level2": {"typeid": "type3", "item1": 1, "item2": "2", "item3": True}}})
import sys
if sys.version_info[0] < 3:
val = self.PVA.dict_to_pv_object_structure(
OrderedDict({
"typeid": "type1",
"val1": "1",
"val2": 2,
"val3": True,
"val4": long(0),
"val5": 0.5,
"val6": ['', ''],
"val7": [5, 1],
"val8": [True, False],
"val9": [long(0), long(1)],
"val10": [0.2, 0.3],
}))
test_dict = OrderedDict()
test_dict["val1"] = pvaccess.STRING
test_dict["val2"] = pvaccess.INT
test_dict["val3"] = pvaccess.BOOLEAN
test_dict["val4"] = pvaccess.LONG
test_dict["val5"] = pvaccess.FLOAT
test_dict["val6"] = [pvaccess.STRING]
test_dict["val7"] = [pvaccess.INT]
test_dict["val8"] = [pvaccess.BOOLEAN]
test_dict["val9"] = [pvaccess.LONG]
test_dict["val10"] = [pvaccess.FLOAT]
test_val = pvaccess.PvObject(test_dict, "type1")
self.assertEquals(val, test_val)
else:
val = self.PVA.dict_to_pv_object_structure(
OrderedDict({
"typeid": "type1",
"val1": "1",
"val2": 2,
"val3": True,
"val5": 0.5,
"val6": ['', ''],
"val7": [5, 1],
"val8": [True, False],
"val10": [0.2, 0.3],
}))
test_dict = OrderedDict()
test_dict["val1"] = pvaccess.STRING
test_dict["val2"] = pvaccess.INT
test_dict["val3"] = pvaccess.BOOLEAN
test_dict["val5"] = pvaccess.FLOAT
test_dict["val6"] = [pvaccess.STRING]
test_dict["val7"] = [pvaccess.INT]
test_dict["val8"] = [pvaccess.BOOLEAN]
test_dict["val10"] = [pvaccess.FLOAT]
test_val = pvaccess.PvObject(test_dict, "type1")
self.assertEquals(val, test_val)
# Test the variant union array type
val = self.PVA.dict_to_pv_object_structure(
OrderedDict({
"union_array":
[OrderedDict({"val1": 1}),
OrderedDict({"val2": "2"})]
}))
test_dict = OrderedDict()
test_dict["union_array"] = [({}, )]
test_val = pvaccess.PvObject(test_dict, "")
self.assertEquals(val, test_val)
def test_register_monitor(self):
self.PVA = PvaServerComms(self.p)
self.mon = MagicMock()
self.PVA.register_monitor(1, self.mon)
self.assertEqual(self.PVA._monitors, {1: self.mon})
class TestPVAServerComms(unittest.TestCase):
def setUp(self):
pvaccess.PvaServer = MagicMock()
pvaccess.Endpoint = MagicMock()
pvaccess.PvObject = PvTempObject
self.p = MagicMock()
@patch('malcolm.comms.pva.pvaservercomms.PvaRpcImplementation')
def test_pva_endpoint(self, mock_rpc):
pva_server_mock = MagicMock()
server_mock = MagicMock()
pvaccess.Endpoint.registerEndpointGet = MagicMock()
pvaccess.Endpoint.registerEndpointPut = MagicMock()
pvaccess.Endpoint.registerEndpointRPC = MagicMock()
endpoint = PvaEndpoint("test.name", "test.block", pva_server_mock,
server_mock)
request = MagicMock()
endpoint.get_callback(request)
server_mock.get_request.assert_has_calls([call("test.block", request)])
request = MagicMock()
endpoint.rpc_callback(request)
server_mock._get_unique_id.assert_called_once()
server_mock.register_rpc.assert_called_once()
server_mock.reset_mock()
endpoint.put_callback(request)
server_mock._get_unique_id.assert_called_once()
server_mock.register_put.assert_called_once()
server_mock.get_request.assert_has_calls([call("test.block", request)])
def test_pva_get_implementation(self):
server = MagicMock()
server.get_request = MagicMock(return_value="test_return_1")
request = MagicMock()
pva = PvaGetImplementation("test.name", request, "test.block", server)
server.get_request.assert_called_with("test.block", request)
self.assertEqual(pva.getPVStructure(), "test_return_1")
server.get_request = MagicMock(return_value="test_return_2")
pva.get()
server.get_request.assert_called_with("test.block", request)
self.assertEqual(pva.getPVStructure(), "test_return_2")
self.assertEqual(pva._name, "test.name")
def test_pva_put_implementation(self):
server = MagicMock()
server.get_request = MagicMock(return_value="test_return_1")
request = MagicMock()
pva = PvaPutImplementation(1, "test.name", request, "test.block",
server)
self.assertEqual(pva._name, "test.name")
server.get_request.assert_called_with("test.block", request)
self.assertEqual(pva.getPVStructure(), "test_return_1")
path = pva.dict_to_path({'p1': {'p2': {'p3': 'v3'}}})
self.assertEqual(path, ['p1', 'p2', 'p3'])
value = pva.dict_to_value({'p1': {'p2': {'p3': 'v3'}}})
self.assertEqual(value, 'v3')
pva._lock = MagicMock()
pva._event = MagicMock()
pva.check_lock()
pva._lock.acquire.assert_has_calls([call(False)])
pva.wait_for_reply()
pva._event.wait.assert_called_once()
response = MagicMock()
pva.notify_reply(response)
pva._event.set.assert_called_once()
self.assertEqual(pva._response, response)
server.get_request = MagicMock(return_value="test_return_2")
pva.get()
server.get_request.assert_called_with("test.block", request)
self.assertEqual(pva.getPVStructure(), "test_return_2")
pva.dict_to_path = MagicMock()
pva.dict_to_value = MagicMock()
pv = MagicMock()
pva.put(pv)
pva.dict_to_path.assert_called_once()
pva.dict_to_value.assert_called_once()
server.send_to_process.assert_called_once()
server.remove_put.assert_called_once()
def test_pva_rpc_implementation(self):
self.p = MagicMock()
self.p = MagicMock()
pva = PvaRpcImplementation(1, self.p, "test.block", "test.method")
self.assertEqual(pva._id, 1)
self.assertEqual(pva._block, "test.block")
self.assertEqual(pva._method, "test.method")
self.assertEqual(pva._server, self.p)
response = Return(id_=2, value="test.value")
pva.notify_reply(response)
self.pv = MagicMock()
pva.execute(self.pv)
self.p.process.q.put.assert_called_once()
self.pv.toDict.assert_called_once()
pva._lock = MagicMock()
pva.check_lock()
pva._lock.acquire.assert_has_calls([call(False)])
pva._event = MagicMock()
pva.wait_for_reply()
pva._event.wait.assert_called_once()
def test_init(self):
self.PVA = PvaServerComms(self.p)
self.assertEqual("PvaServerComms", self.PVA.name)
self.assertEqual(self.p, self.PVA.process)
def test_unique_id(self):
self.PVA = PvaServerComms(self.p)
self.assertEqual(self.PVA._get_unique_id(), 2)
self.assertEqual(self.PVA._get_unique_id(), 3)
self.assertEqual(self.PVA._get_unique_id(), 4)
self.assertEqual(self.PVA._get_unique_id(), 5)
def test_update_block_list(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
self.PVA._cache = {"block1": 1, "block2": 2, "block3": 3}
self.PVA._update_block_list()
calls = [call("block3"), call("block2"), call("block1")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.PVA._add_new_pva_channel.reset_mock()
self.PVA._cache = {"block1": 1, "block2": 2, "block3": 3, "block4": 4}
self.PVA._update_block_list()
calls = [call("block4")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
def test_update_cache(self):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel = MagicMock()
request = Delta(id_=1,
changes=[[["block1"], 1], [["block2"], 2],
[["block3"], 3]])
self.PVA._update_cache(request)
calls = [call("block1"), call("block2"), call("block3")]
self.PVA._add_new_pva_channel.assert_has_calls(calls, any_order=True)
self.assertEqual(self.PVA._cache, {
"block1": 1,
"block2": 2,
"block3": 3
})
def test_send_to_client(self):
self.PVA = PvaServerComms(self.p)
self.PVA._update_cache = MagicMock()
rpc_mock1 = MagicMock()
rpc_mock2 = MagicMock()
self.PVA._rpcs[1] = rpc_mock1
self.PVA._rpcs[2] = rpc_mock2
response1 = Return(id_=1)
self.PVA.send_to_client(response1)
rpc_mock1.notify_reply.assert_has_calls([call(response1)])
response2 = Error(id_=2)
self.PVA.send_to_client(response2)
rpc_mock2.notify_reply.assert_has_calls([call(response2)])
response3 = Delta(id_=3)
self.PVA.send_to_client(response3)
self.PVA._update_cache.assert_has_calls([call(response3)])
def test_create_pva_server(self):
self.PVA = PvaServerComms(self.p)
pvaccess.PvaServer.reset_mock()
self.PVA.create_pva_server()
pvaccess.PvaServer.assert_called_once()
def test_start_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.startListener = MagicMock()
self.PVA.start_pva_server()
self.PVA._server.startListener.assert_called_once()
def test_stop_pva_server(self):
self.PVA = PvaServerComms(self.p)
self.PVA._server.stop = MagicMock()
self.PVA.stop_pva_server()
self.PVA._server.stop.assert_called_once()
@patch('malcolm.comms.pva.pvaservercomms.PvaEndpoint')
def test_add_new_pva_channel(self, mock_endpoint):
self.PVA = PvaServerComms(self.p)
self.PVA._add_new_pva_channel("test.block")
mock_endpoint.assert_called_with("PvaServerComms", "test.block",
self.PVA._server, self.PVA)
def test_register_rpc(self):
self.PVA = PvaServerComms(self.p)
self.rpc = MagicMock()
self.PVA.register_rpc(1, self.rpc)
self.assertEqual(self.PVA._rpcs, {1: self.rpc})
def test_register_dead_rpc(self):
self.PVA = PvaServerComms(self.p)
self.PVA.register_dead_rpc(1)
self.PVA.register_dead_rpc(2)
self.assertEqual(self.PVA._dead_rpcs, [1, 2])
def test_purge_rpcs(self):
self.PVA = PvaServerComms(self.p)
self.rpc1 = MagicMock()
self.rpc2 = MagicMock()
self.PVA.register_rpc(1, self.rpc1)
self.PVA.register_rpc(2, self.rpc2)
self.assertEqual(self.PVA._rpcs, {1: self.rpc1, 2: self.rpc2})
self.PVA.register_dead_rpc(1)
self.assertEqual(self.PVA._dead_rpcs, [1])
self.PVA.purge_rpcs()
self.assertEqual(self.PVA._rpcs, {2: self.rpc2})
self.assertEqual(self.PVA._dead_rpcs, [])
def test_cache_to_pvobject(self):
self.PVA = PvaServerComms(self.p)
self.PVA._cache["test.block"] = OrderedDict({
"p1":
OrderedDict({
"p2": "val2",
"typeid": "type2"
}),
"typeid":
"type1"
})
object = self.PVA.cache_to_pvobject("test.block", [["p1", "p2"]])
self.assertEqual(
object,
PvTempObject(OrderedDict({"p1": OrderedDict({"p2": "val2"})}),
"type1"))
self.PVA._cache["test.block"] = OrderedDict({
"p1": [
OrderedDict({
"p2": 2,
"typeid": "type2"
}),
OrderedDict({
"p3": "val3",
"typeid": "type3"
})
],
"typeid":
"type1"
})
object = self.PVA.cache_to_pvobject("test.block", [["p1"]])
self.assertEqual(
object,
PvTempObject(
OrderedDict({
"p1": [
OrderedDict({
"p2": 2,
"typeid": "type2"
}),
OrderedDict({
"p3": "val3",
"typeid": "type3"
})
]
}), "type1"))
def test_dict_to_stucture(self):
self.PVA = PvaServerComms(self.p)
#val = self.PVA.dict_to_structure({"typeid": "type1", "level1": {"typeid": "type2", "level2": {"typeid": "type3", "item1": 1, "item2": "2", "item3": True}}})
import sys
if sys.version_info[0] < 3:
val = self.PVA.dict_to_pv_object_structure(
OrderedDict({
"typeid": "type1",
"val1": "1",
"val2": 2,
"val3": True,
"val4": long(0),
"val5": 0.5,
"val6": ['', ''],
"val7": [5, 1],
"val8": [True, False],
"val9": [long(0), long(1)],
"val10": [0.2, 0.3],
}))
test_dict = OrderedDict()
test_dict["val1"] = pvaccess.STRING
test_dict["val2"] = pvaccess.INT
test_dict["val3"] = pvaccess.BOOLEAN
test_dict["val4"] = pvaccess.LONG
test_dict["val5"] = pvaccess.FLOAT
test_dict["val6"] = [pvaccess.STRING]
test_dict["val7"] = [pvaccess.INT]
test_dict["val8"] = [pvaccess.BOOLEAN]
test_dict["val9"] = [pvaccess.LONG]
test_dict["val10"] = [pvaccess.FLOAT]
test_val = pvaccess.PvObject(test_dict, "type1")
self.assertEquals(val, test_val)
else:
val = self.PVA.dict_to_pv_object_structure(
OrderedDict({
"typeid": "type1",
"val1": "1",
"val2": 2,
"val3": True,
"val5": 0.5,
"val6": ['', ''],
"val7": [5, 1],
"val8": [True, False],
"val10": [0.2, 0.3],
}))
test_dict = OrderedDict()
test_dict["val1"] = pvaccess.STRING
test_dict["val2"] = pvaccess.INT
test_dict["val3"] = pvaccess.BOOLEAN
test_dict["val5"] = pvaccess.FLOAT
test_dict["val6"] = [pvaccess.STRING]
test_dict["val7"] = [pvaccess.INT]
test_dict["val8"] = [pvaccess.BOOLEAN]
test_dict["val10"] = [pvaccess.FLOAT]
test_val = pvaccess.PvObject(test_dict, "type1")
self.assertEquals(val, test_val)
# Test the variant union array type
val = self.PVA.dict_to_pv_object_structure(
OrderedDict({
"union_array":
[OrderedDict({"val1": 1}),
OrderedDict({"val2": "2"})]
}))
test_dict = OrderedDict()
test_dict["union_array"] = [({}, )]
test_val = pvaccess.PvObject(test_dict, "")
self.assertEquals(val, test_val)
def test_strip_type_id(self):
self.PVA = PvaServerComms(self.p)
#val = self.PVA.dict_to_structure({"typeid": "type1", "level1": {"typeid": "type2", "level2": {"typeid": "type3", "item1": 1, "item2": "2", "item3": True}}})
val = self.PVA.strip_type_id(
OrderedDict({
"typeid": "type1",
"val1": "1"
}))
self.assertEquals(val, OrderedDict({"val1": "1"}))
def test_strip_type_id(self):
self.PVA = PvaServerComms(self.p)
# val = self.PVA.dict_to_structure({"typeid": "type1", "level1": {"typeid": "type2", "level2": {"typeid": "type3", "item1": 1, "item2": "2", "item3": True}}})
val = self.PVA.strip_type_id(OrderedDict({"typeid": "type1", "val1": "1"}))
self.assertEquals(val, OrderedDict({"val1": "1"}))
