def test_get_identities(self):
"""Test identity retrieval."""
db = ContentDB(tempfile.NamedTemporaryFile().name)
id1 = dandelion.identity.generate()
id2 = dandelion.identity.generate().public_identity()
id3 = dandelion.identity.generate()
db.add_identities([id1, id2, id3])
db.add_messages([Message("fu")])
_, idlist = db.get_identities()
self.assertTrue(id1 in idlist)
self.assertTrue(id2 in idlist)
self.assertTrue(id3 in idlist)
for id in idlist:
self.assertFalse(id.rsa_key.is_private)
self.assertFalse(id.dsa_key.is_private)
_, idlist = db.get_identities(fingerprints=[id1.fingerprint, id2.fingerprint])
self.assertTrue(id1 in idlist)
self.assertTrue(id2 in idlist)
self.assertFalse(id3 in idlist)
for id in idlist:
self.assertFalse(id.rsa_key.is_private)
self.assertFalse(id.dsa_key.is_private)
def test_private_identities(self):
"""Test private id interface"""
db = ContentDB(tempfile.NamedTemporaryFile().name)
id_priv = dandelion.identity.generate()
id_pub = dandelion.identity.generate().public_identity()
# Add junk
self.assertRaises(TypeError, db.add_private_identity, None)
self.assertRaises(ValueError, db.add_private_identity, id_pub)
# Add, get, remove
db.add_private_identity(id_priv)
id = db.get_private_identity(id_priv.fingerprint)
self.assertEqual(id_priv.fingerprint, id.fingerprint)
self.assertEqual(id_priv, id)
self.assertTrue(IdentityInfo(db, id).is_private())
db.remove_private_identity(id_priv, keep_public_identity=False)
self.assertFalse(db.contains_identity(id_priv.fingerprint))
# Add and remove private, but keep public
db.add_private_identity(id_priv)
db.remove_private_identity(id_priv, keep_public_identity=True)
self.assertTrue(db.contains_identity(id_priv.fingerprint))
self.assertFalse(IdentityInfo(db, db.get_identities([id_priv.fingerprint])[1][0]).is_private())
self.assertRaises(ValueError, db.get_private_identity, id_priv.fingerprint)
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)
def test_client_server_transaction_partial_sync(self):
"""Tests the whole, client driven transaction protocol and logic"""
client_db = ContentDB(tempfile.NamedTemporaryFile().name)
server_db = ContentDB(tempfile.NamedTemporaryFile().name)
id1 = dandelion.identity.generate()
id2 = dandelion.identity.generate()
client_db.add_identities([id1])
server_db.add_identities([id1, id2])
client_db.add_messages([Message("fubar")])
server_db.add_messages([Message("fubar"), Message("foo"), Message("bar")])
self.assertEqual(client_db.identity_count, 1)
self.assertEqual(server_db.identity_count, 2)
self.assertEqual(client_db.message_count, 1)
self.assertEqual(server_db.message_count, 3)
with TestServerHelper() as server_helper, TestClientHelper() as client_helper:
client_transaction = ClientTransaction(client_helper.sock, client_db)
server_transaction = ServerTransaction(server_helper.sock, server_db)
"""Run the client transactions asynchronously"""
server_thread = threading.Thread(target=server_transaction.process)
client_thread = threading.Thread(target=client_transaction.process)
server_thread.start()
client_thread.start()
"""Wait for client to hang up"""
client_thread.join(1) # One sec should be plenty
server_thread.join(2 * TIMEOUT)
"""Make sure the client has updated the db"""
self.assertEqual(client_db.identity_count, 2)
self.assertEqual(server_db.identity_count, 2)
self.assertEqual(client_db.message_count, 3)
self.assertEqual(server_db.message_count, 3)
self.assertEqual(
len([srvmsg for srvmsg in server_db.get_messages()[1] if srvmsg not in client_db.get_messages()[1]]), 0
)
self.assertEqual(
len([srvids for srvids in server_db.get_identities()[1] if srvids not in client_db.get_identities()[1]]), 0
)
def test_identity_interface(self):
"""Test functions relating to storing and recovering identities."""
db = ContentDB(tempfile.NamedTemporaryFile().name)
_, idlist = db.get_identities()
self.assertEqual(idlist, [])
id_a = dandelion.identity.generate()
id_b = dandelion.identity.generate()
first_id_list = [id_a, id_b]
# Try to add junk
self.assertRaises(TypeError, db.add_identities, None)
self.assertRaises(TypeError, db.add_identities, 23)
self.assertRaises(AttributeError, db.add_identities, [None])
# Add a message list
self.assertEqual(db.identity_count, 0)
db.add_identities(first_id_list)
self.assertNotEqual(db.identity_count, None)
self.assertEqual(db.identity_count, len(first_id_list))
self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [True, True])
# And for another message list?
second_id_list = [dandelion.identity.generate(), id_a]
self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [False, True])
# Adding the second message list
db.add_identities(second_id_list)
self.assertEqual(db.identity_count, 3)
self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [True, True])
self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [True, True])
# Remove a list
db.remove_identities(first_id_list)
self.assertEqual(db.identity_count, 1)
self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [False, False])
self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [True, False])
# Remove same message list
db.remove_identities(first_id_list)
self.assertEqual(db.identity_count, 1)
self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [False, False])
self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [True, False])
# Remove all messages
db.remove_identities()
self.assertEqual(db.identity_count, 0)
self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [False, False])
self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [False, False])
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
)
