def test_init_connection(self, mock_Socket, mock_select, mock_events):
mock_Socket.return_value = Socket(MockPythonSocket())
mock_select.side_effect = [([], [], []), Exception]
mock_events.side_effect = [TypeError]
test_TCP_Client = TCPClient()
cmd_signal = mock.Mock()
cmd_signal.emit.side_effect = [None, Expected_1]
test_TCP_Client.cmd_signal = cmd_signal
with pytest.raises(Expected_1):
test_TCP_Client.init_connection(
extra_commands=[ThreadCommand('test')])
assert not test_TCP_Client.connected
test_TCP_Client = TCPClient()
test_Socket = Socket(MockPythonSocket())
test_Socket.send_string('init')
mock_Socket.return_value = test_Socket
mock_select.side_effect = [(['init'], [], ['error'])]
test_TCP_Client.init_connection()
assert not test_TCP_Client.connected
mock_Socket.side_effect = [ConnectionRefusedError]
cmd_signal = mock.Mock()
cmd_signal.emit.side_effect = [None, Expected_2]
test_TCP_Client.cmd_signal = cmd_signal
with pytest.raises(Expected_2):
test_TCP_Client.init_connection()
def test_send_list(self):
listing = [
np.random.rand(7, 2),
'Hello World',
1,
2.654,
]
server = SimpleServer(
('127.0.0.1', 0),
handle_fun=lambda x: Socket(x).send_list(listing))
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
sleep(0.1)
data = []
list_len = client.get_int()
for ind in range(list_len):
data_type = client.get_string()
if data_type == 'scalar':
data.append(client.get_scalar())
elif data_type == 'string':
data.append(client.get_string())
elif data_type == 'array':
data.append(client.get_array())
utils.check_vals_in_iterable(data, listing)
client.close()
server.stop()
def test_get_array(self):
test_Socket = Socket(MockPythonSocket())
array = np.array([1, 2.1, 3.0])
test_Socket.send_array(array)
result = test_Socket.get_array()
assert np.array_equal(array, result)
assert not test_Socket.socket._send
def test_bytes_to_int(self):
integer = 5
bytes_integer = Socket.int_to_bytes(integer)
result = Socket.bytes_to_int(bytes_integer)
assert isinstance(result, int)
assert result == integer
with pytest.raises(TypeError):
Socket.bytes_to_int(integer)
def test_int_to_bytes(self):
integer = 5
bytes_integer = Socket.int_to_bytes(integer)
assert isinstance(bytes_integer, bytes)
with pytest.raises(TypeError):
Socket.int_to_bytes(1.5)
with pytest.raises(TypeError):
Socket.int_to_bytes('5')
def test_get_list(self):
test_Socket = Socket(MockPythonSocket())
data_list = [np.array([1, 2]), 'test', 47]
test_Socket.send_list(data_list)
result = test_Socket.get_list()
for elem1, elem2 in zip(data_list, result):
if isinstance(elem1, np.ndarray):
assert np.array_equal(elem1, elem2)
else:
assert elem1 == elem2
assert not test_Socket.socket._send
def test_send_command(self, mock_emit):
mock_emit.side_effect = [Expected_1, None]
test_TCP_Server = TCPServer()
test_Socket = Socket(MockPythonSocket())
test_TCP_Server.message_list = []
with pytest.raises(Expected_1):
test_TCP_Server.send_command(test_Socket)
test_TCP_Server.message_list = ['move_at']
test_TCP_Server.send_command(test_Socket)
assert test_Socket.get_string() == 'move_at'
assert not test_TCP_Server.send_command(test_Socket, command='test')
def test_close_server(self):
test_TCP_Server = TCPServer()
socket_1 = Socket(MockPythonSocket())
socket_1.bind(('0.0.0.1', 4455))
socket_2 = Socket(MockPythonSocket())
socket_2.bind(('0.0.0.2', 4456))
dict_list = [{
'socket': socket_1,
'type': 'server'
}, {
'socket': socket_2,
'type': 'Client'
}]
test_TCP_Server.connected_clients = dict_list
params = [{'name': 'conn_clients', 'value': dict_list}]
test_TCP_Server.settings = Parameter.create(name='Settings',
type='group',
children=params)
test_TCP_Server.close_server()
for socket_dict in test_TCP_Server.connected_clients:
assert socket_dict['type'] != 'server'
for socket in test_TCP_Server.settings.child(('conn_clients')).value():
assert not 'server' in socket
def test_methods(self, get_server, qtbot):
server = get_server()
server.settings.child(
('socket_ip')).setValue('127.0.0.1') # local host
server.settings.child(('port_id')).setValue(6341)
server.connected_clients.append(
dict(type='server', socket=server.serversocket))
actu_socket = Socket(
native_socket.socket(socket.AF_INET, socket.SOCK_STREAM))
server.connected_clients.append(
dict(type='ACTUATOR', socket=actu_socket))
#find_socket_within_connected_clients
assert server.find_socket_within_connected_clients(
'ACTUATOR') == actu_socket
assert server.find_socket_within_connected_clients('ACTUAT') is None
#find_socket_type_within_connected_clients
assert server.find_socket_type_within_connected_clients(
server.serversocket) == 'server'
#set_connected_clients_table
assert server.set_connected_clients_table() == OrderedDict(
server="unconnected invalid socket",
ACTUATOR="unconnected invalid socket")
#remove_client
server.remove_client(actu_socket)
assert server.set_connected_clients_table() == OrderedDict(
server="unconnected invalid socket")
def test_send_infos_xml(self):
test_TCP_Client = TCPClient()
test_TCP_Client.socket = Socket(MockPythonSocket())
test_TCP_Client.send_infos_xml('test_send_infos_xml')
assert test_TCP_Client.socket.get_string() == 'Infos'
assert test_TCP_Client.socket.get_string() == 'test_send_infos_xml'
assert not test_TCP_Client.socket.socket._send
def test_send_another_list(self):
listing = [
'another list that should raise an exception because there is a boolean that is not a valid type',
[
'gg',
],
]
server = SimpleServer(('127.0.0.1', 0), )
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
sleep(0.1)
server_socket = Socket(server.do_read()[0])
with pytest.raises(TypeError):
assert server_socket.send_list(listing)
server.stop()
def test_get_scalar(self):
scalars = [15489, 2.4589]
server = SimpleServer(('127.0.0.1', 0), )
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
sleep(0.1)
server_socket = Socket(server.do_read()[0])
for scalar in scalars:
server_socket.send_scalar(scalar)
assert client.get_scalar() == scalar
client.close()
server.stop()
def test_send_scalar(self):
test_Socket = Socket(MockPythonSocket())
scalar = 7
test_Socket.send_scalar(scalar)
data = np.array(scalar)
data_bytes = data.tobytes()
data_type = data.dtype.descr[0][1]
cmd_bytes, cmd_length_bytes = test_Socket.message_to_bytes(data_type)
assert test_Socket.recv() == cmd_length_bytes
assert test_Socket.recv() == cmd_bytes
assert test_Socket.recv() == test_Socket.int_to_bytes(len(data_bytes))
assert test_Socket.recv() == data_bytes
assert not test_Socket.socket._send
with pytest.raises(TypeError):
test_Socket.send_scalar('5')
def test_send_infos_string(self):
test_TCP_Client = TCPClient()
test_TCP_Client.socket = Socket(MockPythonSocket())
info_to_display = 'info to display'
value_as_string = 192.7654
test_TCP_Client.send_info_string(info_to_display, value_as_string)
assert test_TCP_Client.socket.get_string() == 'Info'
assert test_TCP_Client.socket.get_string() == info_to_display
assert test_TCP_Client.socket.get_string() == str(value_as_string)
assert not test_TCP_Client.socket.socket._send
def test_check_sended(self):
string = 'this is a message of a given length'
server = SimpleServer(
('127.0.0.1', 0),
handle_fun=lambda x: Socket(x).check_sended(string.encode()))
server.start()
client = socket.create_connection(('127.0.0.1', server.server_port))
response = client.recv(4096)
assert response == b'this is a message of a given length'
client.close()
server.stop()
def test_check_sended(self):
test_Socket = Socket(MockPythonSocket())
test_Socket.check_sended(b'test')
assert b'test' in test_Socket.socket._send
with pytest.raises(TypeError):
test_Socket.check_sended('test')
def test_send_string(self):
string = 'this is a message'
server = SimpleServer(
('127.0.0.1', 0),
handle_fun=lambda x: Socket(x).send_string(string))
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
len_string = int.from_bytes(client.check_received_length(4), 'big')
assert len_string == len(string)
assert client.check_received_length(len_string) == string.encode()
client.close()
server.stop()
def test_get_array(self):
arrays = [
np.random.rand(7, 1),
np.random.rand(10, 2),
np.random.rand(10, 2, 4),
np.random.rand(10, 1, 3),
np.random.rand(10, 4, 3, 1),
]
server = SimpleServer(('127.0.0.1', 0), )
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
server_socket = Socket(server.do_read()[0])
for array in arrays:
server_socket.send_array(array)
data = client.get_array()
assert np.all(data == array)
client.close()
server.stop()
def test_send_data(self):
test_TCP_Client = TCPClient()
test_TCP_Client.socket = Socket(MockPythonSocket())
data_list = [14, 1.1, 'test', np.array([1, 2, 3])]
test_TCP_Client.send_data(data_list)
assert test_TCP_Client.socket.get_string() == 'Done'
result = test_TCP_Client.socket.get_list()
for elem1, elem2 in zip(data_list, result):
if isinstance(elem1, np.ndarray):
assert np.array_equal(elem1, elem2)
else:
assert elem1 == elem2
assert not test_TCP_Client.socket.socket._send
with pytest.raises(TypeError):
test_TCP_Client.send_data([1j])
def test_get_string(self):
string = 'this is a message'
server = SimpleServer(
('127.0.0.1', 0),
handle_fun=lambda x: Socket(x).send_string(string))
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
assert client.get_string() == string
client.close()
server.stop()
def test_get_int(self):
one_integer = 15489
server = SimpleServer(
('127.0.0.1', 0),
handle_fun=lambda x: x.sendall(Socket.int_to_bytes(one_integer)))
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
assert client.get_int() == one_integer
client.close()
server.stop()
def test_data_ready(self):
test_TCP_Client = TCPClient()
test_TCP_Client.socket = Socket(MockPythonSocket())
data = [1, 5.3, 'test']
datas = [{
'data': data,
'name': 'TestData'
}, {
'data': None,
'name': 'FalseData'
}]
test_TCP_Client.data_ready(datas)
assert test_TCP_Client.socket.get_string() == 'Done'
result = np.array(test_TCP_Client.socket.get_list())
assert np.array_equal(np.array(data), result)
assert not test_TCP_Client.socket.socket._send
def test_get_data(self):
test_TCP_Client = TCPClient()
test_TCP_Client.socket = Socket(MockPythonSocket())
data_list = [1, 2, 3]
data_param = 'test'
test_TCP_Client.socket.send_list(data_list)
test_TCP_Client.socket.send_string(data_param)
test_TCP_Client.get_data('set_info')
assert not test_TCP_Client.socket.socket._send
test_TCP_Client.socket.send_scalar(10)
test_TCP_Client.get_data('move_abs')
assert not test_TCP_Client.socket.socket._send
test_TCP_Client.socket.send_scalar(7)
test_TCP_Client.get_data('move_rel')
assert not test_TCP_Client.socket.socket._send
def test_check_received_length(self):
string = 'this is a message'
server = SimpleServer(
('127.0.0.1', 0),
handle_fun=lambda x: Socket(x).check_sended(string.encode()))
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
assert client.check_received_length(len(
string.encode())) == string.encode()
client.close()
server.stop()
def test_remove_client(self, mock_emit):
mock_emit.side_effect = [Expected_1, Expected_2]
test_TCP_Server = TCPServer()
socket_1 = Socket(MockPythonSocket())
socket_1.bind(('0.0.0.1', 4455))
socket_2 = Socket(MockPythonSocket())
socket_2.bind(('0.0.0.2', 4456))
dict_list = [{
'socket': socket_1,
'type': 'Server'
}, {
'socket': socket_2,
'type': 'Client'
}]
test_TCP_Server.connected_clients = dict_list
params = [{'name': 'conn_clients', 'value': dict_list}]
test_TCP_Server.settings = Parameter.create(name='Settings',
type='group',
children=params)
with pytest.raises(Expected_1):
test_TCP_Server.remove_client(socket_1)
clients = test_TCP_Server.settings.child('conn_clients').value()
assert not 'Server' in clients
assert 'Client' in clients
for socket_dict in test_TCP_Server.connected_clients:
assert not 'Server' in socket_dict['type']
socket_except = mock.Mock()
socket_except.close.side_effect = [Exception]
dict_list = [{'socket': socket_except, 'type': 'Exception'}]
test_TCP_Server.connected_clients = dict_list
with pytest.raises(Expected_2):
test_TCP_Server.remove_client(socket_except)
def test_message_to_bytes(self):
string = 'this is a message'
assert Socket.message_to_bytes(string)[0] == string.encode()
assert Socket.message_to_bytes(string)[1] == Socket.int_to_bytes(
len(string))
def test_methods(self, qtbot):
server = SimpleServer(('127.0.0.1', 6341), )
server.start()
params = [{
'title': 'Device index:',
'name': 'device',
'type': 'int',
'value': 0,
'max': 3,
'min': 0
}, {
'title': 'Infos:',
'name': 'infos',
'type': 'str',
'value': "one_info",
'readonly': True
}, {
'title':
'Line Settings:',
'name':
'line_settings',
'type':
'group',
'expanded':
False,
'children': [
{
'name': 'someparam',
'type': 'float',
'value': 15.54,
'readonly': True
},
]
}]
param = Parameter.create(name='settings',
type='group',
children=params)
client = TCPClient(ipaddress="127.0.0.1",
port=6341,
params_state=param.saveState(),
client_type="sometype")
client.cmd_signal.connect(self.get_cmd_signal)
#check init method
assert client.ipaddress == "127.0.0.1"
assert client.port == 6341
assert client.client_type == 'sometype'
client.socket = Socket(
native_socket.socket(socket.AF_INET, socket.SOCK_STREAM))
client.socket.connect((client.ipaddress, client.port))
sleep(0.5)
server_socket = Socket(server.do_read()[0])
client.send_data([np.array([0, 1, 2, 3]), 'item', 5.1])
assert server_socket.get_string() == 'Done'
utils.check_vals_in_iterable(server_socket.get_list(),
[np.array([0, 1, 2, 3]), 'item', 5.1])
client.send_infos_xml(custom_tree.parameter_to_xml_string(param))
assert server_socket.get_string() == 'Infos'
assert server_socket.get_string(
) == custom_tree.parameter_to_xml_string(param).decode()
client.send_info_string('someinfo', 'this is an info')
assert server_socket.get_string() == 'Info'
assert server_socket.get_string() == 'someinfo'
assert server_socket.get_string() == 'this is an info'
#test queue_command
client.cmd_signal.connect(self.get_cmd_signal)
client_manager = ClientObjectManager()
client_manager.cmd_signal.connect(client.queue_command)
with pytest.raises(Exception):
client.queue_command(utils.ThreadCommand('Weird command'))
#test get_data
server_socket.send_string('set_info')
server_socket.send_list(['line_settings', 'someparam'])
server_socket.send_string(
custom_tree.parameter_to_xml_string(
param.child('line_settings', 'someparam')))
msg = client.socket.get_string()
client.get_data(msg)
assert self.command == 'set_info'
utils.check_vals_in_iterable(
self.attributes,
[['line_settings', 'someparam'],
custom_tree.parameter_to_xml_string(
param.child('line_settings', 'someparam')).decode()])
server_socket.send_string('move_abs')
server_socket.send_scalar(12.546)
msg = client.socket.get_string()
client.get_data(msg)
assert self.command == 'move_abs'
utils.check_vals_in_iterable(self.attributes, [12.546])
server_socket.send_string('move_rel')
server_socket.send_scalar(3.2)
msg = client.socket.get_string()
client.get_data(msg)
assert self.command == 'move_rel'
utils.check_vals_in_iterable(self.attributes, [3.2])
server.stop()
def test_int_to_bytes(self):
one_integer = 254
assert Socket.int_to_bytes(one_integer) == one_integer.to_bytes(
4, 'big')
def test_send_scalar(self):
scalars = [15489, 2.4589]
server = SimpleServer(('127.0.0.1', 0), )
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
sleep(0.1)
server_socket = Socket(server.do_read()[0])
for scalar in scalars:
server_socket.send_scalar(scalar)
data_type = client.get_string()
data_len = client.get_int()
data_bytes = client.check_received_length(data_len)
data = np.frombuffer(data_bytes, dtype=data_type)[0]
assert data == scalar
client.close()
server.stop()
def test_send_array(self):
arrays = [
np.random.rand(7, 1),
np.random.rand(10, 2),
np.random.rand(10, 2, 4),
np.random.rand(10, 1, 3),
np.random.rand(10, 4, 3, 1),
]
server = SimpleServer(('127.0.0.1', 0), )
server.start()
client = Socket(
socket.create_connection(('127.0.0.1', server.server_port)))
sleep(0.1)
server_socket = Socket(server.do_read()[0])
for array in arrays:
server_socket.send_array(array)
data_type = client.get_string()
data_len = client.get_int()
shape_len = client.get_int()
shape = []
for ind in range(shape_len):
shape.append(client.get_int())
data_bytes = client.check_received_length(data_len)
data = np.frombuffer(data_bytes, dtype=data_type)
data = data.reshape(tuple(shape))
assert np.all(data == array)
client.close()
server.stop()