def test_basic_client_transaction(self):
"""Tests the client transaction protocol and logic"""
client_db = ContentDB()
srv_db = ContentDB()
tc = srv_db.add_messages(
[Message('fubar'),
Message('foo'), Message('bar')])
self.assertEqual(client_db.message_count, 0)
self.assertEqual(srv_db.message_count, 3)
with TestServerHelper() as server_helper, TestClientHelper(
) as client_helper:
client_transaction = ClientTransaction(client_helper.sock,
client_db)
srv_sock = SocketTransaction(server_helper.sock, b'\n')
"""Run the client transaction in a separate thread"""
thread = threading.Thread(target=client_transaction.process)
thread.start()
"""Send a greeting (should be req. by client)"""
srv_sock._write(
Protocol.create_greeting_message(srv_db.id).encode())
"""Reading msg id list request"""
rcv = srv_sock._read()
self.assertEqual(
rcv,
Protocol.create_message_id_list_request().encode())
"""Sending the msg id list"""
srv_sock._write(
Protocol.create_message_id_list(
tc, srv_db.get_messages()).encode())
"""Reading msg list request"""
rcv = srv_sock._read()
self.assertEqual(
rcv,
Protocol.create_message_list_request(
[msg.id for msg in srv_db.get_messages()]).encode())
"""Sending the msg id list"""
srv_sock._write(
Protocol.create_message_list(srv_db.get_messages()).encode())
"""Wait for client to hang up"""
thread.join(2 * TIMEOUT)
"""Make sure the client has updated the db"""
self.assertEqual(client_db.message_count, 3)
self.assertEqual(srv_db.message_count, 3)
self.assertEqual(
len([
srvmsg for srvmsg in srv_db.get_messages()
if srvmsg not in client_db.get_messages()
]), 0)
def test_basic_server_transaction(self):
"""Tests the server transaction protocol and logic"""
db = ContentDB()
tc = db.add_messages([Message('fubar'), Message('foo'), Message('bar')])
with TestServerHelper() as server_helper, TestClientHelper() as client_helper:
srv_transaction = ServerTransaction(server_helper.sock, db)
test_client = SocketTransaction(client_helper.sock, b'\n')
"""Run the server transaction in a separate thread to allow client access"""
thread = threading.Thread(target=srv_transaction.process)
thread.start()
"""Check greeting from server"""
rcv = test_client._read()
self.assertEqual(rcv, Protocol.create_greeting_message(db.id).encode())
"""Check response to mdgid list req"""
test_client._write(Protocol.create_message_id_list_request(tc).encode())
rcv = test_client._read()
self.assertEqual(rcv, Protocol.create_message_id_list(tc, None).encode())
"""Check response to mdg req"""
test_client._write(Protocol.create_message_list_request([msg.id for msg in db.get_messages()]).encode())
rcv = test_client._read()
self.assertEqual(rcv, Protocol.create_message_list(db.get_messages()).encode())
"""Wait for server (will time out if no requests)"""
thread.join(2*TIMEOUT)
def test_client_transaction_protocol_violation(self):
"""Tests the client transaction protocol and logic"""
client_db = ContentDB()
with TestServerHelper() as server_helper, TestClientHelper(
) as client_helper:
client_transaction = ClientTransaction(client_helper.sock,
client_db)
srv_sock = SocketTransaction(server_helper.sock, b'\n')
"""Run the client transaction in a separate thread"""
thread = threading.Thread(target=client_transaction.process)
thread.start()
"""Send a greeting (should be req. by client)"""
srv_sock._write(b'NON PROTOCOL MESSAGE\n')
self.assertRaises(socket.timeout, srv_sock._read)
"""Wait for client to hang up"""
thread.join(2 * TIMEOUT)
def test_client_transaction_protocol_violation(self):
"""Tests the client transaction protocol and logic"""
client_db = ContentDB()
with TestServerHelper() as server_helper, TestClientHelper() as client_helper:
client_transaction = ClientTransaction(client_helper.sock, client_db)
srv_sock = SocketTransaction(server_helper.sock, b'\n')
"""Run the client transaction in a separate thread"""
thread = threading.Thread(target=client_transaction.process)
thread.start()
"""Send a greeting (should be req. by client)"""
srv_sock._write(b'NON PROTOCOL MESSAGE\n')
self.assertRaises(socket.timeout, srv_sock._read)
"""Wait for client to hang up"""
thread.join(2*TIMEOUT)
def test_socket_transaction_read(self):
"""Tests the SocketTransaction base class _read function (protected)"""
with TestServerHelper() as server_helper, TestClientHelper(
) as client_helper:
msg = b'123\n'
"""Using the server socket"""
client_helper.sock.sendall(msg)
ret = SocketTransaction(server_helper.sock, b'\n')._read()
self.assertEqual(msg, ret)
"""Using the client socket"""
server_helper.sock.sendall(msg)
ret = SocketTransaction(client_helper.sock, b'\n')._read()
self.assertEqual(msg, ret)
"""Reading with different buffer lengths"""
server_helper.sock.sendall(msg)
ret = SocketTransaction(client_helper.sock, b'\n', 1)._read()
self.assertEqual(msg, ret)
server_helper.sock.sendall(msg)
ret = SocketTransaction(client_helper.sock, b'\n', 2)._read()
self.assertEqual(msg, ret)
server_helper.sock.sendall(msg)
ret = SocketTransaction(client_helper.sock, b'\n', 3)._read()
self.assertEqual(msg, ret)
server_helper.sock.sendall(msg)
ret = SocketTransaction(client_helper.sock, b'\n', 4)._read()
self.assertEqual(msg, ret)
def test_server_transaction_protocol_violation(self):
"""Tests the servers response to an invalid request"""
db = ContentDB()
with TestServerHelper() as server_helper, TestClientHelper(
) as client_helper:
srv_transaction = ServerTransaction(server_helper.sock, db)
test_client = SocketTransaction(client_helper.sock, b'\n')
"""Run the server transaction in a separate thread to allow client access"""
thread = threading.Thread(target=srv_transaction.process)
thread.start()
"""Check greeting from server"""
rcv = test_client._read()
self.assertEqual(rcv,
Protocol.create_greeting_message(db.id).encode())
"""Check response to mdgid list req"""
test_client._write(b'NON PROTOCOL MESSAGE\n')
self.assertRaises(socket.timeout, test_client._read)
"""Wait for server (will time out if no requests)"""
thread.join(2 * TIMEOUT)
server_helper, client_helper = None, None
def test_basic_client_transaction(self):
"""Tests the client transaction protocol and logic"""
client_db = ContentDB()
srv_db = ContentDB()
tc = srv_db.add_messages([Message('fubar'), Message('foo'), Message('bar')])
self.assertEqual(client_db.message_count, 0)
self.assertEqual(srv_db.message_count, 3)
with TestServerHelper() as server_helper, TestClientHelper() as client_helper:
client_transaction = ClientTransaction(client_helper.sock, client_db)
srv_sock = SocketTransaction(server_helper.sock, b'\n')
"""Run the client transaction in a separate thread"""
thread = threading.Thread(target=client_transaction.process)
thread.start()
"""Send a greeting (should be req. by client)"""
srv_sock._write(Protocol.create_greeting_message(srv_db.id).encode())
"""Reading msg id list request"""
rcv = srv_sock._read()
self.assertEqual(rcv, Protocol.create_message_id_list_request().encode())
"""Sending the msg id list"""
srv_sock._write(Protocol.create_message_id_list(tc, srv_db.get_messages()).encode())
"""Reading msg list request"""
rcv = srv_sock._read()
self.assertEqual(rcv, Protocol.create_message_list_request([msg.id for msg in srv_db.get_messages()]).encode())
"""Sending the msg id list"""
srv_sock._write(Protocol.create_message_list(srv_db.get_messages()).encode())
"""Wait for client to hang up"""
thread.join(2*TIMEOUT)
"""Make sure the client has updated the db"""
self.assertEqual(client_db.message_count, 3)
self.assertEqual(srv_db.message_count, 3)
self.assertEqual(len([srvmsg for srvmsg in srv_db.get_messages() if srvmsg not in client_db.get_messages()]), 0)
def test_socket_transaction_ctor(self):
"""Tests the SocketTransaction base class constructor"""
with TestServerHelper() as server_helper, TestClientHelper() as _:
SocketTransaction(server_helper.sock, b'\n')
SocketTransaction(server_helper.sock, b'\n', 2048)
self.assertRaises(TypeError, SocketTransaction, server_helper.sock,
None)
self.assertRaises(TypeError, SocketTransaction, server_helper.sock,
'\n')
self.assertRaises(ValueError, SocketTransaction,
server_helper.sock, b'12')
self.assertRaises(TypeError, SocketTransaction, server_helper.sock,
b'\n', None)
self.assertRaises(TypeError, SocketTransaction, server_helper.sock,
b'\n', 'str')
self.assertRaises(ValueError, SocketTransaction,
server_helper.sock, b'\n', 0)
self.assertRaises(ValueError, SocketTransaction,
server_helper.sock, b'\n', -10)
def test_server_transaction_protocol_violation(self):
"""Tests the servers response to an invalid request"""
db = ContentDB()
with TestServerHelper() as server_helper, TestClientHelper() as client_helper:
srv_transaction = ServerTransaction(server_helper.sock, db)
test_client = SocketTransaction(client_helper.sock, b'\n')
"""Run the server transaction in a separate thread to allow client access"""
thread = threading.Thread(target=srv_transaction.process)
thread.start()
"""Check greeting from server"""
rcv = test_client._read()
self.assertEqual(rcv, Protocol.create_greeting_message(db.id).encode())
"""Check response to mdgid list req"""
test_client._write(b'NON PROTOCOL MESSAGE\n')
self.assertRaises(socket.timeout, test_client._read)
"""Wait for server (will time out if no requests)"""
thread.join(2*TIMEOUT)
server_helper, client_helper = None, None
def test_socket_transaction_write(self):
"""Tests the SocketTransaction base class _write function (protected)"""
with TestServerHelper() as server_helper, TestClientHelper() as client_helper:
msg = b'123'
"""Using the server socket"""
st_a = SocketTransaction(server_helper.sock, b'\n')
st_a._write(msg)
ret = recv_n(client_helper.sock, len(msg))
self.assertEqual(msg, ret)
st_a._write(b'')
ret = recv_n(client_helper.sock, 0)
self.assertEqual(ret, b'')
self.assertRaises(TypeError, st_a._write, 1)
self.assertRaises(TypeError, st_a._write, None)
self.assertRaises(TypeError, st_a._write, 'str')
"""Using the client socket"""
st_b = SocketTransaction(client_helper.sock, b'\n')
st_b._write(msg)
ret = recv_n(server_helper.sock, len(msg))
self.assertEqual(msg, ret)
st_b._write(b'')
ret = recv_n(server_helper.sock, 0)
self.assertEqual(ret, b'')
self.assertRaises(TypeError, st_b._write, 1)
self.assertRaises(TypeError, st_b._write, None)
self.assertRaises(TypeError, st_b._write, 'str')
def test_basic_server_transaction(self):
"""Tests the server transaction protocol and logic"""
db = ContentDB()
tc = db.add_messages(
[Message('fubar'),
Message('foo'), Message('bar')])
with TestServerHelper() as server_helper, TestClientHelper(
) as client_helper:
srv_transaction = ServerTransaction(server_helper.sock, db)
test_client = SocketTransaction(client_helper.sock, b'\n')
"""Run the server transaction in a separate thread to allow client access"""
thread = threading.Thread(target=srv_transaction.process)
thread.start()
"""Check greeting from server"""
rcv = test_client._read()
self.assertEqual(rcv,
Protocol.create_greeting_message(db.id).encode())
"""Check response to mdgid list req"""
test_client._write(
Protocol.create_message_id_list_request(tc).encode())
rcv = test_client._read()
self.assertEqual(
rcv,
Protocol.create_message_id_list(tc, None).encode())
"""Check response to mdg req"""
test_client._write(
Protocol.create_message_list_request(
[msg.id for msg in db.get_messages()]).encode())
rcv = test_client._read()
self.assertEqual(
rcv,
Protocol.create_message_list(db.get_messages()).encode())
"""Wait for server (will time out if no requests)"""
thread.join(2 * TIMEOUT)
def test_socket_transaction_write(self):
"""Tests the SocketTransaction base class _write function (protected)"""
with TestServerHelper() as server_helper, TestClientHelper(
) as client_helper:
msg = b'123'
"""Using the server socket"""
st_a = SocketTransaction(server_helper.sock, b'\n')
st_a._write(msg)
ret = recv_n(client_helper.sock, len(msg))
self.assertEqual(msg, ret)
st_a._write(b'')
ret = recv_n(client_helper.sock, 0)
self.assertEqual(ret, b'')
self.assertRaises(TypeError, st_a._write, 1)
self.assertRaises(TypeError, st_a._write, None)
self.assertRaises(TypeError, st_a._write, 'str')
"""Using the client socket"""
st_b = SocketTransaction(client_helper.sock, b'\n')
st_b._write(msg)
ret = recv_n(server_helper.sock, len(msg))
self.assertEqual(msg, ret)
st_b._write(b'')
ret = recv_n(server_helper.sock, 0)
self.assertEqual(ret, b'')
self.assertRaises(TypeError, st_b._write, 1)
self.assertRaises(TypeError, st_b._write, None)
self.assertRaises(TypeError, st_b._write, 'str')
def test_basic_client_transaction(self):
"""Tests the client transaction protocol and logic"""
client_db = ContentDB(tempfile.NamedTemporaryFile().name)
srv_db = ContentDB(tempfile.NamedTemporaryFile().name)
self.assertEqual(client_db.message_count, 0)
srv_db.add_identities([dandelion.identity.generate(), dandelion.identity.generate()])
tc = srv_db.add_messages([Message("fubar"), Message("foo"), Message("bar")])
self.assertEqual(client_db.message_count, 0)
self.assertEqual(client_db.identity_count, 0)
self.assertEqual(srv_db.message_count, 3)
self.assertEqual(srv_db.identity_count, 2)
with TestServerHelper() as server_helper, TestClientHelper() as client_helper:
client_transaction = ClientTransaction(client_helper.sock, client_db)
srv_sock = SocketTransaction(server_helper.sock, b"\n")
"""Run the client transaction in a separate thread"""
thread = threading.Thread(target=client_transaction.process)
thread.start()
"""Send a greeting (should be req. by client)"""
srv_sock._write(dandelion.protocol.create_greeting_message(srv_db.id).encode())
"""Reading msg id list request"""
rcv = srv_sock._read()
self.assertEqual(rcv, dandelion.protocol.create_message_id_list_request().encode())
"""Sending the msg id list"""
srv_sock._write(dandelion.protocol.create_message_id_list(tc, srv_db.get_messages()[1]).encode())
"""Reading msg list request"""
rcv = srv_sock._read()
expected_msgs = (
dandelion.protocol.create_message_list_request([msg.id for msg in srv_db.get_messages()[1]])
.split(" ")[1][:-1]
.split(";")
)
for msg in expected_msgs:
self.assertNotEqual(rcv.find(msg.encode()), -1)
"""Sending the msg id list"""
srv_sock._write(dandelion.protocol.create_message_list(srv_db.get_messages()[1]).encode())
"""Reading identity id list request"""
rcv = srv_sock._read()
self.assertEqual(rcv, dandelion.protocol.create_identity_id_list_request().encode())
"""Sending the identity id list"""
srv_sock._write(dandelion.protocol.create_identity_id_list(tc, srv_db.get_identities()[1]).encode())
"""Reading identity list request"""
rcv = srv_sock._read()
expected_ids = (
dandelion.protocol.create_identity_list_request([id.fingerprint for id in srv_db.get_identities()[1]])
.split(" ")[1][:-1]
.split(";")
)
for id in expected_ids:
self.assertNotEqual(rcv.find(id.encode()), -1)
"""Sending the msg id list"""
srv_sock._write(dandelion.protocol.create_identity_list(srv_db.get_identities()[1]).encode())
"""Wait for client to hang up"""
thread.join(2 * TIMEOUT)
"""Make sure the client has updated the db"""
self.assertEqual(client_db.message_count, 3)
self.assertEqual(srv_db.message_count, 3)
self.assertEqual(
len([srvmsg for srvmsg in srv_db.get_messages()[1] if srvmsg not in client_db.get_messages()[1]]), 0
)
def test_basic_server_transaction(self):
"""Tests the server transaction protocol and logic"""
db = ContentDB(tempfile.NamedTemporaryFile().name)
db.add_identities([dandelion.identity.generate(), dandelion.identity.generate()])
tc = db.add_messages([Message("fubar"), Message("foo"), Message("bar")])
with TestServerHelper() as server_helper, TestClientHelper() as client_helper:
srv_transaction = ServerTransaction(server_helper.sock, db)
test_client = SocketTransaction(client_helper.sock, b"\n")
"""Run the server transaction in a separate thread to allow client access"""
thread = threading.Thread(target=srv_transaction.process)
thread.start()
"""Check greeting from server"""
rcv = test_client._read()
self.assertEqual(rcv, dandelion.protocol.create_greeting_message(db.id).encode())
"""Check response to mdgid list req"""
test_client._write(dandelion.protocol.create_message_id_list_request(tc).encode())
rcv = test_client._read()
self.assertEqual(rcv, dandelion.protocol.create_message_id_list(tc, None).encode())
"""Check response to identityid list req"""
test_client._write(dandelion.protocol.create_identity_id_list_request(tc).encode())
rcv = test_client._read()
self.assertEqual(rcv, dandelion.protocol.create_identity_id_list(tc, None).encode())
"""Check response to mdg req"""
test_client._write(
dandelion.protocol.create_message_list_request([msg.id for msg in db.get_messages()[1]]).encode()
)
rcv = test_client._read()
self.assertEqual(rcv, dandelion.protocol.create_message_list(db.get_messages()[1]).encode())
"""Check response to identity req"""
test_client._write(
dandelion.protocol.create_identity_list_request(
[id.fingerprint for id in db.get_identities()[1]]
).encode()
)
rcv = test_client._read()
self.assertEqual(rcv, dandelion.protocol.create_identity_list(db.get_identities()[1]).encode())
"""Wait for server (will time out if no requests)"""
thread.join(2 * TIMEOUT)
