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_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_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_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_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_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_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_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_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_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_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_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_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_init(self):
self.PVA = PvaServerComms(self.p)
self.assertEqual("PvaServerComms", self.PVA.name)
self.assertEqual(self.p, self.PVA.process)
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_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_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})
